/test/test262/data
/test/test262/data.old
/test/test262/tc39-test262-*
+/test/test262-es6/data
+/test/test262-es6/data.old
+/test/test262-es6/tc39-test262-*
/testing/gmock
/testing/gtest
/third_party/icu
GSYMS
GPATH
gtags.files
+turbo*.cfg
turbo*.dot
turbo*.json
BlackBerry Limited
Opera Software ASA
Intel Corporation
+MIPS Technologies, Inc.
+Imagination Technologies, LLC
+Loongson Technology Corporation Limited
Akinori MUSHA <knu@FreeBSD.org>
Alexander Botero-Lowry <alexbl@FreeBSD.org>
Baptiste Afsa <baptiste.afsa@arm.com>
Bert Belder <bertbelder@gmail.com>
Burcu Dogan <burcujdogan@gmail.com>
+Caitlin Potter <caitpotter88@gmail.com>
Craig Schlenter <craig.schlenter@gmail.com>
Chunyang Dai <chunyang.dai@intel.com>
Daniel Andersson <kodandersson@gmail.com>
Filipe David Manana <fdmanana@gmail.com>
Haitao Feng <haitao.feng@intel.com>
Ioseb Dzmanashvili <ioseb.dzmanashvili@gmail.com>
+Isiah Meadows <impinball@gmail.com>
Jacob Bramley <jacob.bramley@arm.com>
Jan de Mooij <jandemooij@gmail.com>
Jay Freeman <saurik@saurik.com>
"src/array.js",
"src/string.js",
"src/uri.js",
- "third_party/fdlibm/fdlibm.js",
+ "src/third_party/fdlibm/fdlibm.js",
"src/math.js",
"src/apinatives.js",
"src/date.js",
"src/generator.js",
"src/harmony-string.js",
"src/harmony-array.js",
+ "src/harmony-typedarray.js",
"src/harmony-classes.js",
+ "src/harmony-tostring.js"
]
outputs = [
"src/assembler.h",
"src/assert-scope.h",
"src/assert-scope.cc",
+ "src/ast-numbering.cc",
+ "src/ast-numbering.h",
"src/ast-value-factory.cc",
"src/ast-value-factory.h",
"src/ast.cc",
"src/bignum-dtoa.h",
"src/bignum.cc",
"src/bignum.h",
+ "src/bit-vector.cc",
+ "src/bit-vector.h",
"src/bootstrapper.cc",
"src/bootstrapper.h",
"src/builtins.cc",
"src/bytecodes-irregexp.h",
"src/cached-powers.cc",
"src/cached-powers.h",
+ "src/char-predicates.cc",
"src/char-predicates-inl.h",
"src/char-predicates.h",
"src/checks.cc",
"src/codegen.h",
"src/compilation-cache.cc",
"src/compilation-cache.h",
+ "src/compilation-statistics.cc",
+ "src/compilation-statistics.h",
"src/compiler/access-builder.cc",
"src/compiler/access-builder.h",
"src/compiler/ast-graph-builder.cc",
"src/compiler/ast-graph-builder.h",
+ "src/compiler/ast-loop-assignment-analyzer.cc",
+ "src/compiler/ast-loop-assignment-analyzer.h",
"src/compiler/basic-block-instrumentor.cc",
"src/compiler/basic-block-instrumentor.h",
"src/compiler/change-lowering.cc",
"src/compiler/common-operator.h",
"src/compiler/control-builders.cc",
"src/compiler/control-builders.h",
+ "src/compiler/control-reducer.cc",
+ "src/compiler/control-reducer.h",
+ "src/compiler/diamond.h",
"src/compiler/frame.h",
"src/compiler/gap-resolver.cc",
"src/compiler/gap-resolver.h",
"src/compiler/js-graph.h",
"src/compiler/js-inlining.cc",
"src/compiler/js-inlining.h",
+ "src/compiler/js-intrinsic-builder.cc",
+ "src/compiler/js-intrinsic-builder.h",
+ "src/compiler/js-operator.cc",
"src/compiler/js-operator.h",
"src/compiler/js-typed-lowering.cc",
"src/compiler/js-typed-lowering.h",
"src/compiler/phi-reducer.h",
"src/compiler/pipeline.cc",
"src/compiler/pipeline.h",
+ "src/compiler/pipeline-statistics.cc",
+ "src/compiler/pipeline-statistics.h",
"src/compiler/raw-machine-assembler.cc",
"src/compiler/raw-machine-assembler.h",
"src/compiler/register-allocator.cc",
"src/compiler/register-allocator.h",
+ "src/compiler/register-configuration.cc",
+ "src/compiler/register-configuration.h",
"src/compiler/representation-change.h",
"src/compiler/schedule.cc",
"src/compiler/schedule.h",
"src/compiler/scheduler.cc",
"src/compiler/scheduler.h",
+ "src/compiler/select-lowering.cc",
+ "src/compiler/select-lowering.h",
"src/compiler/simplified-lowering.cc",
"src/compiler/simplified-lowering.h",
"src/compiler/simplified-operator-reducer.cc",
"src/compiler/value-numbering-reducer.h",
"src/compiler/verifier.cc",
"src/compiler/verifier.h",
+ "src/compiler/zone-pool.cc",
+ "src/compiler/zone-pool.h",
"src/compiler.cc",
"src/compiler.h",
"src/contexts.cc",
"src/cpu-profiler-inl.h",
"src/cpu-profiler.cc",
"src/cpu-profiler.h",
- "src/data-flow.cc",
- "src/data-flow.h",
"src/date.cc",
"src/date.h",
"src/dateparser-inl.h",
"src/factory.h",
"src/fast-dtoa.cc",
"src/fast-dtoa.h",
- "src/feedback-slots.h",
"src/field-index.h",
"src/field-index-inl.h",
"src/fixed-dtoa.cc",
"src/heap/store-buffer-inl.h",
"src/heap/store-buffer.cc",
"src/heap/store-buffer.h",
- "src/heap/sweeper-thread.h",
- "src/heap/sweeper-thread.cc",
"src/hydrogen-alias-analysis.h",
"src/hydrogen-bce.cc",
"src/hydrogen-bce.h",
"src/rewriter.h",
"src/runtime-profiler.cc",
"src/runtime-profiler.h",
+ "src/runtime/runtime-api.cc",
+ "src/runtime/runtime-array.cc",
+ "src/runtime/runtime-classes.cc",
"src/runtime/runtime-collections.cc",
"src/runtime/runtime-compiler.cc",
+ "src/runtime/runtime-date.cc",
+ "src/runtime/runtime-debug.cc",
+ "src/runtime/runtime-function.cc",
+ "src/runtime/runtime-generator.cc",
"src/runtime/runtime-i18n.cc",
+ "src/runtime/runtime-internal.cc",
"src/runtime/runtime-json.cc",
+ "src/runtime/runtime-literals.cc",
+ "src/runtime/runtime-liveedit.cc",
"src/runtime/runtime-maths.cc",
"src/runtime/runtime-numbers.cc",
+ "src/runtime/runtime-object.cc",
+ "src/runtime/runtime-observe.cc",
+ "src/runtime/runtime-proxy.cc",
"src/runtime/runtime-regexp.cc",
+ "src/runtime/runtime-scopes.cc",
"src/runtime/runtime-strings.cc",
+ "src/runtime/runtime-symbol.cc",
"src/runtime/runtime-test.cc",
"src/runtime/runtime-typedarray.cc",
"src/runtime/runtime-uri.cc",
"src/unicode-inl.h",
"src/unicode.cc",
"src/unicode.h",
+ "src/unicode-decoder.cc",
+ "src/unicode-decoder.h",
"src/unique.h",
- "src/uri.h",
"src/utils-inl.h",
"src/utils.cc",
"src/utils.h",
"src/zone-inl.h",
"src/zone.cc",
"src/zone.h",
- "third_party/fdlibm/fdlibm.cc",
- "third_party/fdlibm/fdlibm.h",
+ "src/third_party/fdlibm/fdlibm.cc",
+ "src/third_party/fdlibm/fdlibm.h",
]
if (v8_target_arch == "x86") {
"src/compiler/ia32/instruction-codes-ia32.h",
"src/compiler/ia32/instruction-selector-ia32.cc",
"src/compiler/ia32/linkage-ia32.cc",
+ "src/ic/ia32/access-compiler-ia32.cc",
+ "src/ic/ia32/handler-compiler-ia32.cc",
"src/ic/ia32/ic-ia32.cc",
"src/ic/ia32/ic-compiler-ia32.cc",
"src/ic/ia32/stub-cache-ia32.cc",
"src/mips/regexp-macro-assembler-mips.cc",
"src/mips/regexp-macro-assembler-mips.h",
"src/mips/simulator-mips.cc",
+ "src/compiler/mips/code-generator-mips.cc",
+ "src/compiler/mips/instruction-codes-mips.h",
+ "src/compiler/mips/instruction-selector-mips.cc",
+ "src/compiler/mips/linkage-mips.cc",
"src/ic/mips/access-compiler-mips.cc",
"src/ic/mips/handler-compiler-mips.cc",
"src/ic/mips/ic-mips.cc",
"src/base/division-by-constant.cc",
"src/base/division-by-constant.h",
"src/base/flags.h",
+ "src/base/functional.cc",
+ "src/base/functional.h",
"src/base/lazy-instance.h",
"src/base/logging.cc",
"src/base/logging.h",
sources += [
"src/base/platform/platform-win32.cc",
"src/base/win32-headers.h",
- "src/base/win32-math.cc",
- "src/base/win32-math.h",
]
defines += [ "_CRT_RAND_S" ] # for rand_s()
":v8_base",
":v8_libplatform",
":v8_nosnapshot",
+ "//build/config/sanitizers:deps",
]
if (v8_compress_startup_data == "bz2") {
+2014-11-05: Version 3.30.33
+
+ `1..isPrototypeOf.call(null)` should return false, not throw TypeError
+ (issue 3483).
+
+ Refactor ObjectGetOwnPropertyKeys to accept bitmask rather than boolean
+ (issue 3549).
+
+ Add debug mirror support for ES6 Map/Set iterators (Chromium issue
+ 427868).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-11-04: Version 3.30.30
+
+ Performance and stability improvements on all platforms.
+
+
+2014-11-02: Version 3.30.27
+
+ Performance and stability improvements on all platforms.
+
+
+2014-11-02: Version 3.30.26
+
+ Performance and stability improvements on all platforms.
+
+
+2014-11-01: Version 3.30.25
+
+ Performance and stability improvements on all platforms.
+
+
+2014-11-01: Version 3.30.24
+
+ Ensure we don't try to inline raw access to indexed interceptor
+ receivers (Chromium issue 419220).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-31: Version 3.30.23
+
+ Introduce v8::Exception::GetMessage to find location of an error object
+ (Chromium issue 427954).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-30: Version 3.30.22
+
+ MIPS: Classes: Add super support in methods and accessors (issue 3330).
+
+ Classes: Add super support in methods and accessors (issue 3330).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-29: Version 3.30.21
+
+ MIPS: Classes: Add basic support for properties (issue 3330).
+
+ Classes: Add more tests for prototype edge cases (Chromium issue 3655).
+
+ Classes: Add test for method prototype (issue 3330).
+
+ Get stack trace for uncaught exceptions/promise rejections from the
+ simple stack when available.
+
+ Classes: Add basic support for properties (issue 3330).
+
+ Allow duplicate property names in classes (issue 3570).
+
+ Windows: use SystemTimeToTzSpecificLocalTime instead of localtime_s
+ (Chromium issue 417640).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-28: Version 3.30.20
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-27: Version 3.30.19
+
+ Check string literals with escapes in PreParserTraits::GetSymbol()
+ (issue 3606).
+
+ only define ARRAYSIZE_UNSAFE for NaCl builds (Chromium issue 405225).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-24: Version 3.30.18
+
+ Narrow cases where Sparse/Smart versions of Array methods are used
+ (issues 2615, 3612, 3621).
+
+ Shrink new space in idle notification (Chromium issue 424423).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-23: Version 3.30.17
+
+ ARM64: Fix stack manipulation (Chromium issue 425585).
+
+ Speed up creation of Objects whose prototype has dictionary elements
+ (Chromium issue 422754).
+
+ Enable libstdc++ debug mode in debug builds (issue 3638).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-22: Version 3.30.16
+
+ Remove v8stdint.h, it doesn't serve a purpose anymore.
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-21: Version 3.30.15
+
+ Avoid the Marsaglia effect in 3D (Chromium issue 423311).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-20: Version 3.30.14
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-17: Version 3.30.13
+
+ Don't expose Array.prototype.values as it breaks webcompat (Chromium
+ issue 409858).
+
+ Fix break location calculation (Chromium issue 419663).
+
+ Enable libstdc++ debug mode in debug builds (issue 3638).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-17: Version 3.30.12
+
+ Implement .forEach() on typed arrays (issue 3578).
+
+ Introduce v8::Exception::GetStackTrace API method.
+
+ Remove SmartMove, bringing Array methods further into spec compliance
+ (issue 2615).
+
+ Convert argument toObject() in Object.getOwnPropertyNames/Descriptors
+ (issue 3443).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-15: Version 3.30.11
+
+ Array.prototype.{every, filter, find, findIndex, forEach, map, some}:
+ Use fresh primitive wrapper for calls (issue 3536).
+
+ Correctly expand literal buffer for surrogate pairs (Chromium issue
+ 423212).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-15: Version 3.30.10
+
+ Squeeze the layout of various AST node types (Chromium issue 417697).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-14: Version 3.30.9
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-13: Version 3.30.8
+
+ AST nodes have at most one bailout/typefeedback ID now, saving lots of
+ memory (Chromium issue 417697).
+
+ Allow identifier code points from supplementary multilingual planes
+ (issue 3617).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-10: Version 3.30.7
+
+ Fix computation of UTC time from local time at DST change points (issue
+ 3116, Chromium issues 415424, 417640).
+
+ Convert `obj` ToObject in Object.keys() (issue 3587).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-09: Version 3.30.6
+
+ Update unicode to 7.0.0 (issue 2892).
+
+ Classes: Add support for toString (issue 3330).
+
+ Don't enable WPO on Win64 and require Server 2003 / x64 for win64
+ (Chromium issue 421363).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-08: Version 3.30.5
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-08: Version 3.30.4
+
+ This uses a runtime function to set up the the constructor and its
+ prototype (issue 3330).
+
+ Remove PersistentBase::ClearAndLeak.
+
+ Squeeze the layout of variable proxy nodes (Chromium issue 417697).
+
+ Add MonotonicallyIncreasingTime to V8 Platform (Chromium issue 417668).
+
+ Fix representation of HLoadRoot (Chromium issue 419036).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-03: Version 3.30.3
+
+ Removed the Isolate* field from literal nodes (Chromium issue 417697).
+
+ Squeeze the layout of expression nodes a bit (Chromium issue 417697).
+
+ Merged FeedbackSlotInterface into AstNode, removing the need for a 2nd
+ vtable (Chromium issue 417697).
+
+ Extend CPU profiler with mapping ticks to source lines.
+
+ Remove support for parallel sweeping.
+
+ Introduce v8::Object::GetIsolate().
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-02: Version 3.30.2
+
+ Fix Hydrogen's BuildStore() (Chromium issue 417508).
+
+ Move unit tests to test/unittests (issue 3489).
+
+ Changes to ALLOW_UNUSED to match upcoming changes to the Chromium trunk:
+ * Eliminate usage of ALLOW_UNUSED to define COMPILE_ASSERT and just use
+ static_assert() in all cases now that all platforms build with C++11. *
+ Convert remaining uses of ALLOW_UNUSED to ALLOW_UNUSED_TYPE to match how
+ Chromium will be splitting this functionality. (In Chromium we'll have
+ both ALLOW_UNUSED_TYPE and ALLOW_UNUSED_LOCAL, which have different
+ syntax to enable us to use these with MSVC.) (Chromium issue 81439).
+
+ Performance and stability improvements on all platforms.
+
+
+2014-10-01: Version 3.30.1
+
+ Introduce PromiseRejectCallback (issue 3093).
+
+ ES6: Implement object literal property shorthand (issue 3584).
+
+ Performance and stability improvements on all platforms.
+
+
2014-09-30: Version 3.29.93
Add a getter for the address and size of the code range to the pulic API
# asan=/path/to/clang++
ifneq ($(strip $(asan)),)
GYPFLAGS += -Dasan=1
+ export CC=$(dir $(asan))clang
export CXX=$(asan)
export CXX_host=$(asan)
export LINK=$(asan)
- export ASAN_SYMBOLIZER_PATH="$(dir $(asan))llvm-symbolizer"
+ export ASAN_SYMBOLIZER_PATH=$(dir $(asan))llvm-symbolizer
+ TESTFLAGS += --asan
+ ifeq ($(lsan), on)
+ GYPFLAGS += -Dlsan=1
+ endif
endif
# arm specific flags.
# List of files that trigger Makefile regeneration:
GYPFILES = build/all.gyp build/features.gypi build/standalone.gypi \
- build/toolchain.gypi samples/samples.gyp src/compiler/compiler.gyp \
- src/d8.gyp test/cctest/cctest.gyp tools/gyp/v8.gyp
+ build/toolchain.gypi samples/samples.gyp src/d8.gyp \
+ test/cctest/cctest.gyp test/unittests/unittests.gyp tools/gyp/v8.gyp
# If vtunejit=on, the v8vtune.gyp will be appended.
ifeq ($(vtunejit), on)
ENVFILE = $(OUTDIR)/environment
.PHONY: all check clean builddeps dependencies $(ENVFILE).new native \
- qc quickcheck $(QUICKCHECKS) \
+ qc quickcheck $(QUICKCHECKS) turbocheck \
$(addsuffix .quickcheck,$(MODES)) $(addsuffix .quickcheck,$(ARCHES)) \
$(ARCHES) $(MODES) $(BUILDS) $(CHECKS) $(addsuffix .clean,$(ARCHES)) \
$(addsuffix .check,$(MODES)) $(addsuffix .check,$(ARCHES)) \
--arch-and-mode=$(FASTTESTMODES) $(TESTFLAGS) --quickcheck
qc: quickcheck
+turbocheck: $(subst $(COMMA),$(SPACE),$(FASTCOMPILEMODES))
+ tools/run-tests.py $(TESTJOBS) --outdir=$(OUTDIR) \
+ --arch-and-mode=$(SUPERFASTTESTMODES) $(TESTFLAGS) \
+ --quickcheck --variants=turbofan --download-data mozilla webkit
+ tools/run-tests.py $(TESTJOBS) --outdir=$(OUTDIR) \
+ --arch-and-mode=$(FASTTESTMODES) $(TESTFLAGS) \
+ --quickcheck --variants=turbofan
+tc: turbocheck
+
# Clean targets. You can clean each architecture individually, or everything.
$(addsuffix .clean, $(ARCHES) $(ANDROID_ARCHES) $(NACL_ARCHES)):
rm -f $(OUTDIR)/Makefile.$(basename $@)*
$(addsuffix .$(mode),$(NACL_ARCHES)))
HOST_OS = $(shell uname -s | sed -e 's/Linux/linux/;s/Darwin/mac/')
-ifeq ($(HOST_OS), linux)
- TOOLCHAIN_DIR = linux_x86_glibc
-else
- ifeq ($(HOST_OS), mac)
- TOOLCHAIN_DIR = mac_x86_glibc
- else
- $(error Host platform "${HOST_OS}" is not supported)
- endif
-endif
-
TOOLCHAIN_PATH = $(realpath ${NACL_SDK_ROOT}/toolchain)
-NACL_TOOLCHAIN ?= ${TOOLCHAIN_PATH}/${TOOLCHAIN_DIR}
+NACL_TOOLCHAIN ?= ${TOOLCHAIN_PATH}/linux_pnacl
+
+ifeq ($(wildcard $(NACL_TOOLCHAIN)),)
+ $(error Cannot find Native Client toolchain in "${NACL_TOOLCHAIN}")
+endif
ifeq ($(ARCH), nacl_ia32)
GYPENV = nacl_target_arch=nacl_ia32 v8_target_arch=arm v8_host_arch=ia32
- TOOLCHAIN_ARCH = x86-4.4
- NACL_CC = "$(NACL_TOOLCHAIN)/bin/i686-nacl-gcc"
- NACL_CXX = "$(NACL_TOOLCHAIN)/bin/i686-nacl-g++"
- NACL_LINK = "$(NACL_TOOLCHAIN)/bin/i686-nacl-g++"
+ NACL_CC = "$(NACL_TOOLCHAIN)/bin/pnacl-clang"
+ NACL_CXX = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++"
+ NACL_LINK = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++ --pnacl-allow-native -arch x86-32"
else
ifeq ($(ARCH), nacl_x64)
GYPENV = nacl_target_arch=nacl_x64 v8_target_arch=arm v8_host_arch=ia32
- TOOLCHAIN_ARCH = x86-4.4
- NACL_CC = "$(NACL_TOOLCHAIN)/bin/x86_64-nacl-gcc"
- NACL_CXX = "$(NACL_TOOLCHAIN)/bin/x86_64-nacl-g++"
- NACL_LINK = "$(NACL_TOOLCHAIN)/bin/x86_64-nacl-g++"
+ NACL_CC = "$(NACL_TOOLCHAIN)/bin/pnacl-clang"
+ NACL_CXX = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++"
+ NACL_LINK = "$(NACL_TOOLCHAIN)/bin/pnacl-clang++ --pnacl-allow-native -arch x86-64"
else
$(error Target architecture "${ARCH}" is not supported)
endif
endif
-ifeq ($(wildcard $(NACL_TOOLCHAIN)),)
- $(error Cannot find Native Client toolchain in "${NACL_TOOLCHAIN}")
-endif
-
# For mksnapshot host generation.
GYPENV += host_os=${HOST_OS}
# For some reason the $$(basename $$@) expansion didn't work here...
$(NACL_BUILDS): $(NACL_MAKEFILES)
@$(MAKE) -C "$(OUTDIR)" -f Makefile.$@ \
+ CC=${NACL_CC} \
CXX=${NACL_CXX} \
+ AR="$(NACL_TOOLCHAIN)/bin/pnacl-ar" \
+ RANLIB="$(NACL_TOOLCHAIN)/bin/pnacl-ranlib" \
+ LD="$(NACL_TOOLCHAIN)/bin/pnacl-ld" \
LINK=${NACL_LINK} \
BUILDTYPE=$(shell echo $(subst .,,$(suffix $@)) | \
python -c "print raw_input().capitalize()") \
GYP_DEFINES="${GYPENV}" \
CC=${NACL_CC} \
CXX=${NACL_CXX} \
+ LINK=${NACL_LINK} \
PYTHONPATH="$(shell pwd)/tools/generate_shim_headers:$(shell pwd)/build:$(PYTHONPATH)" \
build/gyp/gyp --generator-output="${OUTDIR}" build/all.gyp \
-Ibuild/standalone.gypi --depth=. \
svenpanne@chromium.org
titzer@chromium.org
ulan@chromium.org
-vegorov@chromium.org
verwaest@chromium.org
vogelheim@chromium.org
yangguo@chromium.org
--- /dev/null
+V8 JavaScript Engine
+=============
+
+V8 is Google's open source JavaScript engine.
+
+V8 implements ECMAScript as specified in ECMA-262.
+
+V8 is written in C++ and is used in Google Chrome, the open source
+browser from Google.
+
+V8 can run standalone, or can be embedded into any C++ application.
+
+V8 Project page: https://code.google.com/p/v8/
+
+
+Getting the Code
+=============
+
+V8 Git repository: https://chromium.googlesource.com/v8/v8.git
+GitHub mirror: https://github.com/v8/v8-git-mirror
+
+For fetching all branches, add the following into your remote
+configuration in `.git/config`:
+
+ fetch = +refs/branch-heads/*:refs/remotes/branch-heads/*
+ fetch = +refs/tags/*:refs/tags/*
'type': 'none',
'dependencies': [
'../samples/samples.gyp:*',
- '../src/base/base.gyp:base-unittests',
- '../src/compiler/compiler.gyp:compiler-unittests',
'../src/d8.gyp:d8',
- '../src/heap/heap.gyp:heap-unittests',
- '../src/libplatform/libplatform.gyp:libplatform-unittests',
'../test/cctest/cctest.gyp:*',
+ '../test/unittests/unittests.gyp:*',
],
'conditions': [
['component!="shared_library"', {
'dependencies': [
- '../tools/lexer-shell.gyp:lexer-shell',
- '../tools/lexer-shell.gyp:parser-shell',
+ '../tools/parser-shell.gyp:parser-shell',
],
}],
]
'configurations': {
'DebugBaseCommon': {
'cflags': [ '-g', '-O0' ],
+ 'conditions': [
+ ['(v8_target_arch=="ia32" or v8_target_arch=="x87") and \
+ OS=="linux"', {
+ 'defines': [
+ '_GLIBCXX_DEBUG'
+ ],
+ }],
+ ],
},
'Optdebug': {
'inherit_from': [ 'DebugBaseCommon', 'DebugBase2' ],
},
'VCLibrarianTool': {
'AdditionalOptions': ['/ignore:4221'],
+ 'conditions': [
+ ['v8_target_arch=="x64"', {
+ 'TargetMachine': '17', # x64
+ }, {
+ 'TargetMachine': '1', # ia32
+ }],
+ ],
},
'VCLinkerTool': {
- 'MinimumRequiredVersion': '5.01', # XP.
'AdditionalDependencies': [
'ws2_32.lib',
],
'advapi32.lib',
],
}],
+ ['v8_target_arch=="x64"', {
+ 'MinimumRequiredVersion': '5.02', # Server 2003.
+ 'TargetMachine': '17', # x64
+ }, {
+ 'MinimumRequiredVersion': '5.01', # XP.
+ 'TargetMachine': '1', # ia32
+ }],
],
},
},
'cflags': ['-mfp32'],
}],
['mips_arch_variant=="r6"', {
- 'cflags!': ['-mfp32'],
+ 'cflags!': ['-mfp32', '-mfpxx'],
'cflags': ['-mips32r6', '-Wa,-mips32r6'],
'ldflags': [
'-mips32r6',
}],
['mips_arch_variant=="r2"', {
'cflags': ['-mips32r2', '-Wa,-mips32r2'],
+ 'ldflags': ['-mips32r2'],
}],
['mips_arch_variant=="r1"', {
- 'cflags!': ['-mfp64'],
+ 'cflags!': ['-mfp64', '-mfpxx'],
'cflags': ['-mips32', '-Wa,-mips32'],
+ 'ldflags': ['-mips32'],
}],
['mips_arch_variant=="rx"', {
- 'cflags!': ['-mfp64'],
- 'cflags': ['-mips32', '-Wa,-mips32'],
+ 'cflags!': ['-mfp64', '-mfp32'],
+ 'cflags': ['-mips32', '-Wa,-mips32', '-mfpxx'],
+ 'ldflags': ['-mips32'],
}],
],
}],
'cflags': ['-mfp32'],
}],
['mips_arch_variant=="r6"', {
- 'cflags!': ['-mfp32'],
+ 'cflags!': ['-mfp32', '-mfpxx'],
'cflags': ['-mips32r6', '-Wa,-mips32r6'],
'ldflags': [
'-mips32r6',
}],
['mips_arch_variant=="r2"', {
'cflags': ['-mips32r2', '-Wa,-mips32r2'],
+ 'ldflags': ['-mips32r2'],
}],
['mips_arch_variant=="r1"', {
- 'cflags!': ['-mfp64'],
+ 'cflags!': ['-mfp64', '-mfpxx'],
'cflags': ['-mips32', '-Wa,-mips32'],
+ 'ldflags': ['-mips32'],
}],
['mips_arch_variant=="rx"', {
- 'cflags!': ['-mfp64'],
- 'cflags': ['-mips32', '-Wa,-mips32'],
+ 'cflags!': ['-mfp64', '-mfp32'],
+ 'cflags': ['-mips32', '-Wa,-mips32', '-mfpxx'],
+ 'ldflags': ['-mips32'],
}],
['mips_arch_variant=="loongson"', {
- 'cflags!': ['-mfp64'],
+ 'cflags!': ['-mfp64', '-mfp32', '-mfpxx'],
'cflags': ['-mips3', '-Wa,-mips3'],
}],
],
['OS=="linux" or OS=="freebsd" or OS=="openbsd" or OS=="netbsd" or \
OS=="qnx"', {
'cflags!': [
- '-O0',
'-O3',
'-O2',
'-O1',
}, {
'RuntimeLibrary': '1', #/MTd
}],
- ['v8_target_arch=="x64"', {
- # TODO(2207): remove this option once the bug is fixed.
- 'WholeProgramOptimization': 'true',
- }],
],
},
'VCLinkerTool': {
}, {
'RuntimeLibrary': '0', #/MT
}],
- ['v8_target_arch=="x64"', {
- # TODO(2207): remove this option once the bug is fixed.
- 'WholeProgramOptimization': 'true',
- }],
],
},
'VCLinkerTool': {
* scheduling. The definition of "foreground" is opaque to V8.
*/
virtual void CallOnForegroundThread(Isolate* isolate, Task* task) = 0;
+
+ /**
+ * Monotonically increasing time in seconds from an arbitrary fixed point in
+ * the past. This function is expected to return at least
+ * millisecond-precision values. For this reason,
+ * it is recommended that the fixed point be no further in the past than
+ * the epoch.
+ **/
+ virtual double MonotonicallyIncreasingTime() = 0;
};
} // namespace v8
*/
class V8_EXPORT CpuProfileNode {
public:
+ struct LineTick {
+ /** The 1-based number of the source line where the function originates. */
+ int line;
+
+ /** The count of samples associated with the source line. */
+ unsigned int hit_count;
+ };
+
/** Returns function name (empty string for anonymous functions.) */
Handle<String> GetFunctionName() const;
*/
int GetColumnNumber() const;
+ /**
+ * Returns the number of the function's source lines that collect the samples.
+ */
+ unsigned int GetHitLineCount() const;
+
+ /** Returns the set of source lines that collect the samples.
+ * The caller allocates buffer and responsible for releasing it.
+ * True if all available entries are copied, otherwise false.
+ * The function copies nothing if buffer is not large enough.
+ */
+ bool GetLineTicks(LineTick* entries, unsigned int length) const;
+
/** Returns bailout reason for the function
* if the optimization was disabled for it.
*/
#ifndef V8_H_
#define V8_H_
-#include "v8stdint.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "v8config.h"
// We reserve the V8_* prefix for macros defined in V8 public API and
// assume there are no name conflicts with the embedder's code.
class ObjectTemplate;
class Platform;
class Primitive;
+class Promise;
class RawOperationDescriptor;
class Script;
class Signature;
P* parameter,
typename WeakCallbackData<S, P>::Callback callback);
+ // Phantom persistents work like weak persistents, except that the pointer to
+ // the object being collected is not available in the finalization callback.
+ // This enables the garbage collector to collect the object and any objects
+ // it references transitively in one GC cycle.
+ template <typename P>
+ V8_INLINE void SetPhantom(P* parameter,
+ typename WeakCallbackData<T, P>::Callback callback);
+
+ template <typename S, typename P>
+ V8_INLINE void SetPhantom(P* parameter,
+ typename WeakCallbackData<S, P>::Callback callback);
+
template<typename P>
V8_INLINE P* ClearWeak();
return Persistent<S>::Cast(*this);
}
- // This will be removed.
- V8_INLINE T* ClearAndLeak();
-
private:
friend class Isolate;
friend class Utils;
};
+// A StateTag represents a possible state of the VM.
+enum StateTag { JS, GC, COMPILER, OTHER, EXTERNAL, IDLE };
+
+
+// A RegisterState represents the current state of registers used
+// by the sampling profiler API.
+struct RegisterState {
+ RegisterState() : pc(NULL), sp(NULL), fp(NULL) {}
+ void* pc; // Instruction pointer.
+ void* sp; // Stack pointer.
+ void* fp; // Frame pointer.
+};
+
+
+// The output structure filled up by GetStackSample API function.
+struct SampleInfo {
+ size_t frames_count;
+ StateTag vm_state;
+};
+
+
/**
* A JSON Parser.
*/
bool IsSet() const;
/**
+ * Returns true if this value is a Map Iterator.
+ * This is an experimental feature.
+ */
+ bool IsMapIterator() const;
+
+ /**
+ * Returns true if this value is a Set Iterator.
+ * This is an experimental feature.
+ */
+ bool IsSetIterator() const;
+
+ /**
* Returns true if this value is a WeakMap.
* This is an experimental feature.
*/
*/
bool IsDataView() const;
- Local<Boolean> ToBoolean() const;
- Local<Number> ToNumber() const;
- Local<String> ToString() const;
- Local<String> ToDetailString() const;
- Local<Object> ToObject() const;
- Local<Integer> ToInteger() const;
- Local<Uint32> ToUint32() const;
- Local<Int32> ToInt32() const;
+ Local<Boolean> ToBoolean(Isolate* isolate) const;
+ Local<Number> ToNumber(Isolate* isolate) const;
+ Local<String> ToString(Isolate* isolate) const;
+ Local<String> ToDetailString(Isolate* isolate) const;
+ Local<Object> ToObject(Isolate* isolate) const;
+ Local<Integer> ToInteger(Isolate* isolate) const;
+ Local<Uint32> ToUint32(Isolate* isolate) const;
+ Local<Int32> ToInt32(Isolate* isolate) const;
+
+ // TODO(dcarney): deprecate all these.
+ inline Local<Boolean> ToBoolean() const;
+ inline Local<Number> ToNumber() const;
+ inline Local<String> ToString() const;
+ inline Local<String> ToDetailString() const;
+ inline Local<Object> ToObject() const;
+ inline Local<Integer> ToInteger() const;
+ inline Local<Uint32> ToUint32() const;
+ inline Local<Int32> ToInt32() const;
/**
* Attempts to convert a string to an array index.
enum Encoding {
UNKNOWN_ENCODING = 0x1,
TWO_BYTE_ENCODING = 0x0,
- ASCII_ENCODING = 0x4, // TODO(yangguo): deprecate this.
ONE_BYTE_ENCODING = 0x4
};
/**
NO_OPTIONS = 0,
HINT_MANY_WRITES_EXPECTED = 1,
NO_NULL_TERMINATION = 2,
- PRESERVE_ASCII_NULL = 4, // TODO(yangguo): deprecate this.
PRESERVE_ONE_BYTE_NULL = 4,
// Used by WriteUtf8 to replace orphan surrogate code units with the
// unicode replacement character. Needs to be set to guarantee valid UTF-8
*/
bool IsExternalOneByte() const;
- // TODO(yangguo): deprecate this.
- bool IsExternalAscii() const { return IsExternalOneByte(); }
-
class V8_EXPORT ExternalStringResourceBase { // NOLINT
public:
virtual ~ExternalStringResourceBase() {}
ExternalOneByteStringResource() {}
};
- typedef ExternalOneByteStringResource ExternalAsciiStringResource;
-
/**
* If the string is an external string, return the ExternalStringResourceBase
* regardless of the encoding, otherwise return NULL. The encoding of the
*/
const ExternalOneByteStringResource* GetExternalOneByteStringResource() const;
- // TODO(yangguo): deprecate this.
- const ExternalAsciiStringResource* GetExternalAsciiStringResource() const {
- return GetExternalOneByteStringResource();
- }
-
V8_INLINE static String* Cast(v8::Value* obj);
enum NewStringType {
// Well-known symbols
static Local<Symbol> GetIterator(Isolate* isolate);
static Local<Symbol> GetUnscopables(Isolate* isolate);
+ static Local<Symbol> GetToStringTag(Isolate* isolate);
V8_INLINE static Symbol* Cast(v8::Value* obj);
bool DeleteHiddenValue(Handle<String> key);
/**
- * Returns true if this is an instance of an api function (one
- * created from a function created from a function template) and has
- * been modified since it was created. Note that this method is
- * conservative and may return true for objects that haven't actually
- * been modified.
- */
- bool IsDirty();
-
- /**
* Clone this object with a fast but shallow copy. Values will point
* to the same values as the original object.
*/
*/
Local<Value> CallAsConstructor(int argc, Handle<Value> argv[]);
+ /**
+ * Return the isolate to which the Object belongs to.
+ */
+ Isolate* GetIsolate();
+
static Local<Object> New(Isolate* isolate);
V8_INLINE static Object* Cast(Value* obj);
Local<Promise> Catch(Handle<Function> handler);
Local<Promise> Then(Handle<Function> handler);
+ /**
+ * Returns true if the promise has at least one derived promise, and
+ * therefore resolve/reject handlers (including default handler).
+ */
+ bool HasHandler();
+
V8_INLINE static Promise* Cast(Value* obj);
private:
bool IsExternal() const;
/**
+ * Returns true if this ArrayBuffer may be neutered.
+ */
+ bool IsNeuterable() const;
+
+ /**
* Neuters this ArrayBuffer and all its views (typed arrays).
* Neutering sets the byte length of the buffer and all typed arrays to zero,
* preventing JavaScript from ever accessing underlying backing store.
- * ArrayBuffer should have been externalized.
+ * ArrayBuffer should have been externalized and must be neuterable.
*/
void Neuter();
static Local<Value> SyntaxError(Handle<String> message);
static Local<Value> TypeError(Handle<String> message);
static Local<Value> Error(Handle<String> message);
+
+ static Local<Message> GetMessage(Handle<Value> exception);
+
+ // DEPRECATED. Use GetMessage()->GetStackTrace()
+ static Local<StackTrace> GetStackTrace(Handle<Value> exception);
};
// --- Leave Script Callback ---
typedef void (*CallCompletedCallback)();
+// --- Promise Reject Callback ---
+enum PromiseRejectEvent {
+ kPromiseRejectWithNoHandler = 0,
+ kPromiseHandlerAddedAfterReject = 1
+};
+
+class PromiseRejectMessage {
+ public:
+ PromiseRejectMessage(Handle<Promise> promise, PromiseRejectEvent event,
+ Handle<Value> value, Handle<StackTrace> stack_trace)
+ : promise_(promise),
+ event_(event),
+ value_(value),
+ stack_trace_(stack_trace) {}
+
+ V8_INLINE Handle<Promise> GetPromise() const { return promise_; }
+ V8_INLINE PromiseRejectEvent GetEvent() const { return event_; }
+ V8_INLINE Handle<Value> GetValue() const { return value_; }
+
+ // DEPRECATED. Use v8::Exception::GetMessage(GetValue())->GetStackTrace()
+ V8_INLINE Handle<StackTrace> GetStackTrace() const { return stack_trace_; }
+
+ private:
+ Handle<Promise> promise_;
+ PromiseRejectEvent event_;
+ Handle<Value> value_;
+ Handle<StackTrace> stack_trace_;
+};
+
+typedef void (*PromiseRejectCallback)(PromiseRejectMessage message);
+
// --- Microtask Callback ---
typedef void (*MicrotaskCallback)(void* data);
/**
+ * Interface for iterating through all external resources in the heap.
+ */
+class V8_EXPORT ExternalResourceVisitor { // NOLINT
+ public:
+ virtual ~ExternalResourceVisitor() {}
+ virtual void VisitExternalString(Handle<String> string) {}
+};
+
+
+/**
+ * Interface for iterating through all the persistent handles in the heap.
+ */
+class V8_EXPORT PersistentHandleVisitor { // NOLINT
+ public:
+ virtual ~PersistentHandleVisitor() {}
+ virtual void VisitPersistentHandle(Persistent<Value>* value,
+ uint16_t class_id) {}
+};
+
+
+/**
* Isolate represents an isolated instance of the V8 engine. V8 isolates have
* completely separate states. Objects from one isolate must not be used in
* other isolates. The embedder can create multiple isolates and use them in
*/
enum UseCounterFeature {
kUseAsm = 0,
+ kBreakIterator = 1,
kUseCounterFeatureCount // This enum value must be last.
};
void GetHeapStatistics(HeapStatistics* heap_statistics);
/**
+ * Get a call stack sample from the isolate.
+ * \param state Execution state.
+ * \param frames Caller allocated buffer to store stack frames.
+ * \param frames_limit Maximum number of frames to capture. The buffer must
+ * be large enough to hold the number of frames.
+ * \param sample_info The sample info is filled up by the function
+ * provides number of actual captured stack frames and
+ * the current VM state.
+ * \note GetStackSample should only be called when the JS thread is paused or
+ * interrupted. Otherwise the behavior is undefined.
+ */
+ void GetStackSample(const RegisterState& state, void** frames,
+ size_t frames_limit, SampleInfo* sample_info);
+
+ /**
* Adjusts the amount of registered external memory. Used to give V8 an
* indication of the amount of externally allocated memory that is kept alive
* by JavaScript objects. V8 uses this to decide when to perform global
*/
void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
+
+ /**
+ * Forcefully terminate the current thread of JavaScript execution
+ * in the given isolate.
+ *
+ * This method can be used by any thread even if that thread has not
+ * acquired the V8 lock with a Locker object.
+ */
+ void TerminateExecution();
+
+ /**
+ * Is V8 terminating JavaScript execution.
+ *
+ * Returns true if JavaScript execution is currently terminating
+ * because of a call to TerminateExecution. In that case there are
+ * still JavaScript frames on the stack and the termination
+ * exception is still active.
+ */
+ bool IsExecutionTerminating();
+
+ /**
+ * Resume execution capability in the given isolate, whose execution
+ * was previously forcefully terminated using TerminateExecution().
+ *
+ * When execution is forcefully terminated using TerminateExecution(),
+ * the isolate can not resume execution until all JavaScript frames
+ * have propagated the uncatchable exception which is generated. This
+ * method allows the program embedding the engine to handle the
+ * termination event and resume execution capability, even if
+ * JavaScript frames remain on the stack.
+ *
+ * This method can be used by any thread even if that thread has not
+ * acquired the V8 lock with a Locker object.
+ */
+ void CancelTerminateExecution();
+
/**
* Request V8 to interrupt long running JavaScript code and invoke
* the given |callback| passing the given |data| to it. After |callback|
*/
void RemoveCallCompletedCallback(CallCompletedCallback callback);
+
+ /**
+ * Set callback to notify about promise reject with no handler, or
+ * revocation of such a previous notification once the handler is added.
+ */
+ void SetPromiseRejectCallback(PromiseRejectCallback callback);
+
/**
* Experimental: Runs the Microtask Work Queue until empty
* Any exceptions thrown by microtask callbacks are swallowed.
* On Win64, embedders are advised to install function table callbacks for
* these ranges, as default SEH won't be able to unwind through jitted code.
*
+ * The first page of the code range is reserved for the embedder and is
+ * committed, writable, and executable.
+ *
* Might be empty on other platforms.
*
* https://code.google.com/p/v8/issues/detail?id=3598
*/
void GetCodeRange(void** start, size_t* length_in_bytes);
+ /** Set the callback to invoke in case of fatal errors. */
+ void SetFatalErrorHandler(FatalErrorCallback that);
+
+ /**
+ * Set the callback to invoke to check if code generation from
+ * strings should be allowed.
+ */
+ void SetAllowCodeGenerationFromStringsCallback(
+ AllowCodeGenerationFromStringsCallback callback);
+
+ /**
+ * Check if V8 is dead and therefore unusable. This is the case after
+ * fatal errors such as out-of-memory situations.
+ */
+ bool IsDead();
+
+ /**
+ * Adds a message listener.
+ *
+ * The same message listener can be added more than once and in that
+ * case it will be called more than once for each message.
+ *
+ * If data is specified, it will be passed to the callback when it is called.
+ * Otherwise, the exception object will be passed to the callback instead.
+ */
+ bool AddMessageListener(MessageCallback that,
+ Handle<Value> data = Handle<Value>());
+
+ /**
+ * Remove all message listeners from the specified callback function.
+ */
+ void RemoveMessageListeners(MessageCallback that);
+
+ /** Callback function for reporting failed access checks.*/
+ void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
+
+ /**
+ * Tells V8 to capture current stack trace when uncaught exception occurs
+ * and report it to the message listeners. The option is off by default.
+ */
+ void SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit = 10,
+ StackTrace::StackTraceOptions options = StackTrace::kOverview);
+
+ /**
+ * Enables the host application to provide a mechanism to be notified
+ * and perform custom logging when V8 Allocates Executable Memory.
+ */
+ void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
+ ObjectSpace space, AllocationAction action);
+
+ /**
+ * Removes callback that was installed by AddMemoryAllocationCallback.
+ */
+ void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
+
+ /**
+ * Iterates through all external resources referenced from current isolate
+ * heap. GC is not invoked prior to iterating, therefore there is no
+ * guarantee that visited objects are still alive.
+ */
+ void VisitExternalResources(ExternalResourceVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in the current isolate's heap
+ * that have class_ids.
+ */
+ void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in the current isolate's heap
+ * that have class_ids and are candidates to be marked as partially dependent
+ * handles. This will visit handles to young objects created since the last
+ * garbage collection but is free to visit an arbitrary superset of these
+ * objects.
+ */
+ void VisitHandlesForPartialDependence(PersistentHandleVisitor* visitor);
+
private:
template<class K, class V, class Traits> friend class PersistentValueMap;
/**
- * Interface for iterating through all external resources in the heap.
- */
-class V8_EXPORT ExternalResourceVisitor { // NOLINT
- public:
- virtual ~ExternalResourceVisitor() {}
- virtual void VisitExternalString(Handle<String> string) {}
-};
-
-
-/**
- * Interface for iterating through all the persistent handles in the heap.
- */
-class V8_EXPORT PersistentHandleVisitor { // NOLINT
- public:
- virtual ~PersistentHandleVisitor() {}
- virtual void VisitPersistentHandle(Persistent<Value>* value,
- uint16_t class_id) {}
-};
-
-
-/**
* Container class for static utility functions.
*/
class V8_EXPORT V8 {
public:
/** Set the callback to invoke in case of fatal errors. */
- static void SetFatalErrorHandler(FatalErrorCallback that);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetFatalErrorHandler(FatalErrorCallback that);
/**
* Set the callback to invoke to check if code generation from
* strings should be allowed.
*/
- static void SetAllowCodeGenerationFromStringsCallback(
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetAllowCodeGenerationFromStringsCallback(
AllowCodeGenerationFromStringsCallback that);
/**
static void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator);
/**
- * Check if V8 is dead and therefore unusable. This is the case after
- * fatal errors such as out-of-memory situations.
- */
- static bool IsDead();
+ * Check if V8 is dead and therefore unusable. This is the case after
+ * fatal errors such as out-of-memory situations.
+ */
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool IsDead();
/**
* The following 4 functions are to be used when V8 is built with
* If data is specified, it will be passed to the callback when it is called.
* Otherwise, the exception object will be passed to the callback instead.
*/
- static bool AddMessageListener(MessageCallback that,
- Handle<Value> data = Handle<Value>());
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool AddMessageListener(
+ MessageCallback that, Handle<Value> data = Handle<Value>());
/**
* Remove all message listeners from the specified callback function.
*/
- static void RemoveMessageListeners(MessageCallback that);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveMessageListeners(MessageCallback that);
/**
* Tells V8 to capture current stack trace when uncaught exception occurs
* and report it to the message listeners. The option is off by default.
*/
- static void SetCaptureStackTraceForUncaughtExceptions(
- bool capture,
- int frame_limit = 10,
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit = 10,
StackTrace::StackTraceOptions options = StackTrace::kOverview);
/**
static const char* GetVersion();
/** Callback function for reporting failed access checks.*/
- static void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetFailedAccessCheckCallbackFunction(
+ FailedAccessCheckCallback);
/**
* Enables the host application to receive a notification before a
* register the same callback function two times with different
* GCType filters.
*/
+ // TODO(dcarney): deprecate this.
static void AddGCPrologueCallback(
GCPrologueCallback callback, GCType gc_type_filter = kGCTypeAll);
* This function removes callback which was installed by
* AddGCPrologueCallback function.
*/
- static void RemoveGCPrologueCallback(GCPrologueCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveGCPrologueCallback(GCPrologueCallback callback);
/**
* Enables the host application to receive a notification after a
* register the same callback function two times with different
* GCType filters.
*/
+ // TODO(dcarney): deprecate this.
static void AddGCEpilogueCallback(
GCEpilogueCallback callback, GCType gc_type_filter = kGCTypeAll);
* This function removes callback which was installed by
* AddGCEpilogueCallback function.
*/
- static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
/**
* Enables the host application to provide a mechanism to be notified
* and perform custom logging when V8 Allocates Executable Memory.
*/
- static void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
- ObjectSpace space,
- AllocationAction action);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void AddMemoryAllocationCallback(
+ MemoryAllocationCallback callback, ObjectSpace space,
+ AllocationAction action);
/**
* Removes callback that was installed by AddMemoryAllocationCallback.
*/
- static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveMemoryAllocationCallback(
+ MemoryAllocationCallback callback);
/**
* Initializes V8. This function needs to be called before the first Isolate
*
* \param isolate The isolate in which to terminate the current JS execution.
*/
- static void TerminateExecution(Isolate* isolate);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void TerminateExecution(Isolate* isolate);
/**
* Is V8 terminating JavaScript execution.
*
* \param isolate The isolate in which to check.
*/
- static bool IsExecutionTerminating(Isolate* isolate = NULL);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool IsExecutionTerminating(Isolate* isolate = NULL);
/**
* Resume execution capability in the given isolate, whose execution
*
* \param isolate The isolate in which to resume execution capability.
*/
- static void CancelTerminateExecution(Isolate* isolate);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void CancelTerminateExecution(Isolate* isolate);
/**
* Releases any resources used by v8 and stops any utility threads
* heap. GC is not invoked prior to iterating, therefore there is no
* guarantee that visited objects are still alive.
*/
- static void VisitExternalResources(ExternalResourceVisitor* visitor);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitExternalResources(
+ ExternalResourceVisitor* visitor);
/**
* Iterates through all the persistent handles in the current isolate's heap
* that have class_ids.
*/
- static void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesWithClassIds(
+ PersistentHandleVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in isolate's heap that have
+ * class_ids.
+ */
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesWithClassIds(
+ Isolate* isolate, PersistentHandleVisitor* visitor);
/**
* Iterates through all the persistent handles in the current isolate's heap
* garbage collection but is free to visit an arbitrary superset of these
* objects.
*/
- static void VisitHandlesForPartialDependence(
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesForPartialDependence(
Isolate* isolate, PersistentHandleVisitor* visitor);
/**
private:
V8();
+ enum WeakHandleType { PhantomHandle, NonphantomHandle };
+
static internal::Object** GlobalizeReference(internal::Isolate* isolate,
internal::Object** handle);
static internal::Object** CopyPersistent(internal::Object** handle);
static void DisposeGlobal(internal::Object** global_handle);
typedef WeakCallbackData<Value, void>::Callback WeakCallback;
- static void MakeWeak(internal::Object** global_handle,
- void* data,
- WeakCallback weak_callback);
+ static void MakeWeak(internal::Object** global_handle, void* data,
+ WeakCallback weak_callback, WeakHandleType phantom);
static void* ClearWeak(internal::Object** global_handle);
static void Eternalize(Isolate* isolate,
Value* handle,
* all TryCatch blocks should be stack allocated because the memory
* location itself is compared against JavaScript try/catch blocks.
*/
+ // TODO(dcarney): deprecate.
TryCatch();
/**
+ * Creates a new try/catch block and registers it with v8. Note that
+ * all TryCatch blocks should be stack allocated because the memory
+ * location itself is compared against JavaScript try/catch blocks.
+ */
+ TryCatch(Isolate* isolate);
+
+ /**
* Unregisters and deletes this try/catch block.
*/
~TryCatch();
bool top_level_;
internal::Isolate* isolate_;
- static bool active_;
-
// Disallow copying and assigning.
Locker(const Locker&);
void operator=(const Locker&);
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
static const int kContextHeaderSize = 2 * kApiPointerSize;
- static const int kContextEmbedderDataIndex = 95;
+ static const int kContextEmbedderDataIndex = 76;
static const int kFullStringRepresentationMask = 0x07;
static const int kStringEncodingMask = 0x4;
static const int kExternalTwoByteRepresentationTag = 0x02;
static const int kNullValueRootIndex = 7;
static const int kTrueValueRootIndex = 8;
static const int kFalseValueRootIndex = 9;
- static const int kEmptyStringRootIndex = 164;
+ static const int kEmptyStringRootIndex = 154;
// The external allocation limit should be below 256 MB on all architectures
// to avoid that resource-constrained embedders run low on memory.
static const int kNodeIsIndependentShift = 4;
static const int kNodeIsPartiallyDependentShift = 5;
- static const int kJSObjectType = 0xbc;
+ static const int kJSObjectType = 0xbd;
static const int kFirstNonstringType = 0x80;
static const int kOddballType = 0x83;
static const int kForeignType = 0x88;
typename WeakCallbackData<S, P>::Callback callback) {
TYPE_CHECK(S, T);
typedef typename WeakCallbackData<Value, void>::Callback Callback;
- V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_),
- parameter,
- reinterpret_cast<Callback>(callback));
+ V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_), parameter,
+ reinterpret_cast<Callback>(callback), V8::NonphantomHandle);
}
template <class T>
-template<typename P>
+template <typename S, typename P>
+void PersistentBase<T>::SetPhantom(
+ P* parameter, typename WeakCallbackData<S, P>::Callback callback) {
+ TYPE_CHECK(S, T);
+ typedef typename WeakCallbackData<Value, void>::Callback Callback;
+ V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_), parameter,
+ reinterpret_cast<Callback>(callback), V8::PhantomHandle);
+}
+
+
+template <class T>
+template <typename P>
+void PersistentBase<T>::SetPhantom(
+ P* parameter, typename WeakCallbackData<T, P>::Callback callback) {
+ SetPhantom<T, P>(parameter, callback);
+}
+
+
+template <class T>
+template <typename P>
P* PersistentBase<T>::ClearWeak() {
return reinterpret_cast<P*>(
V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_)));
}
-template <class T, class M>
-T* Persistent<T, M>::ClearAndLeak() {
- T* old;
- old = this->val_;
- this->val_ = NULL;
- return old;
-}
-
-
template <class T>
void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
typedef internal::Internals I;
}
+Local<Boolean> Value::ToBoolean() const {
+ return ToBoolean(Isolate::GetCurrent());
+}
+
+
+Local<Number> Value::ToNumber() const {
+ return ToNumber(Isolate::GetCurrent());
+}
+
+
+Local<String> Value::ToString() const {
+ return ToString(Isolate::GetCurrent());
+}
+
+
+Local<String> Value::ToDetailString() const {
+ return ToDetailString(Isolate::GetCurrent());
+}
+
+
+Local<Object> Value::ToObject() const {
+ return ToObject(Isolate::GetCurrent());
+}
+
+
+Local<Integer> Value::ToInteger() const {
+ return ToInteger(Isolate::GetCurrent());
+}
+
+
+Local<Uint32> Value::ToUint32() const {
+ return ToUint32(Isolate::GetCurrent());
+}
+
+
+Local<Int32> Value::ToInt32() const { return ToInt32(Isolate::GetCurrent()); }
+
+
Name* Name::Cast(v8::Value* value) {
#ifdef V8_ENABLE_CHECKS
CheckCast(value);
}
+void V8::SetAllowCodeGenerationFromStringsCallback(
+ AllowCodeGenerationFromStringsCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetAllowCodeGenerationFromStringsCallback(callback);
+}
+
+
+bool V8::IsDead() {
+ Isolate* isolate = Isolate::GetCurrent();
+ return isolate->IsDead();
+}
+
+
+bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) {
+ Isolate* isolate = Isolate::GetCurrent();
+ return isolate->AddMessageListener(that, data);
+}
+
+
+void V8::RemoveMessageListeners(MessageCallback that) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveMessageListeners(that);
+}
+
+
+void V8::SetFailedAccessCheckCallbackFunction(
+ FailedAccessCheckCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetFailedAccessCheckCallbackFunction(callback);
+}
+
+
+void V8::SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit, StackTrace::StackTraceOptions options) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
+ options);
+}
+
+
+void V8::SetFatalErrorHandler(FatalErrorCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetFatalErrorHandler(callback);
+}
+
+
+void V8::RemoveGCPrologueCallback(GCPrologueCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveGCPrologueCallback(
+ reinterpret_cast<v8::Isolate::GCPrologueCallback>(callback));
+}
+
+
+void V8::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveGCEpilogueCallback(
+ reinterpret_cast<v8::Isolate::GCEpilogueCallback>(callback));
+}
+
+
+void V8::AddMemoryAllocationCallback(MemoryAllocationCallback callback,
+ ObjectSpace space,
+ AllocationAction action) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->AddMemoryAllocationCallback(callback, space, action);
+}
+
+
+void V8::RemoveMemoryAllocationCallback(MemoryAllocationCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveMemoryAllocationCallback(callback);
+}
+
+
+void V8::TerminateExecution(Isolate* isolate) { isolate->TerminateExecution(); }
+
+
+bool V8::IsExecutionTerminating(Isolate* isolate) {
+ if (isolate == NULL) {
+ isolate = Isolate::GetCurrent();
+ }
+ return isolate->IsExecutionTerminating();
+}
+
+
+void V8::CancelTerminateExecution(Isolate* isolate) {
+ isolate->CancelTerminateExecution();
+}
+
+
+void V8::VisitExternalResources(ExternalResourceVisitor* visitor) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->VisitExternalResources(visitor);
+}
+
+
+void V8::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->VisitHandlesWithClassIds(visitor);
+}
+
+
+void V8::VisitHandlesWithClassIds(Isolate* isolate,
+ PersistentHandleVisitor* visitor) {
+ isolate->VisitHandlesWithClassIds(visitor);
+}
+
+
+void V8::VisitHandlesForPartialDependence(Isolate* isolate,
+ PersistentHandleVisitor* visitor) {
+ isolate->VisitHandlesForPartialDependence(visitor);
+}
+
/**
* \example shell.cc
* A simple shell that takes a list of expressions on the
// V8_LIBC_BIONIC - Bionic libc
// V8_LIBC_BSD - BSD libc derivate
// V8_LIBC_GLIBC - GNU C library
-// V8_LIBC_UCLIBC - uClibc
//
// Note that testing for libc must be done using #if not #ifdef. For example,
// to test for the GNU C library, use:
#elif defined(__BIONIC__)
# define V8_LIBC_BIONIC 1
# define V8_LIBC_BSD 1
-#elif defined(__UCLIBC__)
-# define V8_LIBC_UCLIBC 1
#elif defined(__GLIBC__) || defined(__GNU_LIBRARY__)
# define V8_LIBC_GLIBC 1
#else
// V8_HAS_BUILTIN_CLZ - __builtin_clz() supported
// V8_HAS_BUILTIN_CTZ - __builtin_ctz() supported
// V8_HAS_BUILTIN_EXPECT - __builtin_expect() supported
+// V8_HAS_BUILTIN_FRAME_ADDRESS - __builtin_frame_address() supported
// V8_HAS_BUILTIN_POPCOUNT - __builtin_popcount() supported
// V8_HAS_BUILTIN_SADD_OVERFLOW - __builtin_sadd_overflow() supported
// V8_HAS_BUILTIN_SSUB_OVERFLOW - __builtin_ssub_overflow() supported
// V8_HAS_DECLSPEC_NOINLINE - __declspec(noinline) supported
// V8_HAS___FINAL - __final supported in non-C++11 mode
// V8_HAS___FORCEINLINE - __forceinline supported
-// V8_HAS_SEALED - MSVC style sealed marker supported
//
// Note that testing for compilers and/or features must be done using #if
// not #ifdef. For example, to test for Intel C++ Compiler, use:
# define V8_HAS_BUILTIN_CLZ (__has_builtin(__builtin_clz))
# define V8_HAS_BUILTIN_CTZ (__has_builtin(__builtin_ctz))
# define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect))
+# define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address))
# define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount))
# define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow))
# define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow))
# define V8_HAS_BUILTIN_CLZ (V8_GNUC_PREREQ(3, 4, 0))
# define V8_HAS_BUILTIN_CTZ (V8_GNUC_PREREQ(3, 4, 0))
# define V8_HAS_BUILTIN_EXPECT (V8_GNUC_PREREQ(2, 96, 0))
+# define V8_HAS_BUILTIN_FRAME_ADDRESS (V8_GNUC_PREREQ(2, 96, 0))
# define V8_HAS_BUILTIN_POPCOUNT (V8_GNUC_PREREQ(3, 4, 0))
// g++ requires -std=c++0x or -std=gnu++0x to support C++11 functionality
# define V8_HAS___ALIGNOF 1
-// Override control was added with Visual Studio 2005, but
-// Visual Studio 2010 and earlier spell "final" as "sealed".
-# define V8_HAS_CXX11_FINAL (_MSC_VER >= 1700)
-# define V8_HAS_CXX11_OVERRIDE (_MSC_VER >= 1400)
-# define V8_HAS_SEALED (_MSC_VER >= 1400)
+# define V8_HAS_CXX11_FINAL 1
+# define V8_HAS_CXX11_OVERRIDE 1
# define V8_HAS_DECLSPEC_ALIGN 1
-# define V8_HAS_DECLSPEC_DEPRECATED (_MSC_VER >= 1300)
+# define V8_HAS_DECLSPEC_DEPRECATED 1
# define V8_HAS_DECLSPEC_NOINLINE 1
# define V8_HAS___FORCEINLINE 1
+++ /dev/null
-// Copyright 2012 the V8 project 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 definitions of standard types.
-
-#ifndef V8STDINT_H_
-#define V8STDINT_H_
-
-#include <stddef.h>
-#include <stdio.h>
-
-#include "v8config.h"
-
-#if V8_OS_WIN && !V8_CC_MINGW
-
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef short int16_t; // NOLINT
-typedef unsigned short uint16_t; // NOLINT
-typedef int int32_t;
-typedef unsigned int uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-// intptr_t and friends are defined in crtdefs.h through stdio.h.
-
-#else
-
-#include <stdint.h> // NOLINT
-
-#endif
-
-#endif // V8STDINT_H_
"-src/compiler",
"+src/compiler/pipeline.h",
"-src/libplatform",
- "-include/libplatform",
- "+testing",
+ "-include/libplatform"
]
specific_include_rules = {
}
-template <class C>
-static C* FindInstanceOf(Isolate* isolate, Object* obj) {
- for (PrototypeIterator iter(isolate, obj,
- PrototypeIterator::START_AT_RECEIVER);
- !iter.IsAtEnd(); iter.Advance()) {
- if (Is<C>(iter.GetCurrent())) return C::cast(iter.GetCurrent());
- }
- return NULL;
-}
-
-
static V8_INLINE bool CheckForName(Handle<Name> name,
Handle<String> property_name,
int offset,
LookupIterator it(object, Utils::OpenHandle(*name));
CHECK_EQ(LookupIterator::ACCESSOR, it.state());
DCHECK(it.HolderIsReceiverOrHiddenPrototype());
- Object::SetDataProperty(&it, value);
+
+ if (Object::SetDataProperty(&it, value).is_null()) {
+ isolate->OptionalRescheduleException(false);
+ }
}
if (uint32_v->Number() == number_v->Number()) {
maybe = JSArray::SetElementsLength(array_handle, uint32_v);
- maybe.Check();
+ if (maybe.is_null()) isolate->OptionalRescheduleException(false);
return;
}
}
-static Handle<Object> SetFunctionPrototype(Isolate* isolate,
- Handle<JSFunction> function,
- Handle<Object> value) {
+MUST_USE_RESULT static MaybeHandle<Object> SetFunctionPrototype(
+ Isolate* isolate, Handle<JSFunction> function, Handle<Object> value) {
Handle<Object> old_value;
bool is_observed = function->map()->is_observed();
if (is_observed) {
DCHECK(function->prototype() == *value);
if (is_observed && !old_value->SameValue(*value)) {
- JSObject::EnqueueChangeRecord(
+ MaybeHandle<Object> result = JSObject::EnqueueChangeRecord(
function, "update", isolate->factory()->prototype_string(), old_value);
+ if (result.is_null()) return MaybeHandle<Object>();
}
return function;
}
-Handle<Object> Accessors::FunctionGetPrototype(Handle<JSFunction> function) {
- return GetFunctionPrototype(function->GetIsolate(), function);
-}
-
-
-Handle<Object> Accessors::FunctionSetPrototype(Handle<JSFunction> function,
- Handle<Object> prototype) {
+MaybeHandle<Object> Accessors::FunctionSetPrototype(Handle<JSFunction> function,
+ Handle<Object> prototype) {
DCHECK(function->should_have_prototype());
Isolate* isolate = function->GetIsolate();
return SetFunctionPrototype(isolate, function, prototype);
}
Handle<JSFunction> object =
Handle<JSFunction>::cast(Utils::OpenHandle(*info.Holder()));
- SetFunctionPrototype(isolate, object, value);
+ if (SetFunctionPrototype(isolate, object, value).is_null()) {
+ isolate->OptionalRescheduleException(false);
+ }
}
};
// Accessor functions called directly from the runtime system.
- static Handle<Object> FunctionSetPrototype(Handle<JSFunction> object,
- Handle<Object> value);
- static Handle<Object> FunctionGetPrototype(Handle<JSFunction> object);
+ MUST_USE_RESULT static MaybeHandle<Object> FunctionSetPrototype(
+ Handle<JSFunction> object, Handle<Object> value);
static Handle<Object> FunctionGetArguments(Handle<JSFunction> object);
// Accessor infos.
void* AlignedAlloc(size_t size, size_t alignment) {
DCHECK_LE(V8_ALIGNOF(void*), alignment);
- DCHECK(base::bits::IsPowerOfTwo32(alignment));
+ DCHECK(base::bits::IsPowerOfTwo64(alignment));
void* ptr;
#if V8_OS_WIN
ptr = _aligned_malloc(size, alignment);
#include "src/prototype.h"
#include "src/runtime/runtime.h"
#include "src/runtime-profiler.h"
+#include "src/sampler.h"
#include "src/scanner-character-streams.h"
#include "src/simulator.h"
#include "src/snapshot.h"
#define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr))
-#define ENTER_V8(isolate) \
- DCHECK((isolate)->IsInitialized()); \
- i::VMState<i::OTHER> __state__((isolate))
+#define ENTER_V8(isolate) \
+ i::VMState<v8::OTHER> __state__((isolate))
namespace v8 {
}
-bool V8::IsDead() {
- i::Isolate* isolate = i::Isolate::Current();
- return isolate->IsDead();
-}
-
-
static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
- if (!isolate->IsInitialized()) return false;
if (isolate->has_scheduled_exception()) {
return isolate->scheduled_exception() ==
isolate->heap()->termination_exception();
}
-void V8::SetFatalErrorHandler(FatalErrorCallback that) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->set_exception_behavior(that);
-}
-
-
-void V8::SetAllowCodeGenerationFromStringsCallback(
- AllowCodeGenerationFromStringsCallback callback) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->set_allow_code_gen_callback(callback);
-}
-
-
void V8::SetFlagsFromString(const char* str, int length) {
i::FlagList::SetFlagsFromString(str, length);
}
}
-void V8::MakeWeak(i::Object** object,
- void* parameters,
- WeakCallback weak_callback) {
- i::GlobalHandles::MakeWeak(object, parameters, weak_callback);
+void V8::MakeWeak(i::Object** object, void* parameters,
+ WeakCallback weak_callback, V8::WeakHandleType weak_type) {
+ i::GlobalHandles::PhantomState phantom;
+ phantom = weak_type == V8::PhantomHandle ? i::GlobalHandles::Phantom
+ : i::GlobalHandles::Nonphantom;
+ i::GlobalHandles::MakeWeak(object, parameters, weak_callback, phantom);
}
// about this there is no HandleScope in this method. When you add one to the
// site calling this method you should check that you ensured the VM was not
// dead first.
-void NeanderArray::add(i::Handle<i::Object> value) {
+void NeanderArray::add(i::Isolate* isolate, i::Handle<i::Object> value) {
int length = this->length();
int size = obj_.size();
if (length == size - 1) {
- i::Factory* factory = i::Isolate::Current()->factory();
+ i::Factory* factory = isolate->factory();
i::Handle<i::FixedArray> new_elms = factory->NewFixedArray(2 * size);
for (int i = 0; i < length; i++)
new_elms->set(i + 1, get(i));
Utils::OpenHandle(templ)->set_property_list(*list);
}
NeanderArray array(list);
- array.add(isolate->factory()->NewNumberFromInt(length));
+ array.add(isolate, isolate->factory()->NewNumberFromInt(length));
for (int i = 0; i < length; i++) {
i::Handle<i::Object> value = data[i].IsEmpty() ?
i::Handle<i::Object>(isolate->factory()->undefined_value()) :
Utils::OpenHandle(*data[i]);
- array.add(value);
+ array.add(isolate, value);
}
}
void Template::Set(v8::Handle<Name> name,
v8::Handle<Data> value,
v8::PropertyAttribute attribute) {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
ENTER_V8(isolate);
i::HandleScope scope(isolate);
const int kSize = 3;
int TypeSwitch::match(v8::Handle<Value> value) {
- i::Isolate* isolate = i::Isolate::Current();
- LOG_API(isolate, "TypeSwitch::match");
- USE(isolate);
- i::Handle<i::Object> obj = Utils::OpenHandle(*value);
i::Handle<i::TypeSwitchInfo> info = Utils::OpenHandle(this);
+ LOG_API(info->GetIsolate(), "TypeSwitch::match");
+ i::Handle<i::Object> obj = Utils::OpenHandle(*value);
i::FixedArray* types = i::FixedArray::cast(info->types());
for (int i = 0; i < types->length(); i++) {
if (i::FunctionTemplateInfo::cast(types->get(i))->IsTemplateFor(*obj))
info->set_property_accessors(*list);
}
NeanderArray array(list);
- array.add(obj);
+ array.add(isolate, obj);
}
}
+v8::TryCatch::TryCatch(v8::Isolate* isolate)
+ : isolate_(reinterpret_cast<i::Isolate*>(isolate)),
+ next_(isolate_->try_catch_handler()),
+ is_verbose_(false),
+ can_continue_(true),
+ capture_message_(true),
+ rethrow_(false),
+ has_terminated_(false) {
+ ResetInternal();
+ // Special handling for simulators which have a separate JS stack.
+ js_stack_comparable_address_ =
+ reinterpret_cast<void*>(v8::internal::SimulatorStack::RegisterCTryCatch(
+ v8::internal::GetCurrentStackPosition()));
+ isolate_->RegisterTryCatchHandler(this);
+}
+
+
v8::TryCatch::~TryCatch() {
- DCHECK(isolate_ == i::Isolate::Current());
if (rethrow_) {
v8::Isolate* isolate = reinterpret_cast<Isolate*>(isolate_);
v8::HandleScope scope(isolate);
v8::Local<Value> v8::TryCatch::Exception() const {
- DCHECK(isolate_ == i::Isolate::Current());
if (HasCaught()) {
// Check for out of memory exception.
i::Object* exception = reinterpret_cast<i::Object*>(exception_);
v8::Local<Value> v8::TryCatch::StackTrace() const {
- DCHECK(isolate_ == i::Isolate::Current());
if (HasCaught()) {
i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
if (!raw_obj->IsJSObject()) return v8::Local<Value>();
v8::Local<v8::Message> v8::TryCatch::Message() const {
- DCHECK(isolate_ == i::Isolate::Current());
i::Object* message = reinterpret_cast<i::Object*>(message_obj_);
DCHECK(message->IsJSMessageObject() || message->IsTheHole());
if (HasCaught() && !message->IsTheHole()) {
void v8::TryCatch::Reset() {
- DCHECK(isolate_ == i::Isolate::Current());
if (!rethrow_ && HasCaught() && isolate_->has_scheduled_exception()) {
// If an exception was caught but is still scheduled because no API call
// promoted it, then it is canceled to prevent it from being propagated.
MUST_USE_RESULT static i::MaybeHandle<i::Object> CallV8HeapFunction(
- const char* name,
- i::Handle<i::Object> recv,
- int argc,
+ i::Isolate* isolate, const char* name, i::Handle<i::Object> recv, int argc,
i::Handle<i::Object> argv[]) {
- i::Isolate* isolate = i::Isolate::Current();
i::Handle<i::Object> object_fun =
i::Object::GetProperty(
isolate, isolate->js_builtins_object(), name).ToHandleChecked();
MUST_USE_RESULT static i::MaybeHandle<i::Object> CallV8HeapFunction(
- const char* name,
- i::Handle<i::Object> data) {
+ i::Isolate* isolate, const char* name, i::Handle<i::Object> data) {
i::Handle<i::Object> argv[] = { data };
- return CallV8HeapFunction(name,
- i::Isolate::Current()->js_builtins_object(),
- arraysize(argv),
- argv);
+ return CallV8HeapFunction(isolate, name, isolate->js_builtins_object(),
+ arraysize(argv), argv);
}
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> result;
- has_pending_exception = !CallV8HeapFunction(
- "GetLineNumber", Utils::OpenHandle(this)).ToHandle(&result);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "GetLineNumber", Utils::OpenHandle(this))
+ .ToHandle(&result);
EXCEPTION_BAILOUT_CHECK(isolate, 0);
return static_cast<int>(result->Number());
}
i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> start_col_obj;
- has_pending_exception = !CallV8HeapFunction(
- "GetPositionInLine", data_obj).ToHandle(&start_col_obj);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "GetPositionInLine", data_obj)
+ .ToHandle(&start_col_obj);
EXCEPTION_BAILOUT_CHECK(isolate, 0);
return static_cast<int>(start_col_obj->Number());
}
i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> start_col_obj;
- has_pending_exception = !CallV8HeapFunction(
- "GetPositionInLine", data_obj).ToHandle(&start_col_obj);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "GetPositionInLine", data_obj)
+ .ToHandle(&start_col_obj);
EXCEPTION_BAILOUT_CHECK(isolate, 0);
i::Handle<i::JSMessageObject> message =
i::Handle<i::JSMessageObject>::cast(data_obj);
EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> result;
- has_pending_exception = !CallV8HeapFunction(
- "GetSourceLine", Utils::OpenHandle(this)).ToHandle(&result);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "GetSourceLine", Utils::OpenHandle(this))
+ .ToHandle(&result);
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::String>());
if (result->IsString()) {
return scope.Escape(Utils::ToLocal(i::Handle<i::String>::cast(result)));
}
-Local<String> Value::ToString() const {
+bool Value::IsMapIterator() const {
+ return Utils::OpenHandle(this)->IsJSMapIterator();
+}
+
+
+bool Value::IsSetIterator() const {
+ return Utils::OpenHandle(this)->IsJSSetIterator();
+}
+
+
+Local<String> Value::ToString(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> str;
if (obj->IsString()) {
str = obj;
} else {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToString");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
}
-Local<String> Value::ToDetailString() const {
+Local<String> Value::ToDetailString(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> str;
if (obj->IsString()) {
str = obj;
} else {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToDetailString");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
}
-Local<v8::Object> Value::ToObject() const {
+Local<v8::Object> Value::ToObject(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> val;
if (obj->IsJSObject()) {
val = obj;
} else {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToObject");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
}
-Local<Boolean> Value::ToBoolean() const {
+Local<Boolean> Value::ToBoolean(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
if (obj->IsBoolean()) {
return ToApiHandle<Boolean>(obj);
} else {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToBoolean");
ENTER_V8(isolate);
i::Handle<i::Object> val =
}
-Local<Number> Value::ToNumber() const {
+Local<Number> Value::ToNumber(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> num;
if (obj->IsNumber()) {
num = obj;
} else {
- i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToNumber");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
}
-Local<Integer> Value::ToInteger() const {
+Local<Integer> Value::ToInteger(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> num;
if (obj->IsSmi()) {
num = obj;
} else {
- i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToInteger");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
void i::Internals::CheckInitializedImpl(v8::Isolate* external_isolate) {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
Utils::ApiCheck(isolate != NULL &&
- isolate->IsInitialized() &&
!isolate->IsDead(),
"v8::internal::Internals::CheckInitialized()",
"Isolate is not initialized or V8 has died");
}
-Local<Int32> Value::ToInt32() const {
+Local<Int32> Value::ToInt32(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> num;
if (obj->IsSmi()) {
num = obj;
} else {
- i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToInt32");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
}
-Local<Uint32> Value::ToUint32() const {
+Local<Uint32> Value::ToUint32(Isolate* v8_isolate) const {
i::Handle<i::Object> obj = Utils::OpenHandle(this);
i::Handle<i::Object> num;
if (obj->IsSmi()) {
num = obj;
} else {
- i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
LOG_API(isolate, "ToUInt32");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> args[] = { other };
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> result;
- has_pending_exception = !CallV8HeapFunction(
- "EQUALS", obj, arraysize(args), args).ToHandle(&result);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "EQUALS", obj, arraysize(args), args)
+ .ToHandle(&result);
EXCEPTION_BAILOUT_CHECK(isolate, false);
return *result == i::Smi::FromInt(i::EQUAL);
}
}
+i::MaybeHandle<i::Object> DeleteObjectProperty(
+ i::Isolate* isolate, i::Handle<i::JSReceiver> receiver,
+ i::Handle<i::Object> key, i::JSReceiver::DeleteMode mode) {
+ // Check if the given key is an array index.
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ // In Firefox/SpiderMonkey, Safari and Opera you can access the
+ // characters of a string using [] notation. In the case of a
+ // String object we just need to redirect the deletion to the
+ // underlying string if the index is in range. Since the
+ // underlying string does nothing with the deletion, we can ignore
+ // such deletions.
+ if (receiver->IsStringObjectWithCharacterAt(index)) {
+ return isolate->factory()->true_value();
+ }
+
+ return i::JSReceiver::DeleteElement(receiver, index, mode);
+ }
+
+ i::Handle<i::Name> name;
+ if (key->IsName()) {
+ name = i::Handle<i::Name>::cast(key);
+ } else {
+ // Call-back into JavaScript to convert the key to a string.
+ i::Handle<i::Object> converted;
+ if (!i::Execution::ToString(isolate, key).ToHandle(&converted)) {
+ return i::MaybeHandle<i::Object>();
+ }
+ name = i::Handle<i::String>::cast(converted);
+ }
+
+ if (name->IsString()) {
+ name = i::String::Flatten(i::Handle<i::String>::cast(name));
+ }
+ return i::JSReceiver::DeleteProperty(receiver, name, mode);
+}
+
+
bool v8::Object::ForceDelete(v8::Handle<Value> key) {
i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
ON_BAILOUT(isolate, "v8::Object::ForceDelete()", return false);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
- has_pending_exception = !i::Runtime::DeleteObjectProperty(
- isolate, self, key_obj, i::JSReceiver::FORCE_DELETION).ToHandle(&obj);
+ has_pending_exception =
+ !DeleteObjectProperty(isolate, self, key_obj,
+ i::JSReceiver::FORCE_DELETION).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, false);
return obj->IsTrue();
}
i::Handle<i::Object> args[] = { obj, key_name };
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> result;
- has_pending_exception = !CallV8HeapFunction(
- "ObjectGetOwnPropertyDescriptor",
- isolate->factory()->undefined_value(),
- arraysize(args),
- args).ToHandle(&result);
+ has_pending_exception =
+ !CallV8HeapFunction(isolate, "ObjectGetOwnPropertyDescriptor",
+ isolate->factory()->undefined_value(),
+ arraysize(args), args).ToHandle(&result);
EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>());
return Utils::ToLocal(result);
}
}
+static bool GetPredefinedToString(i::Handle<i::String> tag,
+ Local<String>* result) {
+ i::Isolate* i_isolate = tag->GetIsolate();
+ Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
+ i::Factory* factory = i_isolate->factory();
+
+ if (i::String::Equals(tag, factory->Arguments_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Arguments]");
+ } else if (i::String::Equals(tag, factory->Array_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Array]");
+ } else if (i::String::Equals(tag, factory->Boolean_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Boolean]");
+ } else if (i::String::Equals(tag, factory->Date_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Date]");
+ } else if (i::String::Equals(tag, factory->Error_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Error]");
+ } else if (i::String::Equals(tag, factory->Function_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Function]");
+ } else if (i::String::Equals(tag, factory->Number_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~Number]");
+ } else if (i::String::Equals(tag, factory->RegExp_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~RegExp]");
+ } else if (i::String::Equals(tag, factory->String_string())) {
+ *result = v8::String::NewFromUtf8(isolate, "[object ~String]");
+ } else {
+ return false;
+ }
+ return true;
+}
+
+
Local<String> v8::Object::ObjectProtoToString() {
i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
i::Handle<i::JSObject> self = Utils::OpenHandle(this);
i::Handle<i::Object> name(self->class_name(), i_isolate);
+ i::Handle<i::Object> tag;
// Native implementation of Object.prototype.toString (v8natives.js):
// var c = %_ClassOf(this);
i_isolate->factory()->Arguments_string())) {
return v8::String::NewFromUtf8(isolate, "[object Object]");
} else {
+ if (internal::FLAG_harmony_tostring) {
+ i::Handle<i::Symbol> toStringTag =
+ Utils::OpenHandle(*Symbol::GetToStringTag(isolate));
+ EXCEPTION_PREAMBLE(i_isolate);
+ has_pending_exception =
+ !i::Runtime::GetObjectProperty(i_isolate, self, toStringTag)
+ .ToHandle(&tag);
+ EXCEPTION_BAILOUT_CHECK(i_isolate, Local<v8::String>());
+
+ if (!tag->IsUndefined()) {
+ if (!tag->IsString())
+ return v8::String::NewFromUtf8(isolate, "[object ???]");
+ i::Handle<i::String> tag_name = i::Handle<i::String>::cast(tag);
+ if (!i::String::Equals(class_name, tag_name)) {
+ Local<String> result;
+ if (GetPredefinedToString(tag_name, &result)) return result;
+
+ class_name = tag_name;
+ }
+ }
+ }
const char* prefix = "[object ";
Local<String> str = Utils::ToLocal(class_name);
const char* postfix = "]";
i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
- has_pending_exception = !i::Runtime::DeleteObjectProperty(
- isolate, self, key_obj, i::JSReceiver::NORMAL_DELETION).ToHandle(&obj);
+ has_pending_exception =
+ !DeleteObjectProperty(isolate, self, key_obj,
+ i::JSReceiver::NORMAL_DELETION).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, false);
return obj->IsTrue();
}
i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
EXCEPTION_PREAMBLE(isolate);
- i::Handle<i::Object> obj;
- has_pending_exception = !i::Runtime::HasObjectProperty(
- isolate, self, key_obj).ToHandle(&obj);
+ Maybe<bool> maybe;
+ // Check if the given key is an array index.
+ uint32_t index;
+ if (key_obj->ToArrayIndex(&index)) {
+ maybe = i::JSReceiver::HasElement(self, index);
+ } else {
+ // Convert the key to a name - possibly by calling back into JavaScript.
+ i::Handle<i::Name> name;
+ if (i::Runtime::ToName(isolate, key_obj).ToHandle(&name)) {
+ maybe = i::JSReceiver::HasProperty(self, name);
+ }
+ }
+ if (!maybe.has_value) has_pending_exception = true;
EXCEPTION_BAILOUT_CHECK(isolate, false);
- return obj->IsTrue();
+ DCHECK(maybe.has_value);
+ return maybe.value;
}
}
-bool v8::Object::IsDirty() {
- return Utils::OpenHandle(this)->IsDirty();
-}
-
-
Local<v8::Object> v8::Object::Clone() {
i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
ON_BAILOUT(isolate, "v8::Object::Clone()", return Local<Object>());
heap_size_limit_(0) { }
-void v8::V8::VisitExternalResources(ExternalResourceVisitor* visitor) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->heap()->VisitExternalResources(visitor);
-}
-
-
-class VisitorAdapter : public i::ObjectVisitor {
- public:
- explicit VisitorAdapter(PersistentHandleVisitor* visitor)
- : visitor_(visitor) {}
- virtual void VisitPointers(i::Object** start, i::Object** end) {
- UNREACHABLE();
- }
- virtual void VisitEmbedderReference(i::Object** p, uint16_t class_id) {
- Value* value = ToApi<Value>(i::Handle<i::Object>(p));
- visitor_->VisitPersistentHandle(
- reinterpret_cast<Persistent<Value>*>(&value), class_id);
- }
- private:
- PersistentHandleVisitor* visitor_;
-};
-
-
-void v8::V8::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
- i::Isolate* isolate = i::Isolate::Current();
- i::DisallowHeapAllocation no_allocation;
-
- VisitorAdapter visitor_adapter(visitor);
- isolate->global_handles()->IterateAllRootsWithClassIds(&visitor_adapter);
-}
-
-
-void v8::V8::VisitHandlesForPartialDependence(
- Isolate* exported_isolate, PersistentHandleVisitor* visitor) {
- i::Isolate* isolate = reinterpret_cast<i::Isolate*>(exported_isolate);
- DCHECK(isolate == i::Isolate::Current());
- i::DisallowHeapAllocation no_allocation;
-
- VisitorAdapter visitor_adapter(visitor);
- isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds(
- &visitor_adapter);
-}
-
-
bool v8::V8::InitializeICU(const char* icu_data_file) {
return i::InitializeICU(icu_data_file);
}
void v8::Context::SetSecurityToken(Handle<Value> token) {
- i::Isolate* isolate = i::Isolate::Current();
- ENTER_V8(isolate);
i::Handle<i::Context> env = Utils::OpenHandle(this);
+ i::Isolate* isolate = env->GetIsolate();
+ ENTER_V8(isolate);
i::Handle<i::Object> token_handle = Utils::OpenHandle(*token);
env->set_security_token(*token_handle);
}
void v8::Context::UseDefaultSecurityToken() {
- i::Isolate* isolate = i::Isolate::Current();
- ENTER_V8(isolate);
i::Handle<i::Context> env = Utils::OpenHandle(this);
+ i::Isolate* isolate = env->GetIsolate();
+ ENTER_V8(isolate);
env->set_security_token(env->global_object());
}
Handle<Value> v8::Context::GetSecurityToken() {
- i::Isolate* isolate = i::Isolate::Current();
i::Handle<i::Context> env = Utils::OpenHandle(this);
+ i::Isolate* isolate = env->GetIsolate();
i::Object* security_token = env->security_token();
i::Handle<i::Object> token_handle(security_token, isolate);
return Utils::ToLocal(token_handle);
Local<v8::Object> ObjectTemplate::NewInstance() {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Handle<i::ObjectTemplateInfo> info = Utils::OpenHandle(this);
+ i::Isolate* isolate = info->GetIsolate();
ON_BAILOUT(isolate, "v8::ObjectTemplate::NewInstance()",
return Local<v8::Object>());
LOG_API(isolate, "ObjectTemplate::NewInstance");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
- has_pending_exception = !i::Execution::InstantiateObject(
- Utils::OpenHandle(this)).ToHandle(&obj);
+ has_pending_exception = !i::Execution::InstantiateObject(info).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>());
return Utils::ToLocal(i::Handle<i::JSObject>::cast(obj));
}
Local<v8::Function> FunctionTemplate::GetFunction() {
- i::Isolate* isolate = i::Isolate::Current();
+ i::Handle<i::FunctionTemplateInfo> info = Utils::OpenHandle(this);
+ i::Isolate* isolate = info->GetIsolate();
ON_BAILOUT(isolate, "v8::FunctionTemplate::GetFunction()",
return Local<v8::Function>());
LOG_API(isolate, "FunctionTemplate::GetFunction");
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
- has_pending_exception = !i::Execution::InstantiateFunction(
- Utils::OpenHandle(this)).ToHandle(&obj);
+ has_pending_exception =
+ !i::Execution::InstantiateFunction(info).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Function>());
return Utils::ToLocal(i::Handle<i::JSFunction>::cast(obj));
}
bool FunctionTemplate::HasInstance(v8::Handle<v8::Value> value) {
- ON_BAILOUT(i::Isolate::Current(), "v8::FunctionTemplate::HasInstanceOf()",
- return false);
+ i::Handle<i::FunctionTemplateInfo> info = Utils::OpenHandle(this);
+ i::Isolate* isolate = info->GetIsolate();
+ ON_BAILOUT(isolate, "v8::FunctionTemplate::HasInstanceOf()", return false);
i::Object* obj = *Utils::OpenHandle(*value);
- return Utils::OpenHandle(this)->IsTemplateFor(obj);
+ return info->IsTemplateFor(obj);
}
}
+Isolate* v8::Object::GetIsolate() {
+ i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
+ return reinterpret_cast<Isolate*>(i_isolate);
+}
+
+
Local<v8::Object> v8::Object::New(Isolate* isolate) {
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
LOG_API(i_isolate, "Object::New");
void v8::Date::DateTimeConfigurationChangeNotification(Isolate* isolate) {
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
- if (!i_isolate->IsInitialized()) return;
ON_BAILOUT(i_isolate, "v8::Date::DateTimeConfigurationChangeNotification()",
return);
LOG_API(i_isolate, "Date::DateTimeConfigurationChangeNotification");
}
+bool Promise::HasHandler() {
+ i::Handle<i::JSObject> promise = Utils::OpenHandle(this);
+ i::Isolate* isolate = promise->GetIsolate();
+ LOG_API(isolate, "Promise::HasRejectHandler");
+ ENTER_V8(isolate);
+ i::Handle<i::Symbol> key = isolate->factory()->promise_has_handler_symbol();
+ return i::JSObject::GetDataProperty(promise, key)->IsTrue();
+}
+
+
bool v8::ArrayBuffer::IsExternal() const {
return Utils::OpenHandle(this)->is_external();
}
+bool v8::ArrayBuffer::IsNeuterable() const {
+ return Utils::OpenHandle(this)->is_neuterable();
+}
+
+
v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() {
i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
Utils::ApiCheck(!obj->is_external(),
Utils::ApiCheck(obj->is_external(),
"v8::ArrayBuffer::Neuter",
"Only externalized ArrayBuffers can be neutered");
+ Utils::ApiCheck(obj->is_neuterable(), "v8::ArrayBuffer::Neuter",
+ "Only neuterable ArrayBuffers can be neutered");
LOG_API(obj->GetIsolate(), "v8::ArrayBuffer::Neuter()");
ENTER_V8(isolate);
i::Runtime::NeuterArrayBuffer(obj);
}
-static inline void SetupArrayBufferView(
- i::Isolate* isolate,
- i::Handle<i::JSArrayBufferView> obj,
- i::Handle<i::JSArrayBuffer> buffer,
- size_t byte_offset,
- size_t byte_length) {
- DCHECK(byte_offset + byte_length <=
- static_cast<size_t>(buffer->byte_length()->Number()));
-
- obj->set_buffer(*buffer);
-
- obj->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*obj);
-
- i::Handle<i::Object> byte_offset_object =
- isolate->factory()->NewNumberFromSize(byte_offset);
- obj->set_byte_offset(*byte_offset_object);
-
- i::Handle<i::Object> byte_length_object =
- isolate->factory()->NewNumberFromSize(byte_length);
- obj->set_byte_length(*byte_length_object);
-}
-
-template<typename ElementType,
- ExternalArrayType array_type,
- i::ElementsKind elements_kind>
-i::Handle<i::JSTypedArray> NewTypedArray(
- i::Isolate* isolate,
- Handle<ArrayBuffer> array_buffer, size_t byte_offset, size_t length) {
- i::Handle<i::JSTypedArray> obj =
- isolate->factory()->NewJSTypedArray(array_type);
- i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);
-
- DCHECK(byte_offset % sizeof(ElementType) == 0);
-
- CHECK(length <= (std::numeric_limits<size_t>::max() / sizeof(ElementType)));
- CHECK(length <= static_cast<size_t>(i::Smi::kMaxValue));
- size_t byte_length = length * sizeof(ElementType);
- SetupArrayBufferView(
- isolate, obj, buffer, byte_offset, byte_length);
-
- i::Handle<i::Object> length_object =
- isolate->factory()->NewNumberFromSize(length);
- obj->set_length(*length_object);
-
- i::Handle<i::ExternalArray> elements =
- isolate->factory()->NewExternalArray(
- static_cast<int>(length), array_type,
- static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
- i::Handle<i::Map> map =
- i::JSObject::GetElementsTransitionMap(obj, elements_kind);
- i::JSObject::SetMapAndElements(obj, map, elements);
- return obj;
-}
-
-
#define TYPED_ARRAY_NEW(Type, type, TYPE, ctype, size) \
Local<Type##Array> Type##Array::New(Handle<ArrayBuffer> array_buffer, \
- size_t byte_offset, size_t length) { \
+ size_t byte_offset, size_t length) { \
i::Isolate* isolate = Utils::OpenHandle(*array_buffer)->GetIsolate(); \
LOG_API(isolate, \
- "v8::" #Type "Array::New(Handle<ArrayBuffer>, size_t, size_t)"); \
+ "v8::" #Type "Array::New(Handle<ArrayBuffer>, size_t, size_t)"); \
ENTER_V8(isolate); \
if (!Utils::ApiCheck(length <= static_cast<size_t>(i::Smi::kMaxValue), \
- "v8::" #Type "Array::New(Handle<ArrayBuffer>, size_t, size_t)", \
- "length exceeds max allowed value")) { \
- return Local<Type##Array>(); \
+ "v8::" #Type \
+ "Array::New(Handle<ArrayBuffer>, size_t, size_t)", \
+ "length exceeds max allowed value")) { \
+ return Local<Type##Array>(); \
} \
- i::Handle<i::JSTypedArray> obj = \
- NewTypedArray<ctype, v8::kExternal##Type##Array, \
- i::EXTERNAL_##TYPE##_ELEMENTS>( \
- isolate, array_buffer, byte_offset, length); \
+ i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer); \
+ i::Handle<i::JSTypedArray> obj = isolate->factory()->NewJSTypedArray( \
+ v8::kExternal##Type##Array, buffer, byte_offset, length); \
return Utils::ToLocal##Type##Array(obj); \
}
i::Isolate* isolate = buffer->GetIsolate();
LOG_API(isolate, "v8::DataView::New(void*, size_t, size_t)");
ENTER_V8(isolate);
- i::Handle<i::JSDataView> obj = isolate->factory()->NewJSDataView();
- SetupArrayBufferView(
- isolate, obj, buffer, byte_offset, byte_length);
+ i::Handle<i::JSDataView> obj =
+ isolate->factory()->NewJSDataView(buffer, byte_offset, byte_length);
return Utils::ToLocal(obj);
}
}
+Local<Symbol> v8::Symbol::GetToStringTag(Isolate* isolate) {
+ return GetWellKnownSymbol(isolate, "Symbol.toStringTag");
+}
+
+
Local<Private> v8::Private::New(Isolate* isolate, Local<String> name) {
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
LOG_API(i_isolate, "Private::New()");
Local<Number> v8::Number::New(Isolate* isolate, double value) {
i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
- DCHECK(internal_isolate->IsInitialized());
if (std::isnan(value)) {
// Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
value = base::OS::nan_value();
Local<Integer> v8::Integer::New(Isolate* isolate, int32_t value) {
i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
- DCHECK(internal_isolate->IsInitialized());
if (i::Smi::IsValid(value)) {
return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value),
internal_isolate));
Local<Integer> v8::Integer::NewFromUnsigned(Isolate* isolate, uint32_t value) {
i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
- DCHECK(internal_isolate->IsInitialized());
bool fits_into_int32_t = (value & (1 << 31)) == 0;
if (fits_into_int32_t) {
return Integer::New(isolate, static_cast<int32_t>(value));
}
-bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) {
- i::Isolate* isolate = i::Isolate::Current();
- ON_BAILOUT(isolate, "v8::V8::AddMessageListener()", return false);
- ENTER_V8(isolate);
- i::HandleScope scope(isolate);
- NeanderArray listeners(isolate->factory()->message_listeners());
- NeanderObject obj(isolate, 2);
- obj.set(0, *isolate->factory()->NewForeign(FUNCTION_ADDR(that)));
- obj.set(1, data.IsEmpty() ? isolate->heap()->undefined_value()
- : *Utils::OpenHandle(*data));
- listeners.add(obj.value());
- return true;
-}
-
-
-void V8::RemoveMessageListeners(MessageCallback that) {
- i::Isolate* isolate = i::Isolate::Current();
- ON_BAILOUT(isolate, "v8::V8::RemoveMessageListeners()", return);
- ENTER_V8(isolate);
- i::HandleScope scope(isolate);
- NeanderArray listeners(isolate->factory()->message_listeners());
- for (int i = 0; i < listeners.length(); i++) {
- if (listeners.get(i)->IsUndefined()) continue; // skip deleted ones
-
- NeanderObject listener(i::JSObject::cast(listeners.get(i)));
- i::Handle<i::Foreign> callback_obj(i::Foreign::cast(listener.get(0)));
- if (callback_obj->foreign_address() == FUNCTION_ADDR(that)) {
- listeners.set(i, isolate->heap()->undefined_value());
- }
- }
-}
-
-
-void V8::SetCaptureStackTraceForUncaughtExceptions(
- bool capture,
- int frame_limit,
- StackTrace::StackTraceOptions options) {
- i::Isolate::Current()->SetCaptureStackTraceForUncaughtExceptions(
- capture,
- frame_limit,
- options);
-}
-
-
-void V8::SetFailedAccessCheckCallbackFunction(
- FailedAccessCheckCallback callback) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->SetFailedAccessCheckCallback(callback);
-}
-
-
void Isolate::CollectAllGarbage(const char* gc_reason) {
reinterpret_cast<i::Isolate*>(this)->heap()->CollectAllGarbage(
i::Heap::kNoGCFlags, gc_reason);
}
-void V8::RemoveGCPrologueCallback(GCPrologueCallback callback) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->heap()->RemoveGCPrologueCallback(
- reinterpret_cast<v8::Isolate::GCPrologueCallback>(callback));
-}
-
-
void V8::AddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type) {
i::Isolate* isolate = i::Isolate::Current();
isolate->heap()->AddGCEpilogueCallback(
}
-void V8::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
- i::Isolate* isolate = i::Isolate::Current();
- isolate->heap()->RemoveGCEpilogueCallback(
- reinterpret_cast<v8::Isolate::GCEpilogueCallback>(callback));
-}
-
-
-void V8::AddMemoryAllocationCallback(MemoryAllocationCallback callback,
- ObjectSpace space,
- AllocationAction action) {
- i::Isolate* isolate = i::Isolate::Current();
+void Isolate::AddMemoryAllocationCallback(MemoryAllocationCallback callback,
+ ObjectSpace space,
+ AllocationAction action) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
isolate->memory_allocator()->AddMemoryAllocationCallback(
callback, space, action);
}
-void V8::RemoveMemoryAllocationCallback(MemoryAllocationCallback callback) {
- i::Isolate* isolate = i::Isolate::Current();
+void Isolate::RemoveMemoryAllocationCallback(
+ MemoryAllocationCallback callback) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
isolate->memory_allocator()->RemoveMemoryAllocationCallback(
callback);
}
-void V8::TerminateExecution(Isolate* isolate) {
- i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
- i_isolate->stack_guard()->RequestTerminateExecution();
+void Isolate::TerminateExecution() {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->stack_guard()->RequestTerminateExecution();
}
-bool V8::IsExecutionTerminating(Isolate* isolate) {
- i::Isolate* i_isolate = isolate != NULL ?
- reinterpret_cast<i::Isolate*>(isolate) : i::Isolate::Current();
- return IsExecutionTerminatingCheck(i_isolate);
+bool Isolate::IsExecutionTerminating() {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ return IsExecutionTerminatingCheck(isolate);
}
-void V8::CancelTerminateExecution(Isolate* isolate) {
- i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
- i_isolate->stack_guard()->ClearTerminateExecution();
- i_isolate->CancelTerminateExecution();
+void Isolate::CancelTerminateExecution() {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->stack_guard()->ClearTerminateExecution();
+ isolate->CancelTerminateExecution();
}
void Isolate::RequestInterrupt(InterruptCallback callback, void* data) {
- i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(this);
- i_isolate->set_api_interrupt_callback(callback);
- i_isolate->set_api_interrupt_callback_data(data);
- i_isolate->stack_guard()->RequestApiInterrupt();
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->set_api_interrupt_callback(callback);
+ isolate->set_api_interrupt_callback_data(data);
+ isolate->stack_guard()->RequestApiInterrupt();
}
void Isolate::ClearInterrupt() {
- i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(this);
- i_isolate->stack_guard()->ClearApiInterrupt();
- i_isolate->set_api_interrupt_callback(NULL);
- i_isolate->set_api_interrupt_callback_data(NULL);
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->stack_guard()->ClearApiInterrupt();
+ isolate->set_api_interrupt_callback(NULL);
+ isolate->set_api_interrupt_callback_data(NULL);
}
Isolate* Isolate::New(const Isolate::CreateParams& params) {
- i::Isolate* isolate = new i::Isolate();
+ i::Isolate* isolate = new i::Isolate(params.enable_serializer);
Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
if (params.entry_hook) {
isolate->set_function_entry_hook(params.entry_hook);
params.code_event_handler);
}
SetResourceConstraints(isolate, params.constraints);
- if (params.enable_serializer) {
- isolate->enable_serializer();
- }
// TODO(jochen): Once we got rid of Isolate::Current(), we can remove this.
Isolate::Scope isolate_scope(v8_isolate);
if (params.entry_hook || !i::Snapshot::Initialize(isolate)) {
void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
- if (!isolate->IsInitialized()) {
- heap_statistics->total_heap_size_ = 0;
- heap_statistics->total_heap_size_executable_ = 0;
- heap_statistics->total_physical_size_ = 0;
- heap_statistics->used_heap_size_ = 0;
- heap_statistics->heap_size_limit_ = 0;
- return;
- }
i::Heap* heap = isolate->heap();
heap_statistics->total_heap_size_ = heap->CommittedMemory();
heap_statistics->total_heap_size_executable_ =
}
+void Isolate::GetStackSample(const RegisterState& state, void** frames,
+ size_t frames_limit, SampleInfo* sample_info) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ i::TickSample::GetStackSample(isolate, state, i::TickSample::kSkipCEntryFrame,
+ frames, frames_limit, sample_info);
+}
+
+
void Isolate::SetEventLogger(LogEventCallback that) {
// Do not overwrite the event logger if we want to log explicitly.
- if (i::FLAG_log_timer_events) return;
+ if (i::FLAG_log_internal_timer_events) return;
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
isolate->set_event_logger(that);
}
}
+void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
+ if (callback == NULL) return;
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->SetPromiseRejectCallback(callback);
+}
+
+
void Isolate::RunMicrotasks() {
reinterpret_cast<i::Isolate*>(this)->RunMicrotasks();
}
}
-bool v8::Isolate::IdleNotification(int idle_time_in_ms) {
+bool Isolate::IdleNotification(int idle_time_in_ms) {
// Returning true tells the caller that it need not
// continue to call IdleNotification.
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
}
-void v8::Isolate::LowMemoryNotification() {
+void Isolate::LowMemoryNotification() {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
{
i::HistogramTimerScope idle_notification_scope(
}
-int v8::Isolate::ContextDisposedNotification() {
+int Isolate::ContextDisposedNotification() {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
return isolate->heap()->NotifyContextDisposed();
}
-void v8::Isolate::SetJitCodeEventHandler(JitCodeEventOptions options,
- JitCodeEventHandler event_handler) {
+void Isolate::SetJitCodeEventHandler(JitCodeEventOptions options,
+ JitCodeEventHandler event_handler) {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
// Ensure that logging is initialized for our isolate.
isolate->InitializeLoggingAndCounters();
}
-void v8::Isolate::SetStackLimit(uintptr_t stack_limit) {
+void Isolate::SetStackLimit(uintptr_t stack_limit) {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
CHECK(stack_limit);
isolate->stack_guard()->SetStackLimit(stack_limit);
}
-void v8::Isolate::GetCodeRange(void** start, size_t* length_in_bytes) {
+void Isolate::GetCodeRange(void** start, size_t* length_in_bytes) {
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
if (isolate->code_range()->valid()) {
*start = isolate->code_range()->start();
}
+void Isolate::SetFatalErrorHandler(FatalErrorCallback that) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->set_exception_behavior(that);
+}
+
+
+void Isolate::SetAllowCodeGenerationFromStringsCallback(
+ AllowCodeGenerationFromStringsCallback callback) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->set_allow_code_gen_callback(callback);
+}
+
+
+bool Isolate::IsDead() {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ return isolate->IsDead();
+}
+
+
+bool Isolate::AddMessageListener(MessageCallback that, Handle<Value> data) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ ON_BAILOUT(isolate, "v8::V8::AddMessageListener()", return false);
+ ENTER_V8(isolate);
+ i::HandleScope scope(isolate);
+ NeanderArray listeners(isolate->factory()->message_listeners());
+ NeanderObject obj(isolate, 2);
+ obj.set(0, *isolate->factory()->NewForeign(FUNCTION_ADDR(that)));
+ obj.set(1, data.IsEmpty() ? isolate->heap()->undefined_value()
+ : *Utils::OpenHandle(*data));
+ listeners.add(isolate, obj.value());
+ return true;
+}
+
+
+void Isolate::RemoveMessageListeners(MessageCallback that) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ ON_BAILOUT(isolate, "v8::V8::RemoveMessageListeners()", return);
+ ENTER_V8(isolate);
+ i::HandleScope scope(isolate);
+ NeanderArray listeners(isolate->factory()->message_listeners());
+ for (int i = 0; i < listeners.length(); i++) {
+ if (listeners.get(i)->IsUndefined()) continue; // skip deleted ones
+
+ NeanderObject listener(i::JSObject::cast(listeners.get(i)));
+ i::Handle<i::Foreign> callback_obj(i::Foreign::cast(listener.get(0)));
+ if (callback_obj->foreign_address() == FUNCTION_ADDR(that)) {
+ listeners.set(i, isolate->heap()->undefined_value());
+ }
+ }
+}
+
+
+void Isolate::SetFailedAccessCheckCallbackFunction(
+ FailedAccessCheckCallback callback) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->SetFailedAccessCheckCallback(callback);
+}
+
+
+void Isolate::SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit, StackTrace::StackTraceOptions options) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
+ options);
+}
+
+
+void Isolate::VisitExternalResources(ExternalResourceVisitor* visitor) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ isolate->heap()->VisitExternalResources(visitor);
+}
+
+
+class VisitorAdapter : public i::ObjectVisitor {
+ public:
+ explicit VisitorAdapter(PersistentHandleVisitor* visitor)
+ : visitor_(visitor) {}
+ virtual void VisitPointers(i::Object** start, i::Object** end) {
+ UNREACHABLE();
+ }
+ virtual void VisitEmbedderReference(i::Object** p, uint16_t class_id) {
+ Value* value = ToApi<Value>(i::Handle<i::Object>(p));
+ visitor_->VisitPersistentHandle(
+ reinterpret_cast<Persistent<Value>*>(&value), class_id);
+ }
+
+ private:
+ PersistentHandleVisitor* visitor_;
+};
+
+
+void Isolate::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ i::DisallowHeapAllocation no_allocation;
+ VisitorAdapter visitor_adapter(visitor);
+ isolate->global_handles()->IterateAllRootsWithClassIds(&visitor_adapter);
+}
+
+
+void Isolate::VisitHandlesForPartialDependence(
+ PersistentHandleVisitor* visitor) {
+ i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+ i::DisallowHeapAllocation no_allocation;
+ VisitorAdapter visitor_adapter(visitor);
+ isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds(
+ &visitor_adapter);
+}
+
+
String::Utf8Value::Utf8Value(v8::Handle<v8::Value> obj)
: str_(NULL), length_(0) {
i::Isolate* isolate = i::Isolate::Current();
ENTER_V8(isolate);
i::HandleScope scope(isolate);
TryCatch try_catch;
- Handle<String> str = obj->ToString();
+ Handle<String> str = obj->ToString(reinterpret_cast<v8::Isolate*>(isolate));
if (str.IsEmpty()) return;
i::Handle<i::String> i_str = Utils::OpenHandle(*str);
length_ = v8::Utf8Length(*i_str, isolate);
ENTER_V8(isolate);
i::HandleScope scope(isolate);
TryCatch try_catch;
- Handle<String> str = obj->ToString();
+ Handle<String> str = obj->ToString(reinterpret_cast<v8::Isolate*>(isolate));
if (str.IsEmpty()) return;
length_ = str->Length();
str_ = i::NewArray<uint16_t>(length_ + 1);
#undef DEFINE_ERROR
+Local<Message> Exception::GetMessage(Handle<Value> exception) {
+ i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
+ if (!obj->IsHeapObject()) return Local<Message>();
+ i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
+ ENTER_V8(isolate);
+ i::HandleScope scope(isolate);
+ return Utils::MessageToLocal(
+ scope.CloseAndEscape(isolate->CreateMessage(obj, NULL)));
+}
+
+
+Local<StackTrace> Exception::GetStackTrace(Handle<Value> exception) {
+ i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
+ if (!obj->IsJSObject()) return Local<StackTrace>();
+ i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(obj);
+ i::Isolate* isolate = js_obj->GetIsolate();
+ ENTER_V8(isolate);
+ return Utils::StackTraceToLocal(isolate->GetDetailedStackTrace(js_obj));
+}
+
+
// --- D e b u g S u p p o r t ---
bool Debug::SetDebugEventListener(EventCallback that, Handle<Value> data) {
Local<Value> Debug::Call(v8::Handle<v8::Function> fun,
v8::Handle<v8::Value> data) {
i::Isolate* isolate = i::Isolate::Current();
- if (!isolate->IsInitialized()) return Local<Value>();
ON_BAILOUT(isolate, "v8::Debug::Call()", return Local<Value>());
ENTER_V8(isolate);
i::MaybeHandle<i::Object> maybe_result;
Local<Value> Debug::GetMirror(v8::Handle<v8::Value> obj) {
i::Isolate* isolate = i::Isolate::Current();
- if (!isolate->IsInitialized()) return Local<Value>();
ON_BAILOUT(isolate, "v8::Debug::GetMirror()", return Local<Value>());
ENTER_V8(isolate);
v8::EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
}
+unsigned int CpuProfileNode::GetHitLineCount() const {
+ const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
+ return node->GetHitLineCount();
+}
+
+
+bool CpuProfileNode::GetLineTicks(LineTick* entries,
+ unsigned int length) const {
+ const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
+ return node->GetLineTicks(entries, length);
+}
+
+
const char* CpuProfileNode::GetBailoutReason() const {
const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
return node->entry()->bailout_reason();
void CpuProfiler::SetIdle(bool is_idle) {
i::Isolate* isolate = reinterpret_cast<i::CpuProfiler*>(this)->isolate();
- i::StateTag state = isolate->current_vm_state();
- DCHECK(state == i::EXTERNAL || state == i::IDLE);
+ v8::StateTag state = isolate->current_vm_state();
+ DCHECK(state == v8::EXTERNAL || state == v8::IDLE);
if (isolate->js_entry_sp() != NULL) return;
if (is_idle) {
- isolate->set_current_vm_state(i::IDLE);
- } else if (state == i::IDLE) {
- isolate->set_current_vm_state(i::EXTERNAL);
+ isolate->set_current_vm_state(v8::IDLE);
+ } else if (state == v8::IDLE) {
+ isolate->set_current_vm_state(v8::EXTERNAL);
}
}
return obj_.value();
}
- void add(v8::internal::Handle<v8::internal::Object> value);
+ void add(internal::Isolate* isolate,
+ v8::internal::Handle<v8::internal::Object> value);
int length();
static inline Local<Message> MessageToLocal(
v8::internal::Handle<v8::internal::Object> obj);
+ static inline Local<Promise> PromiseToLocal(
+ v8::internal::Handle<v8::internal::JSObject> obj);
static inline Local<StackTrace> StackTraceToLocal(
v8::internal::Handle<v8::internal::JSArray> obj);
static inline Local<StackFrame> StackFrameToLocal(
MAKE_TO_LOCAL(AccessorSignatureToLocal, FunctionTemplateInfo, AccessorSignature)
MAKE_TO_LOCAL(ToLocal, TypeSwitchInfo, TypeSwitch)
MAKE_TO_LOCAL(MessageToLocal, Object, Message)
+MAKE_TO_LOCAL(PromiseToLocal, JSObject, Promise)
MAKE_TO_LOCAL(StackTraceToLocal, JSArray, StackTrace)
MAKE_TO_LOCAL(StackFrameToLocal, JSObject, StackFrame)
MAKE_TO_LOCAL(NumberToLocal, Object, Number)
if (cpu.architecture() >= 7) {
if (FLAG_enable_armv7) supported_ |= 1u << ARMv7;
+ if (FLAG_enable_armv8 && cpu.architecture() >= 8) {
+ supported_ |= 1u << ARMv8;
+ }
if (FLAG_enable_unaligned_accesses) supported_ |= 1u << UNALIGNED_ACCESSES;
// Use movw/movt for QUALCOMM ARMv7 cores.
if (FLAG_enable_movw_movt && cpu.implementer() == base::CPU::QUALCOMM) {
first_const_pool_32_use_ = -1;
first_const_pool_64_use_ = -1;
last_bound_pos_ = 0;
- constant_pool_available_ = !FLAG_enable_ool_constant_pool;
ClearRecordedAstId();
}
static bool use_mov_immediate_load(const Operand& x,
const Assembler* assembler) {
- if (assembler != NULL && !assembler->is_constant_pool_available()) {
+ if (FLAG_enable_ool_constant_pool && assembler != NULL &&
+ !assembler->is_ool_constant_pool_available()) {
return true;
} else if (CpuFeatures::IsSupported(MOVW_MOVT_IMMEDIATE_LOADS) &&
(assembler == NULL || !assembler->predictable_code_size())) {
mov(rd, target, LeaveCC, cond);
}
} else {
- DCHECK(is_constant_pool_available());
+ DCHECK(!FLAG_enable_ool_constant_pool || is_ool_constant_pool_available());
ConstantPoolArray::LayoutSection section = ConstantPoolAddEntry(rinfo);
if (section == ConstantPoolArray::EXTENDED_SECTION) {
DCHECK(FLAG_enable_ool_constant_pool);
}
-void Assembler::mul(Register dst, Register src1, Register src2,
- SBit s, Condition cond) {
+void Assembler::mul(Register dst, Register src1, Register src2, SBit s,
+ Condition cond) {
DCHECK(!dst.is(pc) && !src1.is(pc) && !src2.is(pc));
// dst goes in bits 16-19 for this instruction!
- emit(cond | s | dst.code()*B16 | src2.code()*B8 | B7 | B4 | src1.code());
+ emit(cond | s | dst.code() * B16 | src2.code() * B8 | B7 | B4 | src1.code());
+}
+
+
+void Assembler::smmla(Register dst, Register src1, Register src2, Register srcA,
+ Condition cond) {
+ DCHECK(!dst.is(pc) && !src1.is(pc) && !src2.is(pc) && !srcA.is(pc));
+ emit(cond | B26 | B25 | B24 | B22 | B20 | dst.code() * B16 |
+ srcA.code() * B12 | src2.code() * B8 | B4 | src1.code());
+}
+
+
+void Assembler::smmul(Register dst, Register src1, Register src2,
+ Condition cond) {
+ DCHECK(!dst.is(pc) && !src1.is(pc) && !src2.is(pc));
+ emit(cond | B26 | B25 | B24 | B22 | B20 | dst.code() * B16 | 0xf * B12 |
+ src2.code() * B8 | B4 | src1.code());
}
int vd, d;
dst.split_code(&vd, &d);
emit(al | 0x1D*B23 | d*B22 | 0x3*B20 | vd*B12 | 0x5*B9 | B8 | enc);
- } else if (FLAG_enable_vldr_imm && is_constant_pool_available()) {
+ } else if (FLAG_enable_vldr_imm && is_ool_constant_pool_available()) {
// TODO(jfb) Temporarily turned off until we have constant blinding or
// some equivalent mitigation: an attacker can otherwise control
// generated data which also happens to be executable, a Very Bad
uint32_t lo, hi;
DoubleAsTwoUInt32(imm, &lo, &hi);
- if (scratch.is(no_reg)) {
- if (dst.code() < 16) {
- const LowDwVfpRegister loc = LowDwVfpRegister::from_code(dst.code());
- // Move the low part of the double into the lower of the corresponsing S
- // registers of D register dst.
- mov(ip, Operand(lo));
- vmov(loc.low(), ip);
-
- // Move the high part of the double into the higher of the
- // corresponsing S registers of D register dst.
- mov(ip, Operand(hi));
- vmov(loc.high(), ip);
+ if (lo == hi) {
+ // Move the low and high parts of the double to a D register in one
+ // instruction.
+ mov(ip, Operand(lo));
+ vmov(dst, ip, ip);
+ } else if (scratch.is(no_reg)) {
+ mov(ip, Operand(lo));
+ vmov(dst, VmovIndexLo, ip);
+ if ((lo & 0xffff) == (hi & 0xffff)) {
+ movt(ip, hi >> 16);
} else {
- // D16-D31 does not have S registers, so move the low and high parts
- // directly to the D register using vmov.32.
- // Note: This may be slower, so we only do this when we have to.
- mov(ip, Operand(lo));
- vmov(dst, VmovIndexLo, ip);
mov(ip, Operand(hi));
- vmov(dst, VmovIndexHi, ip);
}
+ vmov(dst, VmovIndexHi, ip);
} else {
// Move the low and high parts of the double to a D register in one
// instruction.
}
+void Assembler::vrinta(const DwVfpRegister dst, const DwVfpRegister src) {
+ // cond=kSpecialCondition(31-28) | 11101(27-23)| D(22) | 11(21-20) |
+ // 10(19-18) | RM=00(17-16) | Vd(15-12) | 101(11-9) | sz=1(8) | 01(7-6) |
+ // M(5) | 0(4) | Vm(3-0)
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ int vd, d;
+ dst.split_code(&vd, &d);
+ int vm, m;
+ src.split_code(&vm, &m);
+ emit(kSpecialCondition | 0x1D * B23 | d * B22 | 0x3 * B20 | B19 | vd * B12 |
+ 0x5 * B9 | B8 | B6 | m * B5 | vm);
+}
+
+
+void Assembler::vrintn(const DwVfpRegister dst, const DwVfpRegister src) {
+ // cond=kSpecialCondition(31-28) | 11101(27-23)| D(22) | 11(21-20) |
+ // 10(19-18) | RM=01(17-16) | Vd(15-12) | 101(11-9) | sz=1(8) | 01(7-6) |
+ // M(5) | 0(4) | Vm(3-0)
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ int vd, d;
+ dst.split_code(&vd, &d);
+ int vm, m;
+ src.split_code(&vm, &m);
+ emit(kSpecialCondition | 0x1D * B23 | d * B22 | 0x3 * B20 | B19 | 0x1 * B16 |
+ vd * B12 | 0x5 * B9 | B8 | B6 | m * B5 | vm);
+}
+
+
+void Assembler::vrintp(const DwVfpRegister dst, const DwVfpRegister src) {
+ // cond=kSpecialCondition(31-28) | 11101(27-23)| D(22) | 11(21-20) |
+ // 10(19-18) | RM=10(17-16) | Vd(15-12) | 101(11-9) | sz=1(8) | 01(7-6) |
+ // M(5) | 0(4) | Vm(3-0)
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ int vd, d;
+ dst.split_code(&vd, &d);
+ int vm, m;
+ src.split_code(&vm, &m);
+ emit(kSpecialCondition | 0x1D * B23 | d * B22 | 0x3 * B20 | B19 | 0x2 * B16 |
+ vd * B12 | 0x5 * B9 | B8 | B6 | m * B5 | vm);
+}
+
+
+void Assembler::vrintm(const DwVfpRegister dst, const DwVfpRegister src) {
+ // cond=kSpecialCondition(31-28) | 11101(27-23)| D(22) | 11(21-20) |
+ // 10(19-18) | RM=11(17-16) | Vd(15-12) | 101(11-9) | sz=1(8) | 01(7-6) |
+ // M(5) | 0(4) | Vm(3-0)
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ int vd, d;
+ dst.split_code(&vd, &d);
+ int vm, m;
+ src.split_code(&vm, &m);
+ emit(kSpecialCondition | 0x1D * B23 | d * B22 | 0x3 * B20 | B19 | 0x3 * B16 |
+ vd * B12 | 0x5 * B9 | B8 | B6 | m * B5 | vm);
+}
+
+
+void Assembler::vrintz(const DwVfpRegister dst, const DwVfpRegister src,
+ const Condition cond) {
+ // cond(31-28) | 11101(27-23)| D(22) | 11(21-20) | 011(19-17) | 0(16) |
+ // Vd(15-12) | 101(11-9) | sz=1(8) | op=1(7) | 1(6) | M(5) | 0(4) | Vm(3-0)
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ int vd, d;
+ dst.split_code(&vd, &d);
+ int vm, m;
+ src.split_code(&vm, &m);
+ emit(cond | 0x1D * B23 | d * B22 | 0x3 * B20 | 0x3 * B17 | vd * B12 |
+ 0x5 * B9 | B8 | B7 | B6 | m * B5 | vm);
+}
+
+
// Support for NEON.
void Assembler::vld1(NeonSize size,
void mul(Register dst, Register src1, Register src2,
SBit s = LeaveCC, Condition cond = al);
+ void smmla(Register dst, Register src1, Register src2, Register srcA,
+ Condition cond = al);
+
+ void smmul(Register dst, Register src1, Register src2, Condition cond = al);
+
void smlal(Register dstL, Register dstH, Register src1, Register src2,
SBit s = LeaveCC, Condition cond = al);
const DwVfpRegister src,
const Condition cond = al);
+ // ARMv8 rounding instructions.
+ void vrinta(const DwVfpRegister dst, const DwVfpRegister src);
+ void vrintn(const DwVfpRegister dst, const DwVfpRegister src);
+ void vrintm(const DwVfpRegister dst, const DwVfpRegister src);
+ void vrintp(const DwVfpRegister dst, const DwVfpRegister src);
+ void vrintz(const DwVfpRegister dst, const DwVfpRegister src,
+ const Condition cond = al);
+
// Support for NEON.
// All these APIs support D0 to D31 and Q0 to Q15.
// Generate the constant pool for the generated code.
void PopulateConstantPool(ConstantPoolArray* constant_pool);
- bool is_constant_pool_available() const { return constant_pool_available_; }
-
bool use_extended_constant_pool() const {
return constant_pool_builder_.current_section() ==
ConstantPoolArray::EXTENDED_SECTION;
(pc_offset() < no_const_pool_before_);
}
- void set_constant_pool_available(bool available) {
- constant_pool_available_ = available;
- }
-
private:
int next_buffer_check_; // pc offset of next buffer check
// The bound position, before this we cannot do instruction elimination.
int last_bound_pos_;
- // Indicates whether the constant pool can be accessed, which is only possible
- // if the pp register points to the current code object's constant pool.
- bool constant_pool_available_;
-
// Code emission
inline void CheckBuffer();
void GrowBuffer();
friend class RelocInfo;
friend class CodePatcher;
friend class BlockConstPoolScope;
- friend class FrameAndConstantPoolScope;
- friend class ConstantPoolUnavailableScope;
-
PositionsRecorder positions_recorder_;
friend class PositionsRecorder;
friend class EnsureSpace;
__ b(ne, &slow);
// Null is not instance of anything.
- __ cmp(scratch, Operand(isolate()->factory()->null_value()));
+ __ cmp(object, Operand(isolate()->factory()->null_value()));
__ b(ne, &object_not_null);
if (ReturnTrueFalseObject()) {
__ Move(r0, factory->false_value());
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is in lr.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = r3;
+ Register result = r0;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ Ret();
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
// The displacement is the offset of the last parameter (if any)
// relative to the frame pointer.
// A monomorphic miss (i.e, here the cache is not uninitialized) goes
// megamorphic.
- __ CompareRoot(r4, Heap::kUninitializedSymbolRootIndex);
+ __ CompareRoot(r4, Heap::kuninitialized_symbolRootIndex);
__ b(eq, &initialize);
// MegamorphicSentinel is an immortal immovable object (undefined) so no
// write-barrier is needed.
__ bind(&megamorphic);
__ add(r4, r2, Operand::PointerOffsetFromSmiKey(r3));
- __ LoadRoot(ip, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(ip, Heap::kmegamorphic_symbolRootIndex);
__ str(ip, FieldMemOperand(r4, FixedArray::kHeaderSize));
__ jmp(&done);
__ bind(&extra_checks_or_miss);
Label miss;
- __ CompareRoot(r4, Heap::kMegamorphicSymbolRootIndex);
+ __ CompareRoot(r4, Heap::kmegamorphic_symbolRootIndex);
__ b(eq, &slow_start);
- __ CompareRoot(r4, Heap::kUninitializedSymbolRootIndex);
+ __ CompareRoot(r4, Heap::kuninitialized_symbolRootIndex);
__ b(eq, &miss);
if (!FLAG_trace_ic) {
__ CompareObjectType(r4, r5, r5, JS_FUNCTION_TYPE);
__ b(ne, &miss);
__ add(r4, r2, Operand::PointerOffsetFromSmiKey(r3));
- __ LoadRoot(ip, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(ip, Heap::kmegamorphic_symbolRootIndex);
__ str(ip, FieldMemOperand(r4, FixedArray::kHeaderSize));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ ldr(r4, FieldMemOperand(r2, with_types_offset));
+ __ sub(r4, r4, Operand(Smi::FromInt(1)));
+ __ str(r4, FieldMemOperand(r2, with_types_offset));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ ldr(r4, FieldMemOperand(r2, generic_offset));
+ __ add(r4, r4, Operand(Smi::FromInt(1)));
+ __ str(r4, FieldMemOperand(r2, generic_offset));
__ jmp(&slow_start);
}
// StringCharCodeAtGenerator
void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
// If the receiver is a smi trigger the non-string case.
- __ JumpIfSmi(object_, receiver_not_string_);
-
- // Fetch the instance type of the receiver into result register.
- __ ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
- __ ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ tst(result_, Operand(kIsNotStringMask));
- __ b(ne, receiver_not_string_);
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ tst(result_, Operand(kIsNotStringMask));
+ __ b(ne, receiver_not_string_);
+ }
// If the index is non-smi trigger the non-smi case.
__ JumpIfNotSmi(index_, &index_not_smi_);
// r2: length
// r3: from index (untagged)
__ SmiTag(r3, r3);
- StringCharAtGenerator generator(
- r0, r3, r2, r0, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(r0, r3, r2, r0, &runtime, &runtime, &runtime,
+ STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ Drop(3);
__ Ret();
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in r0.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(r0, &check_heap_number);
+ __ Ret();
+
+ __ bind(&check_heap_number);
+ __ ldr(r1, FieldMemOperand(r0, HeapObject::kMapOffset));
+ __ CompareRoot(r1, Heap::kHeapNumberMapRootIndex);
+ __ b(ne, &call_builtin);
+ __ Ret();
+
+ __ bind(&call_builtin);
+ __ push(r0);
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(
MacroAssembler* masm, Register left, Register right, Register scratch1,
Register scratch2, Register scratch3) {
__ add(src_elements, elements,
Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag + 4));
__ add(dst_elements, array, Operand(FixedArray::kHeaderSize));
- __ add(array, array, Operand(kHeapObjectTag));
__ add(dst_end, dst_elements, Operand(length, LSL, 1));
+
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
+ __ b(&initialization_loop_entry);
+ __ bind(&initialization_loop);
+ __ str(scratch, MemOperand(dst_elements, kPointerSize, PostIndex));
+ __ bind(&initialization_loop_entry);
+ __ cmp(dst_elements, dst_end);
+ __ b(lt, &initialization_loop);
+
+ __ add(dst_elements, array, Operand(FixedArray::kHeaderSize));
+ __ add(array, array, Operand(kHeapObjectTag));
__ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
// Using offsetted addresses in src_elements to fully take advantage of
// post-indexing.
// Instruction encoding bits and masks.
enum {
- H = 1 << 5, // Halfword (or byte).
- S6 = 1 << 6, // Signed (or unsigned).
- L = 1 << 20, // Load (or store).
- S = 1 << 20, // Set condition code (or leave unchanged).
- W = 1 << 21, // Writeback base register (or leave unchanged).
- A = 1 << 21, // Accumulate in multiply instruction (or not).
- B = 1 << 22, // Unsigned byte (or word).
- N = 1 << 22, // Long (or short).
- U = 1 << 23, // Positive (or negative) offset/index.
- P = 1 << 24, // Offset/pre-indexed addressing (or post-indexed addressing).
- I = 1 << 25, // Immediate shifter operand (or not).
-
- B4 = 1 << 4,
- B5 = 1 << 5,
- B6 = 1 << 6,
- B7 = 1 << 7,
- B8 = 1 << 8,
- B9 = 1 << 9,
+ H = 1 << 5, // Halfword (or byte).
+ S6 = 1 << 6, // Signed (or unsigned).
+ L = 1 << 20, // Load (or store).
+ S = 1 << 20, // Set condition code (or leave unchanged).
+ W = 1 << 21, // Writeback base register (or leave unchanged).
+ A = 1 << 21, // Accumulate in multiply instruction (or not).
+ B = 1 << 22, // Unsigned byte (or word).
+ N = 1 << 22, // Long (or short).
+ U = 1 << 23, // Positive (or negative) offset/index.
+ P = 1 << 24, // Offset/pre-indexed addressing (or post-indexed addressing).
+ I = 1 << 25, // Immediate shifter operand (or not).
+ B4 = 1 << 4,
+ B5 = 1 << 5,
+ B6 = 1 << 6,
+ B7 = 1 << 7,
+ B8 = 1 << 8,
+ B9 = 1 << 9,
B12 = 1 << 12,
B16 = 1 << 16,
+ B17 = 1 << 17,
B18 = 1 << 18,
B19 = 1 << 19,
B20 = 1 << 20,
B28 = 1 << 28,
// Instruction bit masks.
- kCondMask = 15 << 28,
- kALUMask = 0x6f << 21,
- kRdMask = 15 << 12, // In str instruction.
+ kCondMask = 15 << 28,
+ kALUMask = 0x6f << 21,
+ kRdMask = 15 << 12, // In str instruction.
kCoprocessorMask = 15 << 8,
kOpCodeMask = 15 << 21, // In data-processing instructions.
- kImm24Mask = (1 << 24) - 1,
- kImm16Mask = (1 << 16) - 1,
- kImm8Mask = (1 << 8) - 1,
- kOff12Mask = (1 << 12) - 1,
- kOff8Mask = (1 << 8) - 1
+ kImm24Mask = (1 << 24) - 1,
+ kImm16Mask = (1 << 16) - 1,
+ kImm8Mask = (1 << 8) - 1,
+ kOff12Mask = (1 << 12) - 1,
+ kOff8Mask = (1 << 8) - 1
};
// Calling convention for IC load (from ic-arm.cc).
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0);
}
// These condition names are defined in a way to match the native disassembler
// formatting. See for example the command "objdump -d <binary file>".
-static const char* cond_names[kNumberOfConditions] = {
+static const char* const cond_names[kNumberOfConditions] = {
"eq", "ne", "cs" , "cc" , "mi" , "pl" , "vs" , "vc" ,
"hi", "ls", "ge", "lt", "gt", "le", "", "invalid",
};
break;
}
case db_x: {
+ if (instr->Bits(22, 20) == 0x5) {
+ if (instr->Bits(7, 4) == 0x1) {
+ if (instr->Bits(15, 12) == 0xF) {
+ Format(instr, "smmul'cond 'rn, 'rm, 'rs");
+ } else {
+ // SMMLA (in V8 notation matching ARM ISA format)
+ Format(instr, "smmla'cond 'rn, 'rm, 'rs, 'rd");
+ }
+ break;
+ }
+ }
if (FLAG_enable_sudiv) {
if (instr->Bits(5, 4) == 0x1) {
if ((instr->Bit(22) == 0x0) && (instr->Bit(20) == 0x1)) {
} else {
Unknown(instr); // Not used by V8.
}
+ } else if (((instr->Opc2Value() == 0x6)) && instr->Opc3Value() == 0x3) {
+ bool dp_operation = (instr->SzValue() == 1);
+ // vrintz - round towards zero (truncate)
+ if (dp_operation) {
+ Format(instr, "vrintz'cond.f64.f64 'Dd, 'Dm");
+ } else {
+ Unknown(instr); // Not used by V8.
+ }
} else {
Unknown(instr); // Not used by V8.
}
Unknown(instr);
}
break;
+ case 0x1D:
+ if (instr->Opc1Value() == 0x7 && instr->Bits(19, 18) == 0x2 &&
+ instr->Bits(11, 9) == 0x5 && instr->Bits(7, 6) == 0x1 &&
+ instr->Bit(4) == 0x0) {
+ // VRINTA, VRINTN, VRINTP, VRINTM (floating-point)
+ bool dp_operation = (instr->SzValue() == 1);
+ int rounding_mode = instr->Bits(17, 16);
+ switch (rounding_mode) {
+ case 0x0:
+ if (dp_operation) {
+ Format(instr, "vrinta.f64.f64 'Dd, 'Dm");
+ } else {
+ Unknown(instr);
+ }
+ break;
+ case 0x1:
+ if (dp_operation) {
+ Format(instr, "vrintn.f64.f64 'Dd, 'Dm");
+ } else {
+ Unknown(instr);
+ }
+ break;
+ case 0x2:
+ if (dp_operation) {
+ Format(instr, "vrintp.f64.f64 'Dd, 'Dm");
+ } else {
+ Unknown(instr);
+ }
+ break;
+ case 0x3:
+ if (dp_operation) {
+ Format(instr, "vrintm.f64.f64 'Dd, 'Dm");
+ } else {
+ Unknown(instr);
+ }
+ break;
+ default:
+ UNREACHABLE(); // Case analysis is exhaustive.
+ break;
+ }
+ } else {
+ Unknown(instr);
+ }
+ break;
default:
Unknown(instr);
break;
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
Label loop, exit;
__ push(r0);
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ push(r0);
// Check for proxies.
__ bind(&call_runtime);
__ push(r0); // Duplicate the enumerable object on the stack.
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
// If we got a map from the runtime call, we can do a fast
// modification check. Otherwise, we got a fixed array, and we have
__ Move(r1, FeedbackVector());
__ mov(r2, Operand(TypeFeedbackVector::MegamorphicSentinel(isolate())));
- __ str(r2, FieldMemOperand(r1, FixedArray::OffsetOfElementAt(slot)));
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ str(r2, FieldMemOperand(r1, FixedArray::OffsetOfElementAt(vector_index)));
__ mov(r1, Operand(Smi::FromInt(1))); // Smi indicates slow check
__ ldr(r2, MemOperand(sp, 0 * kPointerSize)); // Get enumerated object
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ Move(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
__ cmp(r0, Operand(isolate()->factory()->undefined_value()));
Label done;
__ mov(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ mov(LoadDescriptor::NameRegister(), Operand(var->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(r0);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in r0.
DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ push(r0);
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
__ Push(result_register());
}
break;
+ case KEYED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ const Register scratch = r1;
+ __ ldr(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch);
+ __ ldr(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch);
+ __ Push(result_register());
+ }
+ break;
case KEYED_PROPERTY:
if (expr->is_compound()) {
VisitForStackValue(property->obj());
EmitNamedSuperPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(r0);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(r0);
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ ldr(load_name, MemOperand(sp, 2 * kPointerSize));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
+ Operand(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
__ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->DoneFeedbackSlot())));
+ Operand(SmiFromSlot(expr->DoneFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // r0=result.done
Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
__ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->ValueFeedbackSlot())));
+ Operand(SmiFromSlot(expr->ValueFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // r0=result.value
context()->DropAndPlug(2, r0); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), r0, r2, r3, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, r0, r2, r3, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ ldr(context_register(),
MemOperand(fp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ mov(r1, Operand(map));
+ __ ldr(r1, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ ldr(r1, FieldMemOperand(r1, GlobalObject::kNativeContextOffset));
+ __ ldr(r1, ContextOperand(r1, Context::ITERATOR_RESULT_MAP_INDEX));
__ pop(r2);
__ mov(r3, Operand(isolate()->factory()->ToBoolean(done)));
__ mov(r4, Operand(isolate()->factory()->empty_fixed_array()));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ str(r1, FieldMemOperand(r0, HeapObject::kMapOffset));
__ str(r4, FieldMemOperand(r0, JSObject::kPropertiesOffset));
__ str(r4, FieldMemOperand(r0, JSObject::kElementsOffset));
__ mov(LoadDescriptor::NameRegister(), Operand(key->value()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in r0.
+ DCHECK(lit != NULL);
+ __ push(r0);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = r1;
+ __ ldr(scratch,
+ FieldMemOperand(r0, JSFunction::kPrototypeOrInitialMapOffset));
+ __ push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ ldr(scratch, MemOperand(sp, kPointerSize)); // constructor
+ } else {
+ __ ldr(scratch, MemOperand(sp, 0)); // prototype
+ }
+ __ push(scratch);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(r0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; r0: home_object
+ Register scratch = r2;
+ Register scratch2 = r3;
+ __ mov(scratch, result_register()); // home_object
+ __ ldr(r0, MemOperand(sp, kPointerSize)); // value
+ __ ldr(scratch2, MemOperand(sp, 0)); // this
+ __ str(scratch2, MemOperand(sp, kPointerSize)); // this
+ __ str(scratch, MemOperand(sp, 0)); // home_object
+ // stack: this, home_object; r0: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(r0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = r2;
+ Register scratch2 = r3;
+ __ ldr(scratch2, MemOperand(sp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; r0: key, r3: value
+ __ ldr(scratch, MemOperand(sp, kPointerSize)); // this
+ __ str(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ ldr(scratch, MemOperand(sp, 0)); // home_object
+ __ str(scratch, MemOperand(sp, kPointerSize));
+ __ str(r0, MemOperand(sp, 0));
+ __ Move(r0, scratch2);
+ // stack: this, home_object, key; r0: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ push(r0); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// r0 : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ Push(r0);
__ Push(key->value());
+ __ Push(r0);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(r0);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // r0 : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(r0);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(r0);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ Move(LoadDescriptor::NameRegister(), r0);
- __ pop(LoadDescriptor::ReceiverRegister());
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), r0);
+ __ pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(r0);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ const Register scratch = r1;
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Push(r0);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(r0);
+ __ Push(r0);
+ __ ldr(scratch, MemOperand(sp, kPointerSize * 2));
+ __ Push(scratch);
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ str(r0, MemOperand(sp, kPointerSize));
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ mov(r3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ mov(r3, Operand(SmiFromSlot(expr->CallFeedbackSlot())));
__ ldr(r1, MemOperand(sp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
- // r4: copy of the first argument or undefined if it doesn't exist.
+ // r5: copy of the first argument or undefined if it doesn't exist.
if (arg_count > 0) {
- __ ldr(r4, MemOperand(sp, arg_count * kPointerSize));
+ __ ldr(r5, MemOperand(sp, arg_count * kPointerSize));
} else {
- __ LoadRoot(r4, Heap::kUndefinedValueRootIndex);
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
}
+ // r4: the receiver of the enclosing function.
+ __ ldr(r4, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+
// r3: the receiver of the enclosing function.
int receiver_offset = 2 + info_->scope()->num_parameters();
__ ldr(r3, MemOperand(fp, receiver_offset * kPointerSize));
__ mov(r1, Operand(Smi::FromInt(scope()->start_position())));
// Do the runtime call.
+ __ Push(r5);
__ Push(r4, r3, r2, r1);
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ Push(r0);
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// r1 (receiver). Touch up the stack with the right values.
__ str(r0, MemOperand(sp, (arg_count + 1) * kPointerSize));
__ str(r1, MemOperand(sp, arg_count * kPointerSize));
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
__ Push(context_register(), r2);
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ Push(r0, r1); // Function, receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the
// function and receiver and have the slow path jump around this
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ Move(r2, FeedbackVector());
- __ mov(r3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ mov(r3, Operand(SmiFromSlot(expr->CallNewFeedbackSlot())));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r0, if_false);
+ Register map = r1;
+ Register type_reg = r2;
+ __ ldr(map, FieldMemOperand(r0, HeapObject::kMapOffset));
+ __ ldrb(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ sub(type_reg, type_reg, Operand(FIRST_JS_PROXY_TYPE));
+ __ cmp(type_reg, Operand(LAST_JS_PROXY_TYPE - FIRST_JS_PROXY_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ls, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ mov(LoadDescriptor::NameRegister(), Operand(expr->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
+ Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
__ mov(ip, Operand(Smi::FromInt(0)));
__ push(ip);
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ ldr(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ ldr(LoadDescriptor::ReceiverRegister(),
- MemOperand(sp, 1 * kPointerSize));
- __ ldr(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ ldr(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ const Register scratch = r1;
+ __ ldr(scratch, MemOperand(sp, kPointerSize));
+ __ Push(scratch);
+ __ Push(result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(result_register());
+ const Register scratch = r1;
+ __ ldr(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch);
+ __ ldr(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch);
+ __ Push(result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ ldr(LoadDescriptor::ReceiverRegister(),
+ MemOperand(sp, 1 * kPointerSize));
+ __ ldr(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ str(r0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ str(r0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ str(r0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ str(r0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
case NAMED_PROPERTY:
__ str(r0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ str(r0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ str(r0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ str(r0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r0);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r0);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ Pop(StoreDescriptor::ReceiverRegister(),
StoreDescriptor::NameRegister());
__ mov(LoadDescriptor::NameRegister(), Operand(proxy->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return r0; }
+const Register StoreTransitionDescriptor::MapRegister() { return r3; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r3; }
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // cp -- context
+ Register registers[] = {cp};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#include "src/arm/lithium-codegen-arm.h"
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift
// by 0 and the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ Move(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ Move(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(r0));
- __ mov(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(instr->hydrogen()->slot())));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
+ __ mov(VectorLoadICDescriptor::SlotRegister(), Operand(Smi::FromInt(index)));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr, NEVER_INLINE_TARGET_ADDRESS);
}
add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
if (FLAG_enable_ool_constant_pool) {
LoadConstantPoolPointerRegister();
- set_constant_pool_available(true);
+ set_ool_constant_pool_available(true);
}
}
}
if (FLAG_enable_ool_constant_pool) {
LoadConstantPoolPointerRegister();
- set_constant_pool_available(true);
+ set_ool_constant_pool_available(true);
}
}
void MacroAssembler::EnterFrame(StackFrame::Type type,
- bool load_constant_pool) {
+ bool load_constant_pool_pointer_reg) {
// r0-r3: preserved
PushFixedFrame();
- if (FLAG_enable_ool_constant_pool && load_constant_pool) {
+ if (FLAG_enable_ool_constant_pool && load_constant_pool_pointer_reg) {
LoadConstantPoolPointerRegister();
}
mov(ip, Operand(Smi::FromInt(type)));
DCHECK(!dividend.is(ip));
DCHECK(!result.is(ip));
base::MagicNumbersForDivision<uint32_t> mag =
- base::SignedDivisionByConstant(static_cast<uint32_t>(divisor));
+ base::SignedDivisionByConstant(bit_cast<uint32_t>(divisor));
mov(ip, Operand(mag.multiplier));
- smull(ip, result, dividend, ip);
- bool neg = (mag.multiplier & (static_cast<uint32_t>(1) << 31)) != 0;
+ bool neg = (mag.multiplier & (1U << 31)) != 0;
if (divisor > 0 && neg) {
- add(result, result, Operand(dividend));
- }
- if (divisor < 0 && !neg && mag.multiplier > 0) {
- sub(result, result, Operand(dividend));
+ smmla(result, dividend, ip, dividend);
+ } else {
+ smmul(result, dividend, ip);
+ if (divisor < 0 && !neg && mag.multiplier > 0) {
+ sub(result, result, Operand(dividend));
+ }
}
if (mag.shift > 0) mov(result, Operand(result, ASR, mag.shift));
add(result, result, Operand(dividend, LSR, 31));
}
-
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_TARGET_ARCH_ARM
}
// Activation support.
- void EnterFrame(StackFrame::Type type, bool load_constant_pool = false);
+ void EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg = false);
// Returns the pc offset at which the frame ends.
int LeaveFrame(StackFrame::Type type);
};
-class FrameAndConstantPoolScope {
- public:
- FrameAndConstantPoolScope(MacroAssembler* masm, StackFrame::Type type)
- : masm_(masm),
- type_(type),
- old_has_frame_(masm->has_frame()),
- old_constant_pool_available_(masm->is_constant_pool_available()) {
- // We only want to enable constant pool access for non-manual frame scopes
- // to ensure the constant pool pointer is valid throughout the scope.
- DCHECK(type_ != StackFrame::MANUAL && type_ != StackFrame::NONE);
- masm->set_has_frame(true);
- masm->set_constant_pool_available(true);
- masm->EnterFrame(type, !old_constant_pool_available_);
- }
-
- ~FrameAndConstantPoolScope() {
- masm_->LeaveFrame(type_);
- masm_->set_has_frame(old_has_frame_);
- masm_->set_constant_pool_available(old_constant_pool_available_);
- }
-
- // Normally we generate the leave-frame code when this object goes
- // out of scope. Sometimes we may need to generate the code somewhere else
- // in addition. Calling this will achieve that, but the object stays in
- // scope, the MacroAssembler is still marked as being in a frame scope, and
- // the code will be generated again when it goes out of scope.
- void GenerateLeaveFrame() {
- DCHECK(type_ != StackFrame::MANUAL && type_ != StackFrame::NONE);
- masm_->LeaveFrame(type_);
- }
-
- private:
- MacroAssembler* masm_;
- StackFrame::Type type_;
- bool old_has_frame_;
- bool old_constant_pool_available_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(FrameAndConstantPoolScope);
-};
-
-
-// Class for scoping the the unavailability of constant pool access.
-class ConstantPoolUnavailableScope {
- public:
- explicit ConstantPoolUnavailableScope(MacroAssembler* masm)
- : masm_(masm),
- old_constant_pool_available_(masm->is_constant_pool_available()) {
- if (FLAG_enable_ool_constant_pool) {
- masm_->set_constant_pool_available(false);
- }
- }
- ~ConstantPoolUnavailableScope() {
- if (FLAG_enable_ool_constant_pool) {
- masm_->set_constant_pool_available(old_constant_pool_available_);
- }
- }
-
- private:
- MacroAssembler* masm_;
- int old_constant_pool_available_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(ConstantPoolUnavailableScope);
-};
-
-
// -----------------------------------------------------------------------------
// Static helper functions.
break;
}
case db_x: {
+ if (instr->Bits(22, 20) == 0x5) {
+ if (instr->Bits(7, 4) == 0x1) {
+ int rm = instr->RmValue();
+ int32_t rm_val = get_register(rm);
+ int rs = instr->RsValue();
+ int32_t rs_val = get_register(rs);
+ if (instr->Bits(15, 12) == 0xF) {
+ // SMMUL (in V8 notation matching ARM ISA format)
+ // Format(instr, "smmul'cond 'rn, 'rm, 'rs");
+ rn_val = base::bits::SignedMulHigh32(rm_val, rs_val);
+ } else {
+ // SMMLA (in V8 notation matching ARM ISA format)
+ // Format(instr, "smmla'cond 'rn, 'rm, 'rs, 'rd");
+ int rd = instr->RdValue();
+ int32_t rd_val = get_register(rd);
+ rn_val = base::bits::SignedMulHighAndAdd32(rm_val, rs_val, rd_val);
+ }
+ set_register(rn, rn_val);
+ return;
+ }
+ }
if (FLAG_enable_sudiv) {
if (instr->Bits(5, 4) == 0x1) {
if ((instr->Bit(22) == 0x0) && (instr->Bit(20) == 0x1)) {
int rs = instr->RsValue();
int32_t rs_val = get_register(rs);
int32_t ret_val = 0;
- DCHECK(rs_val != 0);
// udiv
if (instr->Bit(21) == 0x1) {
- ret_val = static_cast<int32_t>(static_cast<uint32_t>(rm_val) /
- static_cast<uint32_t>(rs_val));
- } else if ((rm_val == kMinInt) && (rs_val == -1)) {
- ret_val = kMinInt;
+ ret_val = bit_cast<int32_t>(base::bits::UnsignedDiv32(
+ bit_cast<uint32_t>(rm_val), bit_cast<uint32_t>(rs_val)));
} else {
- ret_val = rm_val / rs_val;
+ ret_val = base::bits::SignedDiv32(rm_val, rs_val);
}
set_register(rn, ret_val);
return;
} else {
UNREACHABLE(); // Not used by v8.
}
+ } else if (((instr->Opc2Value() == 0x6)) && (instr->Opc3Value() == 0x3)) {
+ // vrintz - truncate
+ double dm_value = get_double_from_d_register(vm);
+ double dd_value = trunc(dm_value);
+ dd_value = canonicalizeNaN(dd_value);
+ set_d_register_from_double(vd, dd_value);
} else {
UNREACHABLE(); // Not used by V8.
}
UNIMPLEMENTED();
}
break;
+ case 0x1D:
+ if (instr->Opc1Value() == 0x7 && instr->Opc3Value() == 0x1 &&
+ instr->Bits(11, 9) == 0x5 && instr->Bits(19, 18) == 0x2 &&
+ instr->Bit(8) == 0x1) {
+ int vm = instr->VFPMRegValue(kDoublePrecision);
+ int vd = instr->VFPDRegValue(kDoublePrecision);
+ double dm_value = get_double_from_d_register(vm);
+ double dd_value = 0.0;
+ int rounding_mode = instr->Bits(17, 16);
+ switch (rounding_mode) {
+ case 0x0: // vrinta - round with ties to away from zero
+ dd_value = round(dm_value);
+ break;
+ case 0x1: { // vrintn - round with ties to even
+ dd_value = std::floor(dm_value);
+ double error = dm_value - dd_value;
+ // Take care of correctly handling the range [-0.5, -0.0], which
+ // must yield -0.0.
+ if ((-0.5 <= dm_value) && (dm_value < 0.0)) {
+ dd_value = -0.0;
+ // If the error is greater than 0.5, or is equal to 0.5 and the
+ // integer result is odd, round up.
+ } else if ((error > 0.5) ||
+ ((error == 0.5) && (fmod(dd_value, 2) != 0))) {
+ dd_value++;
+ }
+ break;
+ }
+ case 0x2: // vrintp - ceil
+ dd_value = std::ceil(dm_value);
+ break;
+ case 0x3: // vrintm - floor
+ dd_value = std::floor(dm_value);
+ break;
+ default:
+ UNREACHABLE(); // Case analysis is exhaustive.
+ break;
+ }
+ dd_value = canonicalizeNaN(dd_value);
+ set_d_register_from_double(vd, dd_value);
+ } else {
+ UNIMPLEMENTED();
+ }
+ break;
default:
UNIMPLEMENTED();
break;
}
+void Assembler::frintp(const FPRegister& fd, const FPRegister& fn) {
+ DCHECK(fd.SizeInBits() == fn.SizeInBits());
+ FPDataProcessing1Source(fd, fn, FRINTP);
+}
+
+
void Assembler::frintz(const FPRegister& fd,
const FPRegister& fn) {
DCHECK(fd.SizeInBits() == fn.SizeInBits());
// FP round to integer (nearest with ties to even).
void frintn(const FPRegister& fd, const FPRegister& fn);
+ // FP round to integer (towards plus infinity).
+ void frintp(const FPRegister& fd, const FPRegister& fn);
+
// FP round to integer (towards zero.)
void frintz(const FPRegister& fd, const FPRegister& fn);
__ Cbz(argc, &no_arguments);
// First args = sp[(argc - 1) * 8].
__ Sub(argc, argc, 1);
- __ Claim(argc, kXRegSize);
+ __ Drop(argc, kXRegSize);
// jssp now point to args[0], load and drop args[0] + receiver.
Register arg = argc;
__ Ldr(arg, MemOperand(jssp, 2 * kPointerSize, PostIndex));
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is in lr.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register result = x0;
+ Register scratch = x3;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ Ret();
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ Bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
void InstanceofStub::Generate(MacroAssembler* masm) {
// Stack on entry:
// jssp[0]: function.
__ Mov(result, res_false);
// Null is not instance of anything.
- __ Cmp(object_type, Operand(isolate()->factory()->null_value()));
+ __ Cmp(object, Operand(isolate()->factory()->null_value()));
__ B(ne, &object_not_null);
__ Ret();
// A monomorphic miss (i.e, here the cache is not uninitialized) goes
// megamorphic.
- __ JumpIfRoot(scratch1, Heap::kUninitializedSymbolRootIndex, &initialize);
+ __ JumpIfRoot(scratch1, Heap::kuninitialized_symbolRootIndex, &initialize);
// MegamorphicSentinel is an immortal immovable object (undefined) so no
// write-barrier is needed.
__ Bind(&megamorphic);
__ Add(scratch1, feedback_vector,
Operand::UntagSmiAndScale(index, kPointerSizeLog2));
- __ LoadRoot(scratch2, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(scratch2, Heap::kmegamorphic_symbolRootIndex);
__ Str(scratch2, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
__ B(&done);
__ bind(&extra_checks_or_miss);
Label miss;
- __ JumpIfRoot(x4, Heap::kMegamorphicSymbolRootIndex, &slow_start);
- __ JumpIfRoot(x4, Heap::kUninitializedSymbolRootIndex, &miss);
+ __ JumpIfRoot(x4, Heap::kmegamorphic_symbolRootIndex, &slow_start);
+ __ JumpIfRoot(x4, Heap::kuninitialized_symbolRootIndex, &miss);
if (!FLAG_trace_ic) {
// We are going megamorphic. If the feedback is a JSFunction, it is fine
__ JumpIfNotObjectType(x4, x5, x5, JS_FUNCTION_TYPE, &miss);
__ Add(x4, feedback_vector,
Operand::UntagSmiAndScale(index, kPointerSizeLog2));
- __ LoadRoot(x5, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(x5, Heap::kmegamorphic_symbolRootIndex);
__ Str(x5, FieldMemOperand(x4, FixedArray::kHeaderSize));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ Ldr(x4, FieldMemOperand(feedback_vector, with_types_offset));
+ __ Subs(x4, x4, Operand(Smi::FromInt(1)));
+ __ Str(x4, FieldMemOperand(feedback_vector, with_types_offset));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ Ldr(x4, FieldMemOperand(feedback_vector, generic_offset));
+ __ Adds(x4, x4, Operand(Smi::FromInt(1)));
+ __ Str(x4, FieldMemOperand(feedback_vector, generic_offset));
__ B(&slow_start);
}
void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
// If the receiver is a smi trigger the non-string case.
- __ JumpIfSmi(object_, receiver_not_string_);
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
- // Fetch the instance type of the receiver into result register.
- __ Ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
- __ Ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ // Fetch the instance type of the receiver into result register.
+ __ Ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ Ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ TestAndBranchIfAnySet(result_, kIsNotStringMask, receiver_not_string_);
+ // If the receiver is not a string trigger the non-string case.
+ __ TestAndBranchIfAnySet(result_, kIsNotStringMask, receiver_not_string_);
+ }
// If the index is non-smi trigger the non-smi case.
__ JumpIfNotSmi(index_, &index_not_smi_);
// x12: input_type
// x15: from (untagged)
__ SmiTag(from);
- StringCharAtGenerator generator(
- input_string, from, result_length, x0,
- &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(input_string, from, result_length, x0,
+ &runtime, &runtime, &runtime,
+ STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ Drop(3);
__ Ret();
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in x0.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(x0, &check_heap_number);
+ __ Ret();
+
+ __ bind(&check_heap_number);
+ __ JumpIfNotHeapNumber(x0, &call_builtin);
+ __ Ret();
+
+ __ bind(&call_builtin);
+ __ push(x0);
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(
MacroAssembler* masm, Register left, Register right, Register scratch1,
Register scratch2, Register scratch3) {
Register src_elements = x10;
Register dst_elements = x11;
Register dst_end = x12;
+ Register the_hole = x14;
+ __ LoadRoot(the_hole, Heap::kTheHoleValueRootIndex);
__ Add(src_elements, elements,
FixedDoubleArray::kHeaderSize - kHeapObjectTag);
__ Add(dst_elements, array, FixedArray::kHeaderSize);
- __ Add(array, array, kHeapObjectTag);
__ Add(dst_end, dst_elements, Operand(length, LSL, kPointerSizeLog2));
- Register the_hole = x14;
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ B(&initialization_loop_entry);
+ __ bind(&initialization_loop);
+ __ Str(the_hole, MemOperand(dst_elements, kPointerSize, PostIndex));
+ __ bind(&initialization_loop_entry);
+ __ Cmp(dst_elements, dst_end);
+ __ B(lt, &initialization_loop);
+
+ __ Add(dst_elements, array, FixedArray::kHeaderSize);
+ __ Add(array, array, kHeapObjectTag);
+
Register heap_num_map = x15;
- __ LoadRoot(the_hole, Heap::kTheHoleValueRootIndex);
__ LoadRoot(heap_num_map, Heap::kHeapNumberMapRootIndex);
Label entry;
// Calling convention for IC load (from ic-arm.cc).
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.Bit() | name.Bit(), 0, x10);
+ RegList regs = receiver.Bit() | name.Bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().Bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0, x10);
}
void DelayedMasm::StackSlotMove(LOperand* src, LOperand* dst) {
- DCHECK(src->IsStackSlot());
- DCHECK(dst->IsStackSlot());
+ DCHECK((src->IsStackSlot() && dst->IsStackSlot()) ||
+ (src->IsDoubleStackSlot() && dst->IsDoubleStackSlot()));
MemOperand src_operand = cgen_->ToMemOperand(src);
MemOperand dst_operand = cgen_->ToMemOperand(dst);
if (pending_ == kStackSlotMove) {
DCHECK(format[0] == 'M');
USE(format);
- static const char* options[4][4] = {
+ static const char* const options[4][4] = {
{ "sy (0b0000)", "oshld", "oshst", "osh" },
{ "sy (0b0100)", "nshld", "nshst", "nsh" },
{ "sy (0b1000)", "ishld", "ishst", "ish" },
}
VisitDeclarations(scope()->declarations());
}
- }
- { Comment cmnt(masm_, "[ Stack check");
- PrepareForBailoutForId(BailoutId::Declarations(), NO_REGISTERS);
- Label ok;
- DCHECK(jssp.Is(__ StackPointer()));
- __ CompareRoot(jssp, Heap::kStackLimitRootIndex);
- __ B(hs, &ok);
- PredictableCodeSizeScope predictable(masm_,
- Assembler::kCallSizeWithRelocation);
- __ Call(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET);
- __ Bind(&ok);
- }
+ {
+ Comment cmnt(masm_, "[ Stack check");
+ PrepareForBailoutForId(BailoutId::Declarations(), NO_REGISTERS);
+ Label ok;
+ DCHECK(jssp.Is(__ StackPointer()));
+ __ CompareRoot(jssp, Heap::kStackLimitRootIndex);
+ __ B(hs, &ok);
+ PredictableCodeSizeScope predictable(masm_,
+ Assembler::kCallSizeWithRelocation);
+ __ Call(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET);
+ __ Bind(&ok);
+ }
- { Comment cmnt(masm_, "[ Body");
- DCHECK(loop_depth() == 0);
- VisitStatements(function()->body());
- DCHECK(loop_depth() == 0);
+ {
+ Comment cmnt(masm_, "[ Body");
+ DCHECK(loop_depth() == 0);
+ VisitStatements(function()->body());
+ DCHECK(loop_depth() == 0);
+ }
}
// Always emit a 'return undefined' in case control fell off the end of
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
ASM_LOCATION("FullCodeGenerator::VisitForInStatement");
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
// TODO(all): This visitor probably needs better comments and a revisit.
SetStatementPosition(stmt);
__ Push(x0);
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ Bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ Push(x0);
// Check for proxies.
__ Bind(&call_runtime);
__ Push(x0); // Duplicate the enumerable object on the stack.
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
// If we got a map from the runtime call, we can do a fast
// modification check. Otherwise, we got a fixed array, and we have
__ LoadObject(x1, FeedbackVector());
__ Mov(x10, Operand(TypeFeedbackVector::MegamorphicSentinel(isolate())));
- __ Str(x10, FieldMemOperand(x1, FixedArray::OffsetOfElementAt(slot)));
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ Str(x10, FieldMemOperand(x1, FixedArray::OffsetOfElementAt(vector_index)));
__ Mov(x1, Smi::FromInt(1)); // Smi indicates slow check.
__ Peek(x10, 0); // Get enumerated object.
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ Mov(LoadDescriptor::NameRegister(), Operand(home_object_symbol));
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ Mov(VectorLoadICDescriptor::SlotRegister(),
+ SmiFromSlot(expr->HomeObjectFeedbackSlot()));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
__ Mov(x10, Operand(isolate()->factory()->undefined_value()));
__ cmp(x0, x10);
__ Mov(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF) ? NOT_CONTEXTUAL
__ Mov(LoadDescriptor::NameRegister(), Operand(var->name()));
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(x0);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in x0.
DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ Peek(x0, 0);
__ Push(x0);
VisitForStackValue(value);
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
VisitForEffect(value);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
__ Push(scratch, result_register());
}
break;
+ case KEYED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ const Register scratch1 = x10;
+ const Register scratch2 = x11;
+ __ Peek(scratch1, 2 * kPointerSize);
+ __ Peek(scratch2, kPointerSize);
+ __ Push(scratch1, scratch2, result_register());
+ }
+ break;
case KEYED_PROPERTY:
if (expr->is_compound()) {
VisitForStackValue(property->obj());
EmitNamedSuperPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(x0);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(x0);
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ Mov(LoadDescriptor::NameRegister(), Operand(key->value()));
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(prop->PropertyFeedbackSlot()));
+ SmiFromSlot(prop->PropertyFeedbackSlot()));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
void FullCodeGenerator::EmitKeyedPropertyLoad(Property* prop) {
SetSourcePosition(prop->position());
- // Call keyed load IC. It has arguments key and receiver in r0 and r1.
+ // Call keyed load IC. It has arguments key and receiver in x0 and x1.
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(prop->PropertyFeedbackSlot()));
+ SmiFromSlot(prop->PropertyFeedbackSlot()));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in x0.
+ DCHECK(lit != NULL);
+ __ push(x0);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = x1;
+ __ Ldr(scratch,
+ FieldMemOperand(x0, JSFunction::kPrototypeOrInitialMapOffset));
+ __ Push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ Peek(scratch, kPointerSize); // constructor
+ } else {
+ __ Peek(scratch, 0); // prototype
+ }
+ __ Push(scratch);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(x0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; x0: home_object
+ Register scratch = x10;
+ Register scratch2 = x11;
+ __ mov(scratch, result_register()); // home_object
+ __ Peek(x0, kPointerSize); // value
+ __ Peek(scratch2, 0); // this
+ __ Poke(scratch2, kPointerSize); // this
+ __ Poke(scratch, 0); // home_object
+ // stack: this, home_object; x0: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(x0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = x10;
+ Register scratch2 = x11;
+ __ Peek(scratch2, 2 * kPointerSize); // value
+ // stack: value, this, home_object; x0: key, x11: value
+ __ Peek(scratch, kPointerSize); // this
+ __ Poke(scratch, 2 * kPointerSize);
+ __ Peek(scratch, 0); // home_object
+ __ Poke(scratch, kPointerSize);
+ __ Poke(x0, 0);
+ __ Move(x0, scratch2);
+ // stack: this, home_object, key; x0: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ Push(x0); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// x0 : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ Push(x0);
__ Push(key->value());
+ __ Push(x0);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(x0);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // x0 : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(x0);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(x0);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ Move(LoadDescriptor::NameRegister(), x0);
- __ Pop(LoadDescriptor::ReceiverRegister());
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), x0);
+ __ Pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(x0);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+
+ // Load the function from the receiver.
+ const Register scratch = x10;
+ SuperReference* super_ref = callee->AsProperty()->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Push(x0);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(x0);
+ __ Peek(scratch, kPointerSize);
+ __ Push(x0, scratch);
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ Poke(x0, kPointerSize);
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ Mov(x3, Smi::FromInt(expr->CallFeedbackSlot()));
+ __ Mov(x3, SmiFromSlot(expr->CallFeedbackSlot()));
__ Peek(x1, (arg_count + 1) * kXRegSize);
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
// Prepare to push a copy of the first argument or undefined if it doesn't
// exist.
if (arg_count > 0) {
- __ Peek(x10, arg_count * kXRegSize);
+ __ Peek(x9, arg_count * kXRegSize);
} else {
- __ LoadRoot(x10, Heap::kUndefinedValueRootIndex);
+ __ LoadRoot(x9, Heap::kUndefinedValueRootIndex);
}
+ __ Ldr(x10, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
// Prepare to push the receiver of the enclosing function.
int receiver_offset = 2 + info_->scope()->num_parameters();
__ Ldr(x11, MemOperand(fp, receiver_offset * kPointerSize));
__ Mov(x13, Smi::FromInt(scope()->start_position()));
// Push.
- __ Push(x10, x11, x12, x13);
+ __ Push(x9, x10, x11, x12, x13);
// Do the runtime call.
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ ldr(x0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ Push(x0);
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// The runtime call returns a pair of values in x0 (function) and
// x1 (receiver). Touch up the stack with the right values.
__ PokePair(x1, x0, arg_count * kPointerSize);
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
__ Push(context_register(), x10);
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ Push(x0, x1); // Receiver, function.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the
// function and receiver and have the slow path jump around this
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ LoadObject(x2, FeedbackVector());
- __ Mov(x3, Smi::FromInt(expr->CallNewFeedbackSlot()));
+ __ Mov(x3, SmiFromSlot(expr->CallNewFeedbackSlot()));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(x0, if_false);
+ Register map = x10;
+ Register type_reg = x11;
+ __ Ldr(map, FieldMemOperand(x0, HeapObject::kMapOffset));
+ __ Ldrb(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ Sub(type_reg, type_reg, Operand(FIRST_JS_PROXY_TYPE));
+ __ Cmp(type_reg, Operand(LAST_JS_PROXY_TYPE - FIRST_JS_PROXY_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ls, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ Mov(LoadDescriptor::NameRegister(), Operand(name));
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->CallRuntimeFeedbackSlot()));
+ SmiFromSlot(expr->CallRuntimeFeedbackSlot()));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
if (expr->is_postfix() && !context()->IsEffect()) {
__ Push(xzr);
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ Peek(LoadDescriptor::ReceiverRegister(), 0);
- EmitNamedPropertyLoad(prop);
- } else {
- // KEYED_PROPERTY
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ Peek(LoadDescriptor::ReceiverRegister(), 1 * kPointerSize);
- __ Peek(LoadDescriptor::NameRegister(), 0);
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ Peek(LoadDescriptor::ReceiverRegister(), 0);
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ const Register scratch = x10;
+ __ Peek(scratch, kPointerSize);
+ __ Push(scratch, result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(result_register());
+ const Register scratch1 = x10;
+ const Register scratch2 = x11;
+ __ Peek(scratch1, 2 * kPointerSize);
+ __ Peek(scratch2, kPointerSize);
+ __ Push(scratch1, scratch2, result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ Peek(LoadDescriptor::ReceiverRegister(), 1 * kPointerSize);
+ __ Peek(LoadDescriptor::NameRegister(), 0);
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ Poke(x0, kPointerSize);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ Poke(x0, kPointerSize * 2);
+ break;
case KEYED_PROPERTY:
__ Poke(x0, kPointerSize * 2);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ Poke(x0, kPointerSize * 3);
+ break;
}
}
}
case NAMED_PROPERTY:
__ Poke(x0, kXRegSize);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ Poke(x0, 2 * kXRegSize);
+ break;
case KEYED_PROPERTY:
__ Poke(x0, 2 * kXRegSize);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ Poke(x0, 3 * kXRegSize);
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(x0);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(x0);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ Pop(StoreDescriptor::NameRegister());
__ Pop(StoreDescriptor::ReceiverRegister());
__ Mov(LoadDescriptor::NameRegister(), Operand(proxy->name()));
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
__ Peek(load_name, 2 * kPointerSize);
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->KeyedLoadFeedbackSlot()));
+ SmiFromSlot(expr->KeyedLoadFeedbackSlot()));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
__ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->DoneFeedbackSlot()));
+ SmiFromSlot(expr->DoneFeedbackSlot()));
}
CallLoadIC(NOT_CONTEXTUAL); // x0=result.done
// The ToBooleanStub argument (result.done) is in x0.
__ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
if (FLAG_vector_ics) {
__ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->ValueFeedbackSlot()));
+ SmiFromSlot(expr->ValueFeedbackSlot()));
}
CallLoadIC(NOT_CONTEXTUAL); // x0=result.value
context()->DropAndPlug(2, x0); // drop iter and g
// The value stays in x0, and is ultimately read by the resumed generator, as
// if CallRuntime(Runtime::kSuspendJSGeneratorObject) returned it. Or it
- // is read to throw the value when the resumed generator is already closed. r1
+ // is read to throw the value when the resumed generator is already closed. x1
// will hold the generator object until the activation has been resumed.
VisitForStackValue(generator);
VisitForAccumulatorValue(value);
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
// Allocate and populate an object with this form: { value: VAL, done: DONE }
Register result = x0;
- __ Allocate(map->instance_size(), result, x10, x11, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, result, x10, x11, &gc_required, TAG_OBJECT);
__ B(&allocated);
__ Bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ Ldr(context_register(),
MemOperand(fp, StandardFrameConstants::kContextOffset));
Register boolean_done = x3;
Register empty_fixed_array = x4;
Register untagged_result = x5;
- __ Mov(map_reg, Operand(map));
+ __ Ldr(map_reg, GlobalObjectMemOperand());
+ __ Ldr(map_reg, FieldMemOperand(map_reg, GlobalObject::kNativeContextOffset));
+ __ Ldr(map_reg,
+ ContextMemOperand(map_reg, Context::ITERATOR_RESULT_MAP_INDEX));
__ Pop(result_value);
__ Mov(boolean_done, Operand(isolate()->factory()->ToBoolean(done)));
__ Mov(empty_fixed_array, Operand(isolate()->factory()->empty_fixed_array()));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
STATIC_ASSERT(JSObject::kPropertiesOffset + kPointerSize ==
JSObject::kElementsOffset);
STATIC_ASSERT(JSGeneratorObject::kResultValuePropertyOffset + kPointerSize ==
const Register StoreDescriptor::ValueRegister() { return x0; }
+const Register StoreTransitionDescriptor::MapRegister() { return x3; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() { return x3; }
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // cp: context
+ Register registers[] = {cp};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// cp: context
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#include "src/arm64/lithium-codegen-arm64.h"
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access();
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
stream->Add(" <- ");
value()->PrintTo(stream);
}
(JSShiftAmountFromHConstant(instr->right()) == 0);
bool can_deopt = false;
if ((op == Token::SHR) && right_can_be_zero) {
- if (FLAG_opt_safe_uint32_operations) {
- can_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- can_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ can_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result;
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ Mov(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ Mov(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(x0));
- __ Mov(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(instr->hydrogen()->slot()));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
+ __ Mov(VectorLoadICDescriptor::SlotRegister(), Smi::FromInt(index));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
DCHECK(ToRegister(instr->result()).Is(x0));
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
DCHECK(ToRegister(instr->result()).is(x0));
}
+void MacroAssembler::Frintp(const FPRegister& fd, const FPRegister& fn) {
+ DCHECK(allow_macro_instructions_);
+ frintp(fd, fn);
+}
+
+
void MacroAssembler::Frintz(const FPRegister& fd, const FPRegister& fn) {
DCHECK(allow_macro_instructions_);
frintz(fd, fn);
}
+void MacroAssembler::Umull(const Register& rd, const Register& rn,
+ const Register& rm) {
+ DCHECK(allow_macro_instructions_);
+ DCHECK(!rd.IsZero());
+ umaddl(rd, rn, rm, xzr);
+}
+
+
void MacroAssembler::Stnp(const CPURegister& rt,
const CPURegister& rt2,
const MemOperand& dst) {
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on arm64.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
DCHECK(jssp.Is(StackPointer()));
UseScratchRegisterScope temps(this);
inline void Frinta(const FPRegister& fd, const FPRegister& fn);
inline void Frintm(const FPRegister& fd, const FPRegister& fn);
inline void Frintn(const FPRegister& fd, const FPRegister& fn);
+ inline void Frintp(const FPRegister& fd, const FPRegister& fn);
inline void Frintz(const FPRegister& fd, const FPRegister& fn);
inline void Fsqrt(const FPRegister& fd, const FPRegister& fn);
inline void Fsub(const FPRegister& fd,
inline void Smulh(const Register& rd,
const Register& rn,
const Register& rm);
+ inline void Umull(const Register& rd, const Register& rn, const Register& rm);
inline void Stnp(const CPURegister& rt,
const CPURegister& rt2,
const MemOperand& dst);
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Returns map with validated enum cache in object register.
set_sreg(fd, FPRoundInt(sreg(fn), FPNegativeInfinity)); break;
case FRINTM_d:
set_dreg(fd, FPRoundInt(dreg(fn), FPNegativeInfinity)); break;
+ case FRINTP_s:
+ set_sreg(fd, FPRoundInt(sreg(fn), FPPositiveInfinity));
+ break;
+ case FRINTP_d:
+ set_dreg(fd, FPRoundInt(dreg(fn), FPPositiveInfinity));
+ break;
case FRINTN_s: set_sreg(fd, FPRoundInt(sreg(fn), FPTieEven)); break;
case FRINTN_d: set_dreg(fd, FPRoundInt(dreg(fn), FPTieEven)); break;
case FRINTZ_s: set_sreg(fd, FPRoundInt(sreg(fn), FPZero)); break;
// We always use floor(value).
break;
}
+ case FPPositiveInfinity: {
+ int_result = ceil(value);
+ break;
+ }
default: UNIMPLEMENTED();
}
return int_result;
%FunctionSetName(ArrayIteratorIterator, '[Symbol.iterator]');
%AddNamedProperty(ArrayIterator.prototype, symbolIterator,
ArrayIteratorIterator, DONT_ENUM);
+ %AddNamedProperty(ArrayIterator.prototype, symbolToStringTag,
+ "Array Iterator", READ_ONLY | DONT_ENUM);
}
SetUpArrayIterator();
%CheckIsBootstrapping();
InstallFunctions($Array.prototype, DONT_ENUM, $Array(
+ // No 'values' since it breaks webcompat: http://crbug.com/409858
'entries', ArrayEntries,
- 'values', ArrayValues,
'keys', ArrayKeys
));
// Only use the sparse variant on arrays that are likely to be sparse and the
// number of elements touched in the operation is relatively small compared to
// the overall size of the array.
- if (!is_array || length < 1000 || %IsObserved(array)) {
+ if (!is_array || length < 1000 || %IsObserved(array) ||
+ %HasComplexElements(array)) {
return false;
}
if (!%_IsSmi(length)) {
// This function implements the optimized splice implementation that can use
// special array operations to handle sparse arrays in a sensible fashion.
-function SmartSlice(array, start_i, del_count, len, deleted_elements) {
+function SparseSlice(array, start_i, del_count, len, deleted_elements) {
// Move deleted elements to a new array (the return value from splice).
var indices = %GetArrayKeys(array, start_i + del_count);
if (IS_NUMBER(indices)) {
for (var i = start_i; i < limit; ++i) {
var current = array[i];
if (!IS_UNDEFINED(current) || i in array) {
- deleted_elements[i - start_i] = current;
+ %AddElement(deleted_elements, i - start_i, current, NONE);
}
}
} else {
if (key >= start_i) {
var current = array[key];
if (!IS_UNDEFINED(current) || key in array) {
- deleted_elements[key - start_i] = current;
+ %AddElement(deleted_elements, key - start_i, current, NONE);
}
}
}
// This function implements the optimized splice implementation that can use
// special array operations to handle sparse arrays in a sensible fashion.
-function SmartMove(array, start_i, del_count, len, num_additional_args) {
+function SparseMove(array, start_i, del_count, len, num_additional_args) {
+ // Bail out if no moving is necessary.
+ if (num_additional_args === del_count) return;
// Move data to new array.
var new_array = new InternalArray(len - del_count + num_additional_args);
var indices = %GetArrayKeys(array, len);
function SimpleSlice(array, start_i, del_count, len, deleted_elements) {
for (var i = 0; i < del_count; i++) {
var index = start_i + i;
- // The spec could also be interpreted such that %HasOwnProperty
- // would be the appropriate test. We follow KJS in consulting the
- // prototype.
- var current = array[index];
- if (!IS_UNDEFINED(current) || index in array) {
- deleted_elements[i] = current;
+ if (index in array) {
+ var current = array[index];
+ // The spec requires [[DefineOwnProperty]] here, %AddElement is close
+ // enough (in that it ignores the prototype).
+ %AddElement(deleted_elements, i, current, NONE);
}
}
}
for (var i = len - del_count; i > start_i; i--) {
var from_index = i + del_count - 1;
var to_index = i + num_additional_args - 1;
- // The spec could also be interpreted such that
- // %HasOwnProperty would be the appropriate test. We follow
- // KJS in consulting the prototype.
- var current = array[from_index];
- if (!IS_UNDEFINED(current) || from_index in array) {
- array[to_index] = current;
+ if (from_index in array) {
+ array[to_index] = array[from_index];
} else {
delete array[to_index];
}
for (var i = start_i; i < len - del_count; i++) {
var from_index = i + del_count;
var to_index = i + num_additional_args;
- // The spec could also be interpreted such that
- // %HasOwnProperty would be the appropriate test. We follow
- // KJS in consulting the prototype.
- var current = array[from_index];
- if (!IS_UNDEFINED(current) || from_index in array) {
- array[to_index] = current;
+ if (from_index in array) {
+ array[to_index] = array[from_index];
} else {
delete array[to_index];
}
func = array.join;
}
if (!IS_SPEC_FUNCTION(func)) {
- return %_CallFunction(array, ObjectToString);
+ return %_CallFunction(array, NoSideEffectsObjectToString);
}
return %_CallFunction(array, func);
}
var result = %_FastOneByteArrayJoin(array, separator);
if (!IS_UNDEFINED(result)) return result;
+ // Fast case for one-element arrays.
+ if (length === 1) {
+ var e = array[0];
+ if (IS_STRING(e)) return e;
+ if (IS_NULL_OR_UNDEFINED(e)) return '';
+ return NonStringToString(e);
+ }
+
return Join(array, length, separator, ConvertToString);
}
var first = array[0];
- if (IS_ARRAY(array)) {
- SmartMove(array, 0, 1, len, 0);
+ if (UseSparseVariant(array, len, IS_ARRAY(array), len)) {
+ SparseMove(array, 0, 1, len, 0);
} else {
SimpleMove(array, 0, 1, len, 0);
}
var array = TO_OBJECT_INLINE(this);
var len = TO_UINT32(array.length);
var num_arguments = %_ArgumentsLength();
- var is_sealed = ObjectIsSealed(array);
- if (IS_ARRAY(array) && !is_sealed && len > 0) {
- SmartMove(array, 0, 0, len, num_arguments);
+ if (len > 0 && UseSparseVariant(array, len, IS_ARRAY(array), len) &&
+ !ObjectIsSealed(array)) {
+ SparseMove(array, 0, 0, len, num_arguments);
} else {
SimpleMove(array, 0, 0, len, num_arguments);
}
if (UseSparseVariant(array, len, IS_ARRAY(array), end_i - start_i)) {
%NormalizeElements(array);
%NormalizeElements(result);
- SmartSlice(array, start_i, end_i - start_i, len, result);
+ SparseSlice(array, start_i, end_i - start_i, len, result);
} else {
SimpleSlice(array, start_i, end_i - start_i, len, result);
}
if (UseSparseVariant(array, len, IS_ARRAY(array), changed_elements)) {
%NormalizeElements(array);
%NormalizeElements(deleted_elements);
- SmartSlice(array, start_i, del_count, len, deleted_elements);
- SmartMove(array, start_i, del_count, len, num_elements_to_add);
+ SparseSlice(array, start_i, del_count, len, deleted_elements);
+ SparseMove(array, start_i, del_count, len, num_elements_to_add);
} else {
SimpleSlice(array, start_i, del_count, len, deleted_elements);
SimpleMove(array, start_i, del_count, len, num_elements_to_add);
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [ f ]);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(receiver)) {
receiver = %GetDefaultReceiver(f) || receiver;
- } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f)) {
- receiver = ToObject(receiver);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
}
var result = new $Array();
var element = array[i];
// Prepare break slots for debugger step in.
if (stepping) %DebugPrepareStepInIfStepping(f);
- if (%_CallFunction(receiver, element, i, array, f)) {
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ if (%_CallFunction(new_receiver, element, i, array, f)) {
accumulator[accumulator_length++] = element;
}
}
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [ f ]);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(receiver)) {
receiver = %GetDefaultReceiver(f) || receiver;
- } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f)) {
- receiver = ToObject(receiver);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
}
var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
var element = array[i];
// Prepare break slots for debugger step in.
if (stepping) %DebugPrepareStepInIfStepping(f);
- %_CallFunction(receiver, element, i, array, f);
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ %_CallFunction(new_receiver, element, i, array, f);
}
}
}
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [ f ]);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(receiver)) {
receiver = %GetDefaultReceiver(f) || receiver;
- } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f)) {
- receiver = ToObject(receiver);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
}
var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
var element = array[i];
// Prepare break slots for debugger step in.
if (stepping) %DebugPrepareStepInIfStepping(f);
- if (%_CallFunction(receiver, element, i, array, f)) return true;
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ if (%_CallFunction(new_receiver, element, i, array, f)) return true;
}
}
return false;
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [ f ]);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(receiver)) {
receiver = %GetDefaultReceiver(f) || receiver;
- } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f)) {
- receiver = ToObject(receiver);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
}
var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
var element = array[i];
// Prepare break slots for debugger step in.
if (stepping) %DebugPrepareStepInIfStepping(f);
- if (!%_CallFunction(receiver, element, i, array, f)) return false;
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ if (!%_CallFunction(new_receiver, element, i, array, f)) return false;
}
}
return true;
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [ f ]);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(receiver)) {
receiver = %GetDefaultReceiver(f) || receiver;
- } else if (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(f)) {
- receiver = ToObject(receiver);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
}
var result = new $Array();
var element = array[i];
// Prepare break slots for debugger step in.
if (stepping) %DebugPrepareStepInIfStepping(f);
- accumulator[i] = %_CallFunction(receiver, element, i, array, f);
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ accumulator[i] = %_CallFunction(new_receiver, element, i, array, f);
}
}
%MoveArrayContents(accumulator, result);
var i = 0;
find_initial: if (%_ArgumentsLength() < 2) {
for (; i < length; i++) {
- current = array[i];
- if (!IS_UNDEFINED(current) || i in array) {
- i++;
+ if (i in array) {
+ current = array[i++];
break find_initial;
}
}
var i = length - 1;
find_initial: if (%_ArgumentsLength() < 2) {
for (; i >= 0; i--) {
- current = array[i];
- if (!IS_UNDEFINED(current) || i in array) {
- i--;
+ if (i in array) {
+ current = array[i--];
break find_initial;
}
}
find: true,
findIndex: true,
keys: true,
- values: true,
};
%AddNamedProperty($Array.prototype, symbolUnscopables, unscopables,
DONT_ENUM | READ_ONLY);
%AddNamedProperty(
$ArrayBuffer.prototype, "constructor", $ArrayBuffer, DONT_ENUM);
+ %AddNamedProperty($ArrayBuffer.prototype,
+ symbolToStringTag, "ArrayBuffer", DONT_ENUM | READ_ONLY);
+
InstallGetter($ArrayBuffer.prototype, "byteLength", ArrayBufferGetByteLen);
InstallFunctions($ArrayBuffer, DONT_ENUM, $Array(
#include <cmath>
#include "src/api.h"
#include "src/base/cpu.h"
+#include "src/base/functional.h"
#include "src/base/lazy-instance.h"
#include "src/base/platform/platform.h"
#include "src/builtins.h"
emit_debug_code_(FLAG_debug_code),
predictable_code_size_(false),
// We may use the assembler without an isolate.
- serializer_enabled_(isolate && isolate->serializer_enabled()) {
+ serializer_enabled_(isolate && isolate->serializer_enabled()),
+ ool_constant_pool_available_(false) {
if (FLAG_mask_constants_with_cookie && isolate != NULL) {
jit_cookie_ = isolate->random_number_generator()->NextInt();
}
}
-void RelocInfo::Print(Isolate* isolate, OStream& os) { // NOLINT
- os << pc_ << " " << RelocModeName(rmode_);
+void RelocInfo::Print(Isolate* isolate, std::ostream& os) { // NOLINT
+ os << static_cast<const void*>(pc_) << " " << RelocModeName(rmode_);
if (IsComment(rmode_)) {
os << " (" << reinterpret_cast<char*>(data_) << ")";
} else if (rmode_ == EMBEDDED_OBJECT) {
} else if (rmode_ == EXTERNAL_REFERENCE) {
ExternalReferenceEncoder ref_encoder(isolate);
os << " (" << ref_encoder.NameOfAddress(target_reference()) << ") ("
- << target_reference() << ")";
+ << static_cast<const void*>(target_reference()) << ")";
} else if (IsCodeTarget(rmode_)) {
Code* code = Code::GetCodeFromTargetAddress(target_address());
- os << " (" << Code::Kind2String(code->kind()) << ") (" << target_address()
- << ")";
+ os << " (" << Code::Kind2String(code->kind()) << ") ("
+ << static_cast<const void*>(target_address()) << ")";
if (rmode_ == CODE_TARGET_WITH_ID) {
os << " (id=" << static_cast<int>(data_) << ")";
}
}
+bool operator==(ExternalReference lhs, ExternalReference rhs) {
+ return lhs.address() == rhs.address();
+}
+
+
+bool operator!=(ExternalReference lhs, ExternalReference rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(ExternalReference reference) {
+ return base::hash<Address>()(reference.address());
+}
+
+
+std::ostream& operator<<(std::ostream& os, ExternalReference reference) {
+ os << static_cast<const void*>(reference.address());
+ const Runtime::Function* fn = Runtime::FunctionForEntry(reference.address());
+ if (fn) os << "<" << fn->name << ".entry>";
+ return os;
+}
+
+
void PositionsRecorder::RecordPosition(int pos) {
DCHECK(pos != RelocInfo::kNoPosition);
DCHECK(pos >= 0);
return (enabled_cpu_features_ & (static_cast<uint64_t>(1) << f)) != 0;
}
+ bool is_ool_constant_pool_available() const {
+ if (FLAG_enable_ool_constant_pool) {
+ return ool_constant_pool_available_;
+ } else {
+ // Out-of-line constant pool not supported on this architecture.
+ UNREACHABLE();
+ return false;
+ }
+ }
+
// Overwrite a host NaN with a quiet target NaN. Used by mksnapshot for
// cross-snapshotting.
static void QuietNaN(HeapObject* nan) { }
int buffer_size_;
bool own_buffer_;
+ void set_ool_constant_pool_available(bool available) {
+ if (FLAG_enable_ool_constant_pool) {
+ ool_constant_pool_available_ = available;
+ } else {
+ // Out-of-line constant pool not supported on this architecture.
+ UNREACHABLE();
+ }
+ }
+
// The program counter, which points into the buffer above and moves forward.
byte* pc_;
bool emit_debug_code_;
bool predictable_code_size_;
bool serializer_enabled_;
+
+ // Indicates whether the constant pool can be accessed, which is only possible
+ // if the pp register points to the current code object's constant pool.
+ bool ool_constant_pool_available_;
+
+ // Constant pool.
+ friend class FrameAndConstantPoolScope;
+ friend class ConstantPoolUnavailableScope;
};
// unknown pc location. Assembler::bind() is used to bind a label to the
// current pc. A label can be bound only once.
-class Label BASE_EMBEDDED {
+class Label {
public:
enum Distance {
kNear, kFar
#ifdef ENABLE_DISASSEMBLER
// Printing
static const char* RelocModeName(Mode rmode);
- void Print(Isolate* isolate, OStream& os); // NOLINT
+ void Print(Isolate* isolate, std::ostream& os); // NOLINT
#endif // ENABLE_DISASSEMBLER
#ifdef VERIFY_HEAP
void Verify(Isolate* isolate);
static ExternalReference stress_deopt_count(Isolate* isolate);
- bool operator==(const ExternalReference& other) const {
- return address_ == other.address_;
- }
-
- bool operator!=(const ExternalReference& other) const {
- return !(*this == other);
- }
-
private:
explicit ExternalReference(void* address)
: address_(address) {}
void* address_;
};
+bool operator==(ExternalReference, ExternalReference);
+bool operator!=(ExternalReference, ExternalReference);
+
+size_t hash_value(ExternalReference);
+
+std::ostream& operator<<(std::ostream&, ExternalReference);
+
// -----------------------------------------------------------------------------
// Position recording support
#ifndef V8_ASSERT_SCOPE_H_
#define V8_ASSERT_SCOPE_H_
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/macros.h"
namespace v8 {
--- /dev/null
+// Copyright 2012 the V8 project 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/ast.h"
+#include "src/ast-numbering.h"
+#include "src/compiler.h"
+#include "src/scopes.h"
+
+namespace v8 {
+namespace internal {
+
+
+class AstNumberingVisitor FINAL : public AstVisitor {
+ public:
+ explicit AstNumberingVisitor(Zone* zone)
+ : AstVisitor(), next_id_(BailoutId::FirstUsable().ToInt()) {
+ InitializeAstVisitor(zone);
+ }
+
+ void Renumber(FunctionLiteral* node);
+
+ private:
+// AST node visitor interface.
+#define DEFINE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+ AST_NODE_LIST(DEFINE_VISIT)
+#undef DEFINE_VISIT
+
+ void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitArguments(ZoneList<Expression*>* arguments);
+ void VisitObjectLiteralProperty(ObjectLiteralProperty* property);
+
+ int ReserveIdRange(int n) {
+ int tmp = next_id_;
+ next_id_ += n;
+ return tmp;
+ }
+
+ void IncrementNodeCount() { properties_.add_node_count(1); }
+
+ int next_id_;
+ AstProperties properties_;
+
+ DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
+ DISALLOW_COPY_AND_ASSIGN(AstNumberingVisitor);
+};
+
+
+void AstNumberingVisitor::VisitVariableDeclaration(VariableDeclaration* node) {
+ IncrementNodeCount();
+ VisitVariableProxy(node->proxy());
+}
+
+
+void AstNumberingVisitor::VisitExportDeclaration(ExportDeclaration* node) {
+ IncrementNodeCount();
+ VisitVariableProxy(node->proxy());
+}
+
+
+void AstNumberingVisitor::VisitModuleUrl(ModuleUrl* node) {
+ IncrementNodeCount();
+}
+
+
+void AstNumberingVisitor::VisitEmptyStatement(EmptyStatement* node) {
+ IncrementNodeCount();
+}
+
+
+void AstNumberingVisitor::VisitContinueStatement(ContinueStatement* node) {
+ IncrementNodeCount();
+}
+
+
+void AstNumberingVisitor::VisitBreakStatement(BreakStatement* node) {
+ IncrementNodeCount();
+}
+
+
+void AstNumberingVisitor::VisitDebuggerStatement(DebuggerStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(DebuggerStatement::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitNativeFunctionLiteral(
+ NativeFunctionLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(NativeFunctionLiteral::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitLiteral(Literal* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Literal::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitRegExpLiteral(RegExpLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(RegExpLiteral::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitVariableProxy(VariableProxy* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(VariableProxy::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitThisFunction(ThisFunction* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ThisFunction::num_ids()));
+}
+
+
+void AstNumberingVisitor::VisitSuperReference(SuperReference* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(SuperReference::num_ids()));
+ Visit(node->this_var());
+}
+
+
+void AstNumberingVisitor::VisitModuleDeclaration(ModuleDeclaration* node) {
+ IncrementNodeCount();
+ VisitVariableProxy(node->proxy());
+ Visit(node->module());
+}
+
+
+void AstNumberingVisitor::VisitImportDeclaration(ImportDeclaration* node) {
+ IncrementNodeCount();
+ VisitVariableProxy(node->proxy());
+ Visit(node->module());
+}
+
+
+void AstNumberingVisitor::VisitModuleVariable(ModuleVariable* node) {
+ IncrementNodeCount();
+ Visit(node->proxy());
+}
+
+
+void AstNumberingVisitor::VisitModulePath(ModulePath* node) {
+ IncrementNodeCount();
+ Visit(node->module());
+}
+
+
+void AstNumberingVisitor::VisitModuleStatement(ModuleStatement* node) {
+ IncrementNodeCount();
+ Visit(node->body());
+}
+
+
+void AstNumberingVisitor::VisitExpressionStatement(ExpressionStatement* node) {
+ IncrementNodeCount();
+ Visit(node->expression());
+}
+
+
+void AstNumberingVisitor::VisitReturnStatement(ReturnStatement* node) {
+ IncrementNodeCount();
+ Visit(node->expression());
+}
+
+
+void AstNumberingVisitor::VisitYield(Yield* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Yield::num_ids()));
+ Visit(node->generator_object());
+ Visit(node->expression());
+}
+
+
+void AstNumberingVisitor::VisitThrow(Throw* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Throw::num_ids()));
+ Visit(node->exception());
+}
+
+
+void AstNumberingVisitor::VisitUnaryOperation(UnaryOperation* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(UnaryOperation::num_ids()));
+ Visit(node->expression());
+}
+
+
+void AstNumberingVisitor::VisitCountOperation(CountOperation* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(CountOperation::num_ids()));
+ Visit(node->expression());
+}
+
+
+void AstNumberingVisitor::VisitBlock(Block* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Block::num_ids()));
+ if (node->scope() != NULL) VisitDeclarations(node->scope()->declarations());
+ VisitStatements(node->statements());
+}
+
+
+void AstNumberingVisitor::VisitFunctionDeclaration(FunctionDeclaration* node) {
+ IncrementNodeCount();
+ VisitVariableProxy(node->proxy());
+ VisitFunctionLiteral(node->fun());
+}
+
+
+void AstNumberingVisitor::VisitModuleLiteral(ModuleLiteral* node) {
+ IncrementNodeCount();
+ VisitBlock(node->body());
+}
+
+
+void AstNumberingVisitor::VisitCallRuntime(CallRuntime* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(CallRuntime::num_ids()));
+ VisitArguments(node->arguments());
+}
+
+
+void AstNumberingVisitor::VisitWithStatement(WithStatement* node) {
+ IncrementNodeCount();
+ Visit(node->expression());
+ Visit(node->statement());
+}
+
+
+void AstNumberingVisitor::VisitDoWhileStatement(DoWhileStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(DoWhileStatement::num_ids()));
+ Visit(node->body());
+ Visit(node->cond());
+}
+
+
+void AstNumberingVisitor::VisitWhileStatement(WhileStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(WhileStatement::num_ids()));
+ Visit(node->cond());
+ Visit(node->body());
+}
+
+
+void AstNumberingVisitor::VisitTryCatchStatement(TryCatchStatement* node) {
+ IncrementNodeCount();
+ Visit(node->try_block());
+ Visit(node->catch_block());
+}
+
+
+void AstNumberingVisitor::VisitTryFinallyStatement(TryFinallyStatement* node) {
+ IncrementNodeCount();
+ Visit(node->try_block());
+ Visit(node->finally_block());
+}
+
+
+void AstNumberingVisitor::VisitProperty(Property* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Property::num_ids()));
+ Visit(node->key());
+ Visit(node->obj());
+}
+
+
+void AstNumberingVisitor::VisitAssignment(Assignment* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Assignment::num_ids()));
+ if (node->is_compound()) VisitBinaryOperation(node->binary_operation());
+ Visit(node->target());
+ Visit(node->value());
+}
+
+
+void AstNumberingVisitor::VisitBinaryOperation(BinaryOperation* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(BinaryOperation::num_ids()));
+ Visit(node->left());
+ Visit(node->right());
+}
+
+
+void AstNumberingVisitor::VisitCompareOperation(CompareOperation* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(CompareOperation::num_ids()));
+ Visit(node->left());
+ Visit(node->right());
+}
+
+
+void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ForInStatement::num_ids()));
+ Visit(node->each());
+ Visit(node->enumerable());
+ Visit(node->body());
+}
+
+
+void AstNumberingVisitor::VisitForOfStatement(ForOfStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ForOfStatement::num_ids()));
+ Visit(node->assign_iterator());
+ Visit(node->next_result());
+ Visit(node->result_done());
+ Visit(node->assign_each());
+ Visit(node->body());
+}
+
+
+void AstNumberingVisitor::VisitConditional(Conditional* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Conditional::num_ids()));
+ Visit(node->condition());
+ Visit(node->then_expression());
+ Visit(node->else_expression());
+}
+
+
+void AstNumberingVisitor::VisitIfStatement(IfStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(IfStatement::num_ids()));
+ Visit(node->condition());
+ Visit(node->then_statement());
+ if (node->HasElseStatement()) {
+ Visit(node->else_statement());
+ }
+}
+
+
+void AstNumberingVisitor::VisitSwitchStatement(SwitchStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(SwitchStatement::num_ids()));
+ Visit(node->tag());
+ ZoneList<CaseClause*>* cases = node->cases();
+ for (int i = 0; i < cases->length(); i++) {
+ VisitCaseClause(cases->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitCaseClause(CaseClause* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(CaseClause::num_ids()));
+ if (!node->is_default()) Visit(node->label());
+ VisitStatements(node->statements());
+}
+
+
+void AstNumberingVisitor::VisitForStatement(ForStatement* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ForStatement::num_ids()));
+ if (node->init() != NULL) Visit(node->init());
+ if (node->cond() != NULL) Visit(node->cond());
+ if (node->next() != NULL) Visit(node->next());
+ Visit(node->body());
+}
+
+
+void AstNumberingVisitor::VisitClassLiteral(ClassLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ClassLiteral::num_ids()));
+ if (node->extends()) Visit(node->extends());
+ if (node->constructor()) Visit(node->constructor());
+ for (int i = 0; i < node->properties()->length(); i++) {
+ VisitObjectLiteralProperty(node->properties()->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitObjectLiteral(ObjectLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(ObjectLiteral::num_ids()));
+ for (int i = 0; i < node->properties()->length(); i++) {
+ VisitObjectLiteralProperty(node->properties()->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitObjectLiteralProperty(
+ ObjectLiteralProperty* node) {
+ Visit(node->key());
+ Visit(node->value());
+}
+
+
+void AstNumberingVisitor::VisitArrayLiteral(ArrayLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(node->num_ids()));
+ for (int i = 0; i < node->values()->length(); i++) {
+ Visit(node->values()->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitCall(Call* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(Call::num_ids()));
+ Visit(node->expression());
+ VisitArguments(node->arguments());
+}
+
+
+void AstNumberingVisitor::VisitCallNew(CallNew* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(CallNew::num_ids()));
+ Visit(node->expression());
+ VisitArguments(node->arguments());
+}
+
+
+void AstNumberingVisitor::VisitStatements(ZoneList<Statement*>* statements) {
+ if (statements == NULL) return;
+ for (int i = 0; i < statements->length(); i++) {
+ Visit(statements->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitDeclarations(
+ ZoneList<Declaration*>* declarations) {
+ for (int i = 0; i < declarations->length(); i++) {
+ Visit(declarations->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitArguments(ZoneList<Expression*>* arguments) {
+ for (int i = 0; i < arguments->length(); i++) {
+ Visit(arguments->at(i));
+ }
+}
+
+
+void AstNumberingVisitor::VisitFunctionLiteral(FunctionLiteral* node) {
+ IncrementNodeCount();
+ node->set_base_id(ReserveIdRange(FunctionLiteral::num_ids()));
+ // We don't recurse into the declarations or body of the function literal:
+ // you have to separately Renumber() each FunctionLiteral that you compile.
+}
+
+
+void AstNumberingVisitor::Renumber(FunctionLiteral* node) {
+ properties_.flags()->Add(*node->flags());
+ properties_.increase_feedback_slots(node->slot_count());
+ properties_.increase_ic_feedback_slots(node->ic_slot_count());
+
+ if (node->scope()->HasIllegalRedeclaration()) {
+ node->scope()->VisitIllegalRedeclaration(this);
+ return;
+ }
+
+ Scope* scope = node->scope();
+ VisitDeclarations(scope->declarations());
+ if (scope->is_function_scope() && scope->function() != NULL) {
+ // Visit the name of the named function expression.
+ Visit(scope->function());
+ }
+ VisitStatements(node->body());
+
+ node->set_ast_properties(&properties_);
+}
+
+
+bool AstNumbering::Renumber(FunctionLiteral* function, Zone* zone) {
+ AstNumberingVisitor visitor(zone);
+ visitor.Renumber(function);
+ return !visitor.HasStackOverflow();
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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.
+
+#ifndef V8_AST_NUMBERING_H_
+#define V8_AST_NUMBERING_H_
+
+namespace v8 {
+namespace internal {
+
+namespace AstNumbering {
+// Assign type feedback IDs and bailout IDs to an AST node tree.
+//
+bool Renumber(FunctionLiteral* function, Zone* zone);
+}
+}
+} // namespace v8::internal
+
+#endif // V8_AST_NUMBERING_H_
bool AstRawString::Compare(void* a, void* b) {
- AstRawString* string1 = reinterpret_cast<AstRawString*>(a);
- AstRawString* string2 = reinterpret_cast<AstRawString*>(b);
- if (string1->is_one_byte_ != string2->is_one_byte_) return false;
- if (string1->hash_ != string2->hash_) return false;
- int length = string1->literal_bytes_.length();
- if (string2->literal_bytes_.length() != length) return false;
- return memcmp(string1->literal_bytes_.start(),
- string2->literal_bytes_.start(), length) == 0;
+ return *static_cast<AstRawString*>(a) == *static_cast<AstRawString*>(b);
+}
+
+bool AstRawString::operator==(const AstRawString& rhs) const {
+ if (is_one_byte_ != rhs.is_one_byte_) return false;
+ if (hash_ != rhs.hash_) return false;
+ int len = literal_bytes_.length();
+ if (rhs.literal_bytes_.length() != len) return false;
+ return memcmp(literal_bytes_.start(), rhs.literal_bytes_.start(), len) == 0;
}
return DoubleToBoolean(number_);
case SMI:
return smi_ != 0;
- case STRING_ARRAY:
- UNREACHABLE();
- break;
case BOOLEAN:
return bool_;
case NULL_TYPE:
value_ = isolate->factory()->false_value();
}
break;
- case STRING_ARRAY: {
- DCHECK(strings_ != NULL);
- Factory* factory = isolate->factory();
- int len = strings_->length();
- Handle<FixedArray> elements = factory->NewFixedArray(len, TENURED);
- for (int i = 0; i < len; i++) {
- const AstRawString* string = (*strings_)[i];
- Handle<Object> element = string->string();
- // Strings are already internalized.
- DCHECK(!element.is_null());
- elements->set(i, *element);
- }
- value_ =
- factory->NewJSArrayWithElements(elements, FAST_ELEMENTS, TENURED);
- break;
- }
case NULL_TYPE:
value_ = isolate->factory()->null_value();
break;
}
-const AstRawString* AstValueFactory::GetOneByteString(
+AstRawString* AstValueFactory::GetOneByteStringInternal(
Vector<const uint8_t> literal) {
uint32_t hash = StringHasher::HashSequentialString<uint8_t>(
literal.start(), literal.length(), hash_seed_);
}
-const AstRawString* AstValueFactory::GetTwoByteString(
+AstRawString* AstValueFactory::GetTwoByteStringInternal(
Vector<const uint16_t> literal) {
uint32_t hash = StringHasher::HashSequentialString<uint16_t>(
literal.start(), literal.length(), hash_seed_);
const AstRawString* AstValueFactory::GetString(Handle<String> literal) {
- DisallowHeapAllocation no_gc;
- String::FlatContent content = literal->GetFlatContent();
- if (content.IsOneByte()) {
- return GetOneByteString(content.ToOneByteVector());
+ // For the FlatContent to stay valid, we shouldn't do any heap
+ // allocation. Make sure we won't try to internalize the string in GetString.
+ AstRawString* result = NULL;
+ Isolate* saved_isolate = isolate_;
+ isolate_ = NULL;
+ {
+ DisallowHeapAllocation no_gc;
+ String::FlatContent content = literal->GetFlatContent();
+ if (content.IsOneByte()) {
+ result = GetOneByteStringInternal(content.ToOneByteVector());
+ } else {
+ DCHECK(content.IsTwoByte());
+ result = GetTwoByteStringInternal(content.ToUC16Vector());
+ }
}
- DCHECK(content.IsTwoByte());
- return GetTwoByteString(content.ToUC16Vector());
+ isolate_ = saved_isolate;
+ if (isolate_) result->Internalize(isolate_);
+ return result;
}
}
-const AstValue* AstValueFactory::NewBoolean(bool b) {
- AstValue* value = new (zone_) AstValue(b);
- if (isolate_) {
- value->Internalize(isolate_);
- }
- values_.Add(value);
+#define GENERATE_VALUE_GETTER(value, initializer) \
+ if (!value) { \
+ value = new (zone_) AstValue(initializer); \
+ if (isolate_) { \
+ value->Internalize(isolate_); \
+ } \
+ values_.Add(value); \
+ } \
return value;
-}
-const AstValue* AstValueFactory::NewStringList(
- ZoneList<const AstRawString*>* strings) {
- AstValue* value = new (zone_) AstValue(strings);
- if (isolate_) {
- value->Internalize(isolate_);
+const AstValue* AstValueFactory::NewBoolean(bool b) {
+ if (b) {
+ GENERATE_VALUE_GETTER(true_value_, true);
+ } else {
+ GENERATE_VALUE_GETTER(false_value_, false);
}
- values_.Add(value);
- return value;
}
const AstValue* AstValueFactory::NewNull() {
- AstValue* value = new (zone_) AstValue(AstValue::NULL_TYPE);
- if (isolate_) {
- value->Internalize(isolate_);
- }
- values_.Add(value);
- return value;
+ GENERATE_VALUE_GETTER(null_value_, AstValue::NULL_TYPE);
}
const AstValue* AstValueFactory::NewUndefined() {
- AstValue* value = new (zone_) AstValue(AstValue::UNDEFINED);
- if (isolate_) {
- value->Internalize(isolate_);
- }
- values_.Add(value);
- return value;
+ GENERATE_VALUE_GETTER(undefined_value_, AstValue::UNDEFINED);
}
const AstValue* AstValueFactory::NewTheHole() {
- AstValue* value = new (zone_) AstValue(AstValue::THE_HOLE);
- if (isolate_) {
- value->Internalize(isolate_);
- }
- values_.Add(value);
- return value;
+ GENERATE_VALUE_GETTER(the_hole_value_, AstValue::THE_HOLE);
}
-const AstRawString* AstValueFactory::GetString(
- uint32_t hash, bool is_one_byte, Vector<const byte> literal_bytes) {
+#undef GENERATE_VALUE_GETTER
+
+AstRawString* AstValueFactory::GetString(uint32_t hash, bool is_one_byte,
+ Vector<const byte> literal_bytes) {
// literal_bytes here points to whatever the user passed, and this is OK
// because we use vector_compare (which checks the contents) to compare
// against the AstRawStrings which are in the string_table_. We should not
return *c;
}
+ V8_INLINE bool IsArguments(AstValueFactory* ast_value_factory) const;
+
// For storing AstRawStrings in a hash map.
uint32_t hash() const {
return hash_;
}
static bool Compare(void* a, void* b);
+ bool operator==(const AstRawString& rhs) const;
+
private:
friend class AstValueFactory;
friend class AstRawStringInternalizationKey;
NUMBER,
SMI,
BOOLEAN,
- STRING_ARRAY,
NULL_TYPE,
UNDEFINED,
THE_HOLE
explicit AstValue(bool b) : type_(BOOLEAN) { bool_ = b; }
- explicit AstValue(ZoneList<const AstRawString*>* s) : type_(STRING_ARRAY) {
- strings_ = s;
- }
-
explicit AstValue(Type t) : type_(t) {
DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
}
};
-// For generating string constants.
-#define STRING_CONSTANTS(F) \
- F(anonymous_function, "(anonymous function)") \
- F(arguments, "arguments") \
- F(constructor, "constructor") \
- F(done, "done") \
- F(dot, ".") \
- F(dot_for, ".for") \
- F(dot_generator, ".generator") \
- F(dot_generator_object, ".generator_object") \
- F(dot_iterator, ".iterator") \
- F(dot_module, ".module") \
- F(dot_result, ".result") \
- F(empty, "") \
- F(eval, "eval") \
- F(initialize_const_global, "initializeConstGlobal") \
- F(initialize_var_global, "initializeVarGlobal") \
- F(make_reference_error, "MakeReferenceError") \
- F(make_syntax_error, "MakeSyntaxError") \
- F(make_type_error, "MakeTypeError") \
- F(module, "module") \
- F(native, "native") \
- F(next, "next") \
- F(proto, "__proto__") \
- F(prototype, "prototype") \
- F(this, "this") \
- F(use_asm, "use asm") \
- F(use_strict, "use strict") \
+// For generating constants.
+#define STRING_CONSTANTS(F) \
+ F(anonymous_function, "(anonymous function)") \
+ F(arguments, "arguments") \
+ F(constructor, "constructor") \
+ F(done, "done") \
+ F(dot, ".") \
+ F(dot_for, ".for") \
+ F(dot_generator, ".generator") \
+ F(dot_generator_object, ".generator_object") \
+ F(dot_iterator, ".iterator") \
+ F(dot_module, ".module") \
+ F(dot_result, ".result") \
+ F(empty, "") \
+ F(eval, "eval") \
+ F(initialize_const_global, "initializeConstGlobal") \
+ F(initialize_var_global, "initializeVarGlobal") \
+ F(make_reference_error, "MakeReferenceErrorEmbedded") \
+ F(make_syntax_error, "MakeSyntaxErrorEmbedded") \
+ F(make_type_error, "MakeTypeErrorEmbedded") \
+ F(module, "module") \
+ F(native, "native") \
+ F(next, "next") \
+ F(proto, "__proto__") \
+ F(prototype, "prototype") \
+ F(this, "this") \
+ F(use_asm, "use asm") \
+ F(use_strict, "use strict") \
F(value, "value")
+#define OTHER_CONSTANTS(F) \
+ F(true_value) \
+ F(false_value) \
+ F(null_value) \
+ F(undefined_value) \
+ F(the_hole_value)
class AstValueFactory {
public:
zone_(zone),
isolate_(NULL),
hash_seed_(hash_seed) {
-#define F(name, str) \
- name##_string_ = NULL;
+#define F(name, str) name##_string_ = NULL;
STRING_CONSTANTS(F)
#undef F
+#define F(name) name##_ = NULL;
+ OTHER_CONSTANTS(F)
+#undef F
}
- const AstRawString* GetOneByteString(Vector<const uint8_t> literal);
+ Zone* zone() const { return zone_; }
+
+ const AstRawString* GetOneByteString(Vector<const uint8_t> literal) {
+ return GetOneByteStringInternal(literal);
+ }
const AstRawString* GetOneByteString(const char* string) {
return GetOneByteString(Vector<const uint8_t>(
reinterpret_cast<const uint8_t*>(string), StrLength(string)));
}
- const AstRawString* GetTwoByteString(Vector<const uint16_t> literal);
+ const AstRawString* GetTwoByteString(Vector<const uint16_t> literal) {
+ return GetTwoByteStringInternal(literal);
+ }
const AstRawString* GetString(Handle<String> literal);
const AstConsString* NewConsString(const AstString* left,
const AstString* right);
return isolate_ != NULL;
}
-#define F(name, str) \
- const AstRawString* name##_string() { \
- if (name##_string_ == NULL) { \
- const char* data = str; \
- name##_string_ = GetOneByteString( \
+#define F(name, str) \
+ const AstRawString* name##_string() { \
+ if (name##_string_ == NULL) { \
+ const char* data = str; \
+ name##_string_ = GetOneByteString( \
Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), \
- static_cast<int>(strlen(data)))); \
- } \
- return name##_string_; \
+ static_cast<int>(strlen(data)))); \
+ } \
+ return name##_string_; \
}
STRING_CONSTANTS(F)
#undef F
const AstValue* NewTheHole();
private:
- const AstRawString* GetString(uint32_t hash, bool is_one_byte,
- Vector<const byte> literal_bytes);
+ AstRawString* GetOneByteStringInternal(Vector<const uint8_t> literal);
+ AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
+ AstRawString* GetString(uint32_t hash, bool is_one_byte,
+ Vector<const byte> literal_bytes);
// All strings are copied here, one after another (no NULLs inbetween).
HashMap string_table_;
uint32_t hash_seed_;
-#define F(name, str) \
- const AstRawString* name##_string_;
+#define F(name, str) const AstRawString* name##_string_;
STRING_CONSTANTS(F)
#undef F
+
+#define F(name) AstValue* name##_;
+ OTHER_CONSTANTS(F)
+#undef F
};
+
+bool AstRawString::IsArguments(AstValueFactory* ast_value_factory) const {
+ return ast_value_factory->arguments_string() == this;
+}
} } // namespace v8::internal
#undef STRING_CONSTANTS
+#undef OTHER_CONSTANTS
#endif // V8_AST_VALUE_FACTORY_H_
}
-VariableProxy::VariableProxy(Zone* zone, Variable* var, int position,
- IdGen* id_gen)
- : Expression(zone, position, id_gen),
- name_(var->raw_name()),
- var_(NULL), // Will be set by the call to BindTo.
- is_this_(var->is_this()),
- is_assigned_(false),
- interface_(var->interface()),
- variable_feedback_slot_(kInvalidFeedbackSlot) {
+VariableProxy::VariableProxy(Zone* zone, Variable* var, int position)
+ : Expression(zone, position),
+ bit_field_(IsThisField::encode(var->is_this()) |
+ IsAssignedField::encode(false) |
+ IsResolvedField::encode(false)),
+ variable_feedback_slot_(FeedbackVectorICSlot::Invalid()),
+ raw_name_(var->raw_name()),
+ interface_(var->interface()) {
BindTo(var);
}
VariableProxy::VariableProxy(Zone* zone, const AstRawString* name, bool is_this,
- Interface* interface, int position, IdGen* id_gen)
- : Expression(zone, position, id_gen),
- name_(name),
- var_(NULL),
- is_this_(is_this),
- is_assigned_(false),
- interface_(interface),
- variable_feedback_slot_(kInvalidFeedbackSlot) {}
+ Interface* interface, int position)
+ : Expression(zone, position),
+ bit_field_(IsThisField::encode(is_this) | IsAssignedField::encode(false) |
+ IsResolvedField::encode(false)),
+ variable_feedback_slot_(FeedbackVectorICSlot::Invalid()),
+ raw_name_(name),
+ interface_(interface) {}
void VariableProxy::BindTo(Variable* var) {
- DCHECK(var_ == NULL); // must be bound only once
- DCHECK(var != NULL); // must bind
DCHECK(!FLAG_harmony_modules || interface_->IsUnified(var->interface()));
- DCHECK((is_this() && var->is_this()) || name_ == var->raw_name());
+ DCHECK((is_this() && var->is_this()) || raw_name() == var->raw_name());
// Ideally CONST-ness should match. However, this is very hard to achieve
// because we don't know the exact semantics of conflicting (const and
// non-const) multiple variable declarations, const vars introduced via
// eval() etc. Const-ness and variable declarations are a complete mess
// in JS. Sigh...
- var_ = var;
+ set_var(var);
+ set_is_resolved();
var->set_is_used();
}
Assignment::Assignment(Zone* zone, Token::Value op, Expression* target,
- Expression* value, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
- op_(op),
+ Expression* value, int pos)
+ : Expression(zone, pos),
+ bit_field_(IsUninitializedField::encode(false) |
+ KeyTypeField::encode(ELEMENT) |
+ StoreModeField::encode(STANDARD_STORE) |
+ TokenField::encode(op)),
target_(target),
value_(value),
- binary_operation_(NULL),
- assignment_id_(id_gen->GetNextId()),
- is_uninitialized_(false),
- store_mode_(STANDARD_STORE) {}
+ binary_operation_(NULL) {}
Token::Value Assignment::binary_op() const {
- switch (op_) {
+ switch (op()) {
case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
case Token::ASSIGN_BIT_AND: return Token::BIT_AND;
bool BinaryOperation::ResultOverwriteAllowed() const {
- switch (op_) {
+ switch (op()) {
case Token::COMMA:
case Token::OR:
case Token::AND:
// once we use the common type field in the AST consistently.
void Expression::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
- to_boolean_types_ = oracle->ToBooleanTypes(test_id());
+ set_to_boolean_types(oracle->ToBooleanTypes(test_id()));
}
}
}
+ if (expression()->AsSuperReference() != NULL) return SUPER_CALL;
+
Property* property = expression()->AsProperty();
return property != NULL ? PROPERTY_CALL : OTHER_CALL;
}
void CallNew::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
- int allocation_site_feedback_slot = FLAG_pretenuring_call_new
- ? AllocationSiteFeedbackSlot()
- : CallNewFeedbackSlot();
+ FeedbackVectorSlot allocation_site_feedback_slot =
+ FLAG_pretenuring_call_new ? AllocationSiteFeedbackSlot()
+ : CallNewFeedbackSlot();
allocation_site_ =
oracle->GetCallNewAllocationSite(allocation_site_feedback_slot);
is_monomorphic_ = oracle->CallNewIsMonomorphic(CallNewFeedbackSlot());
// output formats are alike.
class RegExpUnparser FINAL : public RegExpVisitor {
public:
- RegExpUnparser(OStream& os, Zone* zone) : os_(os), zone_(zone) {}
+ RegExpUnparser(std::ostream& os, Zone* zone) : os_(os), zone_(zone) {}
void VisitCharacterRange(CharacterRange that);
#define MAKE_CASE(Name) virtual void* Visit##Name(RegExp##Name*, \
void* data) OVERRIDE;
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
#undef MAKE_CASE
private:
- OStream& os_;
+ std::ostream& os_;
Zone* zone_;
};
}
-OStream& RegExpTree::Print(OStream& os, Zone* zone) { // NOLINT
+std::ostream& RegExpTree::Print(std::ostream& os, Zone* zone) { // NOLINT
RegExpUnparser unparser(os, zone);
Accept(&unparser, NULL);
return os;
CaseClause::CaseClause(Zone* zone, Expression* label,
- ZoneList<Statement*>* statements, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ ZoneList<Statement*>* statements, int pos)
+ : Expression(zone, pos),
label_(label),
statements_(statements),
- compare_type_(Type::None(zone)),
- compare_id_(id_gen->GetNextId()),
- entry_id_(id_gen->GetNextId()) {}
+ compare_type_(Type::None(zone)) {}
#define REGULAR_NODE(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
}
#define REGULAR_NODE_WITH_FEEDBACK_SLOTS(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
add_slot_node(node); \
}
#define DONT_OPTIMIZE_NODE(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
set_dont_crankshaft_reason(k##NodeType); \
add_flag(kDontSelfOptimize); \
}
#define DONT_OPTIMIZE_NODE_WITH_FEEDBACK_SLOTS(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
add_slot_node(node); \
set_dont_crankshaft_reason(k##NodeType); \
add_flag(kDontSelfOptimize); \
}
#define DONT_TURBOFAN_NODE(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
+ set_dont_crankshaft_reason(k##NodeType); \
+ set_dont_turbofan_reason(k##NodeType); \
+ add_flag(kDontSelfOptimize); \
+ }
+#define DONT_TURBOFAN_NODE_WITH_FEEDBACK_SLOTS(NodeType) \
+ void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
+ add_slot_node(node); \
set_dont_crankshaft_reason(k##NodeType); \
set_dont_turbofan_reason(k##NodeType); \
add_flag(kDontSelfOptimize); \
}
#define DONT_SELFOPTIMIZE_NODE(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
add_flag(kDontSelfOptimize); \
}
#define DONT_SELFOPTIMIZE_NODE_WITH_FEEDBACK_SLOTS(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
add_slot_node(node); \
add_flag(kDontSelfOptimize); \
}
#define DONT_CACHE_NODE(NodeType) \
void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
- increase_node_count(); \
set_dont_crankshaft_reason(k##NodeType); \
add_flag(kDontSelfOptimize); \
add_flag(kDontCache); \
DONT_OPTIMIZE_NODE(ModuleStatement)
DONT_OPTIMIZE_NODE(WithStatement)
DONT_OPTIMIZE_NODE(DebuggerStatement)
-DONT_OPTIMIZE_NODE(ClassLiteral)
DONT_OPTIMIZE_NODE(NativeFunctionLiteral)
-DONT_OPTIMIZE_NODE(SuperReference)
DONT_OPTIMIZE_NODE_WITH_FEEDBACK_SLOTS(Yield)
// TODO(turbofan): Remove the dont_turbofan_reason once this list is empty.
+// This list must be kept in sync with Pipeline::GenerateCode.
DONT_TURBOFAN_NODE(ForOfStatement)
DONT_TURBOFAN_NODE(TryCatchStatement)
DONT_TURBOFAN_NODE(TryFinallyStatement)
+DONT_TURBOFAN_NODE(ClassLiteral)
+
+DONT_TURBOFAN_NODE_WITH_FEEDBACK_SLOTS(SuperReference)
DONT_SELFOPTIMIZE_NODE(DoWhileStatement)
DONT_SELFOPTIMIZE_NODE(WhileStatement)
void AstConstructionVisitor::VisitCallRuntime(CallRuntime* node) {
- increase_node_count();
add_slot_node(node);
if (node->is_jsruntime()) {
// Don't try to optimize JS runtime calls because we bailout on them.
#undef DONT_CACHE_NODE
-Handle<String> Literal::ToString() {
- if (value_->IsString()) return value_->AsString()->string();
- DCHECK(value_->IsNumber());
- char arr[100];
- Vector<char> buffer(arr, arraysize(arr));
- const char* str;
- if (value()->IsSmi()) {
- // Optimization only, the heap number case would subsume this.
- SNPrintF(buffer, "%d", Smi::cast(*value())->value());
- str = arr;
- } else {
- str = DoubleToCString(value()->Number(), buffer);
- }
- return isolate_->factory()->NewStringFromAsciiChecked(str);
+uint32_t Literal::Hash() {
+ return raw_value()->IsString()
+ ? raw_value()->AsString()->hash()
+ : ComputeLongHash(double_to_uint64(raw_value()->AsNumber()));
+}
+
+
+// static
+bool Literal::Match(void* literal1, void* literal2) {
+ const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
+ const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
+ return (x->IsString() && y->IsString() && *x->AsString() == *y->AsString()) ||
+ (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
}
#include "src/ast-value-factory.h"
#include "src/bailout-reason.h"
#include "src/factory.h"
-#include "src/feedback-slots.h"
#include "src/interface.h"
#include "src/isolate.h"
#include "src/jsregexp.h"
class Expression;
class IterationStatement;
class MaterializedLiteral;
-class OStream;
class Statement;
class TargetCollector;
class TypeFeedbackOracle;
};
+class FeedbackVectorRequirements {
+ public:
+ FeedbackVectorRequirements(int slots, int ic_slots)
+ : slots_(slots), ic_slots_(ic_slots) {}
+
+ int slots() const { return slots_; }
+ int ic_slots() const { return ic_slots_; }
+
+ private:
+ int slots_;
+ int ic_slots_;
+};
+
+
class AstProperties FINAL BASE_EMBEDDED {
public:
class Flags : public EnumSet<AstPropertiesFlag, int> {};
-AstProperties() : node_count_(0), feedback_slots_(0) {}
+ AstProperties() : node_count_(0), feedback_slots_(0), ic_feedback_slots_(0) {}
Flags* flags() { return &flags_; }
int node_count() { return node_count_; }
feedback_slots_ += count;
}
+ int ic_feedback_slots() const { return ic_feedback_slots_; }
+ void increase_ic_feedback_slots(int count) { ic_feedback_slots_ += count; }
+
private:
Flags flags_;
int node_count_;
int feedback_slots_;
+ int ic_feedback_slots_;
};
class AstNode: public ZoneObject {
public:
- // For generating IDs for AstNodes.
- class IdGen {
- public:
- explicit IdGen(int id = 0) : id_(id) {}
-
- int GetNextId() { return ReserveIdRange(1); }
- int ReserveIdRange(int n) {
- int tmp = id_;
- id_ += n;
- return tmp;
- }
-
- private:
- int id_;
- };
-
#define DECLARE_TYPE_ENUM(type) k##type,
enum NodeType {
AST_NODE_LIST(DECLARE_TYPE_ENUM)
virtual IterationStatement* AsIterationStatement() { return NULL; }
virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
- protected:
- // Some nodes re-use bailout IDs for type feedback.
- static TypeFeedbackId reuse(BailoutId id) {
- return TypeFeedbackId(id.ToInt());
+ // The interface for feedback slots, with default no-op implementations for
+ // node types which don't actually have this. Note that this is conceptually
+ // not really nice, but multiple inheritance would introduce yet another
+ // vtable entry per node, something we don't want for space reasons.
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() {
+ return FeedbackVectorRequirements(0, 0);
+ }
+ virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) { UNREACHABLE(); }
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) {
+ UNREACHABLE();
}
-
private:
// Hidden to prevent accidental usage. It would have to load the
void set_bounds(Bounds bounds) { bounds_ = bounds; }
// Whether the expression is parenthesized
- unsigned parenthesization_level() const { return parenthesization_level_; }
- bool is_parenthesized() const { return parenthesization_level_ > 0; }
- void increase_parenthesization_level() { ++parenthesization_level_; }
+ bool is_parenthesized() const {
+ return IsParenthesizedField::decode(bit_field_);
+ }
+ bool is_multi_parenthesized() const {
+ return IsMultiParenthesizedField::decode(bit_field_);
+ }
+ void increase_parenthesization_level() {
+ bit_field_ =
+ IsMultiParenthesizedField::update(bit_field_, is_parenthesized());
+ bit_field_ = IsParenthesizedField::update(bit_field_, true);
+ }
// Type feedback information for assignments and properties.
virtual bool IsMonomorphic() {
UNREACHABLE();
return NULL;
}
- virtual KeyedAccessStoreMode GetStoreMode() {
+ virtual KeyedAccessStoreMode GetStoreMode() const {
UNREACHABLE();
return STANDARD_STORE;
}
+ virtual IcCheckType GetKeyType() const {
+ UNREACHABLE();
+ return ELEMENT;
+ }
// TODO(rossberg): this should move to its own AST node eventually.
virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
- byte to_boolean_types() const { return to_boolean_types_; }
+ byte to_boolean_types() const {
+ return ToBooleanTypesField::decode(bit_field_);
+ }
- BailoutId id() const { return id_; }
- TypeFeedbackId test_id() const { return test_id_; }
+ void set_base_id(int id) { base_id_ = id; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId id() const { return BailoutId(local_id(0)); }
+ TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
protected:
- Expression(Zone* zone, int pos, IdGen* id_gen)
+ Expression(Zone* zone, int pos)
: AstNode(pos),
+ base_id_(BailoutId::None().ToInt()),
bounds_(Bounds::Unbounded(zone)),
- parenthesization_level_(0),
- id_(id_gen->GetNextId()),
- test_id_(id_gen->GetNextId()) {}
- void set_to_boolean_types(byte types) { to_boolean_types_ = types; }
+ bit_field_(0) {}
+ static int parent_num_ids() { return 0; }
+ void set_to_boolean_types(byte types) {
+ bit_field_ = ToBooleanTypesField::update(bit_field_, types);
+ }
+
+ int base_id() const {
+ DCHECK(!BailoutId(base_id_).IsNone());
+ return base_id_;
+ }
private:
- Bounds bounds_;
- byte to_boolean_types_;
- unsigned parenthesization_level_;
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
- const BailoutId id_;
- const TypeFeedbackId test_id_;
+ int base_id_;
+ Bounds bounds_;
+ class ToBooleanTypesField : public BitField16<byte, 0, 8> {};
+ class IsParenthesizedField : public BitField16<bool, 8, 1> {};
+ class IsMultiParenthesizedField : public BitField16<bool, 9, 1> {};
+ uint16_t bit_field_;
+ // Ends with 16-bit field; deriving classes in turn begin with
+ // 16-bit fields for optimum packing efficiency.
};
return breakable_type_ == TARGET_FOR_ANONYMOUS;
}
- BailoutId EntryId() const { return entry_id_; }
- BailoutId ExitId() const { return exit_id_; }
+ void set_base_id(int id) { base_id_ = id; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId EntryId() const { return BailoutId(local_id(0)); }
+ BailoutId ExitId() const { return BailoutId(local_id(1)); }
protected:
BreakableStatement(Zone* zone, ZoneList<const AstRawString*>* labels,
- BreakableType breakable_type, int position, IdGen* id_gen)
+ BreakableType breakable_type, int position)
: Statement(zone, position),
labels_(labels),
breakable_type_(breakable_type),
- entry_id_(id_gen->GetNextId()),
- exit_id_(id_gen->GetNextId()) {
+ base_id_(BailoutId::None().ToInt()) {
DCHECK(labels == NULL || labels->length() > 0);
}
+ static int parent_num_ids() { return 0; }
+ int base_id() const {
+ DCHECK(!BailoutId(base_id_).IsNone());
+ return base_id_;
+ }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
ZoneList<const AstRawString*>* labels_;
BreakableType breakable_type_;
Label break_target_;
- const BailoutId entry_id_;
- const BailoutId exit_id_;
+ int base_id_;
};
ZoneList<Statement*>* statements() { return &statements_; }
bool is_initializer_block() const { return is_initializer_block_; }
- BailoutId DeclsId() const { return decls_id_; }
+ static int num_ids() { return parent_num_ids() + 1; }
+ BailoutId DeclsId() const { return BailoutId(local_id(0)); }
virtual bool IsJump() const OVERRIDE {
return !statements_.is_empty() && statements_.last()->IsJump()
protected:
Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
- bool is_initializer_block, int pos, IdGen* id_gen)
- : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos, id_gen),
+ bool is_initializer_block, int pos)
+ : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
statements_(capacity, zone),
is_initializer_block_(is_initializer_block),
- decls_id_(id_gen->GetNextId()),
scope_(NULL) {}
+ static int parent_num_ids() { return BreakableStatement::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
ZoneList<Statement*> statements_;
bool is_initializer_block_;
- const BailoutId decls_id_;
Scope* scope_;
};
virtual bool IsInlineable() const;
protected:
- Declaration(Zone* zone,
- VariableProxy* proxy,
- VariableMode mode,
- Scope* scope,
+ Declaration(Zone* zone, VariableProxy* proxy, VariableMode mode, Scope* scope,
int pos)
- : AstNode(pos),
- proxy_(proxy),
- mode_(mode),
- scope_(scope) {
+ : AstNode(pos), mode_(mode), proxy_(proxy), scope_(scope) {
DCHECK(IsDeclaredVariableMode(mode));
}
private:
- VariableProxy* proxy_;
VariableMode mode_;
+ VariableProxy* proxy_;
// Nested scope from which the declaration originated.
Scope* scope_;
Statement* body() const { return body_; }
- BailoutId OsrEntryId() const { return osr_entry_id_; }
+ static int num_ids() { return parent_num_ids() + 1; }
+ BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
virtual BailoutId ContinueId() const = 0;
virtual BailoutId StackCheckId() const = 0;
Label* continue_target() { return &continue_target_; }
protected:
- IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos, id_gen),
- body_(NULL),
- osr_entry_id_(id_gen->GetNextId()) {}
-
- void Initialize(Statement* body) {
- body_ = body;
- }
+ IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
+ body_(NULL) {}
+ static int parent_num_ids() { return BreakableStatement::num_ids(); }
+ void Initialize(Statement* body) { body_ = body; }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Statement* body_;
Label continue_target_;
-
- const BailoutId osr_entry_id_;
};
Expression* cond() const { return cond_; }
- virtual BailoutId ContinueId() const OVERRIDE { return continue_id_; }
- virtual BailoutId StackCheckId() const OVERRIDE { return back_edge_id_; }
- BailoutId BackEdgeId() const { return back_edge_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ virtual BailoutId ContinueId() const OVERRIDE {
+ return BailoutId(local_id(0));
+ }
+ virtual BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
+ BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
protected:
- DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : IterationStatement(zone, labels, pos, id_gen),
- cond_(NULL),
- continue_id_(id_gen->GetNextId()),
- back_edge_id_(id_gen->GetNextId()) {}
+ DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : IterationStatement(zone, labels, pos), cond_(NULL) {}
+ static int parent_num_ids() { return IterationStatement::num_ids(); }
private:
- Expression* cond_;
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
- const BailoutId continue_id_;
- const BailoutId back_edge_id_;
+ Expression* cond_;
};
may_have_function_literal_ = value;
}
+ static int num_ids() { return parent_num_ids() + 1; }
virtual BailoutId ContinueId() const OVERRIDE { return EntryId(); }
- virtual BailoutId StackCheckId() const OVERRIDE { return body_id_; }
- BailoutId BodyId() const { return body_id_; }
+ virtual BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+ BailoutId BodyId() const { return BailoutId(local_id(0)); }
protected:
- WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : IterationStatement(zone, labels, pos, id_gen),
+ WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : IterationStatement(zone, labels, pos),
cond_(NULL),
- may_have_function_literal_(true),
- body_id_(id_gen->GetNextId()) {}
+ may_have_function_literal_(true) {}
+ static int parent_num_ids() { return IterationStatement::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Expression* cond_;
// True if there is a function literal subexpression in the condition.
bool may_have_function_literal_;
-
- const BailoutId body_id_;
};
may_have_function_literal_ = value;
}
- virtual BailoutId ContinueId() const OVERRIDE { return continue_id_; }
- virtual BailoutId StackCheckId() const OVERRIDE { return body_id_; }
- BailoutId BodyId() const { return body_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ virtual BailoutId ContinueId() const OVERRIDE {
+ return BailoutId(local_id(0));
+ }
+ virtual BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+ BailoutId BodyId() const { return BailoutId(local_id(1)); }
bool is_fast_smi_loop() { return loop_variable_ != NULL; }
Variable* loop_variable() { return loop_variable_; }
void set_loop_variable(Variable* var) { loop_variable_ = var; }
protected:
- ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : IterationStatement(zone, labels, pos, id_gen),
+ ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : IterationStatement(zone, labels, pos),
init_(NULL),
cond_(NULL),
next_(NULL),
may_have_function_literal_(true),
- loop_variable_(NULL),
- continue_id_(id_gen->GetNextId()),
- body_id_(id_gen->GetNextId()) {}
+ loop_variable_(NULL) {}
+ static int parent_num_ids() { return IterationStatement::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Statement* init_;
Expression* cond_;
Statement* next_;
// True if there is a function literal subexpression in the condition.
bool may_have_function_literal_;
Variable* loop_variable_;
-
- const BailoutId continue_id_;
- const BailoutId body_id_;
};
Expression* subject() const { return subject_; }
protected:
- ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : IterationStatement(zone, labels, pos, id_gen),
- each_(NULL),
- subject_(NULL) {}
+ ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : IterationStatement(zone, labels, pos), each_(NULL), subject_(NULL) {}
private:
Expression* each_;
};
-class ForInStatement FINAL : public ForEachStatement,
- public FeedbackSlotInterface {
+class ForInStatement FINAL : public ForEachStatement {
public:
DECLARE_NODE_TYPE(ForInStatement)
}
// Type feedback information.
- virtual int ComputeFeedbackSlotCount() { return 1; }
- virtual void SetFirstFeedbackSlot(int slot) { for_in_feedback_slot_ = slot; }
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(1, 0);
+ }
+ virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+ for_in_feedback_slot_ = slot;
+ }
- int ForInFeedbackSlot() {
- DCHECK(for_in_feedback_slot_ != kInvalidFeedbackSlot);
+ FeedbackVectorSlot ForInFeedbackSlot() {
+ DCHECK(!for_in_feedback_slot_.IsInvalid());
return for_in_feedback_slot_;
}
ForInType for_in_type() const { return for_in_type_; }
void set_for_in_type(ForInType type) { for_in_type_ = type; }
- BailoutId BodyId() const { return body_id_; }
- BailoutId PrepareId() const { return prepare_id_; }
+ static int num_ids() { return parent_num_ids() + 4; }
+ BailoutId BodyId() const { return BailoutId(local_id(0)); }
+ BailoutId PrepareId() const { return BailoutId(local_id(1)); }
+ BailoutId EnumId() const { return BailoutId(local_id(2)); }
+ BailoutId ToObjectId() const { return BailoutId(local_id(3)); }
virtual BailoutId ContinueId() const OVERRIDE { return EntryId(); }
- virtual BailoutId StackCheckId() const OVERRIDE { return body_id_; }
+ virtual BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
protected:
- ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : ForEachStatement(zone, labels, pos, id_gen),
+ ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : ForEachStatement(zone, labels, pos),
for_in_type_(SLOW_FOR_IN),
- for_in_feedback_slot_(kInvalidFeedbackSlot),
- body_id_(id_gen->GetNextId()),
- prepare_id_(id_gen->GetNextId()) {}
+ for_in_feedback_slot_(FeedbackVectorSlot::Invalid()) {}
+ static int parent_num_ids() { return ForEachStatement::num_ids(); }
+
+ private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
ForInType for_in_type_;
- int for_in_feedback_slot_;
- const BailoutId body_id_;
- const BailoutId prepare_id_;
+ FeedbackVectorSlot for_in_feedback_slot_;
};
virtual BailoutId ContinueId() const OVERRIDE { return EntryId(); }
virtual BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
- BailoutId BackEdgeId() const { return back_edge_id_; }
+ static int num_ids() { return parent_num_ids() + 1; }
+ BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
protected:
- ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : ForEachStatement(zone, labels, pos, id_gen),
+ ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : ForEachStatement(zone, labels, pos),
assign_iterator_(NULL),
next_result_(NULL),
result_done_(NULL),
- assign_each_(NULL),
- back_edge_id_(id_gen->GetNextId()) {}
+ assign_each_(NULL) {}
+ static int parent_num_ids() { return ForEachStatement::num_ids(); }
+
+ private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
Expression* assign_iterator_;
Expression* next_result_;
Expression* result_done_;
Expression* assign_each_;
- const BailoutId back_edge_id_;
};
Label* body_target() { return &body_target_; }
ZoneList<Statement*>* statements() const { return statements_; }
- BailoutId EntryId() const { return entry_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId EntryId() const { return BailoutId(local_id(0)); }
+ TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
- // Type feedback information.
- TypeFeedbackId CompareId() { return compare_id_; }
Type* compare_type() { return compare_type_; }
void set_compare_type(Type* type) { compare_type_ = type; }
+ protected:
+ static int parent_num_ids() { return Expression::num_ids(); }
+
private:
CaseClause(Zone* zone, Expression* label, ZoneList<Statement*>* statements,
- int pos, IdGen* id_gen);
+ int pos);
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
Expression* label_;
Label body_target_;
ZoneList<Statement*>* statements_;
Type* compare_type_;
-
- const TypeFeedbackId compare_id_;
- const BailoutId entry_id_;
};
ZoneList<CaseClause*>* cases() const { return cases_; }
protected:
- SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos,
- IdGen* id_gen)
- : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos, id_gen),
+ SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
+ : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
tag_(NULL),
cases_(NULL) {}
&& HasElseStatement() && else_statement()->IsJump();
}
- BailoutId IfId() const { return if_id_; }
- BailoutId ThenId() const { return then_id_; }
- BailoutId ElseId() const { return else_id_; }
+ void set_base_id(int id) { base_id_ = id; }
+ static int num_ids() { return parent_num_ids() + 3; }
+ BailoutId IfId() const { return BailoutId(local_id(0)); }
+ BailoutId ThenId() const { return BailoutId(local_id(1)); }
+ BailoutId ElseId() const { return BailoutId(local_id(2)); }
protected:
IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
- Statement* else_statement, int pos, IdGen* id_gen)
+ Statement* else_statement, int pos)
: Statement(zone, pos),
condition_(condition),
then_statement_(then_statement),
else_statement_(else_statement),
- if_id_(id_gen->GetNextId()),
- then_id_(id_gen->GetNextId()),
- else_id_(id_gen->GetNextId()) {}
+ base_id_(BailoutId::None().ToInt()) {}
+ static int parent_num_ids() { return 0; }
+
+ int base_id() const {
+ DCHECK(!BailoutId(base_id_).IsNone());
+ return base_id_;
+ }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Expression* condition_;
Statement* then_statement_;
Statement* else_statement_;
- const BailoutId if_id_;
- const BailoutId then_id_;
- const BailoutId else_id_;
+ int base_id_;
};
public:
DECLARE_NODE_TYPE(DebuggerStatement)
- BailoutId DebugBreakId() const { return debugger_id_; }
+ void set_base_id(int id) { base_id_ = id; }
+ static int num_ids() { return parent_num_ids() + 1; }
+ BailoutId DebugBreakId() const { return BailoutId(local_id(0)); }
protected:
- explicit DebuggerStatement(Zone* zone, int pos, IdGen* id_gen)
- : Statement(zone, pos), debugger_id_(id_gen->GetNextId()) {}
+ explicit DebuggerStatement(Zone* zone, int pos)
+ : Statement(zone, pos), base_id_(BailoutId::None().ToInt()) {}
+ static int parent_num_ids() { return 0; }
+
+ int base_id() const {
+ DCHECK(!BailoutId(base_id_).IsNone());
+ return base_id_;
+ }
private:
- const BailoutId debugger_id_;
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ int base_id_;
};
// Support for using Literal as a HashMap key. NOTE: Currently, this works
// only for string and number literals!
- uint32_t Hash() { return ToString()->Hash(); }
+ uint32_t Hash();
+ static bool Match(void* literal1, void* literal2);
- static bool Match(void* literal1, void* literal2) {
- Handle<String> s1 = static_cast<Literal*>(literal1)->ToString();
- Handle<String> s2 = static_cast<Literal*>(literal2)->ToString();
- return String::Equals(s1, s2);
+ static int num_ids() { return parent_num_ids() + 1; }
+ TypeFeedbackId LiteralFeedbackId() const {
+ return TypeFeedbackId(local_id(0));
}
- TypeFeedbackId LiteralFeedbackId() const { return reuse(id()); }
-
protected:
- Literal(Zone* zone, const AstValue* value, int position, IdGen* id_gen)
- : Expression(zone, position, id_gen),
- value_(value),
- isolate_(zone->isolate()) {}
+ Literal(Zone* zone, const AstValue* value, int position)
+ : Expression(zone, position), value_(value) {}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
- Handle<String> ToString();
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
const AstValue* value_;
- // TODO(dcarney): remove. this is only needed for Match and Hash.
- Isolate* isolate_;
};
}
protected:
- MaterializedLiteral(Zone* zone, int literal_index, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ MaterializedLiteral(Zone* zone, int literal_index, int pos)
+ : Expression(zone, pos),
literal_index_(literal_index),
is_simple_(false),
depth_(0) {}
void set_emit_store(bool emit_store);
bool emit_store();
+ bool is_static() const { return is_static_; }
+
protected:
template<class> friend class AstNodeFactory;
};
struct Accessors: public ZoneObject {
- Accessors() : getter(NULL), setter(NULL) { }
+ Accessors() : getter(NULL), setter(NULL) {}
Expression* getter;
Expression* setter;
};
+ BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
+
+ static int num_ids() { return parent_num_ids() + 1; }
+
protected:
ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
- int boilerplate_properties, bool has_function, int pos,
- IdGen* id_gen)
- : MaterializedLiteral(zone, literal_index, pos, id_gen),
+ int boilerplate_properties, bool has_function, int pos)
+ : MaterializedLiteral(zone, literal_index, pos),
properties_(properties),
boilerplate_properties_(boilerplate_properties),
fast_elements_(false),
may_store_doubles_(false),
has_function_(has_function) {}
+ static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
Handle<FixedArray> constant_properties_;
ZoneList<Property*>* properties_;
int boilerplate_properties_;
protected:
RegExpLiteral(Zone* zone, const AstRawString* pattern,
- const AstRawString* flags, int literal_index, int pos,
- IdGen* id_gen)
- : MaterializedLiteral(zone, literal_index, pos, id_gen),
+ const AstRawString* flags, int literal_index, int pos)
+ : MaterializedLiteral(zone, literal_index, pos),
pattern_(pattern),
flags_(flags) {
set_depth(1);
Handle<FixedArray> constant_elements() const { return constant_elements_; }
ZoneList<Expression*>* values() const { return values_; }
+ // Unlike other AST nodes, this number of bailout IDs allocated for an
+ // ArrayLiteral can vary, so num_ids() is not a static method.
+ int num_ids() const { return parent_num_ids() + values()->length(); }
+
// Return an AST id for an element that is used in simulate instructions.
- BailoutId GetIdForElement(int i) {
- return BailoutId(first_element_id_.ToInt() + i);
- }
+ BailoutId GetIdForElement(int i) { return BailoutId(local_id(i)); }
// Populate the constant elements fixed array.
void BuildConstantElements(Isolate* isolate);
protected:
ArrayLiteral(Zone* zone, ZoneList<Expression*>* values, int literal_index,
- int pos, IdGen* id_gen)
- : MaterializedLiteral(zone, literal_index, pos, id_gen),
- values_(values),
- first_element_id_(id_gen->ReserveIdRange(values->length())) {}
+ int pos)
+ : MaterializedLiteral(zone, literal_index, pos), values_(values) {}
+ static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Handle<FixedArray> constant_elements_;
ZoneList<Expression*>* values_;
- const BailoutId first_element_id_;
};
-class VariableProxy FINAL : public Expression, public FeedbackSlotInterface {
+class VariableProxy FINAL : public Expression {
public:
DECLARE_NODE_TYPE(VariableProxy)
virtual bool IsValidReferenceExpression() const OVERRIDE {
- return var_ == NULL ? true : var_->IsValidReference();
+ return !is_resolved() || var()->IsValidReference();
}
- bool IsArguments() const { return var_ != NULL && var_->is_arguments(); }
+ bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
- Handle<String> name() const { return name_->string(); }
- const AstRawString* raw_name() const { return name_; }
- Variable* var() const { return var_; }
- bool is_this() const { return is_this_; }
- Interface* interface() const { return interface_; }
+ Handle<String> name() const { return raw_name()->string(); }
+ const AstRawString* raw_name() const {
+ return is_resolved() ? var_->raw_name() : raw_name_;
+ }
+
+ Variable* var() const {
+ DCHECK(is_resolved());
+ return var_;
+ }
+ void set_var(Variable* v) {
+ DCHECK(!is_resolved());
+ DCHECK_NOT_NULL(v);
+ var_ = v;
+ }
+
+ bool is_this() const { return IsThisField::decode(bit_field_); }
- bool is_assigned() const { return is_assigned_; }
- void set_is_assigned() { is_assigned_ = true; }
+ bool is_assigned() const { return IsAssignedField::decode(bit_field_); }
+ void set_is_assigned() {
+ bit_field_ = IsAssignedField::update(bit_field_, true);
+ }
+
+ bool is_resolved() const { return IsResolvedField::decode(bit_field_); }
+ void set_is_resolved() {
+ bit_field_ = IsResolvedField::update(bit_field_, true);
+ }
+
+ Interface* interface() const { return interface_; }
// Bind this proxy to the variable var. Interfaces must match.
void BindTo(Variable* var);
- virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; }
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
+ }
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
variable_feedback_slot_ = slot;
}
- int VariableFeedbackSlot() { return variable_feedback_slot_; }
+ FeedbackVectorICSlot VariableFeedbackSlot() {
+ return variable_feedback_slot_;
+ }
protected:
- VariableProxy(Zone* zone, Variable* var, int position, IdGen* id_gen);
+ VariableProxy(Zone* zone, Variable* var, int position);
VariableProxy(Zone* zone, const AstRawString* name, bool is_this,
- Interface* interface, int position, IdGen* id_gen);
-
- const AstRawString* name_;
- Variable* var_; // resolved variable, or NULL
- bool is_this_;
- bool is_assigned_;
+ Interface* interface, int position);
+
+ class IsThisField : public BitField8<bool, 0, 1> {};
+ class IsAssignedField : public BitField8<bool, 1, 1> {};
+ class IsResolvedField : public BitField8<bool, 2, 1> {};
+
+ // Start with 16-bit (or smaller) field, which should get packed together
+ // with Expression's trailing 16-bit field.
+ uint8_t bit_field_;
+ FeedbackVectorICSlot variable_feedback_slot_;
+ union {
+ const AstRawString* raw_name_; // if !is_resolved_
+ Variable* var_; // if is_resolved_
+ };
Interface* interface_;
- int variable_feedback_slot_;
};
-class Property FINAL : public Expression, public FeedbackSlotInterface {
+class Property FINAL : public Expression {
public:
DECLARE_NODE_TYPE(Property)
Expression* obj() const { return obj_; }
Expression* key() const { return key_; }
- BailoutId LoadId() const { return load_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId LoadId() const { return BailoutId(local_id(0)); }
+ TypeFeedbackId PropertyFeedbackId() { return TypeFeedbackId(local_id(1)); }
- bool IsStringAccess() const { return is_string_access_; }
+ bool IsStringAccess() const {
+ return IsStringAccessField::decode(bit_field_);
+ }
// Type feedback information.
virtual bool IsMonomorphic() OVERRIDE {
virtual SmallMapList* GetReceiverTypes() OVERRIDE {
return &receiver_types_;
}
- virtual KeyedAccessStoreMode GetStoreMode() OVERRIDE {
+ virtual KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
return STANDARD_STORE;
}
- bool IsUninitialized() { return !is_for_call_ && is_uninitialized_; }
- bool HasNoTypeInformation() {
- return is_uninitialized_;
+ virtual IcCheckType GetKeyType() const OVERRIDE {
+ // PROPERTY key types currently aren't implemented for KeyedLoadICs.
+ return ELEMENT;
+ }
+ bool IsUninitialized() const {
+ return !is_for_call() && HasNoTypeInformation();
+ }
+ bool HasNoTypeInformation() const {
+ return IsUninitializedField::decode(bit_field_);
}
- void set_is_uninitialized(bool b) { is_uninitialized_ = b; }
- void set_is_string_access(bool b) { is_string_access_ = b; }
- void mark_for_call() { is_for_call_ = true; }
- bool IsForCall() { return is_for_call_; }
+ void set_is_uninitialized(bool b) {
+ bit_field_ = IsUninitializedField::update(bit_field_, b);
+ }
+ void set_is_string_access(bool b) {
+ bit_field_ = IsStringAccessField::update(bit_field_, b);
+ }
+ void mark_for_call() {
+ bit_field_ = IsForCallField::update(bit_field_, true);
+ }
+ bool is_for_call() const { return IsForCallField::decode(bit_field_); }
bool IsSuperAccess() {
return obj()->IsSuperReference();
}
- TypeFeedbackId PropertyFeedbackId() { return reuse(id()); }
-
- virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; }
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
+ }
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
property_feedback_slot_ = slot;
}
- int PropertyFeedbackSlot() const { return property_feedback_slot_; }
+ FeedbackVectorICSlot PropertyFeedbackSlot() const {
+ return property_feedback_slot_;
+ }
protected:
- Property(Zone* zone, Expression* obj, Expression* key, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ Property(Zone* zone, Expression* obj, Expression* key, int pos)
+ : Expression(zone, pos),
+ bit_field_(IsForCallField::encode(false) |
+ IsUninitializedField::encode(false) |
+ IsStringAccessField::encode(false)),
+ property_feedback_slot_(FeedbackVectorICSlot::Invalid()),
obj_(obj),
- key_(key),
- load_id_(id_gen->GetNextId()),
- property_feedback_slot_(kInvalidFeedbackSlot),
- is_for_call_(false),
- is_uninitialized_(false),
- is_string_access_(false) {}
+ key_(key) {}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ class IsForCallField : public BitField8<bool, 0, 1> {};
+ class IsUninitializedField : public BitField8<bool, 1, 1> {};
+ class IsStringAccessField : public BitField8<bool, 2, 1> {};
+ uint8_t bit_field_;
+ FeedbackVectorICSlot property_feedback_slot_;
Expression* obj_;
Expression* key_;
- const BailoutId load_id_;
- int property_feedback_slot_;
-
SmallMapList receiver_types_;
- bool is_for_call_ : 1;
- bool is_uninitialized_ : 1;
- bool is_string_access_ : 1;
};
-class Call FINAL : public Expression, public FeedbackSlotInterface {
+class Call FINAL : public Expression {
public:
DECLARE_NODE_TYPE(Call)
ZoneList<Expression*>* arguments() const { return arguments_; }
// Type feedback information.
- virtual int ComputeFeedbackSlotCount() { return 1; }
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(0, 1);
+ }
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
call_feedback_slot_ = slot;
}
- bool HasCallFeedbackSlot() const {
- return call_feedback_slot_ != kInvalidFeedbackSlot;
- }
- int CallFeedbackSlot() const { return call_feedback_slot_; }
+ bool HasCallFeedbackSlot() const { return !call_feedback_slot_.IsInvalid(); }
+ FeedbackVectorICSlot CallFeedbackSlot() const { return call_feedback_slot_; }
virtual SmallMapList* GetReceiverTypes() OVERRIDE {
if (expression()->IsProperty()) {
}
bool ComputeGlobalTarget(Handle<GlobalObject> global, LookupIterator* it);
- BailoutId ReturnId() const { return return_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId ReturnId() const { return BailoutId(local_id(0)); }
+ BailoutId EvalOrLookupId() const { return BailoutId(local_id(1)); }
enum CallType {
POSSIBLY_EVAL_CALL,
GLOBAL_CALL,
LOOKUP_SLOT_CALL,
PROPERTY_CALL,
+ SUPER_CALL,
OTHER_CALL
};
protected:
Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
- int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ int pos)
+ : Expression(zone, pos),
+ call_feedback_slot_(FeedbackVectorICSlot::Invalid()),
expression_(expression),
- arguments_(arguments),
- call_feedback_slot_(kInvalidFeedbackSlot),
- return_id_(id_gen->GetNextId()) {
+ arguments_(arguments) {
if (expression->IsProperty()) {
expression->AsProperty()->mark_for_call();
}
}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ FeedbackVectorICSlot call_feedback_slot_;
Expression* expression_;
ZoneList<Expression*>* arguments_;
-
Handle<JSFunction> target_;
Handle<Cell> cell_;
Handle<AllocationSite> allocation_site_;
- int call_feedback_slot_;
-
- const BailoutId return_id_;
};
-class CallNew FINAL : public Expression, public FeedbackSlotInterface {
+class CallNew FINAL : public Expression {
public:
DECLARE_NODE_TYPE(CallNew)
ZoneList<Expression*>* arguments() const { return arguments_; }
// Type feedback information.
- virtual int ComputeFeedbackSlotCount() {
- return FLAG_pretenuring_call_new ? 2 : 1;
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(FLAG_pretenuring_call_new ? 2 : 1, 0);
}
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
callnew_feedback_slot_ = slot;
}
- int CallNewFeedbackSlot() {
- DCHECK(callnew_feedback_slot_ != kInvalidFeedbackSlot);
- return callnew_feedback_slot_;
- }
- int AllocationSiteFeedbackSlot() {
- DCHECK(callnew_feedback_slot_ != kInvalidFeedbackSlot);
+ FeedbackVectorSlot CallNewFeedbackSlot() { return callnew_feedback_slot_; }
+ FeedbackVectorSlot AllocationSiteFeedbackSlot() {
DCHECK(FLAG_pretenuring_call_new);
- return callnew_feedback_slot_ + 1;
+ return CallNewFeedbackSlot().next();
}
void RecordTypeFeedback(TypeFeedbackOracle* oracle);
return allocation_site_;
}
+ static int num_ids() { return parent_num_ids() + 1; }
static int feedback_slots() { return 1; }
-
- BailoutId ReturnId() const { return return_id_; }
+ BailoutId ReturnId() const { return BailoutId(local_id(0)); }
protected:
CallNew(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
- int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ int pos)
+ : Expression(zone, pos),
expression_(expression),
arguments_(arguments),
is_monomorphic_(false),
- callnew_feedback_slot_(kInvalidFeedbackSlot),
- return_id_(id_gen->GetNextId()) {}
+ callnew_feedback_slot_(FeedbackVectorSlot::Invalid()) {}
+
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Expression* expression_;
ZoneList<Expression*>* arguments_;
-
bool is_monomorphic_;
Handle<JSFunction> target_;
Handle<AllocationSite> allocation_site_;
- int callnew_feedback_slot_;
-
- const BailoutId return_id_;
+ FeedbackVectorSlot callnew_feedback_slot_;
};
// language construct. Instead it is used to call a C or JS function
// with a set of arguments. This is used from the builtins that are
// implemented in JavaScript (see "v8natives.js").
-class CallRuntime FINAL : public Expression, public FeedbackSlotInterface {
+class CallRuntime FINAL : public Expression {
public:
DECLARE_NODE_TYPE(CallRuntime)
bool is_jsruntime() const { return function_ == NULL; }
// Type feedback information.
- virtual int ComputeFeedbackSlotCount() {
- return (FLAG_vector_ics && is_jsruntime()) ? 1 : 0;
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(
+ 0, (FLAG_vector_ics && is_jsruntime()) ? 1 : 0);
}
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
callruntime_feedback_slot_ = slot;
}
- int CallRuntimeFeedbackSlot() {
- DCHECK(!is_jsruntime() ||
- callruntime_feedback_slot_ != kInvalidFeedbackSlot);
+ FeedbackVectorICSlot CallRuntimeFeedbackSlot() {
return callruntime_feedback_slot_;
}
- TypeFeedbackId CallRuntimeFeedbackId() const { return reuse(id()); }
+ static int num_ids() { return parent_num_ids() + 1; }
+ TypeFeedbackId CallRuntimeFeedbackId() const {
+ return TypeFeedbackId(local_id(0));
+ }
protected:
CallRuntime(Zone* zone, const AstRawString* name,
const Runtime::Function* function,
- ZoneList<Expression*>* arguments, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ ZoneList<Expression*>* arguments, int pos)
+ : Expression(zone, pos),
raw_name_(name),
function_(function),
- arguments_(arguments) {}
+ arguments_(arguments),
+ callruntime_feedback_slot_(FeedbackVectorICSlot::Invalid()) {}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
const AstRawString* raw_name_;
const Runtime::Function* function_;
ZoneList<Expression*>* arguments_;
- int callruntime_feedback_slot_;
+ FeedbackVectorICSlot callruntime_feedback_slot_;
};
Token::Value op() const { return op_; }
Expression* expression() const { return expression_; }
- BailoutId MaterializeTrueId() { return materialize_true_id_; }
- BailoutId MaterializeFalseId() { return materialize_false_id_; }
+ // For unary not (Token::NOT), the AST ids where true and false will
+ // actually be materialized, respectively.
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
+ BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
virtual void RecordToBooleanTypeFeedback(
TypeFeedbackOracle* oracle) OVERRIDE;
protected:
- UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos,
- IdGen* id_gen)
- : Expression(zone, pos, id_gen),
- op_(op),
- expression_(expression),
- materialize_true_id_(id_gen->GetNextId()),
- materialize_false_id_(id_gen->GetNextId()) {
+ UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
+ : Expression(zone, pos), op_(op), expression_(expression) {
DCHECK(Token::IsUnaryOp(op));
}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Token::Value op_;
Expression* expression_;
-
- // For unary not (Token::NOT), the AST ids where true and false will
- // actually be materialized, respectively.
- const BailoutId materialize_true_id_;
- const BailoutId materialize_false_id_;
};
virtual bool ResultOverwriteAllowed() const OVERRIDE;
- Token::Value op() const { return op_; }
+ Token::Value op() const { return static_cast<Token::Value>(op_); }
Expression* left() const { return left_; }
Expression* right() const { return right_; }
Handle<AllocationSite> allocation_site() const { return allocation_site_; }
allocation_site_ = allocation_site;
}
- BailoutId RightId() const { return right_id_; }
+ // The short-circuit logical operations need an AST ID for their
+ // right-hand subexpression.
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId RightId() const { return BailoutId(local_id(0)); }
- TypeFeedbackId BinaryOperationFeedbackId() const { return reuse(id()); }
- Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
- void set_fixed_right_arg(Maybe<int> arg) { fixed_right_arg_ = arg; }
+ TypeFeedbackId BinaryOperationFeedbackId() const {
+ return TypeFeedbackId(local_id(1));
+ }
+ Maybe<int> fixed_right_arg() const {
+ return has_fixed_right_arg_ ? Maybe<int>(fixed_right_arg_value_)
+ : Maybe<int>();
+ }
+ void set_fixed_right_arg(Maybe<int> arg) {
+ has_fixed_right_arg_ = arg.has_value;
+ if (arg.has_value) fixed_right_arg_value_ = arg.value;
+ }
virtual void RecordToBooleanTypeFeedback(
TypeFeedbackOracle* oracle) OVERRIDE;
protected:
BinaryOperation(Zone* zone, Token::Value op, Expression* left,
- Expression* right, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
- op_(op),
+ Expression* right, int pos)
+ : Expression(zone, pos),
+ op_(static_cast<byte>(op)),
+ has_fixed_right_arg_(false),
+ fixed_right_arg_value_(0),
left_(left),
- right_(right),
- right_id_(id_gen->GetNextId()) {
+ right_(right) {
DCHECK(Token::IsBinaryOp(op));
}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
- Token::Value op_;
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ const byte op_; // actually Token::Value
+ // TODO(rossberg): the fixed arg should probably be represented as a Constant
+ // type for the RHS. Currenty it's actually a Maybe<int>
+ bool has_fixed_right_arg_;
+ int fixed_right_arg_value_;
Expression* left_;
Expression* right_;
Handle<AllocationSite> allocation_site_;
-
- // TODO(rossberg): the fixed arg should probably be represented as a Constant
- // type for the RHS.
- Maybe<int> fixed_right_arg_;
-
- // The short-circuit logical operations need an AST ID for their
- // right-hand subexpression.
- const BailoutId right_id_;
};
public:
DECLARE_NODE_TYPE(CountOperation)
- bool is_prefix() const { return is_prefix_; }
- bool is_postfix() const { return !is_prefix_; }
+ bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
+ bool is_postfix() const { return !is_prefix(); }
- Token::Value op() const { return op_; }
+ Token::Value op() const { return TokenField::decode(bit_field_); }
Token::Value binary_op() {
return (op() == Token::INC) ? Token::ADD : Token::SUB;
}
virtual SmallMapList* GetReceiverTypes() OVERRIDE {
return &receiver_types_;
}
- virtual KeyedAccessStoreMode GetStoreMode() OVERRIDE {
- return store_mode_;
+ virtual IcCheckType GetKeyType() const OVERRIDE {
+ return KeyTypeField::decode(bit_field_);
+ }
+ virtual KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+ return StoreModeField::decode(bit_field_);
}
Type* type() const { return type_; }
- void set_store_mode(KeyedAccessStoreMode mode) { store_mode_ = mode; }
+ void set_key_type(IcCheckType type) {
+ bit_field_ = KeyTypeField::update(bit_field_, type);
+ }
+ void set_store_mode(KeyedAccessStoreMode mode) {
+ bit_field_ = StoreModeField::update(bit_field_, mode);
+ }
void set_type(Type* type) { type_ = type; }
- BailoutId AssignmentId() const { return assignment_id_; }
-
- TypeFeedbackId CountBinOpFeedbackId() const { return count_id_; }
- TypeFeedbackId CountStoreFeedbackId() const { return reuse(id()); }
+ static int num_ids() { return parent_num_ids() + 3; }
+ BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
+ TypeFeedbackId CountBinOpFeedbackId() const {
+ return TypeFeedbackId(local_id(1));
+ }
+ TypeFeedbackId CountStoreFeedbackId() const {
+ return TypeFeedbackId(local_id(2));
+ }
protected:
CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
- int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
- op_(op),
- is_prefix_(is_prefix),
- store_mode_(STANDARD_STORE),
- expression_(expr),
- assignment_id_(id_gen->GetNextId()),
- count_id_(id_gen->GetNextId()) {}
-
- private:
- Token::Value op_;
- bool is_prefix_ : 1;
- KeyedAccessStoreMode store_mode_ : 5; // Windows treats as signed,
- // must have extra bit.
+ int pos)
+ : Expression(zone, pos),
+ bit_field_(IsPrefixField::encode(is_prefix) |
+ KeyTypeField::encode(ELEMENT) |
+ StoreModeField::encode(STANDARD_STORE) |
+ TokenField::encode(op)),
+ type_(NULL),
+ expression_(expr) {}
+ static int parent_num_ids() { return Expression::num_ids(); }
+
+ private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ class IsPrefixField : public BitField16<bool, 0, 1> {};
+ class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
+ class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 4> {};
+ class TokenField : public BitField16<Token::Value, 6, 8> {};
+
+ // Starts with 16-bit field, which should get packed together with
+ // Expression's trailing 16-bit field.
+ uint16_t bit_field_;
Type* type_;
-
Expression* expression_;
- const BailoutId assignment_id_;
- const TypeFeedbackId count_id_;
SmallMapList receiver_types_;
};
Expression* right() const { return right_; }
// Type feedback information.
- TypeFeedbackId CompareOperationFeedbackId() const { return reuse(id()); }
+ static int num_ids() { return parent_num_ids() + 1; }
+ TypeFeedbackId CompareOperationFeedbackId() const {
+ return TypeFeedbackId(local_id(0));
+ }
Type* combined_type() const { return combined_type_; }
void set_combined_type(Type* type) { combined_type_ = type; }
protected:
CompareOperation(Zone* zone, Token::Value op, Expression* left,
- Expression* right, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ Expression* right, int pos)
+ : Expression(zone, pos),
op_(op),
left_(left),
right_(right),
combined_type_(Type::None(zone)) {
DCHECK(Token::IsCompareOp(op));
}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Token::Value op_;
Expression* left_;
Expression* right_;
Expression* then_expression() const { return then_expression_; }
Expression* else_expression() const { return else_expression_; }
- BailoutId ThenId() const { return then_id_; }
- BailoutId ElseId() const { return else_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId ThenId() const { return BailoutId(local_id(0)); }
+ BailoutId ElseId() const { return BailoutId(local_id(1)); }
protected:
Conditional(Zone* zone, Expression* condition, Expression* then_expression,
- Expression* else_expression, int position, IdGen* id_gen)
- : Expression(zone, position, id_gen),
+ Expression* else_expression, int position)
+ : Expression(zone, position),
condition_(condition),
then_expression_(then_expression),
- else_expression_(else_expression),
- then_id_(id_gen->GetNextId()),
- else_id_(id_gen->GetNextId()) {}
+ else_expression_(else_expression) {}
+ static int parent_num_ids() { return Expression::num_ids(); }
private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
Expression* condition_;
Expression* then_expression_;
Expression* else_expression_;
- const BailoutId then_id_;
- const BailoutId else_id_;
};
Token::Value binary_op() const;
- Token::Value op() const { return op_; }
+ Token::Value op() const { return TokenField::decode(bit_field_); }
Expression* target() const { return target_; }
Expression* value() const { return value_; }
BinaryOperation* binary_operation() const { return binary_operation_; }
// This check relies on the definition order of token in token.h.
bool is_compound() const { return op() > Token::ASSIGN; }
- BailoutId AssignmentId() const { return assignment_id_; }
+ static int num_ids() { return parent_num_ids() + 2; }
+ BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
// Type feedback information.
- TypeFeedbackId AssignmentFeedbackId() { return reuse(id()); }
+ TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
virtual bool IsMonomorphic() OVERRIDE {
return receiver_types_.length() == 1;
}
- bool IsUninitialized() { return is_uninitialized_; }
+ bool IsUninitialized() const {
+ return IsUninitializedField::decode(bit_field_);
+ }
bool HasNoTypeInformation() {
- return is_uninitialized_;
+ return IsUninitializedField::decode(bit_field_);
}
virtual SmallMapList* GetReceiverTypes() OVERRIDE {
return &receiver_types_;
}
- virtual KeyedAccessStoreMode GetStoreMode() OVERRIDE {
- return store_mode_;
+ virtual IcCheckType GetKeyType() const OVERRIDE {
+ return KeyTypeField::decode(bit_field_);
+ }
+ virtual KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+ return StoreModeField::decode(bit_field_);
+ }
+ void set_is_uninitialized(bool b) {
+ bit_field_ = IsUninitializedField::update(bit_field_, b);
+ }
+ void set_key_type(IcCheckType key_type) {
+ bit_field_ = KeyTypeField::update(bit_field_, key_type);
+ }
+ void set_store_mode(KeyedAccessStoreMode mode) {
+ bit_field_ = StoreModeField::update(bit_field_, mode);
}
- void set_is_uninitialized(bool b) { is_uninitialized_ = b; }
- void set_store_mode(KeyedAccessStoreMode mode) { store_mode_ = mode; }
protected:
Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
- int pos, IdGen* id_gen);
+ int pos);
+ static int parent_num_ids() { return Expression::num_ids(); }
- template<class Visitor>
- void Init(Zone* zone, AstNodeFactory<Visitor>* factory) {
- DCHECK(Token::IsAssignmentOp(op_));
+ template <class Visitor>
+ void Init(AstNodeFactory<Visitor>* factory) {
+ DCHECK(Token::IsAssignmentOp(op()));
if (is_compound()) {
binary_operation_ = factory->NewBinaryOperation(
binary_op(), target_, value_, position() + 1);
}
private:
- Token::Value op_;
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+ class IsUninitializedField : public BitField16<bool, 0, 1> {};
+ class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
+ class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 4> {};
+ class TokenField : public BitField16<Token::Value, 6, 8> {};
+
+ // Starts with 16-bit field, which should get packed together with
+ // Expression's trailing 16-bit field.
+ uint16_t bit_field_;
Expression* target_;
Expression* value_;
BinaryOperation* binary_operation_;
- const BailoutId assignment_id_;
-
- bool is_uninitialized_ : 1;
- KeyedAccessStoreMode store_mode_ : 5; // Windows treats as signed,
- // must have extra bit.
SmallMapList receiver_types_;
};
-class Yield FINAL : public Expression, public FeedbackSlotInterface {
+class Yield FINAL : public Expression {
public:
DECLARE_NODE_TYPE(Yield)
}
// Type feedback information.
- virtual int ComputeFeedbackSlotCount() {
- return (FLAG_vector_ics && yield_kind() == kDelegating) ? 3 : 0;
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(
+ 0, (FLAG_vector_ics && yield_kind() == kDelegating) ? 3 : 0);
}
- virtual void SetFirstFeedbackSlot(int slot) {
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
yield_first_feedback_slot_ = slot;
}
- int KeyedLoadFeedbackSlot() {
- DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
+ FeedbackVectorICSlot KeyedLoadFeedbackSlot() {
return yield_first_feedback_slot_;
}
- int DoneFeedbackSlot() {
- DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
- return yield_first_feedback_slot_ + 1;
+ FeedbackVectorICSlot DoneFeedbackSlot() {
+ return KeyedLoadFeedbackSlot().next();
}
- int ValueFeedbackSlot() {
- DCHECK(yield_first_feedback_slot_ != kInvalidFeedbackSlot);
- return yield_first_feedback_slot_ + 2;
- }
+ FeedbackVectorICSlot ValueFeedbackSlot() { return DoneFeedbackSlot().next(); }
protected:
Yield(Zone* zone, Expression* generator_object, Expression* expression,
- Kind yield_kind, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen),
+ Kind yield_kind, int pos)
+ : Expression(zone, pos),
generator_object_(generator_object),
expression_(expression),
yield_kind_(yield_kind),
index_(-1),
- yield_first_feedback_slot_(kInvalidFeedbackSlot) {}
+ yield_first_feedback_slot_(FeedbackVectorICSlot::Invalid()) {}
private:
Expression* generator_object_;
Expression* expression_;
Kind yield_kind_;
int index_;
- int yield_first_feedback_slot_;
+ FeedbackVectorICSlot yield_first_feedback_slot_;
};
Expression* exception() const { return exception_; }
protected:
- Throw(Zone* zone, Expression* exception, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen), exception_(exception) {}
+ Throw(Zone* zone, Expression* exception, int pos)
+ : Expression(zone, pos), exception_(exception) {}
private:
Expression* exception_;
int slot_count() {
return ast_properties_.feedback_slots();
}
+ int ic_slot_count() { return ast_properties_.ic_feedback_slots(); }
bool dont_optimize() { return dont_optimize_reason_ != kNoReason; }
BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
void set_dont_optimize_reason(BailoutReason reason) {
ParameterFlag has_duplicate_parameters,
IsFunctionFlag is_function,
IsParenthesizedFlag is_parenthesized, FunctionKind kind,
- int position, IdGen* id_gen)
- : Expression(zone, position, id_gen),
+ int position)
+ : Expression(zone, position),
raw_name_(name),
scope_(scope),
body_(body),
Expression* extends() const { return extends_; }
Expression* constructor() const { return constructor_; }
ZoneList<Property*>* properties() const { return properties_; }
+ int start_position() const { return position(); }
+ int end_position() const { return end_position_; }
protected:
ClassLiteral(Zone* zone, const AstRawString* name, Expression* extends,
Expression* constructor, ZoneList<Property*>* properties,
- int position, IdGen* id_gen)
- : Expression(zone, position, id_gen),
+ int start_position, int end_position)
+ : Expression(zone, start_position),
raw_name_(name),
extends_(extends),
constructor_(constructor),
- properties_(properties) {}
+ properties_(properties),
+ end_position_(end_position) {}
private:
const AstRawString* raw_name_;
Expression* extends_;
Expression* constructor_;
ZoneList<Property*>* properties_;
+ int end_position_;
};
protected:
NativeFunctionLiteral(Zone* zone, const AstRawString* name,
- v8::Extension* extension, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen), name_(name), extension_(extension) {}
+ v8::Extension* extension, int pos)
+ : Expression(zone, pos), name_(name), extension_(extension) {}
private:
const AstRawString* name_;
DECLARE_NODE_TYPE(ThisFunction)
protected:
- ThisFunction(Zone* zone, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen) {}
+ ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
};
VariableProxy* this_var() const { return this_var_; }
- TypeFeedbackId HomeObjectFeedbackId() { return reuse(id()); }
+ static int num_ids() { return parent_num_ids() + 1; }
+ TypeFeedbackId HomeObjectFeedbackId() { return TypeFeedbackId(local_id(0)); }
+
+ // Type feedback information.
+ virtual FeedbackVectorRequirements ComputeFeedbackRequirements() OVERRIDE {
+ return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
+ }
+ virtual void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot) OVERRIDE {
+ homeobject_feedback_slot_ = slot;
+ }
+
+ FeedbackVectorICSlot HomeObjectFeedbackSlot() {
+ DCHECK(!FLAG_vector_ics || !homeobject_feedback_slot_.IsInvalid());
+ return homeobject_feedback_slot_;
+ }
protected:
- SuperReference(Zone* zone, VariableProxy* this_var, int pos, IdGen* id_gen)
- : Expression(zone, pos, id_gen), this_var_(this_var) {
+ SuperReference(Zone* zone, VariableProxy* this_var, int pos)
+ : Expression(zone, pos),
+ this_var_(this_var),
+ homeobject_feedback_slot_(FeedbackVectorICSlot::Invalid()) {
DCHECK(this_var->is_this());
}
+ static int parent_num_ids() { return Expression::num_ids(); }
+
+ private:
+ int local_id(int n) const { return base_id() + parent_num_ids() + n; }
VariableProxy* this_var_;
+ FeedbackVectorICSlot homeobject_feedback_slot_;
};
// expression.
virtual Interval CaptureRegisters() { return Interval::Empty(); }
virtual void AppendToText(RegExpText* text, Zone* zone);
- OStream& Print(OStream& os, Zone* zone); // NOLINT
+ std::ostream& Print(std::ostream& os, Zone* zone); // NOLINT
#define MAKE_ASTYPE(Name) \
virtual RegExp##Name* As##Name(); \
virtual bool Is##Name();
AST_NODE_LIST(DEF_VISIT)
#undef DEF_VISIT
- void increase_node_count() { properties_.add_node_count(1); }
void add_flag(AstPropertiesFlag flag) { properties_.flags()->Add(flag); }
void set_dont_crankshaft_reason(BailoutReason reason) {
dont_crankshaft_reason_ = reason;
dont_turbofan_reason_ = reason;
}
- void add_slot_node(FeedbackSlotInterface* slot_node) {
- int count = slot_node->ComputeFeedbackSlotCount();
- if (count > 0) {
- slot_node->SetFirstFeedbackSlot(properties_.feedback_slots());
- properties_.increase_feedback_slots(count);
+ void add_slot_node(AstNode* slot_node) {
+ FeedbackVectorRequirements reqs = slot_node->ComputeFeedbackRequirements();
+ if (reqs.slots() > 0) {
+ slot_node->SetFirstFeedbackSlot(
+ FeedbackVectorSlot(properties_.feedback_slots()));
+ properties_.increase_feedback_slots(reqs.slots());
+ }
+ if (reqs.ic_slots() > 0) {
+ slot_node->SetFirstFeedbackICSlot(
+ FeedbackVectorICSlot(properties_.ic_feedback_slots()));
+ properties_.increase_ic_feedback_slots(reqs.ic_slots());
}
}
template<class Visitor>
class AstNodeFactory FINAL BASE_EMBEDDED {
public:
- AstNodeFactory(Zone* zone, AstValueFactory* ast_value_factory,
- AstNode::IdGen* id_gen)
- : zone_(zone), ast_value_factory_(ast_value_factory), id_gen_(id_gen) {}
+ explicit AstNodeFactory(AstValueFactory* ast_value_factory)
+ : zone_(ast_value_factory->zone()),
+ ast_value_factory_(ast_value_factory) {}
Visitor* visitor() { return &visitor_; }
int capacity,
bool is_initializer_block,
int pos) {
- Block* block = new (zone_)
- Block(zone_, labels, capacity, is_initializer_block, pos, id_gen_);
+ Block* block =
+ new (zone_) Block(zone_, labels, capacity, is_initializer_block, pos);
VISIT_AND_RETURN(Block, block)
}
#define STATEMENT_WITH_LABELS(NodeType) \
NodeType* New##NodeType(ZoneList<const AstRawString*>* labels, int pos) { \
- NodeType* stmt = new (zone_) NodeType(zone_, labels, pos, id_gen_); \
+ NodeType* stmt = new (zone_) NodeType(zone_, labels, pos); \
VISIT_AND_RETURN(NodeType, stmt); \
}
STATEMENT_WITH_LABELS(DoWhileStatement)
int pos) {
switch (visit_mode) {
case ForEachStatement::ENUMERATE: {
- ForInStatement* stmt =
- new (zone_) ForInStatement(zone_, labels, pos, id_gen_);
+ ForInStatement* stmt = new (zone_) ForInStatement(zone_, labels, pos);
VISIT_AND_RETURN(ForInStatement, stmt);
}
case ForEachStatement::ITERATE: {
- ForOfStatement* stmt =
- new (zone_) ForOfStatement(zone_, labels, pos, id_gen_);
+ ForOfStatement* stmt = new (zone_) ForOfStatement(zone_, labels, pos);
VISIT_AND_RETURN(ForOfStatement, stmt);
}
}
Statement* then_statement,
Statement* else_statement,
int pos) {
- IfStatement* stmt = new (zone_) IfStatement(
- zone_, condition, then_statement, else_statement, pos, id_gen_);
+ IfStatement* stmt = new (zone_)
+ IfStatement(zone_, condition, then_statement, else_statement, pos);
VISIT_AND_RETURN(IfStatement, stmt)
}
}
DebuggerStatement* NewDebuggerStatement(int pos) {
- DebuggerStatement* stmt =
- new (zone_) DebuggerStatement(zone_, pos, id_gen_);
+ DebuggerStatement* stmt = new (zone_) DebuggerStatement(zone_, pos);
VISIT_AND_RETURN(DebuggerStatement, stmt)
}
CaseClause* NewCaseClause(
Expression* label, ZoneList<Statement*>* statements, int pos) {
- CaseClause* clause =
- new (zone_) CaseClause(zone_, label, statements, pos, id_gen_);
+ CaseClause* clause = new (zone_) CaseClause(zone_, label, statements, pos);
VISIT_AND_RETURN(CaseClause, clause)
}
Literal* NewStringLiteral(const AstRawString* string, int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewString(string), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewString(string), pos);
VISIT_AND_RETURN(Literal, lit)
}
// A JavaScript symbol (ECMA-262 edition 6).
Literal* NewSymbolLiteral(const char* name, int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewSymbol(name), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewSymbol(name), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewNumberLiteral(double number, int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewNumber(number), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewNumber(number), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewSmiLiteral(int number, int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewSmi(number), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewSmi(number), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewBooleanLiteral(bool b, int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewBoolean(b), pos, id_gen_);
- VISIT_AND_RETURN(Literal, lit)
- }
-
- Literal* NewStringListLiteral(ZoneList<const AstRawString*>* strings,
- int pos) {
- Literal* lit = new (zone_) Literal(
- zone_, ast_value_factory_->NewStringList(strings), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewBoolean(b), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewNullLiteral(int pos) {
Literal* lit =
- new (zone_) Literal(zone_, ast_value_factory_->NewNull(), pos, id_gen_);
+ new (zone_) Literal(zone_, ast_value_factory_->NewNull(), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewUndefinedLiteral(int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewUndefined(), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewUndefined(), pos);
VISIT_AND_RETURN(Literal, lit)
}
Literal* NewTheHoleLiteral(int pos) {
- Literal* lit = new (zone_)
- Literal(zone_, ast_value_factory_->NewTheHole(), pos, id_gen_);
+ Literal* lit =
+ new (zone_) Literal(zone_, ast_value_factory_->NewTheHole(), pos);
VISIT_AND_RETURN(Literal, lit)
}
int boilerplate_properties,
bool has_function,
int pos) {
- ObjectLiteral* lit = new (zone_)
- ObjectLiteral(zone_, properties, literal_index, boilerplate_properties,
- has_function, pos, id_gen_);
+ ObjectLiteral* lit =
+ new (zone_) ObjectLiteral(zone_, properties, literal_index,
+ boilerplate_properties, has_function, pos);
VISIT_AND_RETURN(ObjectLiteral, lit)
}
const AstRawString* flags,
int literal_index,
int pos) {
- RegExpLiteral* lit = new (zone_)
- RegExpLiteral(zone_, pattern, flags, literal_index, pos, id_gen_);
+ RegExpLiteral* lit =
+ new (zone_) RegExpLiteral(zone_, pattern, flags, literal_index, pos);
VISIT_AND_RETURN(RegExpLiteral, lit);
}
int literal_index,
int pos) {
ArrayLiteral* lit =
- new (zone_) ArrayLiteral(zone_, values, literal_index, pos, id_gen_);
+ new (zone_) ArrayLiteral(zone_, values, literal_index, pos);
VISIT_AND_RETURN(ArrayLiteral, lit)
}
VariableProxy* NewVariableProxy(Variable* var,
int pos = RelocInfo::kNoPosition) {
- VariableProxy* proxy = new (zone_) VariableProxy(zone_, var, pos, id_gen_);
+ VariableProxy* proxy = new (zone_) VariableProxy(zone_, var, pos);
VISIT_AND_RETURN(VariableProxy, proxy)
}
bool is_this,
Interface* interface = Interface::NewValue(),
int position = RelocInfo::kNoPosition) {
- VariableProxy* proxy = new (zone_)
- VariableProxy(zone_, name, is_this, interface, position, id_gen_);
+ VariableProxy* proxy =
+ new (zone_) VariableProxy(zone_, name, is_this, interface, position);
VISIT_AND_RETURN(VariableProxy, proxy)
}
Property* NewProperty(Expression* obj, Expression* key, int pos) {
- Property* prop = new (zone_) Property(zone_, obj, key, pos, id_gen_);
+ Property* prop = new (zone_) Property(zone_, obj, key, pos);
VISIT_AND_RETURN(Property, prop)
}
Call* NewCall(Expression* expression,
ZoneList<Expression*>* arguments,
int pos) {
- Call* call = new (zone_) Call(zone_, expression, arguments, pos, id_gen_);
+ Call* call = new (zone_) Call(zone_, expression, arguments, pos);
VISIT_AND_RETURN(Call, call)
}
CallNew* NewCallNew(Expression* expression,
ZoneList<Expression*>* arguments,
int pos) {
- CallNew* call =
- new (zone_) CallNew(zone_, expression, arguments, pos, id_gen_);
+ CallNew* call = new (zone_) CallNew(zone_, expression, arguments, pos);
VISIT_AND_RETURN(CallNew, call)
}
ZoneList<Expression*>* arguments,
int pos) {
CallRuntime* call =
- new (zone_) CallRuntime(zone_, name, function, arguments, pos, id_gen_);
+ new (zone_) CallRuntime(zone_, name, function, arguments, pos);
VISIT_AND_RETURN(CallRuntime, call)
}
Expression* expression,
int pos) {
UnaryOperation* node =
- new (zone_) UnaryOperation(zone_, op, expression, pos, id_gen_);
+ new (zone_) UnaryOperation(zone_, op, expression, pos);
VISIT_AND_RETURN(UnaryOperation, node)
}
Expression* right,
int pos) {
BinaryOperation* node =
- new (zone_) BinaryOperation(zone_, op, left, right, pos, id_gen_);
+ new (zone_) BinaryOperation(zone_, op, left, right, pos);
VISIT_AND_RETURN(BinaryOperation, node)
}
Expression* expr,
int pos) {
CountOperation* node =
- new (zone_) CountOperation(zone_, op, is_prefix, expr, pos, id_gen_);
+ new (zone_) CountOperation(zone_, op, is_prefix, expr, pos);
VISIT_AND_RETURN(CountOperation, node)
}
Expression* right,
int pos) {
CompareOperation* node =
- new (zone_) CompareOperation(zone_, op, left, right, pos, id_gen_);
+ new (zone_) CompareOperation(zone_, op, left, right, pos);
VISIT_AND_RETURN(CompareOperation, node)
}
Expression* else_expression,
int position) {
Conditional* cond = new (zone_) Conditional(
- zone_, condition, then_expression, else_expression, position, id_gen_);
+ zone_, condition, then_expression, else_expression, position);
VISIT_AND_RETURN(Conditional, cond)
}
Expression* target,
Expression* value,
int pos) {
- Assignment* assign =
- new (zone_) Assignment(zone_, op, target, value, pos, id_gen_);
- assign->Init(zone_, this);
+ Assignment* assign = new (zone_) Assignment(zone_, op, target, value, pos);
+ assign->Init(this);
VISIT_AND_RETURN(Assignment, assign)
}
Yield::Kind yield_kind,
int pos) {
if (!expression) expression = NewUndefinedLiteral(pos);
- Yield* yield = new (zone_)
- Yield(zone_, generator_object, expression, yield_kind, pos, id_gen_);
+ Yield* yield =
+ new (zone_) Yield(zone_, generator_object, expression, yield_kind, pos);
VISIT_AND_RETURN(Yield, yield)
}
Throw* NewThrow(Expression* exception, int pos) {
- Throw* t = new (zone_) Throw(zone_, exception, pos, id_gen_);
+ Throw* t = new (zone_) Throw(zone_, exception, pos);
VISIT_AND_RETURN(Throw, t)
}
FunctionLiteral* lit = new (zone_) FunctionLiteral(
zone_, name, ast_value_factory, scope, body, materialized_literal_count,
expected_property_count, handler_count, parameter_count, function_type,
- has_duplicate_parameters, is_function, is_parenthesized, kind, position,
- id_gen_);
+ has_duplicate_parameters, is_function, is_parenthesized, kind,
+ position);
// Top-level literal doesn't count for the AST's properties.
if (is_function == FunctionLiteral::kIsFunction) {
visitor_.VisitFunctionLiteral(lit);
ClassLiteral* NewClassLiteral(const AstRawString* name, Expression* extends,
Expression* constructor,
ZoneList<ObjectLiteral::Property*>* properties,
- int position) {
- ClassLiteral* lit = new (zone_) ClassLiteral(
- zone_, name, extends, constructor, properties, position, id_gen_);
+ int start_position, int end_position) {
+ ClassLiteral* lit =
+ new (zone_) ClassLiteral(zone_, name, extends, constructor, properties,
+ start_position, end_position);
VISIT_AND_RETURN(ClassLiteral, lit)
}
v8::Extension* extension,
int pos) {
NativeFunctionLiteral* lit =
- new (zone_) NativeFunctionLiteral(zone_, name, extension, pos, id_gen_);
+ new (zone_) NativeFunctionLiteral(zone_, name, extension, pos);
VISIT_AND_RETURN(NativeFunctionLiteral, lit)
}
ThisFunction* NewThisFunction(int pos) {
- ThisFunction* fun = new (zone_) ThisFunction(zone_, pos, id_gen_);
+ ThisFunction* fun = new (zone_) ThisFunction(zone_, pos);
VISIT_AND_RETURN(ThisFunction, fun)
}
SuperReference* NewSuperReference(VariableProxy* this_var, int pos) {
- SuperReference* super =
- new (zone_) SuperReference(zone_, this_var, pos, id_gen_);
+ SuperReference* super = new (zone_) SuperReference(zone_, this_var, pos);
VISIT_AND_RETURN(SuperReference, super);
}
Zone* zone_;
Visitor visitor_;
AstValueFactory* ast_value_factory_;
- AstNode::IdGen* id_gen_;
};
#ifndef V8_BASE_ATOMICOPS_H_
#define V8_BASE_ATOMICOPS_H_
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/build_config.h"
#if defined(_WIN32) && defined(V8_HOST_ARCH_64_BIT)
typedef char Atomic8;
typedef int32_t Atomic32;
-#ifdef V8_HOST_ARCH_64_BIT
+#if defined(__native_client__)
+typedef int64_t Atomic64;
+#elif defined(V8_HOST_ARCH_64_BIT)
// We need to be able to go between Atomic64 and AtomicWord implicitly. This
// means Atomic64 and AtomicWord should be the same type on 64-bit.
#if defined(__ILP32__)
typedef int64_t Atomic64;
#else
typedef intptr_t Atomic64;
-#endif
-#endif
+#endif // defined(V8_HOST_ARCH_64_BIT)
+#endif // defined(__native_client__)
// Use AtomicWord for a machine-sized pointer. It will use the Atomic32 or
// Atomic64 routines below, depending on your architecture.
#include "src/base/atomicops_internals_x86_msvc.h"
#elif defined(__APPLE__)
#include "src/base/atomicops_internals_mac.h"
+#elif defined(__native_client__)
+#include "src/base/atomicops_internals_portable.h"
#elif defined(__GNUC__) && V8_HOST_ARCH_ARM64
#include "src/base/atomicops_internals_arm64_gcc.h"
#elif defined(__GNUC__) && V8_HOST_ARCH_ARM
namespace v8 {
namespace base {
+#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
+
+inline void MemoryBarrier() { OSMemoryBarrier(); }
+
+inline void AcquireMemoryBarrier() {
+// On x86 processors, loads already have acquire semantics, so
+// there is no need to put a full barrier here.
+#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
+ ATOMICOPS_COMPILER_BARRIER();
+#else
+ MemoryBarrier();
+#endif
+}
+
inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
Atomic32 old_value,
Atomic32 new_value) {
return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr));
}
-inline void MemoryBarrier() {
- OSMemoryBarrier();
-}
-
inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
Atomic32 old_value,
Atomic32 new_value) {
inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
Atomic32 value = *ptr;
- MemoryBarrier();
+ AcquireMemoryBarrier();
return value;
}
inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
Atomic64 value = *ptr;
- MemoryBarrier();
+ AcquireMemoryBarrier();
return value;
}
#endif // defined(__LP64__)
+#undef ATOMICOPS_COMPILER_BARRIER
} } // namespace v8::base
#endif // V8_BASE_ATOMICOPS_INTERNALS_MAC_H_
--- /dev/null
+// Copyright 2012 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
+#define V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
+
+namespace v8 {
+namespace base {
+
+inline void MemoryBarrier() { __sync_synchronize(); }
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value,
+ Atomic32 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+ Atomic32 new_value) {
+ return __sync_lock_test_and_set(ptr, new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+ Atomic32 increment) {
+ return __sync_add_and_fetch(ptr, increment);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+ Atomic32 increment) {
+ return __sync_add_and_fetch(ptr, increment);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value, Atomic32 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value, Atomic32 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic8* ptr, Atomic8 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline Atomic8 NoBarrier_Load(volatile const Atomic8* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+// 64-bit versions of the operations.
+// See the 32-bit versions for comments.
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+ Atomic64 old_value,
+ Atomic64 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+ Atomic64 new_value) {
+ return __sync_lock_test_and_set(ptr, new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+ Atomic64 increment) {
+ return __sync_add_and_fetch(ptr, increment);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+ Atomic64 increment) {
+ return __sync_add_and_fetch(ptr, increment);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+ Atomic64 old_value, Atomic64 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+ Atomic64 old_value, Atomic64 new_value) {
+ return __sync_val_compare_and_swap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+ __sync_lock_test_and_set(ptr, value);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+ return __sync_add_and_fetch(ptr, 0);
+}
+}
+} // namespace v8::base
+
+#endif // V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
+++ /dev/null
-# 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.
-
-{
- 'variables': {
- 'v8_code': 1,
- },
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
- 'targets': [
- {
- 'target_name': 'base-unittests',
- 'type': 'executable',
- 'dependencies': [
- '../../testing/gtest.gyp:gtest',
- '../../testing/gtest.gyp:gtest_main',
- '../../tools/gyp/v8.gyp:v8_libbase',
- ],
- 'include_dirs': [
- '../..',
- ],
- 'sources': [ ### gcmole(all) ###
- 'bits-unittest.cc',
- 'cpu-unittest.cc',
- 'division-by-constant-unittest.cc',
- 'flags-unittest.cc',
- 'platform/condition-variable-unittest.cc',
- 'platform/mutex-unittest.cc',
- 'platform/platform-unittest.cc',
- 'platform/semaphore-unittest.cc',
- 'platform/time-unittest.cc',
- 'sys-info-unittest.cc',
- 'utils/random-number-generator-unittest.cc',
- ],
- 'conditions': [
- ['os_posix == 1', {
- # TODO(svenpanne): This is a temporary work-around to fix the warnings
- # that show up because we use -std=gnu++0x instead of -std=c++11.
- 'cflags!': [
- '-pedantic',
- ],
- }],
- ],
- },
- ],
-}
// found in the LICENSE file.
#include "src/base/bits.h"
+
+#include <limits>
+
#include "src/base/logging.h"
namespace v8 {
return value + 1;
}
+
+int32_t SignedMulHigh32(int32_t lhs, int32_t rhs) {
+ int64_t const value = static_cast<int64_t>(lhs) * static_cast<int64_t>(rhs);
+ return bit_cast<int32_t, uint32_t>(bit_cast<uint64_t>(value) >> 32u);
+}
+
+
+int32_t SignedMulHighAndAdd32(int32_t lhs, int32_t rhs, int32_t acc) {
+ return bit_cast<int32_t>(bit_cast<uint32_t>(acc) +
+ bit_cast<uint32_t>(SignedMulHigh32(lhs, rhs)));
+}
+
+
+int32_t SignedDiv32(int32_t lhs, int32_t rhs) {
+ if (rhs == 0) return 0;
+ if (rhs == -1) return -lhs;
+ return lhs / rhs;
+}
+
+
+int32_t SignedMod32(int32_t lhs, int32_t rhs) {
+ if (rhs == 0 || rhs == -1) return 0;
+ return lhs % rhs;
+}
+
} // namespace bits
} // namespace base
} // namespace v8
#ifndef V8_BASE_BITS_H_
#define V8_BASE_BITS_H_
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/macros.h"
#if V8_CC_MSVC
#include <intrin.h>
namespace bits {
// CountPopulation32(value) returns the number of bits set in |value|.
-inline uint32_t CountPopulation32(uint32_t value) {
+inline unsigned CountPopulation32(uint32_t value) {
#if V8_HAS_BUILTIN_POPCOUNT
return __builtin_popcount(value);
#else
value = ((value >> 4) & 0x0f0f0f0f) + (value & 0x0f0f0f0f);
value = ((value >> 8) & 0x00ff00ff) + (value & 0x00ff00ff);
value = ((value >> 16) & 0x0000ffff) + (value & 0x0000ffff);
- return value;
+ return static_cast<unsigned>(value);
+#endif
+}
+
+
+// CountPopulation64(value) returns the number of bits set in |value|.
+inline unsigned CountPopulation64(uint64_t value) {
+#if V8_HAS_BUILTIN_POPCOUNT
+ return __builtin_popcountll(value);
+#else
+ return CountPopulation32(static_cast<uint32_t>(value)) +
+ CountPopulation32(static_cast<uint32_t>(value >> 32));
#endif
}
// CountLeadingZeros32(value) returns the number of zero bits following the most
// significant 1 bit in |value| if |value| is non-zero, otherwise it returns 32.
-inline uint32_t CountLeadingZeros32(uint32_t value) {
+inline unsigned CountLeadingZeros32(uint32_t value) {
#if V8_HAS_BUILTIN_CLZ
return value ? __builtin_clz(value) : 32;
#elif V8_CC_MSVC
unsigned long result; // NOLINT(runtime/int)
if (!_BitScanReverse(&result, value)) return 32;
- return static_cast<uint32_t>(31 - result);
+ return static_cast<unsigned>(31 - result);
#else
value = value | (value >> 1);
value = value | (value >> 2);
}
+// CountLeadingZeros64(value) returns the number of zero bits following the most
+// significant 1 bit in |value| if |value| is non-zero, otherwise it returns 64.
+inline unsigned CountLeadingZeros64(uint64_t value) {
+#if V8_HAS_BUILTIN_CLZ
+ return value ? __builtin_clzll(value) : 64;
+#else
+ value = value | (value >> 1);
+ value = value | (value >> 2);
+ value = value | (value >> 4);
+ value = value | (value >> 8);
+ value = value | (value >> 16);
+ value = value | (value >> 32);
+ return CountPopulation64(~value);
+#endif
+}
+
+
// CountTrailingZeros32(value) returns the number of zero bits preceding the
// least significant 1 bit in |value| if |value| is non-zero, otherwise it
// returns 32.
-inline uint32_t CountTrailingZeros32(uint32_t value) {
+inline unsigned CountTrailingZeros32(uint32_t value) {
#if V8_HAS_BUILTIN_CTZ
return value ? __builtin_ctz(value) : 32;
#elif V8_CC_MSVC
unsigned long result; // NOLINT(runtime/int)
if (!_BitScanForward(&result, value)) return 32;
- return static_cast<uint32_t>(result);
+ return static_cast<unsigned>(result);
#else
if (value == 0) return 32;
unsigned count = 0;
}
+// CountTrailingZeros64(value) returns the number of zero bits preceding the
+// least significant 1 bit in |value| if |value| is non-zero, otherwise it
+// returns 64.
+inline unsigned CountTrailingZeros64(uint64_t value) {
+#if V8_HAS_BUILTIN_CTZ
+ return value ? __builtin_ctzll(value) : 64;
+#else
+ if (value == 0) return 64;
+ unsigned count = 0;
+ for (value ^= value - 1; value >>= 1; ++count)
+ ;
+ return count;
+#endif
+}
+
+
// Returns true iff |value| is a power of 2.
inline bool IsPowerOfTwo32(uint32_t value) {
return value && !(value & (value - 1));
#endif
}
+
+// SignedMulHigh32(lhs, rhs) multiplies two signed 32-bit values |lhs| and
+// |rhs|, extracts the most significant 32 bits of the result, and returns
+// those.
+int32_t SignedMulHigh32(int32_t lhs, int32_t rhs);
+
+
+// SignedMulHighAndAdd32(lhs, rhs, acc) multiplies two signed 32-bit values
+// |lhs| and |rhs|, extracts the most significant 32 bits of the result, and
+// adds the accumulate value |acc|.
+int32_t SignedMulHighAndAdd32(int32_t lhs, int32_t rhs, int32_t acc);
+
+
+// SignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
+// truncated to int32. If |rhs| is zero, then zero is returned. If |lhs|
+// is minint and |rhs| is -1, it returns minint.
+int32_t SignedDiv32(int32_t lhs, int32_t rhs);
+
+
+// SignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
+// truncated to int32. If either |rhs| is zero or |lhs| is minint and |rhs|
+// is -1, it returns zero.
+int32_t SignedMod32(int32_t lhs, int32_t rhs);
+
+
+// UnsignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
+// truncated to uint32. If |rhs| is zero, then zero is returned.
+inline uint32_t UnsignedDiv32(uint32_t lhs, uint32_t rhs) {
+ return rhs ? lhs / rhs : 0u;
+}
+
+
+// UnsignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
+// truncated to uint32. If |rhs| is zero, then zero is returned.
+inline uint32_t UnsignedMod32(uint32_t lhs, uint32_t rhs) {
+ return rhs ? lhs % rhs : 0u;
+}
+
} // namespace bits
} // namespace base
} // namespace v8
#define V8_HOST_ARCH_64_BIT 1
#endif
#endif // __native_client__
+#elif defined(__pnacl__)
+// PNaCl is also ILP-32.
+#define V8_HOST_ARCH_IA32 1
+#define V8_HOST_ARCH_32_BIT 1
#elif defined(_M_IX86) || defined(__i386__)
#define V8_HOST_ARCH_IA32 1
#define V8_HOST_ARCH_32_BIT 1
#include "include/v8config.h"
-// Annotate a variable indicating it's ok if the variable is not used.
-// (Typically used to silence a compiler warning when the assignment
-// is important for some other reason.)
+// Annotate a typedef or function indicating it's ok if it's not used.
// Use like:
-// int x ALLOW_UNUSED = ...;
+// typedef Foo Bar ALLOW_UNUSED_TYPE;
#if V8_HAS_ATTRIBUTE_UNUSED
-#define ALLOW_UNUSED __attribute__((unused))
+#define ALLOW_UNUSED_TYPE __attribute__((unused))
#else
-#define ALLOW_UNUSED
+#define ALLOW_UNUSED_TYPE
#endif
#define FINAL final
#elif V8_HAS___FINAL
#define FINAL __final
-#elif V8_HAS_SEALED
-#define FINAL sealed
#else
#define FINAL /* NOT SUPPORTED */
#endif
#if V8_LIBC_MSVCRT
#include <intrin.h> // __cpuid()
#endif
-#if V8_OS_POSIX
-#include <unistd.h> // sysconf()
+#if V8_OS_LINUX
+#include <linux/auxvec.h> // AT_HWCAP
+#endif
+#if V8_GLIBC_PREREQ(2, 16)
+#include <sys/auxv.h> // getauxval()
#endif
#if V8_OS_QNX
#include <sys/syspage.h> // cpuinfo
#endif
+#if V8_OS_POSIX
+#include <unistd.h> // sysconf()
+#endif
#include <ctype.h>
#include <limits.h>
namespace v8 {
namespace base {
-#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
+#if defined(__pnacl__)
+// Portable host shouldn't do feature detection.
+#elif V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
// Define __cpuid() for non-MSVC libraries.
#if !V8_LIBC_MSVCRT
#define HWCAP_IDIV (HWCAP_IDIVA | HWCAP_IDIVT)
#define HWCAP_LPAE (1 << 20)
-#define AT_HWCAP 16
-
-// Read the ELF HWCAP flags by parsing /proc/self/auxv.
static uint32_t ReadELFHWCaps() {
uint32_t result = 0;
+#if V8_GLIBC_PREREQ(2, 16)
+ result = static_cast<uint32_t>(getauxval(AT_HWCAP));
+#else
+ // Read the ELF HWCAP flags by parsing /proc/self/auxv.
FILE* fp = fopen("/proc/self/auxv", "r");
if (fp != NULL) {
struct { uint32_t tag; uint32_t value; } entry;
}
fclose(fp);
}
+#endif
return result;
}
int __detect_fp64_mode(void) {
double result = 0;
// Bit representation of (double)1 is 0x3FF0000000000000.
- asm(
- "lui $t0, 0x3FF0\n\t"
- "ldc1 $f0, %0\n\t"
- "mtc1 $t0, $f1\n\t"
- "sdc1 $f0, %0\n\t"
- : "+m" (result)
- : : "t0", "$f0", "$f1", "memory");
+ __asm__ volatile(
+ ".set push\n\t"
+ ".set noreorder\n\t"
+ ".set oddspreg\n\t"
+ "lui $t0, 0x3FF0\n\t"
+ "ldc1 $f0, %0\n\t"
+ "mtc1 $t0, $f1\n\t"
+ "sdc1 $f0, %0\n\t"
+ ".set pop\n\t"
+ : "+m"(result)
+ :
+ : "t0", "$f0", "$f1", "memory");
return !(result == 1);
}
int __detect_mips_arch_revision(void) {
// TODO(dusmil): Do the specific syscall as soon as it is implemented in mips
- // kernel. Currently fail-back to the least common denominator which is
- // mips32 revision 1.
- return 1;
+ // kernel.
+ uint32_t result = 0;
+ __asm__ volatile(
+ "move $v0, $zero\n\t"
+ // Encoding for "addi $v0, $v0, 1" on non-r6,
+ // which is encoding for "bovc $v0, %v0, 1" on r6.
+ // Use machine code directly to avoid compilation errors with different
+ // toolchains and maintain compatibility.
+ ".word 0x20420001\n\t"
+ "sw $v0, %0\n\t"
+ : "=m"(result)
+ :
+ : "v0", "memory");
+ // Result is 0 on r6 architectures, 1 on other architecture revisions.
+ // Fall-back to the least common denominator which is mips32 revision 1.
+ return result ? 1 : 6;
}
#endif
has_vfp3_d32_(false),
is_fp64_mode_(false) {
memcpy(vendor_, "Unknown", 8);
-#if V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
+#if V8_OS_NACL
+// Portable host shouldn't do feature detection.
+// TODO(jfb): Remove the hardcoded ARM simulator flags in the build, and
+// hardcode them here instead.
+#elif V8_HOST_ARCH_IA32 || V8_HOST_ARCH_X64
int cpu_info[4];
// __cpuid with an InfoType argument of 0 returns the number of
delta = ad - r2;
} while (q1 < delta || (q1 == delta && r1 == 0));
T mul = q2 + 1;
- return {neg ? (0 - mul) : mul, p - bits, false};
+ return MagicNumbersForDivision<T>(neg ? (0 - mul) : mul, p - bits, false);
}
}
delta = d - 1 - r2;
} while (p < bits * 2 && (q1 < delta || (q1 == delta && r1 == 0)));
- return {q2 + 1, p - bits, a};
+ return MagicNumbersForDivision<T>(q2 + 1, p - bits, a);
}
typedef S mask_type;
Flags() : mask_(0) {}
- Flags(flag_type flag) : mask_(flag) {} // NOLINT(runtime/explicit)
- explicit Flags(mask_type mask) : mask_(mask) {}
+ Flags(flag_type flag) // NOLINT(runtime/explicit)
+ : mask_(static_cast<S>(flag)) {}
+ explicit Flags(mask_type mask) : mask_(static_cast<S>(mask)) {}
Flags& operator&=(const Flags& flags) {
mask_ &= flags.mask_;
};
-#define DEFINE_OPERATORS_FOR_FLAGS(Type) \
- inline Type operator&(Type::flag_type lhs, \
- Type::flag_type rhs)ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator&(Type::flag_type lhs, Type::flag_type rhs) { \
- return Type(lhs) & rhs; \
- } \
- inline Type operator&(Type::flag_type lhs, \
- const Type& rhs)ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator&(Type::flag_type lhs, const Type& rhs) { \
- return rhs & lhs; \
- } \
- inline void operator&(Type::flag_type lhs, Type::mask_type rhs)ALLOW_UNUSED; \
- inline void operator&(Type::flag_type lhs, Type::mask_type rhs) {} \
- inline Type operator|(Type::flag_type lhs, Type::flag_type rhs) \
- ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator|(Type::flag_type lhs, Type::flag_type rhs) { \
- return Type(lhs) | rhs; \
- } \
- inline Type operator|(Type::flag_type lhs, const Type& rhs) \
- ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator|(Type::flag_type lhs, const Type& rhs) { \
- return rhs | lhs; \
- } \
- inline void operator|(Type::flag_type lhs, Type::mask_type rhs) \
- ALLOW_UNUSED; \
- inline void operator|(Type::flag_type lhs, Type::mask_type rhs) {} \
- inline Type operator^(Type::flag_type lhs, Type::flag_type rhs) \
- ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator^(Type::flag_type lhs, Type::flag_type rhs) { \
- return Type(lhs) ^ rhs; \
- } inline Type operator^(Type::flag_type lhs, const Type& rhs) \
- ALLOW_UNUSED WARN_UNUSED_RESULT; \
- inline Type operator^(Type::flag_type lhs, const Type& rhs) { \
- return rhs ^ lhs; \
- } inline void operator^(Type::flag_type lhs, Type::mask_type rhs) \
- ALLOW_UNUSED; \
+#define DEFINE_OPERATORS_FOR_FLAGS(Type) \
+ inline Type operator&( \
+ Type::flag_type lhs, \
+ Type::flag_type rhs)ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator&(Type::flag_type lhs, Type::flag_type rhs) { \
+ return Type(lhs) & rhs; \
+ } \
+ inline Type operator&(Type::flag_type lhs, \
+ const Type& rhs)ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator&(Type::flag_type lhs, const Type& rhs) { \
+ return rhs & lhs; \
+ } \
+ inline void operator&(Type::flag_type lhs, \
+ Type::mask_type rhs)ALLOW_UNUSED_TYPE; \
+ inline void operator&(Type::flag_type lhs, Type::mask_type rhs) {} \
+ inline Type operator|(Type::flag_type lhs, Type::flag_type rhs) \
+ ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator|(Type::flag_type lhs, Type::flag_type rhs) { \
+ return Type(lhs) | rhs; \
+ } \
+ inline Type operator|(Type::flag_type lhs, const Type& rhs) \
+ ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator|(Type::flag_type lhs, const Type& rhs) { \
+ return rhs | lhs; \
+ } \
+ inline void operator|(Type::flag_type lhs, Type::mask_type rhs) \
+ ALLOW_UNUSED_TYPE; \
+ inline void operator|(Type::flag_type lhs, Type::mask_type rhs) {} \
+ inline Type operator^(Type::flag_type lhs, Type::flag_type rhs) \
+ ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator^(Type::flag_type lhs, Type::flag_type rhs) { \
+ return Type(lhs) ^ rhs; \
+ } inline Type operator^(Type::flag_type lhs, const Type& rhs) \
+ ALLOW_UNUSED_TYPE WARN_UNUSED_RESULT; \
+ inline Type operator^(Type::flag_type lhs, const Type& rhs) { \
+ return rhs ^ lhs; \
+ } inline void operator^(Type::flag_type lhs, Type::mask_type rhs) \
+ ALLOW_UNUSED_TYPE; \
inline void operator^(Type::flag_type lhs, Type::mask_type rhs) {}
} // namespace base
--- /dev/null
+// 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.
+//
+// This also contains public domain code from MurmurHash. From the
+// MurmurHash header:
+//
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#include "src/base/functional.h"
+
+#include <limits>
+
+#include "src/base/bits.h"
+
+namespace v8 {
+namespace base {
+
+namespace {
+
+// Thomas Wang, Integer Hash Functions.
+// https://gist.github.com/badboy/6267743
+template <typename T>
+V8_INLINE size_t hash_value_unsigned(T v) {
+ switch (sizeof(T)) {
+ case 4: {
+ // "32 bit Mix Functions"
+ v = ~v + (v << 15); // v = (v << 15) - v - 1;
+ v = v ^ (v >> 12);
+ v = v + (v << 2);
+ v = v ^ (v >> 4);
+ v = v * 2057; // v = (v + (v << 3)) + (v << 11);
+ v = v ^ (v >> 16);
+ return static_cast<size_t>(v);
+ }
+ case 8: {
+ switch (sizeof(size_t)) {
+ case 4: {
+ // "64 bit to 32 bit Hash Functions"
+ v = ~v + (v << 18); // v = (v << 18) - v - 1;
+ v = v ^ (v >> 31);
+ v = v * 21; // v = (v + (v << 2)) + (v << 4);
+ v = v ^ (v >> 11);
+ v = v + (v << 6);
+ v = v ^ (v >> 22);
+ return static_cast<size_t>(v);
+ }
+ case 8: {
+ // "64 bit Mix Functions"
+ v = ~v + (v << 21); // v = (v << 21) - v - 1;
+ v = v ^ (v >> 24);
+ v = (v + (v << 3)) + (v << 8); // v * 265
+ v = v ^ (v >> 14);
+ v = (v + (v << 2)) + (v << 4); // v * 21
+ v = v ^ (v >> 28);
+ v = v + (v << 31);
+ return static_cast<size_t>(v);
+ }
+ }
+ }
+ }
+ UNREACHABLE();
+ return static_cast<size_t>(v);
+}
+
+} // namespace
+
+
+// This code was taken from MurmurHash.
+size_t hash_combine(size_t seed, size_t value) {
+#if V8_HOST_ARCH_32_BIT
+ const uint32_t c1 = 0xcc9e2d51;
+ const uint32_t c2 = 0x1b873593;
+
+ value *= c1;
+ value = bits::RotateRight32(value, 15);
+ value *= c2;
+
+ seed ^= value;
+ seed = bits::RotateRight32(seed, 13);
+ seed = seed * 5 + 0xe6546b64;
+#else
+ const uint64_t m = V8_UINT64_C(0xc6a4a7935bd1e995);
+ const uint32_t r = 47;
+
+ value *= m;
+ value ^= value >> r;
+ value *= m;
+
+ seed ^= value;
+ seed *= m;
+#endif // V8_HOST_ARCH_32_BIT
+ return seed;
+}
+
+
+size_t hash_value(unsigned int v) { return hash_value_unsigned(v); }
+
+
+size_t hash_value(unsigned long v) { // NOLINT(runtime/int)
+ return hash_value_unsigned(v);
+}
+
+
+size_t hash_value(unsigned long long v) { // NOLINT(runtime/int)
+ return hash_value_unsigned(v);
+}
+
+} // namespace base
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_BASE_FUNCTIONAL_H_
+#define V8_BASE_FUNCTIONAL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <cstddef>
+#include <cstring>
+#include <functional>
+#include <utility>
+
+#include "src/base/macros.h"
+
+namespace v8 {
+namespace base {
+
+// base::hash is an implementation of the hash function object specified by
+// C++11. It was designed to be compatible with std::hash (in C++11) and
+// boost:hash (which in turn is based on the hash function object specified by
+// the Draft Technical Report on C++ Library Extensions (TR1)).
+//
+// base::hash is implemented by calling the hash_value function. The namespace
+// isn't specified so that it can detect overloads via argument dependant
+// lookup. So if there is a free function hash_value in the same namespace as a
+// custom type, it will get called.
+//
+// If users are asked to implement a hash function for their own types with no
+// guidance, they generally write bad hash functions. Instead, we provide a
+// simple function base::hash_combine to pass hash-relevant member variables
+// into, in order to define a decent hash function. base::hash_combine is
+// declared as:
+//
+// template<typename T, typename... Ts>
+// size_t hash_combine(const T& v, const Ts& ...vs);
+//
+// Consider the following example:
+//
+// namespace v8 {
+// namespace bar {
+// struct Point { int x; int y; };
+// size_t hash_value(Point const& p) {
+// return base::hash_combine(p.x, p.y);
+// }
+// }
+//
+// namespace foo {
+// void DoSomeWork(bar::Point const& p) {
+// base::hash<bar::Point> h;
+// ...
+// size_t hash_code = h(p); // calls bar::hash_value(Point const&)
+// ...
+// }
+// }
+// }
+//
+// Based on the "Hashing User-Defined Types in C++1y" proposal from Jeffrey
+// Yasskin and Chandler Carruth, see
+// http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2012/n3333.html.
+
+template <typename>
+struct hash;
+
+
+V8_INLINE size_t hash_combine() { return 0u; }
+V8_INLINE size_t hash_combine(size_t seed) { return seed; }
+size_t hash_combine(size_t seed, size_t value);
+template <typename T, typename... Ts>
+V8_INLINE size_t hash_combine(T const& v, Ts const&... vs) {
+ return hash_combine(hash_combine(vs...), hash<T>()(v));
+}
+
+
+template <typename Iterator>
+V8_INLINE size_t hash_range(Iterator first, Iterator last) {
+ size_t seed = 0;
+ for (; first != last; ++first) {
+ seed = hash_combine(seed, *first);
+ }
+ return seed;
+}
+
+
+#define V8_BASE_HASH_VALUE_TRIVIAL(type) \
+ V8_INLINE size_t hash_value(type v) { return static_cast<size_t>(v); }
+V8_BASE_HASH_VALUE_TRIVIAL(bool)
+V8_BASE_HASH_VALUE_TRIVIAL(unsigned char)
+V8_BASE_HASH_VALUE_TRIVIAL(unsigned short) // NOLINT(runtime/int)
+#undef V8_BASE_HASH_VALUE_TRIVIAL
+
+size_t hash_value(unsigned int);
+size_t hash_value(unsigned long); // NOLINT(runtime/int)
+size_t hash_value(unsigned long long); // NOLINT(runtime/int)
+
+#define V8_BASE_HASH_VALUE_SIGNED(type) \
+ V8_INLINE size_t hash_value(signed type v) { \
+ return hash_value(bit_cast<unsigned type>(v)); \
+ }
+V8_BASE_HASH_VALUE_SIGNED(char)
+V8_BASE_HASH_VALUE_SIGNED(short) // NOLINT(runtime/int)
+V8_BASE_HASH_VALUE_SIGNED(int) // NOLINT(runtime/int)
+V8_BASE_HASH_VALUE_SIGNED(long) // NOLINT(runtime/int)
+V8_BASE_HASH_VALUE_SIGNED(long long) // NOLINT(runtime/int)
+#undef V8_BASE_HASH_VALUE_SIGNED
+
+V8_INLINE size_t hash_value(float v) {
+ // 0 and -0 both hash to zero.
+ return v != 0.0f ? hash_value(bit_cast<uint32_t>(v)) : 0;
+}
+
+V8_INLINE size_t hash_value(double v) {
+ // 0 and -0 both hash to zero.
+ return v != 0.0 ? hash_value(bit_cast<uint64_t>(v)) : 0;
+}
+
+template <typename T, size_t N>
+V8_INLINE size_t hash_value(const T (&v)[N]) {
+ return hash_range(v, v + N);
+}
+
+template <typename T, size_t N>
+V8_INLINE size_t hash_value(T (&v)[N]) {
+ return hash_range(v, v + N);
+}
+
+template <typename T>
+V8_INLINE size_t hash_value(T* const& v) {
+ return hash_value(bit_cast<uintptr_t>(v));
+}
+
+template <typename T1, typename T2>
+V8_INLINE size_t hash_value(std::pair<T1, T2> const& v) {
+ return hash_combine(v.first, v.second);
+}
+
+
+template <typename T>
+struct hash : public std::unary_function<T, size_t> {
+ V8_INLINE size_t operator()(T const& v) const { return hash_value(v); }
+};
+
+#define V8_BASE_HASH_SPECIALIZE(type) \
+ template <> \
+ struct hash<type> : public std::unary_function<type, size_t> { \
+ V8_INLINE size_t operator()(type const v) const { \
+ return ::v8::base::hash_value(v); \
+ } \
+ };
+V8_BASE_HASH_SPECIALIZE(bool)
+V8_BASE_HASH_SPECIALIZE(signed char)
+V8_BASE_HASH_SPECIALIZE(unsigned char)
+V8_BASE_HASH_SPECIALIZE(short) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(unsigned short) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(int)
+V8_BASE_HASH_SPECIALIZE(unsigned int)
+V8_BASE_HASH_SPECIALIZE(long) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(unsigned long) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(long long) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(unsigned long long) // NOLINT(runtime/int)
+V8_BASE_HASH_SPECIALIZE(float)
+V8_BASE_HASH_SPECIALIZE(double)
+#undef V8_BASE_HASH_SPECIALIZE
+
+template <typename T>
+struct hash<T*> : public std::unary_function<T*, size_t> {
+ V8_INLINE size_t operator()(T* const v) const {
+ return ::v8::base::hash_value(v);
+ }
+};
+
+
+// base::bit_equal_to is a function object class for bitwise equality
+// comparison, similar to std::equal_to, except that the comparison is performed
+// on the bit representation of the operands.
+//
+// base::bit_hash is a function object class for bitwise hashing, similar to
+// base::hash. It can be used together with base::bit_equal_to to implement a
+// hash data structure based on the bitwise representation of types.
+
+template <typename T>
+struct bit_equal_to : public std::binary_function<T, T, bool> {};
+
+template <typename T>
+struct bit_hash : public std::unary_function<T, size_t> {};
+
+#define V8_BASE_BIT_SPECIALIZE_TRIVIAL(type) \
+ template <> \
+ struct bit_equal_to<type> : public std::equal_to<type> {}; \
+ template <> \
+ struct bit_hash<type> : public hash<type> {};
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(signed char)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned char)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(short) // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned short) // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(long) // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned long) // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(long long) // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned long long) // NOLINT(runtime/int)
+#undef V8_BASE_BIT_SPECIALIZE_TRIVIAL
+
+#define V8_BASE_BIT_SPECIALIZE_BIT_CAST(type, btype) \
+ template <> \
+ struct bit_equal_to<type> : public std::binary_function<type, type, bool> { \
+ V8_INLINE bool operator()(type lhs, type rhs) const { \
+ return bit_cast<btype>(lhs) == bit_cast<btype>(rhs); \
+ } \
+ }; \
+ template <> \
+ struct bit_hash<type> : public std::unary_function<type, size_t> { \
+ V8_INLINE size_t operator()(type v) const { \
+ hash<btype> h; \
+ return h(bit_cast<btype>(v)); \
+ } \
+ };
+V8_BASE_BIT_SPECIALIZE_BIT_CAST(float, uint32_t)
+V8_BASE_BIT_SPECIALIZE_BIT_CAST(double, uint64_t)
+#undef V8_BASE_BIT_SPECIALIZE_BIT_CAST
+
+} // namespace base
+} // namespace v8
+
+#endif // V8_BASE_FUNCTIONAL_H_
#ifndef V8_BASE_LOGGING_H_
#define V8_BASE_LOGGING_H_
+#include <stdint.h>
#include <string.h>
-#include "include/v8stdint.h"
#include "src/base/build_config.h"
extern "C" void V8_Fatal(const char* file, int line, const char* format, ...);
#ifndef V8_BASE_MACROS_H_
#define V8_BASE_MACROS_H_
+#include <stddef.h>
+#include <stdint.h>
+
#include <cstring>
-#include "include/v8stdint.h"
#include "src/base/build_config.h"
#include "src/base/compiler-specific.h"
#include "src/base/logging.h"
(reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(4)->field)) - 4)
+#if V8_OS_NACL
+
// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
// but can be used on anonymous types or types defined inside
// functions. It's less safe than arraysize as it accepts some
((sizeof(a) / sizeof(*(a))) / \
static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) // NOLINT
-
-#if V8_OS_NACL
-
// TODO(bmeurer): For some reason, the NaCl toolchain cannot handle the correct
// definition of arraysize() below, so we have to use the unsafe version for
// now.
#define COMPILE_ASSERT(expr, msg) \
typedef CompileAssert<static_cast<bool>(expr)> \
- msg[static_cast<bool>(expr) ? 1 : -1] ALLOW_UNUSED
+ msg[static_cast<bool>(expr) ? 1 : -1] ALLOW_UNUSED_TYPE
// Implementation details of COMPILE_ASSERT:
//
// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
// // not a compile-time constant.
//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
+// - By using the type CompileAssert<static_cast<bool>(expr)>, we ensure that
// expr is a compile-time constant. (Template arguments must be
// determined at compile-time.)
//
-// - The outer parentheses in CompileAssert<(bool(expr))> are necessary
-// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
-//
-// CompileAssert<bool(expr)>
-//
-// instead, these compilers will refuse to compile
-//
-// COMPILE_ASSERT(5 > 0, some_message);
-//
-// (They seem to think the ">" in "5 > 0" marks the end of the
-// template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
+// - The array size is (static_cast<bool>(expr) ? 1 : -1), instead of simply
//
// ((expr) ? 1 : -1).
//
// actually causes each use to introduce a new defined type with a
// name depending on the source line.
template <int> class StaticAssertionHelper { };
-#define STATIC_ASSERT(test) \
- typedef \
- StaticAssertionHelper<sizeof(StaticAssertion<static_cast<bool>((test))>)> \
- SEMI_STATIC_JOIN(__StaticAssertTypedef__, __LINE__) ALLOW_UNUSED
+#define STATIC_ASSERT(test) \
+ typedef StaticAssertionHelper< \
+ sizeof(StaticAssertion<static_cast<bool>((test))>)> \
+ SEMI_STATIC_JOIN(__StaticAssertTypedef__, __LINE__) ALLOW_UNUSED_TYPE
#endif
return RoundDown<T>(static_cast<T>(x + m - 1), m);
}
+
+namespace v8 {
+namespace base {
+
+// TODO(yangguo): This is a poor man's replacement for std::is_fundamental,
+// which requires C++11. Switch to std::is_fundamental once possible.
+template <typename T>
+inline bool is_fundamental() {
+ return false;
+}
+
+template <>
+inline bool is_fundamental<uint8_t>() {
+ return true;
+}
+}
+} // namespace v8::base
+
#endif // V8_BASE_MACROS_H_
#ifndef V8_BASE_ONCE_H_
#define V8_BASE_ONCE_H_
+#include <stddef.h>
+
#include "src/base/atomicops.h"
namespace v8 {
if (std::isnan(time)) return "";
time_t tv = static_cast<time_t>(std::floor(time/msPerSecond));
struct tm* t = localtime(&tv);
- if (NULL == t) return "";
+ if (!t || !t->tm_zone) return "";
return t->tm_zone;
#endif
}
int OS::GetCurrentThreadId() {
-#if defined(ANDROID)
+#if V8_OS_MACOSX
+ return static_cast<int>(pthread_mach_thread_np(pthread_self()));
+#elif V8_OS_LINUX
return static_cast<int>(syscall(__NR_gettid));
-#elif defined(SYS_gettid)
- return static_cast<int>(syscall(SYS_gettid));
+#elif V8_OS_ANDROID
+ return static_cast<int>(gettid());
#else
- // PNaCL doesn't have a way to get an integral thread ID, but it doesn't
- // really matter, because we only need it in PerfJitLogger::LogRecordedBuffer.
- return 0;
+ return static_cast<int>(pthread_self());
#endif
}
#include "src/base/platform/platform.h"
-// It seems there is a bug in some Solaris distributions (experienced in
-// SunOS 5.10 Generic_141445-09) which make it difficult or impossible to
-// access signbit() despite the availability of other C99 math functions.
-#ifndef signbit
-namespace std {
-// Test sign - usually defined in math.h
-int signbit(double x) {
- // We need to take care of the special case of both positive and negative
- // versions of zero.
- if (x == 0) {
- return fpclass(x) & FP_NZERO;
- } else {
- // This won't detect negative NaN but that should be okay since we don't
- // assume that behavior.
- return x < 0;
- }
-}
-} // namespace std
-#endif // signbit
-
namespace v8 {
namespace base {
#endif // MINGW_HAS_SECURE_API
#endif // __MINGW32__
-#ifdef _MSC_VER
#include <limits>
-#endif
#include "src/base/win32-headers.h"
#include "src/base/platform/time.h"
#include "src/base/utils/random-number-generator.h"
-#ifdef _MSC_VER
-
-// Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually
-// defined in strings.h.
-int strncasecmp(const char* s1, const char* s2, int n) {
- return _strnicmp(s1, s2, n);
-}
-
-#endif // _MSC_VER
-
// Extra functions for MinGW. Most of these are the _s functions which are in
// the Microsoft Visual Studio C++ CRT.
}
+int64_t FileTimeToInt64(FILETIME ft) {
+ ULARGE_INTEGER result;
+ result.LowPart = ft.dwLowDateTime;
+ result.HighPart = ft.dwHighDateTime;
+ return static_cast<int64_t>(result.QuadPart);
+}
+
+
// Return the local timezone offset in milliseconds east of UTC. This
// takes into account whether daylight saving is in effect at the time.
// Only times in the 32-bit Unix range may be passed to this function.
// Also, adding the time-zone offset to the input must not overflow.
// The function EquivalentTime() in date.js guarantees this.
int64_t Win32Time::LocalOffset(TimezoneCache* cache) {
- cache->InitializeIfNeeded();
-
- Win32Time rounded_to_second(*this);
- rounded_to_second.t() = rounded_to_second.t() / 1000 / kTimeScaler *
- 1000 * kTimeScaler;
- // Convert to local time using POSIX localtime function.
- // Windows XP Service Pack 3 made SystemTimeToTzSpecificLocalTime()
- // very slow. Other browsers use localtime().
-
- // Convert from JavaScript milliseconds past 1/1/1970 0:00:00 to
- // POSIX seconds past 1/1/1970 0:00:00.
- double unchecked_posix_time = rounded_to_second.ToJSTime() / 1000;
- if (unchecked_posix_time > INT_MAX || unchecked_posix_time < 0) {
- return 0;
- }
- // Because _USE_32BIT_TIME_T is defined, time_t is a 32-bit int.
- time_t posix_time = static_cast<time_t>(unchecked_posix_time);
-
- // Convert to local time, as struct with fields for day, hour, year, etc.
- tm posix_local_time_struct;
- if (localtime_s(&posix_local_time_struct, &posix_time)) return 0;
-
- if (posix_local_time_struct.tm_isdst > 0) {
- return (cache->tzinfo_.Bias + cache->tzinfo_.DaylightBias) * -kMsPerMinute;
- } else if (posix_local_time_struct.tm_isdst == 0) {
- return (cache->tzinfo_.Bias + cache->tzinfo_.StandardBias) * -kMsPerMinute;
- } else {
- return cache->tzinfo_.Bias * -kMsPerMinute;
- }
+ FILETIME local;
+ SYSTEMTIME system_utc, system_local;
+ FileTimeToSystemTime(&time_.ft_, &system_utc);
+ SystemTimeToTzSpecificLocalTime(NULL, &system_utc, &system_local);
+ SystemTimeToFileTime(&system_local, &local);
+ return (FileTimeToInt64(local) - FileTimeToInt64(time_.ft_)) / kTimeScaler;
}
void OS::DebugBreak() {
-#ifdef _MSC_VER
+#if V8_CC_MSVC
// To avoid Visual Studio runtime support the following code can be used
// instead
// __asm { int 3 }
double OS::nan_value() {
-#ifdef _MSC_VER
return std::numeric_limits<double>::quiet_NaN();
-#else // _MSC_VER
- return NAN;
-#endif // _MSC_VER
}
#ifndef V8_BASE_PLATFORM_PLATFORM_H_
#define V8_BASE_PLATFORM_PLATFORM_H_
-#include <stdarg.h>
+#include <cstdarg>
#include <string>
#include <vector>
#include "src/base/platform/mutex.h"
#include "src/base/platform/semaphore.h"
-#ifdef __sun
-# ifndef signbit
-namespace std {
-int signbit(double x);
-}
-# endif
-#endif
-
#if V8_OS_QNX
#include "src/base/qnx-math.h"
#endif
-// Microsoft Visual C++ specific stuff.
-#if V8_LIBC_MSVCRT
-
-#include "src/base/win32-headers.h"
-#include "src/base/win32-math.h"
-
-int strncasecmp(const char* s1, const char* s2, int n);
-
-// Visual C++ 2013 and higher implement this function.
-#if (_MSC_VER < 1800)
-inline int lrint(double flt) {
- int intgr;
-#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
- __asm {
- fld flt
- fistp intgr
- };
-#else
- intgr = static_cast<int>(flt + 0.5);
- if ((intgr & 1) != 0 && intgr - flt == 0.5) {
- // If the number is halfway between two integers, round to the even one.
- intgr--;
- }
-#endif
- return intgr;
-}
-#endif // _MSC_VER < 1800
-
-#endif // V8_LIBC_MSVCRT
-
namespace v8 {
namespace base {
#ifndef V8_NO_FAST_TLS
-#if defined(_MSC_VER) && (V8_HOST_ARCH_IA32)
+#if V8_CC_MSVC && V8_HOST_ARCH_IA32
#define V8_FAST_TLS_SUPPORTED 1
#ifndef V8_BASE_SYS_INFO_H_
#define V8_BASE_SYS_INFO_H_
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/compiler-specific.h"
namespace v8 {
}
+int64_t RandomNumberGenerator::NextInt64() {
+ uint64_t lo = bit_cast<unsigned>(Next(32));
+ uint64_t hi = bit_cast<unsigned>(Next(32));
+ return lo | (hi << 32);
+}
+
+
void RandomNumberGenerator::NextBytes(void* buffer, size_t buflen) {
for (size_t n = 0; n < buflen; ++n) {
static_cast<uint8_t*>(buffer)[n] = static_cast<uint8_t>(Next(8));
// (exclusive), is pseudorandomly generated and returned.
double NextDouble() WARN_UNUSED_RESULT;
+ // Returns the next pseudorandom, uniformly distributed int64 value from this
+ // random number generator's sequence. The general contract of |NextInt64()|
+ // is that one 64-bit int value is pseudorandomly generated and returned.
+ // All 2^64 possible integer values are produced with (approximately) equal
+ // probability.
+ int64_t NextInt64() WARN_UNUSED_RESULT;
+
// Fills the elements of a specified array of bytes with random numbers.
void NextBytes(void* buffer, size_t buflen);
+++ /dev/null
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Extra POSIX/ANSI routines for Win32 when using Visual Studio C++. Please
-// refer to The Open Group Base Specification for specification of the correct
-// semantics for these functions.
-// (http://www.opengroup.org/onlinepubs/000095399/)
-#if defined(_MSC_VER) && (_MSC_VER < 1800)
-
-#include "src/base/win32-headers.h"
-#include <float.h> // Required for DBL_MAX and on Win32 for finite()
-#include <limits.h> // Required for INT_MAX etc.
-#include <cmath>
-#include "src/base/win32-math.h"
-
-#include "src/base/logging.h"
-
-
-namespace std {
-
-// Test for a NaN (not a number) value - usually defined in math.h
-int isnan(double x) {
- return _isnan(x);
-}
-
-
-// Test for infinity - usually defined in math.h
-int isinf(double x) {
- return (_fpclass(x) & (_FPCLASS_PINF | _FPCLASS_NINF)) != 0;
-}
-
-
-// Test for finite value - usually defined in math.h
-int isfinite(double x) {
- return _finite(x);
-}
-
-
-// Test if x is less than y and both nominal - usually defined in math.h
-int isless(double x, double y) {
- return isnan(x) || isnan(y) ? 0 : x < y;
-}
-
-
-// Test if x is greater than y and both nominal - usually defined in math.h
-int isgreater(double x, double y) {
- return isnan(x) || isnan(y) ? 0 : x > y;
-}
-
-
-// Classify floating point number - usually defined in math.h
-int fpclassify(double x) {
- // Use the MS-specific _fpclass() for classification.
- int flags = _fpclass(x);
-
- // Determine class. We cannot use a switch statement because
- // the _FPCLASS_ constants are defined as flags.
- if (flags & (_FPCLASS_PN | _FPCLASS_NN)) return FP_NORMAL;
- if (flags & (_FPCLASS_PZ | _FPCLASS_NZ)) return FP_ZERO;
- if (flags & (_FPCLASS_PD | _FPCLASS_ND)) return FP_SUBNORMAL;
- if (flags & (_FPCLASS_PINF | _FPCLASS_NINF)) return FP_INFINITE;
-
- // All cases should be covered by the code above.
- DCHECK(flags & (_FPCLASS_SNAN | _FPCLASS_QNAN));
- return FP_NAN;
-}
-
-
-// Test sign - usually defined in math.h
-int signbit(double x) {
- // We need to take care of the special case of both positive
- // and negative versions of zero.
- if (x == 0)
- return _fpclass(x) & _FPCLASS_NZ;
- else
- return x < 0;
-}
-
-} // namespace std
-
-#endif // _MSC_VER
+++ /dev/null
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Extra POSIX/ANSI routines for Win32 when using Visual Studio C++. Please
-// refer to The Open Group Base Specification for specification of the correct
-// semantics for these functions.
-// (http://www.opengroup.org/onlinepubs/000095399/)
-
-#ifndef V8_BASE_WIN32_MATH_H_
-#define V8_BASE_WIN32_MATH_H_
-
-#ifndef _MSC_VER
-#error Wrong environment, expected MSVC.
-#endif // _MSC_VER
-
-// MSVC 2013+ provides implementations of all standard math functions.
-#if (_MSC_VER < 1800)
-enum {
- FP_NAN,
- FP_INFINITE,
- FP_ZERO,
- FP_SUBNORMAL,
- FP_NORMAL
-};
-
-
-namespace std {
-
-int isfinite(double x);
-int isinf(double x);
-int isnan(double x);
-int isless(double x, double y);
-int isgreater(double x, double y);
-int fpclassify(double x);
-int signbit(double x);
-
-} // namespace std
-
-#endif // _MSC_VER < 1800
-
-#endif // V8_BASE_WIN32_MATH_H_
#include "src/basic-block-profiler.h"
+#include <sstream>
+
namespace v8 {
namespace internal {
BasicBlockProfiler::Data::Data(size_t n_blocks)
- : n_blocks_(n_blocks), block_ids_(n_blocks_, -1), counts_(n_blocks_, 0) {}
+ : n_blocks_(n_blocks), block_ids_(n_blocks_), counts_(n_blocks_, 0) {}
BasicBlockProfiler::Data::~Data() {}
-static void InsertIntoString(OStringStream* os, std::string* string) {
- string->insert(string->begin(), os->c_str(), &os->c_str()[os->size()]);
+static void InsertIntoString(std::ostringstream* os, std::string* string) {
+ string->insert(0, os->str());
}
-void BasicBlockProfiler::Data::SetCode(OStringStream* os) {
+void BasicBlockProfiler::Data::SetCode(std::ostringstream* os) {
InsertIntoString(os, &code_);
}
-void BasicBlockProfiler::Data::SetFunctionName(OStringStream* os) {
+void BasicBlockProfiler::Data::SetFunctionName(std::ostringstream* os) {
InsertIntoString(os, &function_name_);
}
-void BasicBlockProfiler::Data::SetSchedule(OStringStream* os) {
+void BasicBlockProfiler::Data::SetSchedule(std::ostringstream* os) {
InsertIntoString(os, &schedule_);
}
-void BasicBlockProfiler::Data::SetBlockId(size_t offset, int block_id) {
+void BasicBlockProfiler::Data::SetBlockId(size_t offset, size_t block_id) {
DCHECK(offset < n_blocks_);
block_ids_[offset] = block_id;
}
}
-OStream& operator<<(OStream& os, const BasicBlockProfiler& p) {
- os << "---- Start Profiling Data ----" << endl;
+std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler& p) {
+ os << "---- Start Profiling Data ----" << std::endl;
typedef BasicBlockProfiler::DataList::const_iterator iterator;
for (iterator i = p.data_list_.begin(); i != p.data_list_.end(); ++i) {
os << **i;
}
- os << "---- End Profiling Data ----" << endl;
+ os << "---- End Profiling Data ----" << std::endl;
return os;
}
-OStream& operator<<(OStream& os, const BasicBlockProfiler::Data& d) {
+std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler::Data& d) {
const char* name = "unknown function";
if (!d.function_name_.empty()) {
name = d.function_name_.c_str();
}
if (!d.schedule_.empty()) {
- os << "schedule for " << name << endl;
- os << d.schedule_.c_str() << endl;
+ os << "schedule for " << name << std::endl;
+ os << d.schedule_.c_str() << std::endl;
}
- os << "block counts for " << name << ":" << endl;
+ os << "block counts for " << name << ":" << std::endl;
for (size_t i = 0; i < d.n_blocks_; ++i) {
- os << "block " << d.block_ids_[i] << " : " << d.counts_[i] << endl;
+ os << "block " << d.block_ids_[i] << " : " << d.counts_[i] << std::endl;
}
- os << endl;
+ os << std::endl;
if (!d.code_.empty()) {
- os << d.code_.c_str() << endl;
+ os << d.code_.c_str() << std::endl;
}
return os;
}
#ifndef V8_BASIC_BLOCK_PROFILER_H_
#define V8_BASIC_BLOCK_PROFILER_H_
+#include <iosfwd>
#include <list>
+#include <string>
#include "src/v8.h"
size_t n_blocks() const { return n_blocks_; }
const uint32_t* counts() const { return &counts_[0]; }
- void SetCode(OStringStream* os);
- void SetFunctionName(OStringStream* os);
- void SetSchedule(OStringStream* os);
- void SetBlockId(size_t offset, int block_id);
+ void SetCode(std::ostringstream* os);
+ void SetFunctionName(std::ostringstream* os);
+ void SetSchedule(std::ostringstream* os);
+ void SetBlockId(size_t offset, size_t block_id);
uint32_t* GetCounterAddress(size_t offset);
private:
friend class BasicBlockProfiler;
- friend OStream& operator<<(OStream& os, const BasicBlockProfiler::Data& s);
+ friend std::ostream& operator<<(std::ostream& os,
+ const BasicBlockProfiler::Data& s);
explicit Data(size_t n_blocks);
~Data();
void ResetCounts();
const size_t n_blocks_;
- std::vector<int> block_ids_;
+ std::vector<size_t> block_ids_;
std::vector<uint32_t> counts_;
std::string function_name_;
std::string schedule_;
const DataList* data_list() { return &data_list_; }
private:
- friend OStream& operator<<(OStream& os, const BasicBlockProfiler& s);
+ friend std::ostream& operator<<(std::ostream& os,
+ const BasicBlockProfiler& s);
DataList data_list_;
DISALLOW_COPY_AND_ASSIGN(BasicBlockProfiler);
};
-OStream& operator<<(OStream& os, const BasicBlockProfiler& s);
-OStream& operator<<(OStream& os, const BasicBlockProfiler::Data& s);
+std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler& s);
+std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler::Data& s);
} // namespace internal
} // namespace v8
#include <cmath>
-#include "include/v8stdint.h"
#include "src/base/logging.h"
#include "src/utils.h"
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/data-flow.h"
+#include "src/bit-vector.h"
#include "src/base/bits.h"
#include "src/scopes.h"
void BitVector::Iterator::Advance() {
current_++;
- uint32_t val = current_value_;
+ uintptr_t val = current_value_;
while (val == 0) {
current_index_++;
if (Done()) return;
val = target_->data_[current_index_];
- current_ = current_index_ << 5;
+ current_ = current_index_ << kDataBitShift;
}
val = SkipZeroBytes(val);
val = SkipZeroBits(val);
int BitVector::Count() const {
int count = 0;
for (int i = 0; i < data_length_; i++) {
- int data = data_[i];
- if (data != 0) count += base::bits::CountPopulation32(data);
+ uintptr_t data = data_[i];
+ if (sizeof(data) == 8) {
+ count += base::bits::CountPopulation64(data);
+ } else {
+ count += base::bits::CountPopulation32(static_cast<uint32_t>(data));
+ }
}
return count;
}
namespace v8 {
namespace internal {
-class BitVector: public ZoneObject {
+class BitVector : public ZoneObject {
public:
// Iterator for the elements of this BitVector.
class Iterator BASE_EMBEDDED {
DCHECK(target->data_length_ > 0);
Advance();
}
- ~Iterator() { }
+ ~Iterator() {}
bool Done() const { return current_index_ >= target_->data_length_; }
void Advance();
}
private:
- uint32_t SkipZeroBytes(uint32_t val) {
+ uintptr_t SkipZeroBytes(uintptr_t val) {
while ((val & 0xFF) == 0) {
val >>= 8;
current_ += 8;
}
return val;
}
- uint32_t SkipZeroBits(uint32_t val) {
+ uintptr_t SkipZeroBits(uintptr_t val) {
while ((val & 0x1) == 0) {
val >>= 1;
current_++;
BitVector* target_;
int current_index_;
- uint32_t current_value_;
+ uintptr_t current_value_;
int current_;
friend class BitVector;
};
+ static const int kDataBits = kPointerSize * 8;
+ static const int kDataBitShift = kPointerSize == 8 ? 6 : 5;
+ static const uintptr_t kOne = 1; // This saves some static_casts.
+
BitVector(int length, Zone* zone)
: length_(length),
data_length_(SizeFor(length)),
- data_(zone->NewArray<uint32_t>(data_length_)) {
+ data_(zone->NewArray<uintptr_t>(data_length_)) {
DCHECK(length > 0);
Clear();
}
BitVector(const BitVector& other, Zone* zone)
: length_(other.length()),
data_length_(SizeFor(length_)),
- data_(zone->NewArray<uint32_t>(data_length_)) {
+ data_(zone->NewArray<uintptr_t>(data_length_)) {
CopyFrom(other);
}
- static int SizeFor(int length) {
- return 1 + ((length - 1) / 32);
- }
-
- BitVector& operator=(const BitVector& rhs) {
- if (this != &rhs) CopyFrom(rhs);
- return *this;
- }
+ static int SizeFor(int length) { return 1 + ((length - 1) / kDataBits); }
void CopyFrom(const BitVector& other) {
DCHECK(other.length() <= length());
bool Contains(int i) const {
DCHECK(i >= 0 && i < length());
- uint32_t block = data_[i / 32];
- return (block & (1U << (i % 32))) != 0;
+ uintptr_t block = data_[i / kDataBits];
+ return (block & (kOne << (i % kDataBits))) != 0;
}
void Add(int i) {
DCHECK(i >= 0 && i < length());
- data_[i / 32] |= (1U << (i % 32));
+ data_[i / kDataBits] |= (kOne << (i % kDataBits));
}
void Remove(int i) {
DCHECK(i >= 0 && i < length());
- data_[i / 32] &= ~(1U << (i % 32));
+ data_[i / kDataBits] &= ~(kOne << (i % kDataBits));
}
void Union(const BitVector& other) {
DCHECK(other.length() == length());
bool changed = false;
for (int i = 0; i < data_length_; i++) {
- uint32_t old_data = data_[i];
+ uintptr_t old_data = data_[i];
data_[i] |= other.data_[i];
if (data_[i] != old_data) changed = true;
}
DCHECK(other.length() == length());
bool changed = false;
for (int i = 0; i < data_length_; i++) {
- uint32_t old_data = data_[i];
+ uintptr_t old_data = data_[i];
data_[i] &= other.data_[i];
if (data_[i] != old_data) changed = true;
}
#endif
private:
- int length_;
- int data_length_;
- uint32_t* data_;
+ const int length_;
+ const int data_length_;
+ uintptr_t* const data_;
+
+ DISALLOW_COPY_AND_ASSIGN(BitVector);
};
class Iterator BASE_EMBEDDED {
public:
Iterator(const GrowableBitVector* target, Zone* zone)
- : it_(target->bits_ == NULL
- ? new(zone) BitVector(1, zone)
- : target->bits_) { }
+ : it_(target->bits_ == NULL ? new (zone) BitVector(1, zone)
+ : target->bits_) {}
bool Done() const { return it_.Done(); }
void Advance() { it_.Advance(); }
int Current() const { return it_.Current(); }
+
private:
BitVector::Iterator it_;
};
- GrowableBitVector() : bits_(NULL) { }
+ GrowableBitVector() : bits_(NULL) {}
GrowableBitVector(int length, Zone* zone)
- : bits_(new(zone) BitVector(length, zone)) { }
+ : bits_(new (zone) BitVector(length, zone)) {}
bool Contains(int value) const {
if (!InBitsRange(value)) return false;
}
}
- void Clear() { if (bits_ != NULL) bits_->Clear(); }
+ void Clear() {
+ if (bits_ != NULL) bits_->Clear();
+ }
private:
static const int kInitialLength = 1024;
if (InBitsRange(value)) return;
int new_length = bits_ == NULL ? kInitialLength : bits_->length();
while (new_length <= value) new_length *= 2;
- BitVector* new_bits = new(zone) BitVector(new_length, zone);
+ BitVector* new_bits = new (zone) BitVector(new_length, zone);
if (bits_ != NULL) new_bits->CopyFrom(*bits_);
bits_ = new_bits;
}
Handle<String> source_code = isolate_->factory()
->NewExternalStringFromOneByte(resource)
.ToHandleChecked();
+ // Mark this external string with a special map.
+ source_code->set_map(isolate_->heap()->native_source_string_map());
heap->natives_source_cache()->set(index, *source_code);
}
Handle<Object> cached_source(heap->natives_source_cache()->get(index),
void Bootstrapper::TearDown() {
if (delete_these_non_arrays_on_tear_down_ != NULL) {
int len = delete_these_non_arrays_on_tear_down_->length();
- DCHECK(len < 28); // Don't use this mechanism for unbounded allocations.
+ DCHECK(len < 1000); // Don't use this mechanism for unbounded allocations.
for (int i = 0; i < len; i++) {
delete delete_these_non_arrays_on_tear_down_->at(i);
delete_these_non_arrays_on_tear_down_->at(i) = NULL;
// Used for creating a context from scratch.
void InstallNativeFunctions();
void InstallExperimentalNativeFunctions();
+
+#define DECLARE_FEATURE_INITIALIZATION(id, descr) \
+ void InstallNativeFunctions_##id(); \
+ void InitializeGlobal_##id();
+
+ HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
+ HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
+ HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
+#undef DECLARE_FEATURE_INITIALIZATION
+
Handle<JSFunction> InstallInternalArray(Handle<JSBuiltinsObject> builtins,
const char* name,
ElementsKind elements_kind);
// prototype, otherwise the missing initial_array_prototype will cause
// assertions during startup.
native_context()->set_initial_array_prototype(*prototype);
- Accessors::FunctionSetPrototype(object_fun, prototype);
+ Accessors::FunctionSetPrototype(object_fun, prototype).Assert();
}
// Allocate the empty function as the prototype for function ECMAScript
delegate->shared()->DontAdaptArguments();
}
+#define FEATURE_INITIALIZE_GLOBAL(id, descr) InitializeGlobal_##id();
+
+ HARMONY_SHIPPING(FEATURE_INITIALIZE_GLOBAL)
+#undef FEATURE_INITIALIZE_GLOBAL
+
// Initialize the embedder data slot.
Handle<FixedArray> embedder_data = factory->NewFixedArray(3);
native_context()->set_embedder_data(*embedder_data);
void Genesis::InitializeExperimentalGlobal() {
- // TODO(erikcorry): Move this into Genesis::InitializeGlobal once we no
- // longer need to live behind a flag.
- Handle<JSObject> builtins(native_context()->builtins());
+#define FEATURE_INITIALIZE_GLOBAL(id, descr) InitializeGlobal_##id();
- Handle<HeapObject> flag(
- FLAG_harmony_regexps ? heap()->true_value() : heap()->false_value());
- PropertyAttributes attributes =
- static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
- Runtime::DefineObjectProperty(builtins, factory()->harmony_regexps_string(),
- flag, attributes).Assert();
+ HARMONY_INPROGRESS(FEATURE_INITIALIZE_GLOBAL)
+ HARMONY_STAGED(FEATURE_INITIALIZE_GLOBAL)
+#undef FEATURE_INITIALIZE_GLOBAL
}
.ToHandleChecked(); \
native_context()->set_##var(Type::cast(*var##_native));
-#define INSTALL_NATIVE_MATH(name) \
- { \
- Handle<Object> fun = \
- ResolveBuiltinIdHolder(native_context(), "Math." #name); \
- native_context()->set_math_##name##_fun(JSFunction::cast(*fun)); \
- }
void Genesis::InstallNativeFunctions() {
HandleScope scope(isolate());
INSTALL_NATIVE(Symbol, "symbolUnscopables", unscopables_symbol);
INSTALL_NATIVE(JSFunction, "ArrayValues", array_values_iterator);
- INSTALL_NATIVE_MATH(abs)
- INSTALL_NATIVE_MATH(acos)
- INSTALL_NATIVE_MATH(asin)
- INSTALL_NATIVE_MATH(atan)
- INSTALL_NATIVE_MATH(atan2)
- INSTALL_NATIVE_MATH(ceil)
- INSTALL_NATIVE_MATH(cos)
- INSTALL_NATIVE_MATH(exp)
- INSTALL_NATIVE_MATH(floor)
- INSTALL_NATIVE_MATH(imul)
- INSTALL_NATIVE_MATH(log)
- INSTALL_NATIVE_MATH(max)
- INSTALL_NATIVE_MATH(min)
- INSTALL_NATIVE_MATH(pow)
- INSTALL_NATIVE_MATH(random)
- INSTALL_NATIVE_MATH(round)
- INSTALL_NATIVE_MATH(sin)
- INSTALL_NATIVE_MATH(sqrt)
- INSTALL_NATIVE_MATH(tan)
+#define INSTALL_NATIVE_FUNCTIONS_FOR(id, descr) InstallNativeFunctions_##id();
+ HARMONY_SHIPPING(INSTALL_NATIVE_FUNCTIONS_FOR)
+#undef INSTALL_NATIVE_FUNCTIONS_FOR
}
INSTALL_NATIVE(JSFunction, "DerivedSetTrap", derived_set_trap);
INSTALL_NATIVE(JSFunction, "ProxyEnumerate", proxy_enumerate);
}
+
+#define INSTALL_NATIVE_FUNCTIONS_FOR(id, descr) InstallNativeFunctions_##id();
+ HARMONY_INPROGRESS(INSTALL_NATIVE_FUNCTIONS_FOR)
+ HARMONY_STAGED(INSTALL_NATIVE_FUNCTIONS_FOR)
+#undef INSTALL_NATIVE_FUNCTIONS_FOR
+}
+
+
+#define EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(id) \
+ void Genesis::InstallNativeFunctions_##id() {}
+
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_scoping)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_modules)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_strings)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_arrays)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_classes)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_object_literals)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_regexps)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_arrow_functions)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_numeric_literals)
+EMPTY_NATIVE_FUNCTIONS_FOR_FEATURE(harmony_tostring)
+
+
+void Genesis::InstallNativeFunctions_harmony_proxies() {
+ if (FLAG_harmony_proxies) {
+ INSTALL_NATIVE(JSFunction, "DerivedHasTrap", derived_has_trap);
+ INSTALL_NATIVE(JSFunction, "DerivedGetTrap", derived_get_trap);
+ INSTALL_NATIVE(JSFunction, "DerivedSetTrap", derived_set_trap);
+ INSTALL_NATIVE(JSFunction, "ProxyEnumerate", proxy_enumerate);
+ }
}
#undef INSTALL_NATIVE
+#define EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(id) \
+ void Genesis::InitializeGlobal_##id() {}
+
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_scoping)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_modules)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_strings)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_arrays)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_classes)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_object_literals)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_arrow_functions)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_numeric_literals)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_tostring)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_proxies)
+
+void Genesis::InitializeGlobal_harmony_regexps() {
+ Handle<JSObject> builtins(native_context()->builtins());
+
+ Handle<HeapObject> flag(FLAG_harmony_regexps ? heap()->true_value()
+ : heap()->false_value());
+ PropertyAttributes attributes =
+ static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
+ Runtime::DefineObjectProperty(builtins, factory()->harmony_regexps_string(),
+ flag, attributes).Assert();
+}
+
Handle<JSFunction> Genesis::InstallInternalArray(
Handle<JSBuiltinsObject> builtins,
isolate()->initial_object_prototype(), Builtins::kIllegal);
Handle<JSObject> prototype =
factory()->NewJSObject(isolate()->object_function(), TENURED);
- Accessors::FunctionSetPrototype(script_fun, prototype);
+ Accessors::FunctionSetPrototype(script_fun, prototype).Assert();
native_context()->set_script_function(*script_fun);
Handle<Map> script_map = Handle<Map>(script_fun->initial_map());
isolate()->initial_object_prototype(), Builtins::kIllegal);
Handle<JSObject> prototype =
factory()->NewJSObject(isolate()->object_function(), TENURED);
- Accessors::FunctionSetPrototype(opaque_reference_fun, prototype);
+ Accessors::FunctionSetPrototype(opaque_reference_fun, prototype).Assert();
native_context()->set_opaque_reference_function(*opaque_reference_fun);
}
// Apply embeds an IC, so we need a type vector of size 1 in the shared
// function info.
Handle<TypeFeedbackVector> feedback_vector =
- factory()->NewTypeFeedbackVector(1);
+ factory()->NewTypeFeedbackVector(0, 1);
apply->shared()->set_feedback_vector(*feedback_vector);
}
}
-#define INSTALL_EXPERIMENTAL_NATIVE(i, flag, file) \
- if (FLAG_harmony_##flag && \
- strcmp(ExperimentalNatives::GetScriptName(i).start(), \
- "native " file) == 0) { \
- if (!CompileExperimentalBuiltin(isolate(), i)) return false; \
+#define INSTALL_EXPERIMENTAL_NATIVE(i, flag, file) \
+ if (FLAG_##flag && \
+ strcmp(ExperimentalNatives::GetScriptName(i).start(), "native " file) == \
+ 0) { \
+ if (!CompileExperimentalBuiltin(isolate(), i)) return false; \
}
bool Genesis::InstallExperimentalNatives() {
+ static const char* harmony_arrays_natives[] = {
+ "native harmony-array.js", "native harmony-typedarray.js", NULL};
+ static const char* harmony_proxies_natives[] = {"native proxy.js", NULL};
+ static const char* harmony_strings_natives[] = {"native harmony-string.js",
+ NULL};
+ static const char* harmony_classes_natives[] = {"native harmony-classes.js",
+ NULL};
+ static const char* harmony_modules_natives[] = {NULL};
+ static const char* harmony_scoping_natives[] = {NULL};
+ static const char* harmony_object_literals_natives[] = {NULL};
+ static const char* harmony_regexps_natives[] = {NULL};
+ static const char* harmony_arrow_functions_natives[] = {NULL};
+ static const char* harmony_numeric_literals_natives[] = {NULL};
+ static const char* harmony_tostring_natives[] = {"native harmony-tostring.js",
+ NULL};
+
for (int i = ExperimentalNatives::GetDebuggerCount();
- i < ExperimentalNatives::GetBuiltinsCount();
- i++) {
- INSTALL_EXPERIMENTAL_NATIVE(i, proxies, "proxy.js")
- INSTALL_EXPERIMENTAL_NATIVE(i, strings, "harmony-string.js")
- INSTALL_EXPERIMENTAL_NATIVE(i, arrays, "harmony-array.js")
- INSTALL_EXPERIMENTAL_NATIVE(i, classes, "harmony-classes.js")
- }
+ i < ExperimentalNatives::GetBuiltinsCount(); i++) {
+#define INSTALL_EXPERIMENTAL_NATIVES(id, desc) \
+ if (FLAG_##id) { \
+ for (size_t j = 0; id##_natives[j] != NULL; j++) { \
+ if (strcmp(ExperimentalNatives::GetScriptName(i).start(), \
+ id##_natives[j]) == 0) { \
+ if (!CompileExperimentalBuiltin(isolate(), i)) return false; \
+ } \
+ } \
+ }
+ // Iterate over flags that are not enabled by default.
+ HARMONY_INPROGRESS(INSTALL_EXPERIMENTAL_NATIVES);
+ HARMONY_STAGED(INSTALL_EXPERIMENTAL_NATIVES);
+#undef INSTALL_EXPERIMENTAL_NATIVES
+ }
+
+#define USE_NATIVES_FOR_FEATURE(id, descr) USE(id##_natives);
+ HARMONY_SHIPPING(USE_NATIVES_FOR_FEATURE)
+#undef USE_NATIVES_FOR_FEATURE
InstallExperimentalNativeFunctions();
return true;
class NoTrackDoubleFieldsForSerializerScope {
public:
explicit NoTrackDoubleFieldsForSerializerScope(Isolate* isolate)
- : flag_(FLAG_track_double_fields) {
+ : flag_(FLAG_track_double_fields), enabled_(false) {
if (isolate->serializer_enabled()) {
// Disable tracking double fields because heap numbers treated as
// immutable by the serializer.
FLAG_track_double_fields = false;
+ enabled_ = true;
}
}
~NoTrackDoubleFieldsForSerializerScope() {
- FLAG_track_double_fields = flag_;
+ if (enabled_) {
+ FLAG_track_double_fields = flag_;
+ }
}
private:
bool flag_;
+ bool enabled_;
};
}
-static bool ArrayPrototypeHasNoElements(Heap* heap,
- Context* native_context,
- JSObject* array_proto) {
+static bool ArrayPrototypeHasNoElements(Heap* heap, PrototypeIterator* iter) {
DisallowHeapAllocation no_gc;
- // This method depends on non writability of Object and Array prototype
- // fields.
- if (array_proto->elements() != heap->empty_fixed_array()) return false;
- // Object.prototype
- PrototypeIterator iter(heap->isolate(), array_proto);
- if (iter.IsAtEnd()) {
- return false;
+ for (; !iter->IsAtEnd(); iter->Advance()) {
+ if (iter->GetCurrent()->IsJSProxy()) return false;
+ if (JSObject::cast(iter->GetCurrent())->elements() !=
+ heap->empty_fixed_array()) {
+ return false;
+ }
}
- array_proto = JSObject::cast(iter.GetCurrent());
- if (array_proto != native_context->initial_object_prototype()) return false;
- if (array_proto->elements() != heap->empty_fixed_array()) return false;
- iter.Advance();
- return iter.IsAtEnd();
+ return true;
+}
+
+
+static inline bool IsJSArrayFastElementMovingAllowed(Heap* heap,
+ JSArray* receiver) {
+ if (!FLAG_clever_optimizations) return false;
+ DisallowHeapAllocation no_gc;
+ PrototypeIterator iter(heap->isolate(), receiver);
+ return ArrayPrototypeHasNoElements(heap, &iter);
}
Handle<JSArray> array = Handle<JSArray>::cast(receiver);
// If there may be elements accessors in the prototype chain, the fast path
// cannot be used if there arguments to add to the array.
- if (args != NULL && array->map()->DictionaryElementsInPrototypeChainOnly()) {
+ Heap* heap = isolate->heap();
+ if (args != NULL && !IsJSArrayFastElementMovingAllowed(heap, *array)) {
return MaybeHandle<FixedArrayBase>();
}
if (array->map()->is_observed()) return MaybeHandle<FixedArrayBase>();
if (!array->map()->is_extensible()) return MaybeHandle<FixedArrayBase>();
Handle<FixedArrayBase> elms(array->elements(), isolate);
- Heap* heap = isolate->heap();
Map* map = elms->map();
if (map == heap->fixed_array_map()) {
if (args == NULL || array->HasFastObjectElements()) return elms;
}
-static inline bool IsJSArrayFastElementMovingAllowed(Heap* heap,
- JSArray* receiver) {
- if (!FLAG_clever_optimizations) return false;
- DisallowHeapAllocation no_gc;
- Context* native_context = heap->isolate()->context()->native_context();
- JSObject* array_proto =
- JSObject::cast(native_context->array_function()->prototype());
- PrototypeIterator iter(heap->isolate(), receiver);
- return iter.GetCurrent() == array_proto &&
- ArrayPrototypeHasNoElements(heap, native_context, array_proto);
-}
-
-
MUST_USE_RESULT static Object* CallJsBuiltin(
Isolate* isolate,
const char* name,
EnsureJSArrayWithWritableFastElements(isolate, receiver, NULL, 0);
Handle<FixedArrayBase> elms_obj;
if (!maybe_elms_obj.ToHandle(&elms_obj) ||
- !IsJSArrayFastElementMovingAllowed(heap,
- *Handle<JSArray>::cast(receiver))) {
+ !IsJSArrayFastElementMovingAllowed(heap, JSArray::cast(*receiver))) {
return CallJsBuiltin(isolate, "ArrayShift", args);
}
Handle<JSArray> array = Handle<JSArray>::cast(receiver);
Heap* heap = isolate->heap();
Handle<Object> receiver = args.receiver();
MaybeHandle<FixedArrayBase> maybe_elms_obj =
- EnsureJSArrayWithWritableFastElements(isolate, receiver, NULL, 0);
+ EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 1);
Handle<FixedArrayBase> elms_obj;
- if (!maybe_elms_obj.ToHandle(&elms_obj) ||
- !IsJSArrayFastElementMovingAllowed(heap,
- *Handle<JSArray>::cast(receiver))) {
+ if (!maybe_elms_obj.ToHandle(&elms_obj)) {
return CallJsBuiltin(isolate, "ArrayUnshift", args);
}
Handle<JSArray> array = Handle<JSArray>::cast(receiver);
Handle<FixedArray> elms = Handle<FixedArray>::cast(elms_obj);
- JSObject::EnsureCanContainElements(array, &args, 1, to_add,
- DONT_ALLOW_DOUBLE_ELEMENTS);
-
if (new_length > elms->length()) {
// New backing storage is needed.
int capacity = new_length + (new_length >> 1) + 16;
MaybeHandle<FixedArrayBase> maybe_elms_obj =
EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 3);
Handle<FixedArrayBase> elms_obj;
- if (!maybe_elms_obj.ToHandle(&elms_obj) ||
- !IsJSArrayFastElementMovingAllowed(heap,
- *Handle<JSArray>::cast(receiver))) {
+ if (!maybe_elms_obj.ToHandle(&elms_obj)) {
return CallJsBuiltin(isolate, "ArraySplice", args);
}
Handle<JSArray> array = Handle<JSArray>::cast(receiver);
DisallowHeapAllocation no_gc;
Heap* heap = isolate->heap();
Context* native_context = isolate->context()->native_context();
- JSObject* array_proto =
- JSObject::cast(native_context->array_function()->prototype());
- if (!ArrayPrototypeHasNoElements(heap, native_context, array_proto)) {
+ Object* array_proto = native_context->array_function()->prototype();
+ PrototypeIterator iter(isolate, array_proto,
+ PrototypeIterator::START_AT_RECEIVER);
+ if (!ArrayPrototypeHasNoElements(heap, &iter)) {
AllowHeapAllocation allow_allocation;
return CallJsBuiltin(isolate, "ArrayConcatJS", args);
}
}
-static void Generate_KeyedLoadIC_String(MacroAssembler* masm) {
- KeyedLoadIC::GenerateString(masm);
-}
-
-
static void Generate_KeyedLoadIC_PreMonomorphic(MacroAssembler* masm) {
KeyedLoadIC::GeneratePreMonomorphic(masm);
}
}
+static void Generate_KeyedStoreIC_Megamorphic(MacroAssembler* masm) {
+ KeyedStoreIC::GenerateMegamorphic(masm, SLOPPY);
+}
+
+
+static void Generate_KeyedStoreIC_Megamorphic_Strict(MacroAssembler* masm) {
+ KeyedStoreIC::GenerateMegamorphic(masm, STRICT);
+}
+
+
static void Generate_KeyedStoreIC_Generic(MacroAssembler* masm) {
KeyedStoreIC::GenerateGeneric(masm, SLOPPY);
}
PROFILE(isolate,
CodeCreateEvent(Logger::BUILTIN_TAG, *code, functions[i].s_name));
builtins_[i] = *code;
- if (code->kind() == Code::BUILTIN) code->set_builtin_index(i);
+ code->set_builtin_index(i);
#ifdef ENABLE_DISASSEMBLER
if (FLAG_print_builtin_code) {
CodeTracer::Scope trace_scope(isolate->GetCodeTracer());
V(KeyedLoadIC_PreMonomorphic, KEYED_LOAD_IC, PREMONOMORPHIC, \
kNoExtraICState) \
V(KeyedLoadIC_Generic, KEYED_LOAD_IC, GENERIC, kNoExtraICState) \
- V(KeyedLoadIC_String, KEYED_LOAD_IC, MEGAMORPHIC, kNoExtraICState) \
\
V(StoreIC_Setter_ForDeopt, STORE_IC, MONOMORPHIC, StoreIC::kStrictModeState) \
\
V(KeyedStoreIC_Initialize, KEYED_STORE_IC, UNINITIALIZED, kNoExtraICState) \
V(KeyedStoreIC_PreMonomorphic, KEYED_STORE_IC, PREMONOMORPHIC, \
kNoExtraICState) \
+ V(KeyedStoreIC_Megamorphic, KEYED_STORE_IC, MEGAMORPHIC, kNoExtraICState) \
V(KeyedStoreIC_Generic, KEYED_STORE_IC, GENERIC, kNoExtraICState) \
\
V(KeyedStoreIC_Initialize_Strict, KEYED_STORE_IC, UNINITIALIZED, \
StoreIC::kStrictModeState) \
V(KeyedStoreIC_PreMonomorphic_Strict, KEYED_STORE_IC, PREMONOMORPHIC, \
StoreIC::kStrictModeState) \
+ V(KeyedStoreIC_Megamorphic_Strict, KEYED_STORE_IC, MEGAMORPHIC, \
+ StoreIC::kStrictModeState) \
V(KeyedStoreIC_Generic_Strict, KEYED_STORE_IC, GENERIC, \
StoreIC::kStrictModeState) \
V(KeyedStoreIC_SloppyArguments, KEYED_STORE_IC, MONOMORPHIC, \
#include <limits.h>
#include <stdarg.h>
+#include <stdint.h>
#include <cmath>
-#include "include/v8stdint.h"
#include "src/base/logging.h"
#include "src/cached-powers.h"
#include "src/globals.h"
--- /dev/null
+// Copyright 2011 the V8 project 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/char-predicates.h"
+
+#ifdef V8_I18N_SUPPORT
+#include "unicode/uchar.h"
+#include "unicode/urename.h"
+#endif // V8_I18N_SUPPORT
+
+namespace v8 {
+namespace internal {
+
+bool SupplementaryPlanes::IsIDStart(uc32 c) {
+ DCHECK(c > 0xFFFF);
+#ifdef V8_I18N_SUPPORT
+ // This only works for code points in the SMPs, since ICU does not exclude
+ // code points with properties 'Pattern_Syntax' or 'Pattern_White_Space'.
+ // Code points in the SMP do not have those properties.
+ return u_isIDStart(c);
+#else
+ // This is incorrect, but if we don't have ICU, use this as fallback.
+ return false;
+#endif // V8_I18N_SUPPORT
+}
+
+
+bool SupplementaryPlanes::IsIDPart(uc32 c) {
+ DCHECK(c > 0xFFFF);
+#ifdef V8_I18N_SUPPORT
+ // This only works for code points in the SMPs, since ICU does not exclude
+ // code points with properties 'Pattern_Syntax' or 'Pattern_White_Space'.
+ // Code points in the SMP do not have those properties.
+ return u_isIDPart(c);
+#else
+ // This is incorrect, but if we don't have ICU, use this as fallback.
+ return false;
+#endif // V8_I18N_SUPPORT
+}
+}
+} // namespace v8::internal
inline bool IsRegExpWord(uc32 c);
inline bool IsRegExpNewline(uc32 c);
+
+struct SupplementaryPlanes {
+ static bool IsIDStart(uc32 c);
+ static bool IsIDPart(uc32 c);
+};
+
+
+// ES6 draft section 11.6
+// This includes '_', '$' and '\', and ID_Start according to
+// http://www.unicode.org/reports/tr31/, which consists of categories
+// 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl', but excluding properties
+// 'Pattern_Syntax' or 'Pattern_White_Space'.
+// For code points in the SMPs, we can resort to ICU (if available).
struct IdentifierStart {
static inline bool Is(uc32 c) {
- switch (c) {
- case '$': case '_': case '\\': return true;
- default: return unibrow::Letter::Is(c);
- }
+ if (c > 0xFFFF) return SupplementaryPlanes::IsIDStart(c);
+ return unibrow::ID_Start::Is(c);
}
};
+// ES6 draft section 11.6
+// This includes \u200c and \u200d, and ID_Continue according to
+// http://www.unicode.org/reports/tr31/, which consists of ID_Start,
+// the categories 'Mn', 'Mc', 'Nd', 'Pc', but excluding properties
+// 'Pattern_Syntax' or 'Pattern_White_Space'.
+// For code points in the SMPs, we can resort to ICU (if available).
struct IdentifierPart {
static inline bool Is(uc32 c) {
- return IdentifierStart::Is(c)
- || unibrow::Number::Is(c)
- || c == 0x200C // U+200C is Zero-Width Non-Joiner.
- || c == 0x200D // U+200D is Zero-Width Joiner.
- || unibrow::CombiningMark::Is(c)
- || unibrow::ConnectorPunctuation::Is(c);
+ if (c > 0xFFFF) return SupplementaryPlanes::IsIDPart(c);
+ return unibrow::ID_Start::Is(c) || unibrow::ID_Continue::Is(c);
}
};
-// WhiteSpace according to ECMA-262 5.1, 7.2.
+// ES6 draft section 11.2
+// This includes all code points of Unicode category 'Zs'.
+// \u180e stops being one as of Unicode 6.3.0, but ES6 adheres to Unicode 5.1,
+// so it is also included.
+// Further included are \u0009, \u000b, \u0020, \u00a0, \u000c, and \ufeff.
+// There are no category 'Zs' code points in the SMPs.
struct WhiteSpace {
- static inline bool Is(uc32 c) {
- return c == 0x0009 || // <TAB>
- c == 0x000B || // <VT>
- c == 0x000C || // <FF>
- c == 0xFEFF || // <BOM>
- // \u0020 and \u00A0 are included in unibrow::WhiteSpace.
- unibrow::WhiteSpace::Is(c);
- }
+ static inline bool Is(uc32 c) { return unibrow::WhiteSpace::Is(c); }
};
-// WhiteSpace and LineTerminator according to ECMA-262 5.1, 7.2 and 7.3.
+// WhiteSpace and LineTerminator according to ES6 draft section 11.2 and 11.3
+// This consists of \000a, \000d, \u2028, and \u2029.
struct WhiteSpaceOrLineTerminator {
static inline bool Is(uc32 c) {
return WhiteSpace::Is(c) || unibrow::LineTerminator::Is(c);
// static
+Callable CodeFactory::LoadICInOptimizedCode(Isolate* isolate,
+ ContextualMode mode) {
+ if (FLAG_vector_ics) {
+ return Callable(LoadIC::initialize_stub_in_optimized_code(
+ isolate, LoadICState(mode).GetExtraICState()),
+ VectorLoadICDescriptor(isolate));
+ }
+ return CodeFactory::LoadIC(isolate, mode);
+}
+
+
+// static
Callable CodeFactory::KeyedLoadIC(Isolate* isolate) {
- return Callable(isolate->builtins()->KeyedLoadIC_Initialize(),
+ return Callable(KeyedLoadIC::initialize_stub(isolate),
LoadDescriptor(isolate));
}
// static
+Callable CodeFactory::KeyedLoadICInOptimizedCode(Isolate* isolate) {
+ if (FLAG_vector_ics) {
+ return Callable(KeyedLoadIC::initialize_stub_in_optimized_code(isolate),
+ VectorLoadICDescriptor(isolate));
+ }
+ return CodeFactory::KeyedLoadIC(isolate);
+}
+
+
+// static
Callable CodeFactory::StoreIC(Isolate* isolate, StrictMode mode) {
return Callable(StoreIC::initialize_stub(isolate, mode),
StoreDescriptor(isolate));
// static
+Callable CodeFactory::AllocateHeapNumber(Isolate* isolate) {
+ AllocateHeapNumberStub stub(isolate);
+ return Callable(stub.GetCode(), stub.GetCallInterfaceDescriptor());
+}
+
+
+// static
Callable CodeFactory::CallFunction(Isolate* isolate, int argc,
CallFunctionFlags flags) {
CallFunctionStub stub(isolate, argc, flags);
public:
// Initial states for ICs.
static Callable LoadIC(Isolate* isolate, ContextualMode mode);
+ static Callable LoadICInOptimizedCode(Isolate* isolate, ContextualMode mode);
static Callable KeyedLoadIC(Isolate* isolate);
+ static Callable KeyedLoadICInOptimizedCode(Isolate* isolate);
static Callable StoreIC(Isolate* isolate, StrictMode mode);
static Callable KeyedStoreIC(Isolate* isolate, StrictMode mode);
static Callable StringAdd(Isolate* isolate, StringAddFlags flags,
PretenureFlag pretenure_flag);
+ static Callable AllocateHeapNumber(Isolate* isolate);
+
static Callable CallFunction(Isolate* isolate, int argc,
CallFunctionFlags flags);
};
-}
-}
+
+} // namespace internal
+} // namespace v8
+
#endif // V8_CODE_FACTORY_H_
HLoadNamedField* BuildLoadNamedField(HValue* object,
FieldIndex index);
void BuildStoreNamedField(HValue* object, HValue* value, FieldIndex index,
- Representation representation);
+ Representation representation,
+ bool transition_to_field);
enum ArgumentClass {
NONE,
// Generate the code for the stub.
masm.set_generating_stub(true);
+ // TODO(yangguo): remove this once we can serialize IC stubs.
+ masm.enable_serializer();
NoCurrentFrameScope scope(&masm);
GenerateLightweightMiss(&masm, miss);
}
}
CodeStubGraphBuilder<Stub> builder(isolate, stub);
LChunk* chunk = OptimizeGraph(builder.CreateGraph());
- // TODO(yangguo) remove this once the code serializer handles code stubs.
- if (FLAG_serialize_toplevel) chunk->info()->PrepareForSerializing();
Handle<Code> code = chunk->Codegen();
if (FLAG_profile_hydrogen_code_stub_compilation) {
OFStream os(stdout);
os << "[Lazy compilation of " << stub << " took "
- << timer.Elapsed().InMillisecondsF() << " ms]" << endl;
+ << timer.Elapsed().InMillisecondsF() << " ms]" << std::endl;
}
return code;
}
template <>
-HValue* CodeStubGraphBuilder<ToNumberStub>::BuildCodeStub() {
- HValue* value = GetParameter(0);
-
- // Check if the parameter is already a SMI or heap number.
- IfBuilder if_number(this);
- if_number.If<HIsSmiAndBranch>(value);
- if_number.OrIf<HCompareMap>(value, isolate()->factory()->heap_number_map());
- if_number.Then();
-
- // Return the number.
- Push(value);
-
- if_number.Else();
-
- // Convert the parameter to number using the builtin.
- HValue* function = AddLoadJSBuiltin(Builtins::TO_NUMBER);
- Add<HPushArguments>(value);
- Push(Add<HInvokeFunction>(function, 1));
-
- if_number.End();
-
- return Pop();
-}
-
-
-Handle<Code> ToNumberStub::GenerateCode() {
- return DoGenerateCode(this);
-}
-
-
-template <>
HValue* CodeStubGraphBuilder<NumberToStringStub>::BuildCodeStub() {
info()->MarkAsSavesCallerDoubles();
HValue* number = GetParameter(NumberToStringStub::kNumber);
HInstruction* boilerplate = Add<HLoadNamedField>(
allocation_site, static_cast<HValue*>(NULL), access);
- int size = JSObject::kHeaderSize + casted_stub()->length() * kPointerSize;
+ int length = casted_stub()->length();
+ if (length == 0) {
+ // Empty objects have some slack added to them.
+ length = JSObject::kInitialGlobalObjectUnusedPropertiesCount;
+ }
+ int size = JSObject::kHeaderSize + length * kPointerSize;
int object_size = size;
if (FLAG_allocation_site_pretenuring) {
size += AllocationMemento::kSize;
void CodeStubGraphBuilderBase::BuildStoreNamedField(
HValue* object, HValue* value, FieldIndex index,
- Representation representation) {
+ Representation representation, bool transition_to_field) {
DCHECK(!index.is_double() || representation.IsDouble());
int offset = index.offset();
HObjectAccess access =
: HObjectAccess::ForBackingStoreOffset(offset, representation);
if (representation.IsDouble()) {
- // Load the heap number.
- object = Add<HLoadNamedField>(
- object, static_cast<HValue*>(NULL),
- access.WithRepresentation(Representation::Tagged()));
- // Store the double value into it.
- access = HObjectAccess::ForHeapNumberValue();
+ HObjectAccess heap_number_access =
+ access.WithRepresentation(Representation::Tagged());
+ if (transition_to_field) {
+ // The store requires a mutable HeapNumber to be allocated.
+ NoObservableSideEffectsScope no_side_effects(this);
+ HInstruction* heap_number_size = Add<HConstant>(HeapNumber::kSize);
+
+ // TODO(hpayer): Allocation site pretenuring support.
+ HInstruction* heap_number =
+ Add<HAllocate>(heap_number_size, HType::HeapObject(), NOT_TENURED,
+ MUTABLE_HEAP_NUMBER_TYPE);
+ AddStoreMapConstant(heap_number,
+ isolate()->factory()->mutable_heap_number_map());
+ Add<HStoreNamedField>(heap_number, HObjectAccess::ForHeapNumberValue(),
+ value);
+ // Store the new mutable heap number into the object.
+ access = heap_number_access;
+ value = heap_number;
+ } else {
+ // Load the heap number.
+ object = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+ heap_number_access);
+ // Store the double value into it.
+ access = HObjectAccess::ForHeapNumberValue();
+ }
} else if (representation.IsHeapObject()) {
BuildCheckHeapObject(value);
}
template <>
HValue* CodeStubGraphBuilder<StoreFieldStub>::BuildCodeStub() {
BuildStoreNamedField(GetParameter(0), GetParameter(2), casted_stub()->index(),
- casted_stub()->representation());
+ casted_stub()->representation(), false);
return GetParameter(2);
}
template <>
+HValue* CodeStubGraphBuilder<StoreTransitionStub>::BuildCodeStub() {
+ HValue* object = GetParameter(StoreTransitionDescriptor::kReceiverIndex);
+
+ switch (casted_stub()->store_mode()) {
+ case StoreTransitionStub::ExtendStorageAndStoreMapAndValue: {
+ HValue* properties =
+ Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+ HObjectAccess::ForPropertiesPointer());
+ HValue* length = AddLoadFixedArrayLength(properties);
+ HValue* delta =
+ Add<HConstant>(static_cast<int32_t>(JSObject::kFieldsAdded));
+ HValue* new_capacity = AddUncasted<HAdd>(length, delta);
+
+ // Grow properties array.
+ ElementsKind kind = FAST_ELEMENTS;
+ Add<HBoundsCheck>(new_capacity,
+ Add<HConstant>((Page::kMaxRegularHeapObjectSize -
+ FixedArray::kHeaderSize) >>
+ ElementsKindToShiftSize(kind)));
+
+ // Reuse this code for properties backing store allocation.
+ HValue* new_properties =
+ BuildAllocateAndInitializeArray(kind, new_capacity);
+
+ BuildCopyProperties(properties, new_properties, length, new_capacity);
+
+ Add<HStoreNamedField>(object, HObjectAccess::ForPropertiesPointer(),
+ new_properties);
+ }
+ // Fall through.
+ case StoreTransitionStub::StoreMapAndValue:
+ // Store the new value into the "extended" object.
+ BuildStoreNamedField(
+ object, GetParameter(StoreTransitionDescriptor::kValueIndex),
+ casted_stub()->index(), casted_stub()->representation(), true);
+ // Fall through.
+
+ case StoreTransitionStub::StoreMapOnly:
+ // And finally update the map.
+ Add<HStoreNamedField>(object, HObjectAccess::ForMap(),
+ GetParameter(StoreTransitionDescriptor::kMapIndex));
+ break;
+ }
+ return GetParameter(StoreTransitionDescriptor::kValueIndex);
+}
+
+
+Handle<Code> StoreTransitionStub::GenerateCode() {
+ return DoGenerateCode(this);
+}
+
+
+template <>
HValue* CodeStubGraphBuilder<StringLengthStub>::BuildCodeStub() {
HValue* string = BuildLoadNamedField(GetParameter(0),
FieldIndex::ForInObjectOffset(JSValue::kValueOffset));
return DoGenerateCode(this);
}
+
+template <>
+HValue* CodeStubGraphBuilder<AllocateHeapNumberStub>::BuildCodeStub() {
+ HValue* result =
+ Add<HAllocate>(Add<HConstant>(HeapNumber::kSize), HType::HeapNumber(),
+ NOT_TENURED, HEAP_NUMBER_TYPE);
+ AddStoreMapConstant(result, isolate()->factory()->heap_number_map());
+ return result;
+}
+
+
+Handle<Code> AllocateHeapNumberStub::GenerateCode() {
+ return DoGenerateCode(this);
+}
+
+
HValue* CodeStubGraphBuilderBase::BuildArrayConstructor(
ElementsKind kind,
AllocationSiteOverrideMode override_mode,
// 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/code-stubs.h"
+
+#include <sstream>
#include "src/bootstrapper.h"
-#include "src/code-stubs.h"
#include "src/cpu-profiler.h"
#include "src/factory.h"
#include "src/gdb-jit.h"
void CodeStub::RecordCodeGeneration(Handle<Code> code) {
IC::RegisterWeakMapDependency(code);
- OStringStream os;
+ std::ostringstream os;
os << *this;
- PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, *code, os.c_str()));
+ PROFILE(isolate(),
+ CodeCreateEvent(Logger::STUB_TAG, *code, os.str().c_str()));
Counters* counters = isolate()->counters();
counters->total_stubs_code_size()->Increment(code->instruction_size());
}
// Generate the new code.
MacroAssembler masm(isolate(), NULL, 256);
- // TODO(yangguo) remove this once the code serializer handles code stubs.
- if (FLAG_serialize_toplevel) masm.enable_serializer();
-
{
// Update the static counter each time a new code stub is generated.
isolate()->counters()->code_stubs()->Increment();
// Generate the code for the stub.
masm.set_generating_stub(true);
+ // TODO(yangguo): remove this once we can serialize IC stubs.
+ masm.enable_serializer();
NoCurrentFrameScope scope(&masm);
Generate(&masm);
}
if (FLAG_print_code_stubs) {
CodeTracer::Scope trace_scope(isolate()->GetCodeTracer());
OFStream os(trace_scope.file());
- OStringStream name;
+ std::ostringstream name;
name << *this;
- new_object->Disassemble(name.c_str(), os);
+ new_object->Disassemble(name.str().c_str(), os);
os << "\n";
}
#endif
}
-void CodeStub::PrintBaseName(OStream& os) const { // NOLINT
+void CodeStub::PrintBaseName(std::ostream& os) const { // NOLINT
os << MajorName(MajorKey(), false);
}
-void CodeStub::PrintName(OStream& os) const { // NOLINT
+void CodeStub::PrintName(std::ostream& os) const { // NOLINT
PrintBaseName(os);
PrintState(os);
}
CODE_STUB_LIST(DEF_CASE)
#undef DEF_CASE
case NUMBER_OF_IDS:
- UNREACHABLE();
case NoCache:
- *value_out = NULL;
+ UNREACHABLE();
break;
}
}
}
-void BinaryOpICStub::PrintState(OStream& os) const { // NOLINT
+void BinaryOpICStub::PrintState(std::ostream& os) const { // NOLINT
os << state();
}
void BinaryOpICWithAllocationSiteStub::PrintState(
- OStream& os) const { // NOLINT
+ std::ostream& os) const { // NOLINT
os << state();
}
}
-void StringAddStub::PrintBaseName(OStream& os) const { // NOLINT
+void StringAddStub::PrintBaseName(std::ostream& os) const { // NOLINT
os << "StringAddStub";
if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_BOTH) {
os << "_CheckBoth";
OFStream os(stdout);
os << "[";
PrintBaseName(os);
- os << ": " << from << "=>" << to << "]" << endl;
+ os << ": " << from << "=>" << to << "]" << std::endl;
}
-void CompareNilICStub::PrintBaseName(OStream& os) const { // NOLINT
+void CompareNilICStub::PrintBaseName(std::ostream& os) const { // NOLINT
CodeStub::PrintBaseName(os);
os << ((nil_value() == kNullValue) ? "(NullValue)" : "(UndefinedValue)");
}
-void CompareNilICStub::PrintState(OStream& os) const { // NOLINT
+void CompareNilICStub::PrintState(std::ostream& os) const { // NOLINT
os << state();
}
// TODO(svenpanne) Make this a real infix_ostream_iterator.
class SimpleListPrinter {
public:
- explicit SimpleListPrinter(OStream& os) : os_(os), first_(true) {}
+ explicit SimpleListPrinter(std::ostream& os) : os_(os), first_(true) {}
void Add(const char* s) {
if (first_) {
}
private:
- OStream& os_;
+ std::ostream& os_;
bool first_;
};
-OStream& operator<<(OStream& os, const CompareNilICStub::State& s) {
+std::ostream& operator<<(std::ostream& os, const CompareNilICStub::State& s) {
os << "(";
SimpleListPrinter p(os);
if (s.IsEmpty()) p.Add("None");
}
-void CallIC_ArrayStub::PrintState(OStream& os) const { // NOLINT
+void CallIC_ArrayStub::PrintState(std::ostream& os) const { // NOLINT
os << state() << " (Array)";
}
-void CallICStub::PrintState(OStream& os) const { // NOLINT
+void CallICStub::PrintState(std::ostream& os) const { // NOLINT
os << state();
}
-void InstanceofStub::PrintName(OStream& os) const { // NOLINT
+void InstanceofStub::PrintName(std::ostream& os) const { // NOLINT
os << "InstanceofStub";
if (HasArgsInRegisters()) os << "_REGS";
if (HasCallSiteInlineCheck()) os << "_INLINE";
CallInterfaceDescriptor HandlerStub::GetCallInterfaceDescriptor() {
if (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC) {
+ if (FLAG_vector_ics) {
+ return VectorLoadICDescriptor(isolate());
+ }
return LoadDescriptor(isolate());
} else {
DCHECK_EQ(Code::STORE_IC, kind());
}
+CallInterfaceDescriptor StoreTransitionStub::GetCallInterfaceDescriptor() {
+ return StoreTransitionDescriptor(isolate());
+}
+
+
static void InitializeVectorLoadStub(Isolate* isolate,
CodeStubDescriptor* descriptor,
Address deoptimization_handler) {
void VectorLoadStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
InitializeVectorLoadStub(isolate(), descriptor,
- FUNCTION_ADDR(VectorLoadIC_MissFromStubFailure));
+ FUNCTION_ADDR(LoadIC_MissFromStubFailure));
}
void VectorKeyedLoadStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
- InitializeVectorLoadStub(
- isolate(), descriptor,
- FUNCTION_ADDR(VectorKeyedLoadIC_MissFromStubFailure));
+ InitializeVectorLoadStub(isolate(), descriptor,
+ FUNCTION_ADDR(KeyedLoadIC_MissFromStubFailure));
}
void FastNewContextStub::InitializeDescriptor(CodeStubDescriptor* d) {}
-void ToNumberStub::InitializeDescriptor(CodeStubDescriptor* d) {}
-
-
void NumberToStringStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
NumberToStringDescriptor call_descriptor(isolate());
descriptor->Initialize(
}
+void AllocateHeapNumberStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ descriptor->Initialize(
+ Runtime::FunctionForId(Runtime::kAllocateHeapNumber)->entry);
+}
+
+
void CompareNilICStub::InitializeDescriptor(CodeStubDescriptor* descriptor) {
descriptor->Initialize(FUNCTION_ADDR(CompareNilIC_Miss));
descriptor->SetMissHandler(
}
-void ArgumentsAccessStub::PrintName(OStream& os) const { // NOLINT
+void ArgumentsAccessStub::PrintName(std::ostream& os) const { // NOLINT
os << "ArgumentsAccessStub_";
switch (type()) {
case READ_ELEMENT:
}
-void CallFunctionStub::PrintName(OStream& os) const { // NOLINT
+void CallFunctionStub::PrintName(std::ostream& os) const { // NOLINT
os << "CallFunctionStub_Args" << argc();
}
-void CallConstructStub::PrintName(OStream& os) const { // NOLINT
+void CallConstructStub::PrintName(std::ostream& os) const { // NOLINT
os << "CallConstructStub";
if (RecordCallTarget()) os << "_Recording";
}
-void ArrayConstructorStub::PrintName(OStream& os) const { // NOLINT
+void ArrayConstructorStub::PrintName(std::ostream& os) const { // NOLINT
os << "ArrayConstructorStub";
switch (argument_count()) {
case ANY:
}
-OStream& ArrayConstructorStubBase::BasePrintName(OStream& os, // NOLINT
- const char* name) const {
+std::ostream& ArrayConstructorStubBase::BasePrintName(
+ std::ostream& os, // NOLINT
+ const char* name) const {
os << name << "_" << ElementsKindToString(elements_kind());
if (override_mode() == DISABLE_ALLOCATION_SITES) {
os << "_DISABLE_ALLOCATION_SITES";
}
-void ToBooleanStub::PrintState(OStream& os) const { // NOLINT
+void ToBooleanStub::PrintState(std::ostream& os) const { // NOLINT
os << types();
}
-OStream& operator<<(OStream& os, const ToBooleanStub::Types& s) {
+std::ostream& operator<<(std::ostream& os, const ToBooleanStub::Types& s) {
os << "(";
SimpleListPrinter p(os);
if (s.IsEmpty()) p.Add("None");
V(KeyedLoadICTrampoline) \
V(LoadICTrampoline) \
V(LoadIndexedInterceptor) \
+ V(LoadIndexedString) \
V(MathPow) \
V(ProfileEntryHook) \
V(RecordWrite) \
V(StringCompare) \
V(StubFailureTrampoline) \
V(SubString) \
+ V(ToNumber) \
/* HydrogenCodeStubs */ \
+ V(AllocateHeapNumber) \
V(ArrayNArgumentsConstructor) \
V(ArrayNoArgumentConstructor) \
V(ArraySingleArgumentConstructor) \
V(StoreFastElement) \
V(StringAdd) \
V(ToBoolean) \
- V(ToNumber) \
V(TransitionElementsKind) \
V(VectorKeyedLoad) \
V(VectorLoad) \
V(KeyedLoadSloppyArguments) \
V(StoreField) \
V(StoreGlobal) \
+ V(StoreTransition) \
V(StringLength)
// List of code stubs only used on ARM 32 bits platforms.
return Code::NORMAL;
}
- friend OStream& operator<<(OStream& os, const CodeStub& s) {
+ friend std::ostream& operator<<(std::ostream& os, const CodeStub& s) {
s.PrintName(os);
return os;
}
// a fixed (non-moveable) code object.
virtual bool NeedsImmovableCode() { return false; }
- virtual void PrintName(OStream& os) const; // NOLINT
- virtual void PrintBaseName(OStream& os) const; // NOLINT
- virtual void PrintState(OStream& os) const { ; } // NOLINT
+ virtual void PrintName(std::ostream& os) const; // NOLINT
+ virtual void PrintBaseName(std::ostream& os) const; // NOLINT
+ virtual void PrintState(std::ostream& os) const { ; } // NOLINT
// Computes the key based on major and minor.
uint32_t GetKey() {
// Retrieve the code for the stub. Generate the code if needed.
virtual Handle<Code> GenerateCode() OVERRIDE;
- virtual Code::Kind GetCodeKind() const { return Code::STUB; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
protected:
explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
INITIALIZED
};
- virtual Code::Kind GetCodeKind() const { return Code::STUB; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
template<class SubClass>
static Handle<Code> GetUninitialized(Isolate* isolate) {
};
-class ToNumberStub: public HydrogenCodeStub {
- public:
- explicit ToNumberStub(Isolate* isolate) : HydrogenCodeStub(isolate) { }
-
- DEFINE_CALL_INTERFACE_DESCRIPTOR(ToNumber);
- DEFINE_HYDROGEN_CODE_STUB(ToNumber, HydrogenCodeStub);
-};
-
-
class NumberToStringStub FINAL : public HydrogenCodeStub {
public:
explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
return (flags() & kReturnTrueFalseObject) != 0;
}
- virtual void PrintName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
class FlagBits : public BitField<Flags, 0, 3> {};
void GenerateDispatchToArrayStub(MacroAssembler* masm,
AllocationSiteOverrideMode mode);
- virtual void PrintName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
class ArgumentCountBits : public BitField<ArgumentCountKey, 0, 2> {};
void GenerateMiss(MacroAssembler* masm);
private:
- virtual void PrintState(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedback);
DEFINE_PLATFORM_CODE_STUB(CallIC, PlatformCodeStub);
}
private:
- virtual void PrintState(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
DEFINE_PLATFORM_CODE_STUB(CallIC_Array, CallICStub);
};
explicit FunctionPrototypeStub(Isolate* isolate)
: PlatformCodeStub(isolate) {}
- virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
// TODO(mvstanton): only the receiver register is accessed. When this is
// translated to a hydrogen code stub, a new CallInterfaceDescriptor
// should be created that just uses that register for more efficient code.
- DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+ virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ if (FLAG_vector_ics) {
+ return VectorLoadICDescriptor(isolate());
+ }
+ return LoadDescriptor(isolate());
+ }
+
DEFINE_PLATFORM_CODE_STUB(FunctionPrototype, PlatformCodeStub);
};
explicit LoadIndexedInterceptorStub(Isolate* isolate)
: PlatformCodeStub(isolate) {}
- virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
DEFINE_PLATFORM_CODE_STUB(LoadIndexedInterceptor, PlatformCodeStub);
};
+class LoadIndexedStringStub : public PlatformCodeStub {
+ public:
+ explicit LoadIndexedStringStub(Isolate* isolate)
+ : PlatformCodeStub(isolate) {}
+
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
+
+ DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+ DEFINE_PLATFORM_CODE_STUB(LoadIndexedString, PlatformCodeStub);
+};
+
+
class HandlerStub : public HydrogenCodeStub {
public:
- virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
- virtual ExtraICState GetExtraICState() const { return kind(); }
- virtual InlineCacheState GetICState() const { return MONOMORPHIC; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
+ virtual ExtraICState GetExtraICState() const OVERRIDE { return kind(); }
+ virtual InlineCacheState GetICState() const OVERRIDE { return MONOMORPHIC; }
virtual void InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE;
protected:
virtual Code::Kind kind() const { return Code::LOAD_IC; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
private:
class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
: HandlerStub(isolate) {}
protected:
- virtual Code::Kind kind() const { return Code::KEYED_LOAD_IC; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::Kind kind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
private:
DEFINE_HANDLER_CODE_STUB(KeyedLoadSloppyArguments, HandlerStub);
}
protected:
- virtual Code::Kind kind() const { return Code::LOAD_IC; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
private:
class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
protected:
- virtual Code::Kind kind() const { return Code::LOAD_IC; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
DEFINE_HANDLER_CODE_STUB(StringLength, HandlerStub);
};
}
protected:
- virtual Code::Kind kind() const { return Code::STORE_IC; }
- virtual Code::StubType GetStubType() { return Code::FAST; }
+ virtual Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
private:
class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
};
+class StoreTransitionStub : public HandlerStub {
+ public:
+ enum StoreMode {
+ StoreMapOnly,
+ StoreMapAndValue,
+ ExtendStorageAndStoreMapAndValue
+ };
+
+ explicit StoreTransitionStub(Isolate* isolate) : HandlerStub(isolate) {
+ set_sub_minor_key(StoreModeBits::encode(StoreMapOnly));
+ }
+
+ StoreTransitionStub(Isolate* isolate, FieldIndex index,
+ Representation representation, StoreMode store_mode)
+ : HandlerStub(isolate) {
+ DCHECK(store_mode != StoreMapOnly);
+ int property_index_key = index.GetFieldAccessStubKey();
+ uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
+ set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
+ RepresentationBits::encode(repr) |
+ StoreModeBits::encode(store_mode));
+ }
+
+ FieldIndex index() const {
+ DCHECK(store_mode() != StoreMapOnly);
+ int property_index_key = StoreFieldByIndexBits::decode(sub_minor_key());
+ return FieldIndex::FromFieldAccessStubKey(property_index_key);
+ }
+
+ Representation representation() {
+ DCHECK(store_mode() != StoreMapOnly);
+ uint8_t repr = RepresentationBits::decode(sub_minor_key());
+ return PropertyDetails::DecodeRepresentation(repr);
+ }
+
+ StoreMode store_mode() const {
+ return StoreModeBits::decode(sub_minor_key());
+ }
+
+ virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
+
+ protected:
+ virtual Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+ virtual Code::StubType GetStubType() OVERRIDE { return Code::FAST; }
+
+ private:
+ class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
+ class RepresentationBits : public BitField<uint8_t, 13, 4> {};
+ class StoreModeBits : public BitField<StoreMode, 17, 2> {};
+
+ DEFINE_HANDLER_CODE_STUB(StoreTransition, HandlerStub);
+};
+
+
class StoreGlobalStub : public HandlerStub {
public:
StoreGlobalStub(Isolate* isolate, bool is_constant, bool check_global)
}
}
- virtual Code::Kind kind() const { return Code::STORE_IC; }
+ virtual Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
bool is_constant() const { return IsConstantBits::decode(sub_minor_key()); }
return BinaryOpICState(isolate(), GetExtraICState());
}
- virtual void PrintState(OStream& os) const FINAL OVERRIDE; // NOLINT
+ virtual void PrintState(std::ostream& os) const FINAL OVERRIDE; // NOLINT
// Parameters accessed via CodeStubGraphBuilder::GetParameter()
static const int kLeft = 0;
return static_cast<ExtraICState>(minor_key_);
}
- virtual void PrintState(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
private:
BinaryOpICState state() const {
class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
- virtual void PrintBaseName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintBaseName(std::ostream& os) const OVERRIDE; // NOLINT
DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
DEFINE_HYDROGEN_CODE_STUB(StringAdd, HydrogenCodeStub);
void set_known_map(Handle<Map> map) { known_map_ = map; }
- virtual InlineCacheState GetICState() const;
+ virtual InlineCacheState GetICState() const OVERRIDE;
Token::Value op() const {
return static_cast<Token::Value>(Token::EQ + OpBits::decode(minor_key_));
CompareICState::State state() const { return StateBits::decode(minor_key_); }
private:
- virtual Code::Kind GetCodeKind() const { return Code::COMPARE_IC; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::COMPARE_IC; }
void GenerateSmis(MacroAssembler* masm);
void GenerateNumbers(MacroAssembler* masm);
bool strict() const { return op() == Token::EQ_STRICT; }
Condition GetCondition() const;
- virtual void AddToSpecialCache(Handle<Code> new_object);
- virtual bool FindCodeInSpecialCache(Code** code_out);
- virtual bool UseSpecialCache() {
+ virtual void AddToSpecialCache(Handle<Code> new_object) OVERRIDE;
+ virtual bool FindCodeInSpecialCache(Code** code_out) OVERRIDE;
+ virtual bool UseSpecialCache() OVERRIDE {
return state() == CompareICState::KNOWN_OBJECT;
}
return CompareNilICStub(isolate, nil, UNINITIALIZED).GetCode();
}
- virtual InlineCacheState GetICState() const {
+ virtual InlineCacheState GetICState() const OVERRIDE {
State state = this->state();
if (state.Contains(GENERIC)) {
return MEGAMORPHIC;
}
}
- virtual Code::Kind GetCodeKind() const { return Code::COMPARE_NIL_IC; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE {
+ return Code::COMPARE_NIL_IC;
+ }
- virtual ExtraICState GetExtraICState() const { return sub_minor_key(); }
+ virtual ExtraICState GetExtraICState() const OVERRIDE {
+ return sub_minor_key();
+ }
void UpdateStatus(Handle<Object> object);
set_sub_minor_key(TypesBits::update(sub_minor_key(), 0));
}
- virtual void PrintState(OStream& os) const OVERRIDE; // NOLINT
- virtual void PrintBaseName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
+ virtual void PrintBaseName(std::ostream& os) const OVERRIDE; // NOLINT
private:
CompareNilICStub(Isolate* isolate, NilValue nil,
State() : EnumSet<CompareNilType, byte>(0) { }
explicit State(byte bits) : EnumSet<CompareNilType, byte>(bits) { }
};
- friend OStream& operator<<(OStream& os, const State& s);
+ friend std::ostream& operator<<(std::ostream& os, const State& s);
State state() const { return State(TypesBits::decode(sub_minor_key())); }
};
-OStream& operator<<(OStream& os, const CompareNilICStub::State& s);
+std::ostream& operator<<(std::ostream& os, const CompareNilICStub::State& s);
class CEntryStub : public PlatformCodeStub {
int result_size() const { return ResultSizeBits::decode(minor_key_); }
#endif // _WIN64
- bool NeedsImmovableCode();
+ bool NeedsImmovableCode() OVERRIDE;
class SaveDoublesBits : public BitField<bool, 0, 1> {};
class ResultSizeBits : public BitField<int, 1, 3> {};
}
private:
- virtual void FinishCode(Handle<Code> code);
+ virtual void FinishCode(Handle<Code> code) OVERRIDE;
- virtual void PrintName(OStream& os) const OVERRIDE { // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
os << (type() == StackFrame::ENTRY ? "JSEntryStub"
: "JSConstructEntryStub");
}
void GenerateNewSloppyFast(MacroAssembler* masm);
void GenerateNewSloppySlow(MacroAssembler* masm);
- virtual void PrintName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
class TypeBits : public BitField<Type, 0, 2> {};
bool NeedsChecks() const { return flags() != WRAP_AND_CALL; }
- virtual void PrintName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
// Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
class FlagBits : public BitField<CallFunctionFlags, 0, 2> {};
minor_key_ = FlagBits::encode(flags);
}
- virtual void FinishCode(Handle<Code> code) {
+ virtual void FinishCode(Handle<Code> code) OVERRIDE {
code->set_has_function_cache(RecordCallTarget());
}
return (flags() & RECORD_CONSTRUCTOR_TARGET) != 0;
}
- virtual void PrintName(OStream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
class FlagBits : public BitField<CallConstructorFlags, 0, 1> {};
};
+enum ReceiverCheckMode {
+ // We don't know anything about the receiver.
+ RECEIVER_IS_UNKNOWN,
+
+ // We know the receiver is a string.
+ RECEIVER_IS_STRING
+};
+
+
// Generates code implementing String.prototype.charCodeAt.
//
// Only supports the case when the receiver is a string and the index
// preserved, |scratch| and |result| are clobbered.
class StringCharCodeAtGenerator {
public:
- StringCharCodeAtGenerator(Register object,
- Register index,
- Register result,
- Label* receiver_not_string,
- Label* index_not_number,
+ StringCharCodeAtGenerator(Register object, Register index, Register result,
+ Label* receiver_not_string, Label* index_not_number,
Label* index_out_of_range,
- StringIndexFlags index_flags)
+ StringIndexFlags index_flags,
+ ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
: object_(object),
index_(index),
result_(result),
receiver_not_string_(receiver_not_string),
index_not_number_(index_not_number),
index_out_of_range_(index_out_of_range),
- index_flags_(index_flags) {
+ index_flags_(index_flags),
+ check_mode_(check_mode) {
DCHECK(!result_.is(object_));
DCHECK(!result_.is(index_));
}
Label* index_out_of_range_;
StringIndexFlags index_flags_;
+ ReceiverCheckMode check_mode_;
Label call_runtime_;
Label index_not_smi_;
// preserved, |scratch1|, |scratch2|, and |result| are clobbered.
class StringCharAtGenerator {
public:
- StringCharAtGenerator(Register object,
- Register index,
- Register scratch,
- Register result,
- Label* receiver_not_string,
- Label* index_not_number,
- Label* index_out_of_range,
- StringIndexFlags index_flags)
- : char_code_at_generator_(object,
- index,
- scratch,
- receiver_not_string,
- index_not_number,
- index_out_of_range,
- index_flags),
+ StringCharAtGenerator(Register object, Register index, Register scratch,
+ Register result, Label* receiver_not_string,
+ Label* index_not_number, Label* index_out_of_range,
+ StringIndexFlags index_flags,
+ ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
+ : char_code_at_generator_(object, index, scratch, receiver_not_string,
+ index_not_number, index_out_of_range,
+ index_flags, check_mode),
char_from_code_generator_(scratch, result) {}
// Generates the fast case code. On the fallthrough path |result|
explicit LoadDictionaryElementStub(Isolate* isolate)
: HydrogenCodeStub(isolate) {}
- DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+ virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ if (FLAG_vector_ics) {
+ return VectorLoadICDescriptor(isolate());
+ }
+ return LoadDescriptor(isolate());
+ }
+
DEFINE_HYDROGEN_CODE_STUB(LoadDictionaryElement, HydrogenCodeStub);
};
public:
explicit KeyedLoadGenericStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
- virtual Code::Kind GetCodeKind() const { return Code::KEYED_LOAD_IC; }
- virtual InlineCacheState GetICState() const { return GENERIC; }
+ virtual Code::Kind GetCodeKind() const OVERRIDE {
+ return Code::KEYED_LOAD_IC;
+ }
+ virtual InlineCacheState GetICState() const OVERRIDE { return GENERIC; }
+ // Since KeyedLoadGeneric stub doesn't miss (simply calls runtime), it
+ // doesn't need to use the VectorLoadICDescriptor for the case when
+ // flag --vector-ics is true.
DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+
DEFINE_HYDROGEN_CODE_STUB(KeyedLoadGeneric, HydrogenCodeStub);
};
virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
- virtual InlineCacheState GetICState() const FINAL OVERRIDE {
- return GENERIC;
- }
+ virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
return static_cast<ExtraICState>(minor_key_);
return static_cast<ExtraICState>(sub_minor_key());
}
- DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+ virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ if (FLAG_vector_ics) {
+ return VectorLoadICDescriptor(isolate());
+ }
+ return LoadDescriptor(isolate());
+ }
+
DEFINE_HYDROGEN_CODE_STUB(MegamorphicLoad, HydrogenCodeStub);
};
virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
- virtual InlineCacheState GetICState() const FINAL OVERRIDE {
- return GENERIC;
- }
+ virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
return static_cast<ExtraICState>(sub_minor_key());
SSE3Bits::encode(CpuFeatures::IsSupported(SSE3) ? 1 : 0);
}
- virtual bool SometimesSetsUpAFrame() { return false; }
+ virtual bool SometimesSetsUpAFrame() OVERRIDE { return false; }
private:
Register source() const {
class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
class IsJSArrayBits: public BitField<bool, 8, 1> {};
- DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+ virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ if (FLAG_vector_ics) {
+ return VectorLoadICDescriptor(isolate());
+ }
+ return LoadDescriptor(isolate());
+ }
+
DEFINE_HYDROGEN_CODE_STUB(LoadFastElement, HydrogenCodeStub);
};
};
+class AllocateHeapNumberStub FINAL : public HydrogenCodeStub {
+ public:
+ explicit AllocateHeapNumberStub(Isolate* isolate)
+ : HydrogenCodeStub(isolate) {}
+
+ private:
+ DEFINE_CALL_INTERFACE_DESCRIPTOR(AllocateHeapNumber);
+ DEFINE_HYDROGEN_CODE_STUB(AllocateHeapNumber, HydrogenCodeStub);
+};
+
+
class ArrayConstructorStubBase : public HydrogenCodeStub {
public:
ArrayConstructorStubBase(Isolate* isolate,
static const int kAllocationSite = 1;
protected:
- OStream& BasePrintName(OStream& os, const char* name) const; // NOLINT
+ std::ostream& BasePrintName(std::ostream& os,
+ const char* name) const; // NOLINT
private:
// Ensure data fits within available bits.
}
private:
- virtual void PrintName(OStream& os) const OVERRIDE { // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
BasePrintName(os, "ArrayNoArgumentConstructorStub");
}
}
private:
- virtual void PrintName(OStream& os) const { // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
BasePrintName(os, "ArraySingleArgumentConstructorStub");
}
}
private:
- virtual void PrintName(OStream& os) const { // NOLINT
+ virtual void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
BasePrintName(os, "ArrayNArgumentsConstructorStub");
}
Types types() const { return Types(TypesBits::decode(sub_minor_key())); }
ResultMode mode() const { return ResultModeBits::decode(sub_minor_key()); }
- virtual Code::Kind GetCodeKind() const { return Code::TO_BOOLEAN_IC; }
- virtual void PrintState(OStream& os) const OVERRIDE; // NOLINT
+ virtual Code::Kind GetCodeKind() const OVERRIDE {
+ return Code::TO_BOOLEAN_IC;
+ }
+ virtual void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
- virtual bool SometimesSetsUpAFrame() { return false; }
+ virtual bool SometimesSetsUpAFrame() OVERRIDE { return false; }
static Handle<Code> GetUninitialized(Isolate* isolate) {
return ToBooleanStub(isolate, UNINITIALIZED).GetCode();
}
- virtual ExtraICState GetExtraICState() const { return types().ToIntegral(); }
+ virtual ExtraICState GetExtraICState() const OVERRIDE {
+ return types().ToIntegral();
+ }
- virtual InlineCacheState GetICState() const {
+ virtual InlineCacheState GetICState() const OVERRIDE {
if (types().IsEmpty()) {
return ::v8::internal::UNINITIALIZED;
} else {
};
-OStream& operator<<(OStream& os, const ToBooleanStub::Types& t);
+std::ostream& operator<<(std::ostream& os, const ToBooleanStub::Types& t);
class ElementsTransitionAndStoreStub : public HydrogenCodeStub {
explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
// The profile entry hook function is not allowed to cause a GC.
- virtual bool SometimesSetsUpAFrame() { return false; }
+ virtual bool SometimesSetsUpAFrame() OVERRIDE { return false; }
// Generates a call to the entry hook if it's enabled.
static void MaybeCallEntryHook(MacroAssembler* masm);
}
static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
- virtual bool SometimesSetsUpAFrame() { return false; }
+ virtual bool SometimesSetsUpAFrame() OVERRIDE { return false; }
private:
bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
};
+class ToNumberStub FINAL : public PlatformCodeStub {
+ public:
+ explicit ToNumberStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
+
+ DEFINE_CALL_INTERFACE_DESCRIPTOR(ToNumber);
+ DEFINE_PLATFORM_CODE_STUB(ToNumber, PlatformCodeStub);
+};
+
+
class StringCompareStub : public PlatformCodeStub {
public:
explicit StringCompareStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
Handle<Script> script = info->script();
if (!script->IsUndefined() && !script->source()->IsUndefined()) {
os << "--- Raw source ---\n";
- ConsStringIteratorOp op;
StringCharacterStream stream(String::cast(script->source()),
- &op,
function->start_position());
// fun->end_position() points to the last character in the stream. We
// need to compensate by adding one to calculate the length.
%FunctionSetName(SetIteratorSymbolIterator, '[Symbol.iterator]');
%AddNamedProperty(SetIterator.prototype, symbolIterator,
SetIteratorSymbolIterator, DONT_ENUM);
+ %AddNamedProperty(SetIterator.prototype, symbolToStringTag,
+ "Set Iterator", READ_ONLY | DONT_ENUM);
}
SetUpSetIterator();
%FunctionSetName(MapIteratorSymbolIterator, '[Symbol.iterator]');
%AddNamedProperty(MapIterator.prototype, symbolIterator,
MapIteratorSymbolIterator, DONT_ENUM);
+ %AddNamedProperty(MapIterator.prototype, symbolToStringTag,
+ "Map Iterator", READ_ONLY | DONT_ENUM);
}
SetUpMapIterator();
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [f]);
}
+ var needs_wrapper = false;
+ if (IS_NULL_OR_UNDEFINED(receiver)) {
+ receiver = %GetDefaultReceiver(f) || receiver;
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
+ }
var iterator = new SetIterator(this, ITERATOR_KIND_VALUES);
var key;
while (%SetIteratorNext(iterator, value_array)) {
if (stepping) %DebugPrepareStepInIfStepping(f);
key = value_array[0];
- %_CallFunction(receiver, key, key, this, f);
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ %_CallFunction(new_receiver, key, key, this, f);
}
}
%SetCode($Set, SetConstructor);
%FunctionSetPrototype($Set, new $Object());
%AddNamedProperty($Set.prototype, "constructor", $Set, DONT_ENUM);
+ %AddNamedProperty(
+ $Set.prototype, symbolToStringTag, "Set", DONT_ENUM | READ_ONLY);
%FunctionSetLength(SetForEach, 1);
if (!IS_SPEC_FUNCTION(f)) {
throw MakeTypeError('called_non_callable', [f]);
}
+ var needs_wrapper = false;
+ if (IS_NULL_OR_UNDEFINED(receiver)) {
+ receiver = %GetDefaultReceiver(f) || receiver;
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
+ }
var iterator = new MapIterator(this, ITERATOR_KIND_ENTRIES);
var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
var value_array = [UNDEFINED, UNDEFINED];
while (%MapIteratorNext(iterator, value_array)) {
if (stepping) %DebugPrepareStepInIfStepping(f);
- %_CallFunction(receiver, value_array[1], value_array[0], this, f);
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ %_CallFunction(new_receiver, value_array[1], value_array[0], this, f);
}
}
%SetCode($Map, MapConstructor);
%FunctionSetPrototype($Map, new $Object());
%AddNamedProperty($Map.prototype, "constructor", $Map, DONT_ENUM);
+ %AddNamedProperty(
+ $Map.prototype, symbolToStringTag, "Map", DONT_ENUM | READ_ONLY);
%FunctionSetLength(MapForEach, 1);
// The number of generations for each sub cache.
-// The number of ScriptGenerations is carefully chosen based on histograms.
-// See issue 458: http://code.google.com/p/v8/issues/detail?id=458
-static const int kScriptGenerations = 5;
-static const int kEvalGlobalGenerations = 2;
-static const int kEvalContextualGenerations = 2;
static const int kRegExpGenerations = 2;
// Initial size of each compilation cache table allocated.
CompilationCache::CompilationCache(Isolate* isolate)
: isolate_(isolate),
- script_(isolate, kScriptGenerations),
- eval_global_(isolate, kEvalGlobalGenerations),
- eval_contextual_(isolate, kEvalContextualGenerations),
+ script_(isolate, 1),
+ eval_global_(isolate, 1),
+ eval_contextual_(isolate, 1),
reg_exp_(isolate, kRegExpGenerations),
enabled_(true) {
CompilationSubCache* subcaches[kSubCacheCount] =
void CompilationSubCache::Age() {
+ // Don't directly age single-generation caches.
+ if (generations_ == 1) {
+ if (tables_[0] != isolate()->heap()->undefined_value()) {
+ CompilationCacheTable::cast(tables_[0])->Age();
+ }
+ return;
+ }
+
// Age the generations implicitly killing off the oldest.
for (int i = generations_ - 1; i > 0; i--) {
tables_[i] = tables_[i - 1];
CompilationCacheScript::CompilationCacheScript(Isolate* isolate,
int generations)
- : CompilationSubCache(isolate, generations),
- script_histogram_(NULL),
- script_histogram_initialized_(false) { }
+ : CompilationSubCache(isolate, generations) {}
// We only re-use a cached function for some script source code if the
}
}
- if (!script_histogram_initialized_) {
- script_histogram_ = isolate()->stats_table()->CreateHistogram(
- "V8.ScriptCache",
- 0,
- kScriptGenerations,
- kScriptGenerations + 1);
- script_histogram_initialized_ = true;
- }
-
- if (script_histogram_ != NULL) {
- // The level NUMBER_OF_SCRIPT_GENERATIONS is equivalent to a cache miss.
- isolate()->stats_table()->AddHistogramSample(script_histogram_, generation);
- }
-
// Once outside the manacles of the handle scope, we need to recheck
// to see if we actually found a cached script. If so, we return a
// handle created in the caller's handle scope.
MaybeHandle<SharedFunctionInfo> CompilationCacheEval::Lookup(
- Handle<String> source,
- Handle<Context> context,
- StrictMode strict_mode,
- int scope_position) {
+ Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ StrictMode strict_mode, int scope_position) {
HandleScope scope(isolate());
// Make sure not to leak the table into the surrounding handle
// scope. Otherwise, we risk keeping old tables around even after
int generation;
for (generation = 0; generation < generations(); generation++) {
Handle<CompilationCacheTable> table = GetTable(generation);
- result = table->LookupEval(source, context, strict_mode, scope_position);
+ result = table->LookupEval(source, outer_info, strict_mode, scope_position);
if (result->IsSharedFunctionInfo()) break;
}
if (result->IsSharedFunctionInfo()) {
Handle<SharedFunctionInfo> function_info =
Handle<SharedFunctionInfo>::cast(result);
if (generation != 0) {
- Put(source, context, function_info, scope_position);
+ Put(source, outer_info, function_info, scope_position);
}
isolate()->counters()->compilation_cache_hits()->Increment();
return scope.CloseAndEscape(function_info);
void CompilationCacheEval::Put(Handle<String> source,
- Handle<Context> context,
+ Handle<SharedFunctionInfo> outer_info,
Handle<SharedFunctionInfo> function_info,
int scope_position) {
HandleScope scope(isolate());
Handle<CompilationCacheTable> table = GetFirstTable();
- table = CompilationCacheTable::PutEval(table, source, context,
+ table = CompilationCacheTable::PutEval(table, source, outer_info,
function_info, scope_position);
SetFirstTable(table);
}
MaybeHandle<SharedFunctionInfo> CompilationCache::LookupEval(
- Handle<String> source,
- Handle<Context> context,
- StrictMode strict_mode,
- int scope_position) {
+ Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ Handle<Context> context, StrictMode strict_mode, int scope_position) {
if (!IsEnabled()) return MaybeHandle<SharedFunctionInfo>();
MaybeHandle<SharedFunctionInfo> result;
if (context->IsNativeContext()) {
- result = eval_global_.Lookup(
- source, context, strict_mode, scope_position);
+ result =
+ eval_global_.Lookup(source, outer_info, strict_mode, scope_position);
} else {
DCHECK(scope_position != RelocInfo::kNoPosition);
- result = eval_contextual_.Lookup(
- source, context, strict_mode, scope_position);
+ result = eval_contextual_.Lookup(source, outer_info, strict_mode,
+ scope_position);
}
return result;
}
void CompilationCache::PutEval(Handle<String> source,
+ Handle<SharedFunctionInfo> outer_info,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position) {
HandleScope scope(isolate());
if (context->IsNativeContext()) {
- eval_global_.Put(source, context, function_info, scope_position);
+ eval_global_.Put(source, outer_info, function_info, scope_position);
} else {
DCHECK(scope_position != RelocInfo::kNoPosition);
- eval_contextual_.Put(source, context, function_info, scope_position);
+ eval_contextual_.Put(source, outer_info, function_info, scope_position);
}
}
int column_offset,
bool is_shared_cross_origin);
- void* script_histogram_;
- bool script_histogram_initialized_;
-
DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheScript);
};
: CompilationSubCache(isolate, generations) { }
MaybeHandle<SharedFunctionInfo> Lookup(Handle<String> source,
- Handle<Context> context,
+ Handle<SharedFunctionInfo> outer_info,
StrictMode strict_mode,
int scope_position);
- void Put(Handle<String> source,
- Handle<Context> context,
- Handle<SharedFunctionInfo> function_info,
- int scope_position);
+ void Put(Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ Handle<SharedFunctionInfo> function_info, int scope_position);
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheEval);
// given context. Returns an empty handle if the cache doesn't
// contain a script for the given source string.
MaybeHandle<SharedFunctionInfo> LookupEval(
- Handle<String> source, Handle<Context> context, StrictMode strict_mode,
- int scope_position);
+ Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ Handle<Context> context, StrictMode strict_mode, int scope_position);
// Returns the regexp data associated with the given regexp if it
// is in cache, otherwise an empty handle.
// Associate the (source, context->closure()->shared(), kind) triple
// with the shared function info. This may overwrite an existing mapping.
- void PutEval(Handle<String> source,
+ void PutEval(Handle<String> source, Handle<SharedFunctionInfo> outer_info,
Handle<Context> context,
- Handle<SharedFunctionInfo> function_info,
- int scope_position);
+ Handle<SharedFunctionInfo> function_info, int scope_position);
// Associate the (source, flags) pair to the given regexp data.
// This may overwrite an existing mapping.
--- /dev/null
+// 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 <ostream> // NOLINT(readability/streams)
+#include <vector>
+
+#include "src/base/platform/platform.h"
+#include "src/compilation-statistics.h"
+
+namespace v8 {
+namespace internal {
+
+void CompilationStatistics::RecordPhaseStats(const char* phase_kind_name,
+ const char* phase_name,
+ const BasicStats& stats) {
+ std::string phase_name_str(phase_name);
+ auto it = phase_map_.find(phase_name_str);
+ if (it == phase_map_.end()) {
+ PhaseStats phase_stats(phase_map_.size(), phase_kind_name);
+ it = phase_map_.insert(std::make_pair(phase_name_str, phase_stats)).first;
+ }
+ it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordPhaseKindStats(const char* phase_kind_name,
+ const BasicStats& stats) {
+ std::string phase_kind_name_str(phase_kind_name);
+ auto it = phase_kind_map_.find(phase_kind_name_str);
+ if (it == phase_kind_map_.end()) {
+ PhaseKindStats phase_kind_stats(phase_kind_map_.size());
+ it = phase_kind_map_.insert(std::make_pair(phase_kind_name_str,
+ phase_kind_stats)).first;
+ }
+ it->second.Accumulate(stats);
+}
+
+
+void CompilationStatistics::RecordTotalStats(size_t source_size,
+ const BasicStats& stats) {
+ source_size += source_size;
+ total_stats_.Accumulate(stats);
+}
+
+
+void CompilationStatistics::BasicStats::Accumulate(const BasicStats& stats) {
+ delta_ += stats.delta_;
+ total_allocated_bytes_ += stats.total_allocated_bytes_;
+ if (stats.absolute_max_allocated_bytes_ > absolute_max_allocated_bytes_) {
+ absolute_max_allocated_bytes_ = stats.absolute_max_allocated_bytes_;
+ max_allocated_bytes_ = stats.max_allocated_bytes_;
+ function_name_ = stats.function_name_;
+ }
+}
+
+
+static void WriteLine(std::ostream& os, const char* name,
+ const CompilationStatistics::BasicStats& stats,
+ const CompilationStatistics::BasicStats& total_stats) {
+ const size_t kBufferSize = 128;
+ char buffer[kBufferSize];
+
+ double ms = stats.delta_.InMillisecondsF();
+ double percent = stats.delta_.PercentOf(total_stats.delta_);
+ double size_percent =
+ static_cast<double>(stats.total_allocated_bytes_ * 100) /
+ static_cast<double>(total_stats.total_allocated_bytes_);
+ base::OS::SNPrintF(buffer, kBufferSize,
+ "%28s %10.3f ms / %5.1f %%"
+ "%10u total / %5.1f %% "
+ "%10u max %10u abs_max",
+ name, ms, percent, stats.total_allocated_bytes_,
+ size_percent, stats.max_allocated_bytes_,
+ stats.absolute_max_allocated_bytes_);
+
+ os << buffer;
+ if (stats.function_name_.size() > 0) {
+ os << " : " << stats.function_name_.c_str();
+ }
+ os << std::endl;
+}
+
+
+static void WriteFullLine(std::ostream& os) {
+ os << "--------------------------------------------------------"
+ "--------------------------------------------------------\n";
+}
+
+
+static void WriteHeader(std::ostream& os) {
+ WriteFullLine(os);
+ os << " Turbofan timing results:\n";
+ WriteFullLine(os);
+}
+
+
+static void WritePhaseKindBreak(std::ostream& os) {
+ os << " ---------------------------"
+ "--------------------------------------------------------\n";
+}
+
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s) {
+ // phase_kind_map_ and phase_map_ don't get mutated, so store a bunch of
+ // pointers into them.
+
+ typedef std::vector<CompilationStatistics::PhaseKindMap::const_iterator>
+ SortedPhaseKinds;
+ SortedPhaseKinds sorted_phase_kinds(s.phase_kind_map_.size());
+ for (auto it = s.phase_kind_map_.begin(); it != s.phase_kind_map_.end();
+ ++it) {
+ sorted_phase_kinds[it->second.insert_order_] = it;
+ }
+
+ typedef std::vector<CompilationStatistics::PhaseMap::const_iterator>
+ SortedPhases;
+ SortedPhases sorted_phases(s.phase_map_.size());
+ for (auto it = s.phase_map_.begin(); it != s.phase_map_.end(); ++it) {
+ sorted_phases[it->second.insert_order_] = it;
+ }
+
+ WriteHeader(os);
+ for (auto phase_kind_it : sorted_phase_kinds) {
+ const auto& phase_kind_name = phase_kind_it->first;
+ for (auto phase_it : sorted_phases) {
+ const auto& phase_stats = phase_it->second;
+ if (phase_stats.phase_kind_name_ != phase_kind_name) continue;
+ const auto& phase_name = phase_it->first;
+ WriteLine(os, phase_name.c_str(), phase_stats, s.total_stats_);
+ }
+ WritePhaseKindBreak(os);
+ const auto& phase_kind_stats = phase_kind_it->second;
+ WriteLine(os, phase_kind_name.c_str(), phase_kind_stats, s.total_stats_);
+ os << std::endl;
+ }
+ WriteFullLine(os);
+ WriteLine(os, "totals", s.total_stats_, s.total_stats_);
+
+ return os;
+}
+
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILATION_STATISTICS_H_
+#define V8_COMPILATION_STATISTICS_H_
+
+#include <map>
+#include <string>
+
+#include "src/allocation.h"
+#include "src/base/platform/time.h"
+
+namespace v8 {
+namespace internal {
+
+class CompilationInfo;
+
+class CompilationStatistics FINAL : public Malloced {
+ public:
+ CompilationStatistics() {}
+
+ class BasicStats {
+ public:
+ BasicStats()
+ : total_allocated_bytes_(0),
+ max_allocated_bytes_(0),
+ absolute_max_allocated_bytes_(0) {}
+
+ void Accumulate(const BasicStats& stats);
+
+ base::TimeDelta delta_;
+ size_t total_allocated_bytes_;
+ size_t max_allocated_bytes_;
+ size_t absolute_max_allocated_bytes_;
+ std::string function_name_;
+ };
+
+ void RecordPhaseStats(const char* phase_kind_name, const char* phase_name,
+ const BasicStats& stats);
+
+ void RecordPhaseKindStats(const char* phase_kind_name,
+ const BasicStats& stats);
+
+ void RecordTotalStats(size_t source_size, const BasicStats& stats);
+
+ private:
+ class TotalStats : public BasicStats {
+ public:
+ TotalStats() : source_size_(0) {}
+ uint64_t source_size_;
+ };
+
+ class OrderedStats : public BasicStats {
+ public:
+ explicit OrderedStats(size_t insert_order) : insert_order_(insert_order) {}
+ size_t insert_order_;
+ };
+
+ class PhaseStats : public OrderedStats {
+ public:
+ PhaseStats(size_t insert_order, const char* phase_kind_name)
+ : OrderedStats(insert_order), phase_kind_name_(phase_kind_name) {}
+ std::string phase_kind_name_;
+ };
+
+ friend std::ostream& operator<<(std::ostream& os,
+ const CompilationStatistics& s);
+
+ typedef OrderedStats PhaseKindStats;
+ typedef std::map<std::string, PhaseKindStats> PhaseKindMap;
+ typedef std::map<std::string, PhaseStats> PhaseMap;
+
+ TotalStats total_stats_;
+ PhaseKindMap phase_kind_map_;
+ PhaseMap phase_map_;
+
+ DISALLOW_COPY_AND_ASSIGN(CompilationStatistics);
+};
+
+std::ostream& operator<<(std::ostream& os, const CompilationStatistics& s);
+
+} // namespace internal
+} // namespace v8
+
+#endif
#include "src/compiler.h"
+#include "src/ast-numbering.h"
#include "src/bootstrapper.h"
#include "src/codegen.h"
#include "src/compilation-cache.h"
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(script->GetIsolate(), BASE, zone);
}
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(isolate, STUB, zone);
}
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(script_->GetIsolate(), BASE, zone);
}
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(script_->GetIsolate(), BASE, zone);
}
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(isolate, STUB, zone);
code_stub_ = stub;
}
parameter_count_(0),
optimization_id_(-1),
ast_value_factory_(NULL),
- ast_value_factory_owned_(false) {
+ ast_value_factory_owned_(false),
+ aborted_due_to_dependency_change_(false) {
Initialize(isolate, BASE, zone);
}
if (!script_.is_null() && script_->type()->value() == Script::TYPE_NATIVE) {
MarkAsNative();
}
+ // Compiling for the snapshot typically results in different code than
+ // compiling later on. This means that code recompiled with deoptimization
+ // support won't be "equivalent" (as defined by SharedFunctionInfo::
+ // EnableDeoptimizationSupport), so it will replace the old code and all
+ // its type feedback. To avoid this, always compile functions in the snapshot
+ // with deoptimization support.
+ if (isolate_->serializer_enabled()) EnableDeoptimizationSupport();
+
if (isolate_->debug()->is_active()) MarkAsDebug();
if (FLAG_context_specialization) MarkAsContextSpecializing();
if (FLAG_turbo_inlining) MarkAsInliningEnabled();
DCHECK(scope_ == NULL);
scope_ = scope;
- int length = function()->slot_count();
if (feedback_vector_.is_null()) {
// Allocate the feedback vector too.
- feedback_vector_ = isolate()->factory()->NewTypeFeedbackVector(length);
+ feedback_vector_ = isolate()->factory()->NewTypeFeedbackVector(
+ function()->slot_count(), function()->ic_slot_count());
}
- DCHECK(feedback_vector_->length() == length);
+ DCHECK(feedback_vector_->Slots() == function()->slot_count() &&
+ feedback_vector_->ICSlots() == function()->ic_slot_count());
}
compiler::Pipeline pipeline(info());
pipeline.GenerateCode();
if (!info()->code().is_null()) {
- if (FLAG_turbo_deoptimization) {
- info()->context()->native_context()->AddOptimizedCode(*info()->code());
- }
return SetLastStatus(SUCCEEDED);
}
}
DCHECK(last_status() == SUCCEEDED);
// TODO(turbofan): Currently everything is done in the first phase.
if (!info()->code().is_null()) {
+ if (FLAG_turbo_deoptimization) {
+ info()->context()->native_context()->AddOptimizedCode(*info()->code());
+ }
RecordOptimizationStats();
return last_status();
}
static bool CompileUnoptimizedCode(CompilationInfo* info) {
DCHECK(AllowCompilation::IsAllowed(info->isolate()));
- DCHECK(info->function() != NULL);
- if (!Rewriter::Rewrite(info)) return false;
- if (!Scope::Analyze(info)) return false;
- DCHECK(info->scope() != NULL);
-
- if (!FullCodeGenerator::MakeCode(info)) {
+ if (!Compiler::Analyze(info) || !FullCodeGenerator::MakeCode(info)) {
Isolate* isolate = info->isolate();
if (!isolate->has_pending_exception()) isolate->StackOverflow();
return false;
shared->set_strict_mode(lit->strict_mode());
SetExpectedNofPropertiesFromEstimate(shared, lit->expected_property_count());
shared->set_bailout_reason(lit->dont_optimize_reason());
- shared->set_ast_node_count(lit->ast_node_count());
// Compile unoptimized code.
if (!CompileUnoptimizedCode(info)) return MaybeHandle<Code>();
}
-static bool CompileOptimizedPrologue(CompilationInfo* info) {
- if (!Parser::Parse(info)) return false;
+static bool Renumber(CompilationInfo* info) {
+ if (!AstNumbering::Renumber(info->function(), info->zone())) return false;
+ if (!info->shared_info().is_null()) {
+ info->shared_info()->set_ast_node_count(info->function()->ast_node_count());
+ }
+ return true;
+}
+
+
+bool Compiler::Analyze(CompilationInfo* info) {
+ DCHECK(info->function() != NULL);
if (!Rewriter::Rewrite(info)) return false;
if (!Scope::Analyze(info)) return false;
+ if (!Renumber(info)) return false;
DCHECK(info->scope() != NULL);
return true;
}
+bool Compiler::ParseAndAnalyze(CompilationInfo* info) {
+ if (!Parser::Parse(info)) return false;
+ return Compiler::Analyze(info);
+}
+
+
static bool GetOptimizedCodeNow(CompilationInfo* info) {
- if (!CompileOptimizedPrologue(info)) return false;
+ if (!Compiler::ParseAndAnalyze(info)) return false;
TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
}
CompilationHandleScope handle_scope(info);
- if (!CompileOptimizedPrologue(info)) return false;
+ if (!Compiler::ParseAndAnalyze(info)) return false;
info->SaveHandles(); // Copy handles to the compilation handle scope.
TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
MaybeHandle<Code> Compiler::GetLazyCode(Handle<JSFunction> function) {
- DCHECK(!function->GetIsolate()->has_pending_exception());
+ Isolate* isolate = function->GetIsolate();
+ DCHECK(!isolate->has_pending_exception());
DCHECK(!function->is_compiled());
-
- if (FLAG_turbo_asm && function->shared()->asm_function()) {
+ // If the debugger is active, do not compile with turbofan unless we can
+ // deopt from turbofan code.
+ if (FLAG_turbo_asm && function->shared()->asm_function() &&
+ (FLAG_turbo_deoptimization || !isolate->debug()->is_active())) {
CompilationInfoWithZone info(function);
- VMState<COMPILER> state(info.isolate());
- PostponeInterruptsScope postpone(info.isolate());
+ VMState<COMPILER> state(isolate);
+ PostponeInterruptsScope postpone(isolate);
info.SetOptimizing(BailoutId::None(),
Handle<Code>(function->shared()->code()));
info.MarkAsTypingEnabled();
info.MarkAsInliningDisabled();
- if (GetOptimizedCodeNow(&info)) return info.code();
+ if (GetOptimizedCodeNow(&info)) {
+ DCHECK(function->shared()->is_compiled());
+ return info.code();
+ }
}
if (function->shared()->is_compiled()) {
CompilationInfoWithZone info(function);
Handle<Code> result;
- ASSIGN_RETURN_ON_EXCEPTION(info.isolate(), result,
- GetUnoptimizedCodeCommon(&info), Code);
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCodeCommon(&info),
+ Code);
- if (FLAG_always_opt &&
- info.isolate()->use_crankshaft() &&
+ if (FLAG_always_opt && isolate->use_crankshaft() &&
!info.shared_info()->optimization_disabled() &&
- !info.isolate()->DebuggerHasBreakPoints()) {
+ !isolate->DebuggerHasBreakPoints()) {
Handle<Code> opt_code;
if (Compiler::GetOptimizedCode(
function, result,
// TODO(turbofan): In the future, unoptimized code with deopt support could
// be generated lazily once deopt is triggered.
bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
+ DCHECK(info->function() != NULL);
+ DCHECK(info->scope() != NULL);
if (!info->shared_info()->has_deoptimization_support()) {
CompilationInfoWithZone unoptimized(info->shared_info());
// Note that we use the same AST that we will use for generating the
MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
- Handle<String> source,
- Handle<Context> context,
- StrictMode strict_mode,
- ParseRestriction restriction,
- int scope_position) {
+ Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ Handle<Context> context, StrictMode strict_mode,
+ ParseRestriction restriction, int scope_position) {
Isolate* isolate = source->GetIsolate();
int source_length = source->length();
isolate->counters()->total_eval_size()->Increment(source_length);
CompilationCache* compilation_cache = isolate->compilation_cache();
MaybeHandle<SharedFunctionInfo> maybe_shared_info =
- compilation_cache->LookupEval(source, context, strict_mode,
+ compilation_cache->LookupEval(source, outer_info, context, strict_mode,
scope_position);
Handle<SharedFunctionInfo> shared_info;
// If caller is strict mode, the result must be in strict mode as well.
DCHECK(strict_mode == SLOPPY || shared_info->strict_mode() == STRICT);
if (!shared_info->dont_cache()) {
- compilation_cache->PutEval(
- source, context, shared_info, scope_position);
+ compilation_cache->PutEval(source, outer_info, context, shared_info,
+ scope_position);
}
}
} else if (shared_info->ic_age() != isolate->heap()->global_ic_age()) {
compile_options == ScriptCompiler::kConsumeCodeCache &&
!isolate->debug()->is_loaded()) {
HistogramTimerScope timer(isolate->counters()->compile_deserialize());
- return CodeSerializer::Deserialize(isolate, *cached_data, source);
+ Handle<SharedFunctionInfo> result;
+ if (CodeSerializer::Deserialize(isolate, *cached_data, source)
+ .ToHandle(&result)) {
+ return result;
+ }
+ // Deserializer failed. Fall through to compile.
} else {
maybe_result = compilation_cache->LookupScript(
source, script_name, line_offset, column_offset,
result = CompileToplevel(&info);
if (extension == NULL && !result.is_null() && !result->dont_cache()) {
compilation_cache->PutScript(source, context, result);
- if (FLAG_serialize_toplevel &&
+ // TODO(yangguo): Issue 3628
+ // With block scoping, top-level variables may resolve to a global,
+ // context, which makes the code context-dependent.
+ if (FLAG_serialize_toplevel && !FLAG_harmony_scoping &&
compile_options == ScriptCompiler::kProduceCodeCache) {
HistogramTimerScope histogram_timer(
isolate->counters()->compile_serialize());
*cached_data = CodeSerializer::Serialize(isolate, result, source);
if (FLAG_profile_deserialization) {
- PrintF("[Compiling and serializing %d bytes took %0.3f ms]\n",
- (*cached_data)->length(), timer.Elapsed().InMillisecondsF());
+ PrintF("[Compiling and serializing took %0.3f ms]\n",
+ timer.Elapsed().InMillisecondsF());
}
}
}
if (outer_info->is_toplevel() && outer_info->will_serialize()) {
// Make sure that if the toplevel code (possibly to be serialized),
- // the inner unction must be allowed to be compiled lazily.
+ // the inner function must be allowed to be compiled lazily.
DCHECK(allow_lazy);
}
Handle<Code> code = isolate->builtins()->CompileLazy();
info.SetCode(code);
scope_info = Handle<ScopeInfo>(ScopeInfo::Empty(isolate));
- } else if (FullCodeGenerator::MakeCode(&info)) {
+ } else if (Renumber(&info) && FullCodeGenerator::MakeCode(&info)) {
DCHECK(!info.code().is_null());
scope_info = ScopeInfo::Create(info.scope(), info.zone());
} else {
bool Compiler::DebuggerWantsEagerCompilation(CompilationInfo* info,
bool allow_lazy_without_ctx) {
- return LiveEditFunctionTracker::IsActive(info->isolate()) ||
- (info->isolate()->DebuggerHasBreakPoints() && !allow_lazy_without_ctx);
+ if (LiveEditFunctionTracker::IsActive(info->isolate())) return true;
+ Debug* debug = info->isolate()->debug();
+ bool debugging = debug->is_active() || debug->has_break_points();
+ return debugging && !allow_lazy_without_ctx;
}
kInliningEnabled = 1 << 17,
kTypingEnabled = 1 << 18,
kDisableFutureOptimization = 1 << 19,
- kAbortedDueToDependency = 1 << 20,
- kToplevel = 1 << 21
+ kToplevel = 1 << 20
};
CompilationInfo(Handle<JSFunction> closure, Zone* zone);
void AbortDueToDependencyChange() {
DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
- SetFlag(kAbortedDueToDependency);
+ aborted_due_to_dependency_change_ = true;
}
bool HasAbortedDueToDependencyChange() const {
DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
- return GetFlag(kAbortedDueToDependency);
+ return aborted_due_to_dependency_change_;
}
bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
ast_value_factory_owned_ = owned;
}
- AstNode::IdGen* ast_node_id_gen() { return &ast_node_id_gen_; }
-
protected:
CompilationInfo(Handle<Script> script,
Zone* zone);
AstValueFactory* ast_value_factory_;
bool ast_value_factory_owned_;
- AstNode::IdGen ast_node_id_gen_;
+
+ // This flag is used by the main thread to track whether this compilation
+ // should be abandoned due to dependency change.
+ bool aborted_due_to_dependency_change_;
DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
};
MUST_USE_RESULT static MaybeHandle<Code> GetDebugCode(
Handle<JSFunction> function);
+ // Parser::Parse, then Compiler::Analyze.
+ static bool ParseAndAnalyze(CompilationInfo* info);
+ // Rewrite, analyze scopes, and renumber.
+ static bool Analyze(CompilationInfo* info);
+ // Adds deoptimization support, requires ParseAndAnalyze.
+ static bool EnsureDeoptimizationSupport(CompilationInfo* info);
+
static bool EnsureCompiled(Handle<JSFunction> function,
ClearExceptionFlag flag);
- static bool EnsureDeoptimizationSupport(CompilationInfo* info);
-
static void CompileForLiveEdit(Handle<Script> script);
// Compile a String source within a context for eval.
MUST_USE_RESULT static MaybeHandle<JSFunction> GetFunctionFromEval(
- Handle<String> source,
- Handle<Context> context,
- StrictMode strict_mode,
- ParseRestriction restriction,
- int scope_position);
+ Handle<String> source, Handle<SharedFunctionInfo> outer_info,
+ Handle<Context> context, StrictMode strict_mode,
+ ParseRestriction restriction, int scope_position);
// Compile a String source within a context.
static Handle<SharedFunctionInfo> CompileScript(
// static
FieldAccess AccessBuilder::ForMap() {
- return {kTaggedBase, HeapObject::kMapOffset, Handle<Name>(), Type::Any(),
+ return {kTaggedBase, HeapObject::kMapOffset, MaybeHandle<Name>(), Type::Any(),
kMachAnyTagged};
}
// static
FieldAccess AccessBuilder::ForJSObjectProperties() {
- return {kTaggedBase, JSObject::kPropertiesOffset, Handle<Name>(), Type::Any(),
- kMachAnyTagged};
+ return {kTaggedBase, JSObject::kPropertiesOffset, MaybeHandle<Name>(),
+ Type::Any(), kMachAnyTagged};
}
// static
FieldAccess AccessBuilder::ForJSObjectElements() {
- return {kTaggedBase, JSObject::kElementsOffset, Handle<Name>(),
+ return {kTaggedBase, JSObject::kElementsOffset, MaybeHandle<Name>(),
Type::Internal(), kMachAnyTagged};
}
// static
FieldAccess AccessBuilder::ForJSFunctionContext() {
- return {kTaggedBase, JSFunction::kContextOffset, Handle<Name>(),
+ return {kTaggedBase, JSFunction::kContextOffset, MaybeHandle<Name>(),
Type::Internal(), kMachAnyTagged};
}
// static
FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() {
- return {kTaggedBase, JSArrayBuffer::kBackingStoreOffset, Handle<Name>(),
+ return {kTaggedBase, JSArrayBuffer::kBackingStoreOffset, MaybeHandle<Name>(),
Type::UntaggedPtr(), kMachPtr};
}
// static
FieldAccess AccessBuilder::ForExternalArrayPointer() {
- return {kTaggedBase, ExternalArray::kExternalPointerOffset, Handle<Name>(),
- Type::UntaggedPtr(), kMachPtr};
+ return {kTaggedBase, ExternalArray::kExternalPointerOffset,
+ MaybeHandle<Name>(), Type::UntaggedPtr(), kMachPtr};
+}
+
+
+// static
+FieldAccess AccessBuilder::ForMapInstanceType() {
+ return {kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(),
+ Type::UntaggedInt8(), kMachUint8};
+}
+
+
+// static
+FieldAccess AccessBuilder::ForStringLength() {
+ return {kTaggedBase, String::kLengthOffset, Handle<Name>(),
+ Type::SignedSmall(), kMachAnyTagged};
+}
+
+
+// static
+FieldAccess AccessBuilder::ForValue() {
+ return {kTaggedBase, JSValue::kValueOffset, Handle<Name>(), Type::Any(),
+ kMachAnyTagged};
}
// static
ElementAccess AccessBuilder::ForFixedArrayElement() {
- return {kTaggedBase, FixedArray::kHeaderSize, Type::Any(), kMachAnyTagged};
+ return {kNoBoundsCheck, kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
+ kMachAnyTagged};
}
int header_size = is_external ? 0 : FixedTypedArrayBase::kDataOffset;
switch (type) {
case kExternalInt8Array:
- return {taggedness, header_size, Type::Signed32(), kMachInt8};
+ return {kTypedArrayBoundsCheck, taggedness, header_size, Type::Signed32(),
+ kMachInt8};
case kExternalUint8Array:
case kExternalUint8ClampedArray:
- return {taggedness, header_size, Type::Unsigned32(), kMachUint8};
+ return {kTypedArrayBoundsCheck, taggedness, header_size,
+ Type::Unsigned32(), kMachUint8};
case kExternalInt16Array:
- return {taggedness, header_size, Type::Signed32(), kMachInt16};
+ return {kTypedArrayBoundsCheck, taggedness, header_size, Type::Signed32(),
+ kMachInt16};
case kExternalUint16Array:
- return {taggedness, header_size, Type::Unsigned32(), kMachUint16};
+ return {kTypedArrayBoundsCheck, taggedness, header_size,
+ Type::Unsigned32(), kMachUint16};
case kExternalInt32Array:
- return {taggedness, header_size, Type::Signed32(), kMachInt32};
+ return {kTypedArrayBoundsCheck, taggedness, header_size, Type::Signed32(),
+ kMachInt32};
case kExternalUint32Array:
- return {taggedness, header_size, Type::Unsigned32(), kMachUint32};
+ return {kTypedArrayBoundsCheck, taggedness, header_size,
+ Type::Unsigned32(), kMachUint32};
case kExternalFloat32Array:
- return {taggedness, header_size, Type::Number(), kRepFloat32};
+ return {kTypedArrayBoundsCheck, taggedness, header_size, Type::Number(),
+ kMachFloat32};
case kExternalFloat64Array:
- return {taggedness, header_size, Type::Number(), kRepFloat64};
+ return {kTypedArrayBoundsCheck, taggedness, header_size, Type::Number(),
+ kMachFloat64};
}
UNREACHABLE();
- return {kUntaggedBase, 0, Type::None(), kMachNone};
+ return {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::None(), kMachNone};
}
} // namespace compiler
// Provides access to ExternalArray::external_pointer() field.
static FieldAccess ForExternalArrayPointer();
+ // Provides access to Map::instance_type() field.
+ static FieldAccess ForMapInstanceType();
+
+ // Provides access to String::length() field.
+ static FieldAccess ForStringLength();
+
+ // Provides access to JSValue::value() field.
+ static FieldAccess ForValue();
+
// Provides access to FixedArray elements.
static ElementAccess ForFixedArrayElement();
break;
}
case kArchJmp:
- __ b(code_->GetLabel(i.InputBlock(0)));
+ __ b(GetLabel(i.InputRpo(0)));
DCHECK_EQ(LeaveCC, i.OutputSBit());
break;
case kArchNop:
AssembleReturn();
DCHECK_EQ(LeaveCC, i.OutputSBit());
break;
+ case kArchStackPointer:
+ __ mov(i.OutputRegister(), sp);
+ DCHECK_EQ(LeaveCC, i.OutputSBit());
+ break;
case kArchTruncateDoubleToI:
__ TruncateDoubleToI(i.OutputRegister(), i.InputFloat64Register(0));
DCHECK_EQ(LeaveCC, i.OutputSBit());
DCHECK_EQ(LeaveCC, i.OutputSBit());
break;
}
+ case kArmSmmul:
+ __ smmul(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
+ DCHECK_EQ(LeaveCC, i.OutputSBit());
+ break;
+ case kArmSmmla:
+ __ smmla(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1),
+ i.InputRegister(2));
+ DCHECK_EQ(LeaveCC, i.OutputSBit());
+ break;
+ case kArmUmull:
+ __ umull(i.OutputRegister(0), i.OutputRegister(1), i.InputRegister(0),
+ i.InputRegister(1), i.OutputSBit());
+ break;
case kArmSdiv: {
CpuFeatureScope scope(masm(), SUDIV);
__ sdiv(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
case kArmVsqrtF64:
__ vsqrt(i.OutputFloat64Register(), i.InputFloat64Register(0));
break;
+ case kArmVfloorF64:
+ __ vrintm(i.OutputFloat64Register(), i.InputFloat64Register(0));
+ break;
+ case kArmVceilF64:
+ __ vrintp(i.OutputFloat64Register(), i.InputFloat64Register(0));
+ break;
+ case kArmVroundTruncateF64:
+ __ vrintz(i.OutputFloat64Register(), i.InputFloat64Register(0));
+ break;
+ case kArmVroundTiesAwayF64:
+ __ vrinta(i.OutputFloat64Register(), i.InputFloat64Register(0));
+ break;
case kArmVnegF64:
__ vneg(i.OutputFloat64Register(), i.InputFloat64Register(0));
break;
// Emit a branch. The true and false targets are always the last two inputs
// to the instruction.
- BasicBlock* tblock = i.InputBlock(instr->InputCount() - 2);
- BasicBlock* fblock = i.InputBlock(instr->InputCount() - 1);
+ BasicBlock::RpoNumber tblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
+ BasicBlock::RpoNumber fblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
bool fallthru = IsNextInAssemblyOrder(fblock);
- Label* tlabel = code()->GetLabel(tblock);
- Label* flabel = fallthru ? &done : code()->GetLabel(fblock);
+ Label* tlabel = GetLabel(tblock);
+ Label* flabel = fallthru ? &done : GetLabel(fblock);
switch (condition) {
case kUnorderedEqual:
__ b(vs, flabel);
__ stm(db_w, sp, saves);
}
} else if (descriptor->IsJSFunctionCall()) {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
__ Prologue(info->IsCodePreAgingActive());
frame()->SetRegisterSaveAreaSize(
StandardFrameConstants::kFixedFrameSizeFromFp);
void CodeGenerator::EnsureSpaceForLazyDeopt() {
int space_needed = Deoptimizer::patch_size();
- if (!linkage()->info()->IsStub()) {
+ if (!info()->IsStub()) {
// Ensure that we have enough space after the previous lazy-bailout
// instruction for patching the code here.
int current_pc = masm()->pc_offset();
V(ArmMul) \
V(ArmMla) \
V(ArmMls) \
+ V(ArmSmmul) \
+ V(ArmSmmla) \
+ V(ArmUmull) \
V(ArmSdiv) \
V(ArmUdiv) \
V(ArmMov) \
V(ArmVmodF64) \
V(ArmVnegF64) \
V(ArmVsqrtF64) \
+ V(ArmVfloorF64) \
+ V(ArmVceilF64) \
+ V(ArmVroundTruncateF64) \
+ V(ArmVroundTiesAwayF64) \
V(ArmVcvtF32F64) \
V(ArmVcvtF64F32) \
V(ArmVcvtF64S32) \
return UseRegister(node);
}
+ bool CanBeImmediate(int32_t value) const {
+ return Assembler::ImmediateFitsAddrMode1Instruction(value);
+ }
+
+ bool CanBeImmediate(uint32_t value) const {
+ return CanBeImmediate(bit_cast<int32_t>(value));
+ }
+
bool CanBeImmediate(Node* node, InstructionCode opcode) {
Int32Matcher m(node);
if (!m.HasValue()) return false;
case kArmMov:
case kArmMvn:
case kArmBic:
- return ImmediateFitsAddrMode1Instruction(value) ||
- ImmediateFitsAddrMode1Instruction(~value);
+ return CanBeImmediate(value) || CanBeImmediate(~value);
case kArmAdd:
case kArmSub:
case kArmCmp:
case kArmCmn:
- return ImmediateFitsAddrMode1Instruction(value) ||
- ImmediateFitsAddrMode1Instruction(-value);
+ return CanBeImmediate(value) || CanBeImmediate(-value);
case kArmTst:
case kArmTeq:
case kArmOrr:
case kArmEor:
case kArmRsb:
- return ImmediateFitsAddrMode1Instruction(value);
+ return CanBeImmediate(value);
case kArmVldrF32:
case kArmVstrF32:
case kArchJmp:
case kArchNop:
case kArchRet:
+ case kArchStackPointer:
case kArchTruncateDoubleToI:
case kArmMul:
case kArmMla:
case kArmMls:
+ case kArmSmmul:
+ case kArmSmmla:
+ case kArmUmull:
case kArmSdiv:
case kArmUdiv:
case kArmBfc:
case kArmVmodF64:
case kArmVnegF64:
case kArmVsqrtF64:
+ case kArmVfloorF64:
+ case kArmVceilF64:
+ case kArmVroundTruncateF64:
+ case kArmVroundTiesAwayF64:
case kArmVcvtF32F64:
case kArmVcvtF64F32:
case kArmVcvtF64S32:
UNREACHABLE();
return false;
}
-
- private:
- bool ImmediateFitsAddrMode1Instruction(int32_t imm) const {
- return Assembler::ImmediateFitsAddrMode1Instruction(imm);
- }
};
+static void VisitRRFloat64(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ ArmOperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)));
+}
+
+
static void VisitRRRFloat64(InstructionSelector* selector, ArchOpcode opcode,
Node* node) {
ArmOperandGenerator g(selector);
}
}
if (IsSupported(ARMv7) && m.right().HasValue()) {
- uint32_t value = m.right().Value();
+ // Try to interpret this AND as UBFX.
+ uint32_t const value = m.right().Value();
uint32_t width = base::bits::CountPopulation32(value);
uint32_t msb = base::bits::CountLeadingZeros32(value);
if (width != 0 && msb + width == 32) {
g.TempImmediate(0), g.TempImmediate(width));
return;
}
+
+ // Try to interpret this AND as BIC.
+ if (g.CanBeImmediate(~value)) {
+ Emit(kArmBic | AddressingModeField::encode(kMode_Operand2_I),
+ g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.TempImmediate(~value));
+ return;
+ }
+
// Try to interpret this AND as BFC.
width = 32 - width;
msb = base::bits::CountLeadingZeros32(~value);
g.UseRegister(mright.right().node()), g.UseRegister(m.left().node()));
return;
}
+ if (m.left().IsInt32MulHigh() && CanCover(node, m.left().node())) {
+ Int32BinopMatcher mleft(m.left().node());
+ Emit(kArmSmmla, g.DefineAsRegister(node),
+ g.UseRegister(mleft.left().node()),
+ g.UseRegister(mleft.right().node()), g.UseRegister(m.right().node()));
+ return;
+ }
+ if (m.right().IsInt32MulHigh() && CanCover(node, m.right().node())) {
+ Int32BinopMatcher mright(m.right().node());
+ Emit(kArmSmmla, g.DefineAsRegister(node),
+ g.UseRegister(mright.left().node()),
+ g.UseRegister(mright.right().node()), g.UseRegister(m.left().node()));
+ return;
+ }
VisitBinop(this, node, kArmAdd, kArmAdd);
}
}
+void InstructionSelector::VisitInt32MulHigh(Node* node) {
+ ArmOperandGenerator g(this);
+ Emit(kArmSmmul, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+}
+
+
+void InstructionSelector::VisitUint32MulHigh(Node* node) {
+ ArmOperandGenerator g(this);
+ InstructionOperand* outputs[] = {g.TempRegister(), g.DefineAsRegister(node)};
+ InstructionOperand* inputs[] = {g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1))};
+ Emit(kArmUmull, arraysize(outputs), outputs, arraysize(inputs), inputs);
+}
+
+
static void EmitDiv(InstructionSelector* selector, ArchOpcode div_opcode,
ArchOpcode f64i32_opcode, ArchOpcode i32f64_opcode,
InstructionOperand* result_operand,
}
-void InstructionSelector::VisitInt32UDiv(Node* node) {
+void InstructionSelector::VisitUint32Div(Node* node) {
VisitDiv(this, node, kArmUdiv, kArmVcvtF64U32, kArmVcvtU32F64);
}
}
-void InstructionSelector::VisitInt32UMod(Node* node) {
+void InstructionSelector::VisitUint32Mod(Node* node) {
VisitMod(this, node, kArmUdiv, kArmVcvtF64U32, kArmVcvtU32F64);
}
}
-void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization) {
+void InstructionSelector::VisitFloat64Floor(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ VisitRRFloat64(this, kArmVfloorF64, node);
+}
+
+
+void InstructionSelector::VisitFloat64Ceil(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ VisitRRFloat64(this, kArmVceilF64, node);
+}
+
+
+void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ VisitRRFloat64(this, kArmVroundTruncateF64, node);
+}
+
+
+void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(ARMv8));
+ VisitRRFloat64(this, kArmVroundTiesAwayF64, node);
+}
+
+
+void InstructionSelector::VisitCall(Node* node) {
ArmOperandGenerator g(this);
- CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call);
+ CallDescriptor* descriptor = OpParameter<CallDescriptor*>(node);
FrameStateDescriptor* frame_state_descriptor = NULL;
if (descriptor->NeedsFrameState()) {
frame_state_descriptor =
- GetFrameStateDescriptor(call->InputAt(descriptor->InputCount()));
+ GetFrameStateDescriptor(node->InputAt(descriptor->InputCount()));
}
CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
// TODO(turbofan): on ARM64 it's probably better to use the code object in a
// register if there are multiple uses of it. Improve constant pool and the
// heuristics in the register allocator for where to emit constants.
- InitializeCallBuffer(call, &buffer, true, false);
+ InitializeCallBuffer(node, &buffer, true, false);
// TODO(dcarney): might be possible to use claim/poke instead
// Push any stack arguments.
opcode |= MiscField::encode(descriptor->flags());
// Emit the call instruction.
+ InstructionOperand** first_output =
+ buffer.outputs.size() > 0 ? &buffer.outputs.front() : NULL;
Instruction* call_instr =
- Emit(opcode, buffer.outputs.size(), &buffer.outputs.front(),
+ Emit(opcode, buffer.outputs.size(), first_output,
buffer.instruction_args.size(), &buffer.instruction_args.front());
-
call_instr->MarkAsCall();
- if (deoptimization != NULL) {
- DCHECK(continuation != NULL);
- call_instr->MarkAsControl();
- }
}
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kArmAdd, kArmAdd, cont);
-}
-
+namespace {
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kArmSub, kArmRsb, cont);
+// Shared routine for multiple float compare operations.
+void VisitFloat64Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ ArmOperandGenerator g(selector);
+ Float64BinopMatcher m(node);
+ if (cont->IsBranch()) {
+ selector->Emit(cont->Encode(kArmVcmpF64), nullptr,
+ g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()), g.Label(cont->true_block()),
+ g.Label(cont->false_block()))->MarkAsControl();
+ } else {
+ DCHECK(cont->IsSet());
+ selector->Emit(
+ cont->Encode(kArmVcmpF64), g.DefineAsRegister(cont->result()),
+ g.UseRegister(m.left().node()), g.UseRegister(m.right().node()));
+ }
}
-// Shared routine for multiple compare operations.
-static void VisitWordCompare(InstructionSelector* selector, Node* node,
- InstructionCode opcode, FlagsContinuation* cont,
- bool commutative) {
+// Shared routine for multiple word compare operations.
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont) {
ArmOperandGenerator g(selector);
Int32BinopMatcher m(node);
InstructionOperand* inputs[5];
input_count++;
} else if (TryMatchImmediateOrShift(selector, &opcode, m.left().node(),
&input_count, &inputs[1])) {
- if (!commutative) cont->Commute();
+ if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
inputs[0] = g.UseRegister(m.right().node());
input_count++;
} else {
}
-void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kInt32Add:
- return VisitWordCompare(this, node, kArmCmn, cont, true);
- case IrOpcode::kInt32Sub:
- return VisitWordCompare(this, node, kArmCmp, cont, false);
- case IrOpcode::kWord32And:
- return VisitWordCompare(this, node, kArmTst, cont, true);
- case IrOpcode::kWord32Or:
- return VisitBinop(this, node, kArmOrr, kArmOrr, cont);
- case IrOpcode::kWord32Xor:
- return VisitWordCompare(this, node, kArmTeq, cont, true);
- case IrOpcode::kWord32Sar:
- return VisitShift(this, node, TryMatchASR, cont);
- case IrOpcode::kWord32Shl:
- return VisitShift(this, node, TryMatchLSL, cont);
- case IrOpcode::kWord32Shr:
- return VisitShift(this, node, TryMatchLSR, cont);
- case IrOpcode::kWord32Ror:
- return VisitShift(this, node, TryMatchROR, cont);
- default:
- break;
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordCompare(selector, node, kArmCmp, cont);
+}
+
+
+// Shared routine for word comparisons against zero.
+void VisitWordCompareZero(InstructionSelector* selector, Node* user,
+ Node* value, FlagsContinuation* cont) {
+ while (selector->CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord32Equal: {
+ // Combine with comparisons against 0 by simply inverting the
+ // continuation.
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont->Negate();
+ continue;
+ }
+ cont->OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(selector, value, cont);
+ }
+ case IrOpcode::kInt32LessThan:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kInt32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kFloat64Equal:
+ cont->OverwriteAndNegateIfEqual(kUnorderedEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThan);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kProjection:
+ // Check if this is the overflow output projection of an
+ // <Operation>WithOverflow node.
+ if (OpParameter<size_t>(value) == 1u) {
+ // We cannot combine the <Operation>WithOverflow with this branch
+ // unless the 0th projection (the use of the actual value of the
+ // <Operation> is either NULL, which means there's no use of the
+ // actual value, or was already defined, which means it is scheduled
+ // *AFTER* this branch).
+ Node* const node = value->InputAt(0);
+ Node* const result = node->FindProjection(0);
+ if (!result || selector->IsDefined(result)) {
+ switch (node->opcode()) {
+ case IrOpcode::kInt32AddWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kArmAdd, kArmAdd, cont);
+ case IrOpcode::kInt32SubWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kArmSub, kArmRsb, cont);
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case IrOpcode::kInt32Add:
+ return VisitWordCompare(selector, value, kArmCmn, cont);
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(selector, value, kArmCmp, cont);
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(selector, value, kArmTst, cont);
+ case IrOpcode::kWord32Or:
+ return VisitBinop(selector, value, kArmOrr, kArmOrr, cont);
+ case IrOpcode::kWord32Xor:
+ return VisitWordCompare(selector, value, kArmTeq, cont);
+ case IrOpcode::kWord32Sar:
+ return VisitShift(selector, value, TryMatchASR, cont);
+ case IrOpcode::kWord32Shl:
+ return VisitShift(selector, value, TryMatchLSL, cont);
+ case IrOpcode::kWord32Shr:
+ return VisitShift(selector, value, TryMatchLSR, cont);
+ case IrOpcode::kWord32Ror:
+ return VisitShift(selector, value, TryMatchROR, cont);
+ default:
+ break;
+ }
+ break;
}
- ArmOperandGenerator g(this);
- InstructionCode opcode =
+ // Continuation could not be combined with a compare, emit compare against 0.
+ ArmOperandGenerator g(selector);
+ InstructionCode const opcode =
cont->Encode(kArmTst) | AddressingModeField::encode(kMode_Operand2_R);
+ InstructionOperand* const value_operand = g.UseRegister(value);
if (cont->IsBranch()) {
- Emit(opcode, NULL, g.UseRegister(node), g.UseRegister(node),
- g.Label(cont->true_block()),
- g.Label(cont->false_block()))->MarkAsControl();
+ selector->Emit(opcode, nullptr, value_operand, value_operand,
+ g.Label(cont->true_block()),
+ g.Label(cont->false_block()))->MarkAsControl();
} else {
- Emit(opcode, g.DefineAsRegister(cont->result()), g.UseRegister(node),
- g.UseRegister(node));
+ selector->Emit(opcode, g.DefineAsRegister(cont->result()), value_operand,
+ value_operand);
}
}
+} // namespace
-void InstructionSelector::VisitWord32Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kArmCmp, cont, false);
+
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
+ FlagsContinuation cont(kNotEqual, tbranch, fbranch);
+ if (IsNextInAssemblyOrder(tbranch)) { // We can fallthru to the true block.
+ cont.Negate();
+ cont.SwapBlocks();
+ }
+ VisitWordCompareZero(this, branch, branch->InputAt(0), &cont);
}
-void InstructionSelector::VisitFloat64Compare(Node* node,
- FlagsContinuation* cont) {
- ArmOperandGenerator g(this);
- Float64BinopMatcher m(node);
- if (cont->IsBranch()) {
- Emit(cont->Encode(kArmVcmpF64), NULL, g.UseRegister(m.left().node()),
- g.UseRegister(m.right().node()), g.Label(cont->true_block()),
- g.Label(cont->false_block()))->MarkAsControl();
- } else {
- DCHECK(cont->IsSet());
- Emit(cont->Encode(kArmVcmpF64), g.DefineAsRegister(cont->result()),
- g.UseRegister(m.left().node()), g.UseRegister(m.right().node()));
+void InstructionSelector::VisitWord32Equal(Node* const node) {
+ FlagsContinuation cont(kEqual, node);
+ Int32BinopMatcher m(node);
+ if (m.right().Is(0)) {
+ return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
+ }
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kArmAdd, kArmAdd, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop(this, node, kArmAdd, kArmAdd, &cont);
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kArmSub, kArmRsb, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop(this, node, kArmSub, kArmRsb, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64Equal(Node* node) {
+ FlagsContinuation cont(kUnorderedEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThan(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThan, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ MachineOperatorBuilder::Flags flags =
+ MachineOperatorBuilder::kInt32DivIsSafe |
+ MachineOperatorBuilder::kInt32ModIsSafe |
+ MachineOperatorBuilder::kUint32DivIsSafe |
+ MachineOperatorBuilder::kUint32ModIsSafe;
+
+ if (CpuFeatures::IsSupported(ARMv8)) {
+ flags |= MachineOperatorBuilder::kFloat64Floor |
+ MachineOperatorBuilder::kFloat64Ceil |
+ MachineOperatorBuilder::kFloat64RoundTruncate |
+ MachineOperatorBuilder::kFloat64RoundTiesAway;
}
+ return flags;
}
} // namespace compiler
typedef LinkageHelper<ArmLinkageHelperTraits> LH;
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone) {
- return LH::GetJSCallDescriptor(zone, parameter_count);
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
+ return LH::GetJSCallDescriptor(zone, parameter_count, flags);
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone) {
return LH::GetStubCallDescriptor(zone, descriptor, stack_parameter_count,
flags);
Register OutputRegister32() { return ToRegister(instr_->Output()).W(); }
+ Operand InputOperand2_32(int index) {
+ switch (AddressingModeField::decode(instr_->opcode())) {
+ case kMode_None:
+ return InputOperand32(index);
+ case kMode_Operand2_R_LSL_I:
+ return Operand(InputRegister32(index), LSL, InputInt5(index + 1));
+ case kMode_Operand2_R_LSR_I:
+ return Operand(InputRegister32(index), LSR, InputInt5(index + 1));
+ case kMode_Operand2_R_ASR_I:
+ return Operand(InputRegister32(index), ASR, InputInt5(index + 1));
+ case kMode_Operand2_R_ROR_I:
+ return Operand(InputRegister32(index), ROR, InputInt5(index + 1));
+ case kMode_MRI:
+ case kMode_MRR:
+ break;
+ }
+ UNREACHABLE();
+ return Operand(-1);
+ }
+
+ Operand InputOperand2_64(int index) {
+ switch (AddressingModeField::decode(instr_->opcode())) {
+ case kMode_None:
+ return InputOperand64(index);
+ case kMode_Operand2_R_LSL_I:
+ return Operand(InputRegister64(index), LSL, InputInt6(index + 1));
+ case kMode_Operand2_R_LSR_I:
+ return Operand(InputRegister64(index), LSR, InputInt6(index + 1));
+ case kMode_Operand2_R_ASR_I:
+ return Operand(InputRegister64(index), ASR, InputInt6(index + 1));
+ case kMode_Operand2_R_ROR_I:
+ return Operand(InputRegister64(index), ROR, InputInt6(index + 1));
+ case kMode_MRI:
+ case kMode_MRR:
+ break;
+ }
+ UNREACHABLE();
+ return Operand(-1);
+ }
+
MemOperand MemoryOperand(int* first_index) {
const int index = *first_index;
switch (AddressingModeField::decode(instr_->opcode())) {
case kMode_None:
+ case kMode_Operand2_R_LSL_I:
+ case kMode_Operand2_R_LSR_I:
+ case kMode_Operand2_R_ASR_I:
+ case kMode_Operand2_R_ROR_I:
break;
case kMode_MRI:
*first_index += 2;
return MemOperand(InputRegister(index + 0), InputInt32(index + 1));
case kMode_MRR:
*first_index += 2;
- return MemOperand(InputRegister(index + 0), InputRegister(index + 1),
- SXTW);
+ return MemOperand(InputRegister(index + 0), InputRegister(index + 1));
}
UNREACHABLE();
return MemOperand(no_reg);
int64_t imm = i.InputOperand##width(1).immediate().value(); \
__ asm_instr(i.OutputRegister##width(), i.InputRegister##width(0), imm); \
} \
- } while (0);
+ } while (0)
+
+
+#define ASSEMBLE_TEST_AND_BRANCH(asm_instr, width) \
+ do { \
+ bool fallthrough = IsNextInAssemblyOrder(i.InputRpo(3)); \
+ __ asm_instr(i.InputRegister##width(0), i.InputInt6(1), \
+ GetLabel(i.InputRpo(2))); \
+ if (!fallthrough) __ B(GetLabel(i.InputRpo(3))); \
+ } while (0)
// Assembles an instruction after register allocation, producing machine code.
break;
}
case kArchJmp:
- __ B(code_->GetLabel(i.InputBlock(0)));
+ __ B(GetLabel(i.InputRpo(0)));
break;
case kArchNop:
// don't emit code for nops.
case kArchRet:
AssembleReturn();
break;
+ case kArchStackPointer:
+ __ mov(i.OutputRegister(), masm()->StackPointer());
+ break;
case kArchTruncateDoubleToI:
__ TruncateDoubleToI(i.OutputRegister(), i.InputDoubleRegister(0));
break;
+ case kArm64Float64Ceil:
+ __ Frintp(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ break;
+ case kArm64Float64Floor:
+ __ Frintm(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ break;
+ case kArm64Float64RoundTruncate:
+ __ Frintz(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ break;
+ case kArm64Float64RoundTiesAway:
+ __ Frinta(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ break;
case kArm64Add:
- __ Add(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Add(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Add32:
if (FlagsModeField::decode(opcode) != kFlags_none) {
__ Adds(i.OutputRegister32(), i.InputRegister32(0),
- i.InputOperand32(1));
+ i.InputOperand2_32(1));
} else {
- __ Add(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Add(i.OutputRegister32(), i.InputRegister32(0),
+ i.InputOperand2_32(1));
}
break;
case kArm64And:
- __ And(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ And(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64And32:
- __ And(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ And(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Bic:
- __ Bic(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Bic(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Bic32:
- __ Bic(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Bic(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Mul:
__ Mul(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
case kArm64Mul32:
__ Mul(i.OutputRegister32(), i.InputRegister32(0), i.InputRegister32(1));
break;
+ case kArm64Smull:
+ __ Smull(i.OutputRegister(), i.InputRegister32(0), i.InputRegister32(1));
+ break;
+ case kArm64Umull:
+ __ Umull(i.OutputRegister(), i.InputRegister32(0), i.InputRegister32(1));
+ break;
case kArm64Madd:
__ Madd(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1),
i.InputRegister(2));
__ Neg(i.OutputRegister32(), i.InputOperand32(0));
break;
case kArm64Or:
- __ Orr(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Orr(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Or32:
- __ Orr(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Orr(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Orn:
- __ Orn(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Orn(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Orn32:
- __ Orn(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Orn(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Eor:
- __ Eor(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Eor(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Eor32:
- __ Eor(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Eor(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Eon:
- __ Eon(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Eon(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Eon32:
- __ Eon(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Eon(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand2_32(1));
break;
case kArm64Sub:
- __ Sub(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ __ Sub(i.OutputRegister(), i.InputRegister(0), i.InputOperand2_64(1));
break;
case kArm64Sub32:
if (FlagsModeField::decode(opcode) != kFlags_none) {
__ Subs(i.OutputRegister32(), i.InputRegister32(0),
- i.InputOperand32(1));
+ i.InputOperand2_32(1));
} else {
- __ Sub(i.OutputRegister32(), i.InputRegister32(0), i.InputOperand32(1));
+ __ Sub(i.OutputRegister32(), i.InputRegister32(0),
+ i.InputOperand2_32(1));
}
break;
- case kArm64Shl:
+ case kArm64Lsl:
ASSEMBLE_SHIFT(Lsl, 64);
break;
- case kArm64Shl32:
+ case kArm64Lsl32:
ASSEMBLE_SHIFT(Lsl, 32);
break;
- case kArm64Shr:
+ case kArm64Lsr:
ASSEMBLE_SHIFT(Lsr, 64);
break;
- case kArm64Shr32:
+ case kArm64Lsr32:
ASSEMBLE_SHIFT(Lsr, 32);
break;
- case kArm64Sar:
+ case kArm64Asr:
ASSEMBLE_SHIFT(Asr, 64);
break;
- case kArm64Sar32:
+ case kArm64Asr32:
ASSEMBLE_SHIFT(Asr, 32);
break;
case kArm64Ror:
case kArm64Sxtw:
__ Sxtw(i.OutputRegister(), i.InputRegister32(0));
break;
+ case kArm64Ubfx:
+ __ Ubfx(i.OutputRegister(), i.InputRegister(0), i.InputInt8(1),
+ i.InputInt8(2));
+ break;
+ case kArm64Ubfx32:
+ __ Ubfx(i.OutputRegister32(), i.InputRegister32(0), i.InputInt8(1),
+ i.InputInt8(2));
+ break;
+ case kArm64Tbz:
+ ASSEMBLE_TEST_AND_BRANCH(Tbz, 64);
+ break;
+ case kArm64Tbz32:
+ ASSEMBLE_TEST_AND_BRANCH(Tbz, 32);
+ break;
+ case kArm64Tbnz:
+ ASSEMBLE_TEST_AND_BRANCH(Tbnz, 64);
+ break;
+ case kArm64Tbnz32:
+ ASSEMBLE_TEST_AND_BRANCH(Tbnz, 32);
+ break;
case kArm64Claim: {
int words = MiscField::decode(instr->opcode());
__ Claim(words);
Register value = i.InputRegister(2);
__ Add(index, object, Operand(index, SXTW));
__ Str(value, MemOperand(index));
- SaveFPRegsMode mode = code_->frame()->DidAllocateDoubleRegisters()
- ? kSaveFPRegs
- : kDontSaveFPRegs;
+ SaveFPRegsMode mode =
+ frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
// TODO(dcarney): we shouldn't test write barriers from c calls.
LinkRegisterStatus lr_status = kLRHasNotBeenSaved;
UseScratchRegisterScope scope(masm());
// Emit a branch. The true and false targets are always the last two inputs
// to the instruction.
- BasicBlock* tblock = i.InputBlock(instr->InputCount() - 2);
- BasicBlock* fblock = i.InputBlock(instr->InputCount() - 1);
+ BasicBlock::RpoNumber tblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
+ BasicBlock::RpoNumber fblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
bool fallthru = IsNextInAssemblyOrder(fblock);
- Label* tlabel = code()->GetLabel(tblock);
- Label* flabel = fallthru ? &done : code()->GetLabel(fblock);
+ Label* tlabel = GetLabel(tblock);
+ Label* flabel = fallthru ? &done : GetLabel(fblock);
switch (condition) {
case kUnorderedEqual:
__ B(vs, flabel);
__ PushCalleeSavedRegisters();
frame()->SetRegisterSaveAreaSize(20 * kPointerSize);
} else if (descriptor->IsJSFunctionCall()) {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
__ SetStackPointer(jssp);
__ Prologue(info->IsCodePreAgingActive());
frame()->SetRegisterSaveAreaSize(
void CodeGenerator::EnsureSpaceForLazyDeopt() {
int space_needed = Deoptimizer::patch_size();
- if (!linkage()->info()->IsStub()) {
+ if (!info()->IsStub()) {
// Ensure that we have enough space after the previous lazy-bailout
// instruction for patching the code here.
intptr_t current_pc = masm()->pc_offset();
V(Arm64Sub32) \
V(Arm64Mul) \
V(Arm64Mul32) \
+ V(Arm64Smull) \
+ V(Arm64Umull) \
V(Arm64Madd) \
V(Arm64Madd32) \
V(Arm64Msub) \
V(Arm64Not32) \
V(Arm64Neg) \
V(Arm64Neg32) \
- V(Arm64Shl) \
- V(Arm64Shl32) \
- V(Arm64Shr) \
- V(Arm64Shr32) \
- V(Arm64Sar) \
- V(Arm64Sar32) \
+ V(Arm64Lsl) \
+ V(Arm64Lsl32) \
+ V(Arm64Lsr) \
+ V(Arm64Lsr32) \
+ V(Arm64Asr) \
+ V(Arm64Asr32) \
V(Arm64Ror) \
V(Arm64Ror32) \
V(Arm64Mov32) \
V(Arm64Sxtw) \
+ V(Arm64Ubfx) \
+ V(Arm64Ubfx32) \
+ V(Arm64Tbz) \
+ V(Arm64Tbz32) \
+ V(Arm64Tbnz) \
+ V(Arm64Tbnz32) \
V(Arm64Claim) \
V(Arm64Poke) \
V(Arm64PokePairZero) \
V(Arm64Float64Div) \
V(Arm64Float64Mod) \
V(Arm64Float64Sqrt) \
+ V(Arm64Float64Floor) \
+ V(Arm64Float64Ceil) \
+ V(Arm64Float64RoundTruncate) \
+ V(Arm64Float64RoundTiesAway) \
V(Arm64Float32ToFloat64) \
V(Arm64Float64ToFloat32) \
V(Arm64Float64ToInt32) \
// I = immediate (handle, external, int32)
// MRI = [register + immediate]
// MRR = [register + register]
-#define TARGET_ADDRESSING_MODE_LIST(V) \
- V(MRI) /* [%r0 + K] */ \
- V(MRR) /* [%r0 + %r1] */
+#define TARGET_ADDRESSING_MODE_LIST(V) \
+ V(MRI) /* [%r0 + K] */ \
+ V(MRR) /* [%r0 + %r1] */ \
+ V(Operand2_R_LSL_I) /* %r0 LSL K */ \
+ V(Operand2_R_LSR_I) /* %r0 LSR K */ \
+ V(Operand2_R_ASR_I) /* %r0 ASR K */ \
+ V(Operand2_R_ROR_I) /* %r0 ROR K */
} // namespace internal
} // namespace compiler
value = OpParameter<int64_t>(node);
else
return false;
+ return CanBeImmediate(value, mode);
+ }
+
+ bool CanBeImmediate(int64_t value, ImmediateMode mode) {
unsigned ignored;
switch (mode) {
case kLogical32Imm:
return Assembler::IsImmLogical(static_cast<uint64_t>(value), 64,
&ignored, &ignored, &ignored);
case kArithmeticImm:
- // TODO(dcarney): -values can be handled by instruction swapping
return Assembler::IsImmAddSub(value);
case kShift32Imm:
return 0 <= value && value < 32;
};
+static void VisitRRFloat64(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ Arm64OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)));
+}
+
+
static void VisitRRR(InstructionSelector* selector, ArchOpcode opcode,
Node* node) {
Arm64OperandGenerator g(selector);
}
+template <typename Matcher>
+static bool TryMatchShift(InstructionSelector* selector, Node* node,
+ InstructionCode* opcode, IrOpcode::Value shift_opcode,
+ ImmediateMode imm_mode,
+ AddressingMode addressing_mode) {
+ if (node->opcode() != shift_opcode) return false;
+ Arm64OperandGenerator g(selector);
+ Matcher m(node);
+ if (g.CanBeImmediate(m.right().node(), imm_mode)) {
+ *opcode |= AddressingModeField::encode(addressing_mode);
+ return true;
+ }
+ return false;
+}
+
+
+static bool TryMatchAnyShift(InstructionSelector* selector, Node* node,
+ InstructionCode* opcode, bool try_ror) {
+ return TryMatchShift<Int32BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord32Shl, kShift32Imm,
+ kMode_Operand2_R_LSL_I) ||
+ TryMatchShift<Int32BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord32Shr, kShift32Imm,
+ kMode_Operand2_R_LSR_I) ||
+ TryMatchShift<Int32BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord32Sar, kShift32Imm,
+ kMode_Operand2_R_ASR_I) ||
+ (try_ror && TryMatchShift<Int32BinopMatcher>(
+ selector, node, opcode, IrOpcode::kWord32Ror,
+ kShift32Imm, kMode_Operand2_R_ROR_I)) ||
+ TryMatchShift<Int64BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord64Shl, kShift64Imm,
+ kMode_Operand2_R_LSL_I) ||
+ TryMatchShift<Int64BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord64Shr, kShift64Imm,
+ kMode_Operand2_R_LSR_I) ||
+ TryMatchShift<Int64BinopMatcher>(selector, node, opcode,
+ IrOpcode::kWord64Sar, kShift64Imm,
+ kMode_Operand2_R_ASR_I) ||
+ (try_ror && TryMatchShift<Int64BinopMatcher>(
+ selector, node, opcode, IrOpcode::kWord64Ror,
+ kShift64Imm, kMode_Operand2_R_ROR_I));
+}
+
+
// Shared routine for multiple binary operations.
template <typename Matcher>
static void VisitBinop(InstructionSelector* selector, Node* node,
size_t input_count = 0;
InstructionOperand* outputs[2];
size_t output_count = 0;
+ bool try_ror_operand = true;
+
+ if (m.IsInt32Add() || m.IsInt64Add() || m.IsInt32Sub() || m.IsInt64Sub()) {
+ try_ror_operand = false;
+ }
- inputs[input_count++] = g.UseRegister(m.left().node());
- inputs[input_count++] = g.UseOperand(m.right().node(), operand_mode);
+ if (g.CanBeImmediate(m.right().node(), operand_mode)) {
+ inputs[input_count++] = g.UseRegister(m.left().node());
+ inputs[input_count++] = g.UseImmediate(m.right().node());
+ } else if (TryMatchAnyShift(selector, m.right().node(), &opcode,
+ try_ror_operand)) {
+ Matcher m_shift(m.right().node());
+ inputs[input_count++] = g.UseRegister(m.left().node());
+ inputs[input_count++] = g.UseRegister(m_shift.left().node());
+ inputs[input_count++] = g.UseImmediate(m_shift.right().node());
+ } else if (m.HasProperty(Operator::kCommutative) &&
+ TryMatchAnyShift(selector, m.left().node(), &opcode,
+ try_ror_operand)) {
+ Matcher m_shift(m.left().node());
+ inputs[input_count++] = g.UseRegister(m.right().node());
+ inputs[input_count++] = g.UseRegister(m_shift.left().node());
+ inputs[input_count++] = g.UseImmediate(m_shift.right().node());
+ } else {
+ inputs[input_count++] = g.UseRegister(m.left().node());
+ inputs[input_count++] = g.UseRegister(m.right().node());
+ }
if (cont->IsBranch()) {
inputs[input_count++] = g.Label(cont->true_block());
}
+template <typename Matcher>
+static void VisitAddSub(InstructionSelector* selector, Node* node,
+ ArchOpcode opcode, ArchOpcode negate_opcode) {
+ Arm64OperandGenerator g(selector);
+ Matcher m(node);
+ if (m.right().HasValue() && (m.right().Value() < 0) &&
+ g.CanBeImmediate(-m.right().Value(), kArithmeticImm)) {
+ selector->Emit(negate_opcode, g.DefineAsRegister(node),
+ g.UseRegister(m.left().node()),
+ g.TempImmediate(-m.right().Value()));
+ } else {
+ VisitBinop<Matcher>(selector, node, opcode, kArithmeticImm);
+ }
+}
+
+
void InstructionSelector::VisitLoad(Node* node) {
MachineType rep = RepresentationOf(OpParameter<LoadRepresentation>(node));
MachineType typ = TypeOf(OpParameter<LoadRepresentation>(node));
void InstructionSelector::VisitWord32And(Node* node) {
+ Arm64OperandGenerator g(this);
Int32BinopMatcher m(node);
+ if (m.left().IsWord32Shr() && CanCover(node, m.left().node()) &&
+ m.right().HasValue()) {
+ uint32_t mask = m.right().Value();
+ uint32_t mask_width = base::bits::CountPopulation32(mask);
+ uint32_t mask_msb = base::bits::CountLeadingZeros32(mask);
+ if ((mask_width != 0) && (mask_msb + mask_width == 32)) {
+ // The mask must be contiguous, and occupy the least-significant bits.
+ DCHECK_EQ(0, base::bits::CountTrailingZeros32(mask));
+
+ // Select Ubfx for And(Shr(x, imm), mask) where the mask is in the least
+ // significant bits.
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().IsInRange(0, 31)) {
+ // Ubfx cannot extract bits past the register size, however since
+ // shifting the original value would have introduced some zeros we can
+ // still use ubfx with a smaller mask and the remaining bits will be
+ // zeros.
+ uint32_t lsb = mleft.right().Value();
+ if (lsb + mask_width > 32) mask_width = 32 - lsb;
+
+ Emit(kArm64Ubfx32, g.DefineAsRegister(node),
+ g.UseRegister(mleft.left().node()),
+ g.UseImmediate(mleft.right().node()), g.TempImmediate(mask_width));
+ return;
+ }
+ // Other cases fall through to the normal And operation.
+ }
+ }
VisitLogical<Int32BinopMatcher>(
this, node, &m, kArm64And32, CanCover(node, m.left().node()),
CanCover(node, m.right().node()), kLogical32Imm);
void InstructionSelector::VisitWord64And(Node* node) {
+ Arm64OperandGenerator g(this);
Int64BinopMatcher m(node);
+ if (m.left().IsWord64Shr() && CanCover(node, m.left().node()) &&
+ m.right().HasValue()) {
+ uint64_t mask = m.right().Value();
+ uint64_t mask_width = base::bits::CountPopulation64(mask);
+ uint64_t mask_msb = base::bits::CountLeadingZeros64(mask);
+ if ((mask_width != 0) && (mask_msb + mask_width == 64)) {
+ // The mask must be contiguous, and occupy the least-significant bits.
+ DCHECK_EQ(0, base::bits::CountTrailingZeros64(mask));
+
+ // Select Ubfx for And(Shr(x, imm), mask) where the mask is in the least
+ // significant bits.
+ Int64BinopMatcher mleft(m.left().node());
+ if (mleft.right().IsInRange(0, 63)) {
+ // Ubfx cannot extract bits past the register size, however since
+ // shifting the original value would have introduced some zeros we can
+ // still use ubfx with a smaller mask and the remaining bits will be
+ // zeros.
+ uint64_t lsb = mleft.right().Value();
+ if (lsb + mask_width > 64) mask_width = 64 - lsb;
+
+ Emit(kArm64Ubfx, g.DefineAsRegister(node),
+ g.UseRegister(mleft.left().node()),
+ g.UseImmediate(mleft.right().node()), g.TempImmediate(mask_width));
+ return;
+ }
+ // Other cases fall through to the normal And operation.
+ }
+ }
VisitLogical<Int64BinopMatcher>(
this, node, &m, kArm64And, CanCover(node, m.left().node()),
CanCover(node, m.right().node()), kLogical64Imm);
void InstructionSelector::VisitWord32Shl(Node* node) {
- VisitRRO(this, kArm64Shl32, node, kShift32Imm);
+ VisitRRO(this, kArm64Lsl32, node, kShift32Imm);
}
void InstructionSelector::VisitWord64Shl(Node* node) {
- VisitRRO(this, kArm64Shl, node, kShift64Imm);
+ VisitRRO(this, kArm64Lsl, node, kShift64Imm);
}
void InstructionSelector::VisitWord32Shr(Node* node) {
- VisitRRO(this, kArm64Shr32, node, kShift32Imm);
+ Arm64OperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ if (m.left().IsWord32And() && m.right().IsInRange(0, 31)) {
+ int32_t lsb = m.right().Value();
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().HasValue()) {
+ uint32_t mask = (mleft.right().Value() >> lsb) << lsb;
+ uint32_t mask_width = base::bits::CountPopulation32(mask);
+ uint32_t mask_msb = base::bits::CountLeadingZeros32(mask);
+ // Select Ubfx for Shr(And(x, mask), imm) where the result of the mask is
+ // shifted into the least-significant bits.
+ if ((mask_msb + mask_width + lsb) == 32) {
+ DCHECK_EQ(lsb, base::bits::CountTrailingZeros32(mask));
+ Emit(kArm64Ubfx32, g.DefineAsRegister(node),
+ g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
+ g.TempImmediate(mask_width));
+ return;
+ }
+ }
+ }
+ VisitRRO(this, kArm64Lsr32, node, kShift32Imm);
}
void InstructionSelector::VisitWord64Shr(Node* node) {
- VisitRRO(this, kArm64Shr, node, kShift64Imm);
+ Arm64OperandGenerator g(this);
+ Int64BinopMatcher m(node);
+ if (m.left().IsWord64And() && m.right().IsInRange(0, 63)) {
+ int64_t lsb = m.right().Value();
+ Int64BinopMatcher mleft(m.left().node());
+ if (mleft.right().HasValue()) {
+ // Select Ubfx for Shr(And(x, mask), imm) where the result of the mask is
+ // shifted into the least-significant bits.
+ uint64_t mask = (mleft.right().Value() >> lsb) << lsb;
+ uint64_t mask_width = base::bits::CountPopulation64(mask);
+ uint64_t mask_msb = base::bits::CountLeadingZeros64(mask);
+ if ((mask_msb + mask_width + lsb) == 64) {
+ DCHECK_EQ(lsb, base::bits::CountTrailingZeros64(mask));
+ Emit(kArm64Ubfx, g.DefineAsRegister(node),
+ g.UseRegister(mleft.left().node()), g.TempImmediate(lsb),
+ g.TempImmediate(mask_width));
+ return;
+ }
+ }
+ }
+ VisitRRO(this, kArm64Lsr, node, kShift64Imm);
}
void InstructionSelector::VisitWord32Sar(Node* node) {
- VisitRRO(this, kArm64Sar32, node, kShift32Imm);
+ VisitRRO(this, kArm64Asr32, node, kShift32Imm);
}
void InstructionSelector::VisitWord64Sar(Node* node) {
- VisitRRO(this, kArm64Sar, node, kShift64Imm);
+ VisitRRO(this, kArm64Asr, node, kShift64Imm);
}
g.UseRegister(mright.right().node()), g.UseRegister(m.left().node()));
return;
}
- VisitBinop<Int32BinopMatcher>(this, node, kArm64Add32, kArithmeticImm);
+ VisitAddSub<Int32BinopMatcher>(this, node, kArm64Add32, kArm64Sub32);
}
g.UseRegister(mright.right().node()), g.UseRegister(m.left().node()));
return;
}
- VisitBinop<Int64BinopMatcher>(this, node, kArm64Add, kArithmeticImm);
+ VisitAddSub<Int64BinopMatcher>(this, node, kArm64Add, kArm64Sub);
}
Emit(kArm64Neg32, g.DefineAsRegister(node),
g.UseRegister(m.right().node()));
} else {
- VisitBinop<Int32BinopMatcher>(this, node, kArm64Sub32, kArithmeticImm);
+ VisitAddSub<Int32BinopMatcher>(this, node, kArm64Sub32, kArm64Add32);
}
}
if (m.left().Is(0)) {
Emit(kArm64Neg, g.DefineAsRegister(node), g.UseRegister(m.right().node()));
} else {
- VisitBinop<Int64BinopMatcher>(this, node, kArm64Sub, kArithmeticImm);
+ VisitAddSub<Int64BinopMatcher>(this, node, kArm64Sub, kArm64Add);
}
}
}
+void InstructionSelector::VisitInt32MulHigh(Node* node) {
+ // TODO(arm64): Can we do better here?
+ Arm64OperandGenerator g(this);
+ InstructionOperand* const smull_operand = g.TempRegister();
+ Emit(kArm64Smull, smull_operand, g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+ Emit(kArm64Asr, g.DefineAsRegister(node), smull_operand, g.TempImmediate(32));
+}
+
+
+void InstructionSelector::VisitUint32MulHigh(Node* node) {
+ // TODO(arm64): Can we do better here?
+ Arm64OperandGenerator g(this);
+ InstructionOperand* const smull_operand = g.TempRegister();
+ Emit(kArm64Umull, smull_operand, g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+ Emit(kArm64Lsr, g.DefineAsRegister(node), smull_operand, g.TempImmediate(32));
+}
+
+
void InstructionSelector::VisitInt32Div(Node* node) {
VisitRRR(this, kArm64Idiv32, node);
}
}
-void InstructionSelector::VisitInt32UDiv(Node* node) {
+void InstructionSelector::VisitUint32Div(Node* node) {
VisitRRR(this, kArm64Udiv32, node);
}
-void InstructionSelector::VisitInt64UDiv(Node* node) {
+void InstructionSelector::VisitUint64Div(Node* node) {
VisitRRR(this, kArm64Udiv, node);
}
}
-void InstructionSelector::VisitInt32UMod(Node* node) {
+void InstructionSelector::VisitUint32Mod(Node* node) {
VisitRRR(this, kArm64Umod32, node);
}
-void InstructionSelector::VisitInt64UMod(Node* node) {
+void InstructionSelector::VisitUint64Mod(Node* node) {
VisitRRR(this, kArm64Umod, node);
}
void InstructionSelector::VisitFloat64Sqrt(Node* node) {
- Arm64OperandGenerator g(this);
- Emit(kArm64Float64Sqrt, g.DefineAsRegister(node),
- g.UseRegister(node->InputAt(0)));
+ VisitRRFloat64(this, kArm64Float64Sqrt, node);
}
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop<Int32BinopMatcher>(this, node, kArm64Add32, kArithmeticImm, cont);
+void InstructionSelector::VisitFloat64Floor(Node* node) {
+ VisitRRFloat64(this, kArm64Float64Floor, node);
}
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop<Int32BinopMatcher>(this, node, kArm64Sub32, kArithmeticImm, cont);
+void InstructionSelector::VisitFloat64Ceil(Node* node) {
+ VisitRRFloat64(this, kArm64Float64Ceil, node);
}
-// Shared routine for multiple compare operations.
-static void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
- InstructionOperand* left, InstructionOperand* right,
- FlagsContinuation* cont) {
- Arm64OperandGenerator g(selector);
- opcode = cont->Encode(opcode);
- if (cont->IsBranch()) {
- selector->Emit(opcode, NULL, left, right, g.Label(cont->true_block()),
- g.Label(cont->false_block()))->MarkAsControl();
- } else {
- DCHECK(cont->IsSet());
- selector->Emit(opcode, g.DefineAsRegister(cont->result()), left, right);
- }
+void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
+ VisitRRFloat64(this, kArm64Float64RoundTruncate, node);
}
-// Shared routine for multiple word compare operations.
-static void VisitWordCompare(InstructionSelector* selector, Node* node,
- InstructionCode opcode, FlagsContinuation* cont,
- bool commutative) {
- Arm64OperandGenerator g(selector);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
-
- // Match immediates on left or right side of comparison.
- if (g.CanBeImmediate(right, kArithmeticImm)) {
- VisitCompare(selector, opcode, g.UseRegister(left), g.UseImmediate(right),
- cont);
- } else if (g.CanBeImmediate(left, kArithmeticImm)) {
- if (!commutative) cont->Commute();
- VisitCompare(selector, opcode, g.UseRegister(right), g.UseImmediate(left),
- cont);
- } else {
- VisitCompare(selector, opcode, g.UseRegister(left), g.UseRegister(right),
- cont);
- }
+void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
+ VisitRRFloat64(this, kArm64Float64RoundTiesAway, node);
}
-void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kInt32Add:
- return VisitWordCompare(this, node, kArm64Cmn32, cont, true);
- case IrOpcode::kInt32Sub:
- return VisitWordCompare(this, node, kArm64Cmp32, cont, false);
- case IrOpcode::kWord32And:
- return VisitWordCompare(this, node, kArm64Tst32, cont, true);
- default:
- break;
- }
-
+void InstructionSelector::VisitCall(Node* node) {
Arm64OperandGenerator g(this);
- VisitCompare(this, kArm64Tst32, g.UseRegister(node), g.UseRegister(node),
- cont);
-}
-
-
-void InstructionSelector::VisitWord64Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kWord64And:
- return VisitWordCompare(this, node, kArm64Tst, cont, true);
- default:
- break;
- }
-
- Arm64OperandGenerator g(this);
- VisitCompare(this, kArm64Tst, g.UseRegister(node), g.UseRegister(node), cont);
-}
-
-
-void InstructionSelector::VisitWord32Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kArm64Cmp32, cont, false);
-}
-
-
-void InstructionSelector::VisitWord64Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kArm64Cmp, cont, false);
-}
-
-
-void InstructionSelector::VisitFloat64Compare(Node* node,
- FlagsContinuation* cont) {
- Arm64OperandGenerator g(this);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
- VisitCompare(this, kArm64Float64Cmp, g.UseRegister(left),
- g.UseRegister(right), cont);
-}
-
-
-void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization) {
- Arm64OperandGenerator g(this);
- CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call);
+ CallDescriptor* descriptor = OpParameter<CallDescriptor*>(node);
FrameStateDescriptor* frame_state_descriptor = NULL;
if (descriptor->NeedsFrameState()) {
frame_state_descriptor =
- GetFrameStateDescriptor(call->InputAt(descriptor->InputCount()));
+ GetFrameStateDescriptor(node->InputAt(descriptor->InputCount()));
}
CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
// TODO(turbofan): on ARM64 it's probably better to use the code object in a
// register if there are multiple uses of it. Improve constant pool and the
// heuristics in the register allocator for where to emit constants.
- InitializeCallBuffer(call, &buffer, true, false);
+ InitializeCallBuffer(node, &buffer, true, false);
// Push the arguments to the stack.
bool pushed_count_uneven = buffer.pushed_nodes.size() & 1;
opcode |= MiscField::encode(descriptor->flags());
// Emit the call instruction.
+ InstructionOperand** first_output =
+ buffer.outputs.size() > 0 ? &buffer.outputs.front() : NULL;
Instruction* call_instr =
- Emit(opcode, buffer.outputs.size(), &buffer.outputs.front(),
+ Emit(opcode, buffer.outputs.size(), first_output,
buffer.instruction_args.size(), &buffer.instruction_args.front());
-
call_instr->MarkAsCall();
- if (deoptimization != NULL) {
- DCHECK(continuation != NULL);
- call_instr->MarkAsControl();
+}
+
+
+// Shared routine for multiple compare operations.
+static void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
+ InstructionOperand* left, InstructionOperand* right,
+ FlagsContinuation* cont) {
+ Arm64OperandGenerator g(selector);
+ opcode = cont->Encode(opcode);
+ if (cont->IsBranch()) {
+ selector->Emit(opcode, NULL, left, right, g.Label(cont->true_block()),
+ g.Label(cont->false_block()))->MarkAsControl();
+ } else {
+ DCHECK(cont->IsSet());
+ selector->Emit(opcode, g.DefineAsRegister(cont->result()), left, right);
+ }
+}
+
+
+// Shared routine for multiple word compare operations.
+static void VisitWordCompare(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont,
+ bool commutative, ImmediateMode immediate_mode) {
+ Arm64OperandGenerator g(selector);
+ Node* left = node->InputAt(0);
+ Node* right = node->InputAt(1);
+
+ // Match immediates on left or right side of comparison.
+ if (g.CanBeImmediate(right, immediate_mode)) {
+ VisitCompare(selector, opcode, g.UseRegister(left), g.UseImmediate(right),
+ cont);
+ } else if (g.CanBeImmediate(left, immediate_mode)) {
+ if (!commutative) cont->Commute();
+ VisitCompare(selector, opcode, g.UseRegister(right), g.UseImmediate(left),
+ cont);
+ } else {
+ VisitCompare(selector, opcode, g.UseRegister(left), g.UseRegister(right),
+ cont);
}
}
+
+static void VisitWord32Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordCompare(selector, node, kArm64Cmp32, cont, false, kArithmeticImm);
+}
+
+
+static void VisitWordTest(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont) {
+ Arm64OperandGenerator g(selector);
+ VisitCompare(selector, opcode, g.UseRegister(node), g.UseRegister(node),
+ cont);
+}
+
+
+static void VisitWord32Test(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordTest(selector, node, kArm64Tst32, cont);
+}
+
+
+static void VisitWord64Test(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordTest(selector, node, kArm64Tst, cont);
+}
+
+
+// Shared routine for multiple float compare operations.
+static void VisitFloat64Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ Arm64OperandGenerator g(selector);
+ Node* left = node->InputAt(0);
+ Node* right = node->InputAt(1);
+ VisitCompare(selector, kArm64Float64Cmp, g.UseRegister(left),
+ g.UseRegister(right), cont);
+}
+
+
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
+ OperandGenerator g(this);
+ Node* user = branch;
+ Node* value = branch->InputAt(0);
+
+ FlagsContinuation cont(kNotEqual, tbranch, fbranch);
+
+ // If we can fall through to the true block, invert the branch.
+ if (IsNextInAssemblyOrder(tbranch)) {
+ cont.Negate();
+ cont.SwapBlocks();
+ }
+
+ // Try to combine with comparisons against 0 by simply inverting the branch.
+ while (CanCover(user, value)) {
+ if (value->opcode() == IrOpcode::kWord32Equal) {
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ } else if (value->opcode() == IrOpcode::kWord64Equal) {
+ Int64BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ // Try to combine the branch with a comparison.
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord32Equal:
+ cont.OverwriteAndNegateIfEqual(kEqual);
+ return VisitWord32Compare(this, value, &cont);
+ case IrOpcode::kInt32LessThan:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWord32Compare(this, value, &cont);
+ case IrOpcode::kInt32LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWord32Compare(this, value, &cont);
+ case IrOpcode::kUint32LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWord32Compare(this, value, &cont);
+ case IrOpcode::kUint32LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
+ return VisitWord32Compare(this, value, &cont);
+ case IrOpcode::kWord64Equal:
+ cont.OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(this, value, kArm64Cmp, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kInt64LessThan:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(this, value, kArm64Cmp, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kInt64LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(this, value, kArm64Cmp, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kUint64LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(this, value, kArm64Cmp, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kFloat64Equal:
+ cont.OverwriteAndNegateIfEqual(kUnorderedEqual);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kFloat64LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnorderedLessThan);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kFloat64LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kProjection:
+ // Check if this is the overflow output projection of an
+ // <Operation>WithOverflow node.
+ if (OpParameter<size_t>(value) == 1u) {
+ // We cannot combine the <Operation>WithOverflow with this branch
+ // unless the 0th projection (the use of the actual value of the
+ // <Operation> is either NULL, which means there's no use of the
+ // actual value, or was already defined, which means it is scheduled
+ // *AFTER* this branch).
+ Node* node = value->InputAt(0);
+ Node* result = node->FindProjection(0);
+ if (result == NULL || IsDefined(result)) {
+ switch (node->opcode()) {
+ case IrOpcode::kInt32AddWithOverflow:
+ cont.OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop<Int32BinopMatcher>(this, node, kArm64Add32,
+ kArithmeticImm, &cont);
+ case IrOpcode::kInt32SubWithOverflow:
+ cont.OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop<Int32BinopMatcher>(this, node, kArm64Sub32,
+ kArithmeticImm, &cont);
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case IrOpcode::kInt32Add:
+ return VisitWordCompare(this, value, kArm64Cmn32, &cont, true,
+ kArithmeticImm);
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(this, value, kArm64Cmp32, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kWord32And: {
+ Int32BinopMatcher m(value);
+ if (m.right().HasValue() &&
+ (base::bits::CountPopulation32(m.right().Value()) == 1)) {
+ // If the mask has only one bit set, we can use tbz/tbnz.
+ DCHECK((cont.condition() == kEqual) ||
+ (cont.condition() == kNotEqual));
+ ArchOpcode opcode =
+ (cont.condition() == kEqual) ? kArm64Tbz32 : kArm64Tbnz32;
+ Emit(opcode, NULL, g.UseRegister(m.left().node()),
+ g.TempImmediate(
+ base::bits::CountTrailingZeros32(m.right().Value())),
+ g.Label(cont.true_block()),
+ g.Label(cont.false_block()))->MarkAsControl();
+ return;
+ }
+ return VisitWordCompare(this, value, kArm64Tst32, &cont, true,
+ kLogical32Imm);
+ }
+ case IrOpcode::kWord64And: {
+ Int64BinopMatcher m(value);
+ if (m.right().HasValue() &&
+ (base::bits::CountPopulation64(m.right().Value()) == 1)) {
+ // If the mask has only one bit set, we can use tbz/tbnz.
+ DCHECK((cont.condition() == kEqual) ||
+ (cont.condition() == kNotEqual));
+ ArchOpcode opcode =
+ (cont.condition() == kEqual) ? kArm64Tbz : kArm64Tbnz;
+ Emit(opcode, NULL, g.UseRegister(m.left().node()),
+ g.TempImmediate(
+ base::bits::CountTrailingZeros64(m.right().Value())),
+ g.Label(cont.true_block()),
+ g.Label(cont.false_block()))->MarkAsControl();
+ return;
+ }
+ return VisitWordCompare(this, value, kArm64Tst, &cont, true,
+ kLogical64Imm);
+ }
+ default:
+ break;
+ }
+ }
+
+ // Branch could not be combined with a compare, emit compare against 0.
+ VisitWord32Test(this, value, &cont);
+}
+
+
+void InstructionSelector::VisitWord32Equal(Node* const node) {
+ Node* const user = node;
+ FlagsContinuation cont(kEqual, node);
+ Int32BinopMatcher m(user);
+ if (m.right().Is(0)) {
+ Node* const value = m.left().node();
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kInt32Add:
+ return VisitWordCompare(this, value, kArm64Cmn32, &cont, true,
+ kArithmeticImm);
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(this, value, kArm64Cmp32, &cont, false,
+ kArithmeticImm);
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(this, value, kArm64Tst32, &cont, true,
+ kLogical32Imm);
+ default:
+ break;
+ }
+ return VisitWord32Test(this, value, &cont);
+ }
+ }
+ VisitWord32Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWord32Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWord32Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWord32Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
+ VisitWord32Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitWord64Equal(Node* const node) {
+ Node* const user = node;
+ FlagsContinuation cont(kEqual, node);
+ Int64BinopMatcher m(user);
+ if (m.right().Is(0)) {
+ Node* const value = m.left().node();
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord64And:
+ return VisitWordCompare(this, value, kArm64Tst, &cont, true,
+ kLogical64Imm);
+ default:
+ break;
+ }
+ return VisitWord64Test(this, value, &cont);
+ }
+ }
+ VisitWordCompare(this, node, kArm64Cmp, &cont, false, kArithmeticImm);
+}
+
+
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop<Int32BinopMatcher>(this, node, kArm64Add32,
+ kArithmeticImm, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop<Int32BinopMatcher>(this, node, kArm64Add32, kArithmeticImm, &cont);
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop<Int32BinopMatcher>(this, node, kArm64Sub32,
+ kArithmeticImm, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop<Int32BinopMatcher>(this, node, kArm64Sub32, kArithmeticImm, &cont);
+}
+
+
+void InstructionSelector::VisitInt64LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, kArm64Cmp, &cont, false, kArithmeticImm);
+}
+
+
+void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, kArm64Cmp, &cont, false, kArithmeticImm);
+}
+
+
+void InstructionSelector::VisitUint64LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, kArm64Cmp, &cont, false, kArithmeticImm);
+}
+
+
+void InstructionSelector::VisitFloat64Equal(Node* node) {
+ FlagsContinuation cont(kUnorderedEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThan(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThan, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ return MachineOperatorBuilder::kFloat64Floor |
+ MachineOperatorBuilder::kFloat64Ceil |
+ MachineOperatorBuilder::kFloat64RoundTruncate |
+ MachineOperatorBuilder::kFloat64RoundTiesAway;
+}
} // namespace compiler
} // namespace internal
} // namespace v8
typedef LinkageHelper<Arm64LinkageHelperTraits> LH;
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone) {
- return LH::GetJSCallDescriptor(zone, parameter_count);
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
+ return LH::GetJSCallDescriptor(zone, parameter_count, flags);
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone) {
return LH::GetStubCallDescriptor(zone, descriptor, stack_parameter_count,
flags);
#include "src/compiler/ast-graph-builder.h"
#include "src/compiler.h"
+#include "src/compiler/ast-loop-assignment-analyzer.h"
#include "src/compiler/control-builders.h"
#include "src/compiler/machine-operator.h"
-#include "src/compiler/node-properties.h"
+#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/node-properties.h"
#include "src/full-codegen.h"
#include "src/parser.h"
#include "src/scopes.h"
namespace internal {
namespace compiler {
-AstGraphBuilder::AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph)
- : StructuredGraphBuilder(jsgraph->graph(), jsgraph->common()),
+AstGraphBuilder::AstGraphBuilder(Zone* local_zone, CompilationInfo* info,
+ JSGraph* jsgraph)
+ : StructuredGraphBuilder(local_zone, jsgraph->graph(), jsgraph->common()),
info_(info),
jsgraph_(jsgraph),
- globals_(0, info->zone()),
+ globals_(0, local_zone),
breakable_(NULL),
- execution_context_(NULL) {
- InitializeAstVisitor(info->zone());
+ execution_context_(NULL),
+ loop_assignment_analysis_(NULL) {
+ InitializeAstVisitor(local_zone);
}
int parameter_count = info()->num_parameters();
graph()->SetStart(graph()->NewNode(common()->Start(parameter_count)));
+ if (FLAG_loop_assignment_analysis) {
+ // TODO(turbofan): use a temporary zone for the loop assignment analysis.
+ AstLoopAssignmentAnalyzer analyzer(zone(), info());
+ loop_assignment_analysis_ = analyzer.Analyze();
+ }
+
// Initialize the top-level environment.
Environment env(this, scope, graph()->start());
set_environment(&env);
// Emit tracing call if requested to do so.
if (FLAG_trace) {
- NewNode(javascript()->Runtime(Runtime::kTraceEnter, 0));
+ NewNode(javascript()->CallRuntime(Runtime::kTraceEnter, 0));
}
// Visit implicit declaration of the function name.
// Visit declarations within the function scope.
VisitDeclarations(scope->declarations());
- // TODO(mstarzinger): This should do an inlined stack check.
- Node* node = NewNode(javascript()->Runtime(Runtime::kStackGuard, 0));
+ // Build a stack-check before the body.
+ Node* node = BuildStackCheck();
PrepareFrameState(node, BailoutId::FunctionEntry());
// Visit statements in the function body.
if (FLAG_trace) {
// TODO(mstarzinger): Only traces implicit return.
Node* return_value = jsgraph()->UndefinedConstant();
- NewNode(javascript()->Runtime(Runtime::kTraceExit, 1), return_value);
+ NewNode(javascript()->CallRuntime(Runtime::kTraceExit, 1), return_value);
}
// Return 'undefined' in case we can fall off the end.
void AstGraphBuilder::VisitForValue(Expression* expr) {
AstValueContext for_value(this);
- if (!HasStackOverflow()) {
+ if (!CheckStackOverflow()) {
expr->Accept(this);
+ } else {
+ ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
}
}
void AstGraphBuilder::VisitForEffect(Expression* expr) {
AstEffectContext for_effect(this);
- if (!HasStackOverflow()) {
+ if (!CheckStackOverflow()) {
expr->Accept(this);
+ } else {
+ ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
}
}
void AstGraphBuilder::VisitForTest(Expression* expr) {
AstTestContext for_condition(this);
- if (!HasStackOverflow()) {
+ if (!CheckStackOverflow()) {
+ expr->Accept(this);
+ } else {
+ ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
+ }
+}
+
+
+void AstGraphBuilder::Visit(Expression* expr) {
+ // Reuses enclosing AstContext.
+ if (!CheckStackOverflow()) {
expr->Accept(this);
+ } else {
+ ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
}
}
void AstGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
LoopBuilder while_loop(this);
- while_loop.BeginLoop();
+ while_loop.BeginLoop(GetVariablesAssignedInLoop(stmt));
VisitIterationBody(stmt, &while_loop, 0);
while_loop.EndBody();
VisitForTest(stmt->cond());
void AstGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
LoopBuilder while_loop(this);
- while_loop.BeginLoop();
+ while_loop.BeginLoop(GetVariablesAssignedInLoop(stmt));
VisitForTest(stmt->cond());
Node* condition = environment()->Pop();
while_loop.BreakUnless(condition);
void AstGraphBuilder::VisitForStatement(ForStatement* stmt) {
LoopBuilder for_loop(this);
VisitIfNotNull(stmt->init());
- for_loop.BeginLoop();
+ for_loop.BeginLoop(GetVariablesAssignedInLoop(stmt));
if (stmt->cond() != NULL) {
VisitForTest(stmt->cond());
Node* condition = environment()->Pop();
for_loop.BreakUnless(condition);
+ } else {
+ for_loop.BreakUnless(jsgraph()->TrueConstant());
}
VisitIterationBody(stmt, &for_loop, 0);
for_loop.EndBody();
// Convert object to jsobject.
// PrepareForBailoutForId(stmt->PrepareId(), TOS_REG);
obj = NewNode(javascript()->ToObject(), obj);
+ PrepareFrameState(obj, stmt->ToObjectId(), OutputFrameStateCombine::Push());
environment()->Push(obj);
// TODO(dcarney): should do a fast enum cache check here to skip runtime.
environment()->Push(obj);
Node* cache_type = ProcessArguments(
- javascript()->Runtime(Runtime::kGetPropertyNamesFast, 1), 1);
+ javascript()->CallRuntime(Runtime::kGetPropertyNamesFast, 1), 1);
+ PrepareFrameState(cache_type, stmt->EnumId(),
+ OutputFrameStateCombine::Push());
// TODO(dcarney): these next runtime calls should be removed in favour of
// a few simplified instructions.
environment()->Push(obj);
environment()->Push(cache_type);
Node* cache_pair =
- ProcessArguments(javascript()->Runtime(Runtime::kForInInit, 2), 2);
+ ProcessArguments(javascript()->CallRuntime(Runtime::kForInInit, 2), 2);
// cache_type may have been replaced.
Node* cache_array = NewNode(common()->Projection(0), cache_pair);
cache_type = NewNode(common()->Projection(1), cache_pair);
environment()->Push(cache_type);
environment()->Push(cache_array);
Node* cache_length = ProcessArguments(
- javascript()->Runtime(Runtime::kForInCacheArrayLength, 2), 2);
+ javascript()->CallRuntime(Runtime::kForInCacheArrayLength, 2), 2);
{
// TODO(dcarney): this check is actually supposed to be for the
// empty enum case only.
environment()->Push(jsgraph()->ZeroConstant());
// PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
LoopBuilder for_loop(this);
- for_loop.BeginLoop();
+ for_loop.BeginLoop(GetVariablesAssignedInLoop(stmt));
// Check loop termination condition.
Node* index = environment()->Peek(0);
Node* exit_cond =
environment()->Push(cache_array);
environment()->Push(cache_type);
environment()->Push(index);
- Node* pair =
- ProcessArguments(javascript()->Runtime(Runtime::kForInNext, 4), 4);
+ Node* pair = ProcessArguments(
+ javascript()->CallRuntime(Runtime::kForInNext, 4), 4);
Node* value = NewNode(common()->Projection(0), pair);
Node* should_filter = NewNode(common()->Projection(1), pair);
environment()->Push(value);
// result is either the string key or Smi(0) indicating the property
// is gone.
Node* res = ProcessArguments(
- javascript()->Call(3, NO_CALL_FUNCTION_FLAGS), 3);
+ javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS), 3);
// TODO(jarin): provide real bailout id.
PrepareFrameState(res, BailoutId::None());
Node* property_missing = NewNode(javascript()->StrictEqual(), res,
void AstGraphBuilder::VisitDebuggerStatement(DebuggerStatement* stmt) {
// TODO(turbofan): Do we really need a separate reloc-info for this?
- Node* node = NewNode(javascript()->Runtime(Runtime::kDebugBreak, 0));
+ Node* node = NewNode(javascript()->CallRuntime(Runtime::kDebugBreak, 0));
PrepareFrameState(node, stmt->DebugBreakId());
}
// Create node to instantiate a new closure.
Node* info = jsgraph()->Constant(shared_info);
- Node* pretenure = expr->pretenure() ? jsgraph()->TrueConstant()
- : jsgraph()->FalseConstant();
- const Operator* op = javascript()->Runtime(Runtime::kNewClosure, 3);
+ Node* pretenure = jsgraph()->BooleanConstant(expr->pretenure());
+ const Operator* op = javascript()->CallRuntime(Runtime::kNewClosure, 3);
Node* value = NewNode(op, context, info, pretenure);
ast_context()->ProduceValue(value);
}
void AstGraphBuilder::VisitClassLiteral(ClassLiteral* expr) {
- // TODO(arv): Implement.
UNREACHABLE();
}
void AstGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
- Node* value = BuildVariableLoad(expr->var(), expr->id());
+ VectorSlotPair pair = CreateVectorSlotPair(expr->VariableFeedbackSlot());
+ Node* value = BuildVariableLoad(expr->var(), expr->id(), pair);
ast_context()->ProduceValue(value);
}
Node* pattern = jsgraph()->Constant(expr->pattern());
Node* flags = jsgraph()->Constant(expr->flags());
const Operator* op =
- javascript()->Runtime(Runtime::kMaterializeRegExpLiteral, 4);
+ javascript()->CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, pattern, flags);
+ PrepareFrameState(literal, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(literal);
}
Node* literal_index = jsgraph()->Constant(expr->literal_index());
Node* constants = jsgraph()->Constant(expr->constant_properties());
Node* flags = jsgraph()->Constant(expr->ComputeFlags());
- const Operator* op = javascript()->Runtime(Runtime::kCreateObjectLiteral, 4);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kCreateObjectLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
+ PrepareFrameState(literal, expr->CreateLiteralId(),
+ OutputFrameStateCombine::Push());
// The object is expected on the operand stack during computation of the
// property values and is the value of the entire expression.
Node* receiver = environment()->Pop();
if (property->emit_store()) {
Node* strict = jsgraph()->Constant(SLOPPY);
- const Operator* op = javascript()->Runtime(Runtime::kSetProperty, 4);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kSetProperty, 4);
NewNode(op, receiver, key, value, strict);
}
break;
Node* value = environment()->Pop();
Node* receiver = environment()->Pop();
if (property->emit_store()) {
- const Operator* op = javascript()->Runtime(Runtime::kSetPrototype, 2);
- NewNode(op, receiver, value);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kInternalSetPrototype, 2);
+ Node* set_prototype = NewNode(op, receiver, value);
+ // SetPrototype should not lazy deopt on an object
+ // literal.
+ PrepareFrameState(set_prototype, BailoutId::None());
}
break;
}
Node* name = environment()->Pop();
Node* attr = jsgraph()->Constant(NONE);
const Operator* op =
- javascript()->Runtime(Runtime::kDefineAccessorPropertyUnchecked, 5);
+ javascript()->CallRuntime(Runtime::kDefineAccessorPropertyUnchecked, 5);
Node* call = NewNode(op, literal, name, getter, setter, attr);
- PrepareFrameState(call, it->first->id());
+ // This should not lazy deopt on a new literal.
+ PrepareFrameState(call, BailoutId::None());
}
// Transform literals that contain functions to fast properties.
if (expr->has_function()) {
- const Operator* op = javascript()->Runtime(Runtime::kToFastProperties, 1);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kToFastProperties, 1);
NewNode(op, literal);
}
Node* literal_index = jsgraph()->Constant(expr->literal_index());
Node* constants = jsgraph()->Constant(expr->constant_elements());
Node* flags = jsgraph()->Constant(expr->ComputeFlags());
- const Operator* op = javascript()->Runtime(Runtime::kCreateArrayLiteral, 4);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kCreateArrayLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
// The array and the literal index are both expected on the operand stack
Node* old_value = NULL;
switch (assign_type) {
case VARIABLE: {
- Variable* variable = expr->target()->AsVariableProxy()->var();
- old_value = BuildVariableLoad(variable, expr->target()->id());
+ VariableProxy* proxy = expr->target()->AsVariableProxy();
+ VectorSlotPair pair =
+ CreateVectorSlotPair(proxy->VariableFeedbackSlot());
+ old_value = BuildVariableLoad(proxy->var(), expr->target()->id(), pair);
break;
}
case NAMED_PROPERTY: {
Node* object = environment()->Top();
Unique<Name> name =
MakeUnique(property->key()->AsLiteral()->AsPropertyName());
- old_value = NewNode(javascript()->LoadNamed(name), object);
- PrepareFrameState(old_value, property->LoadId(), kPushOutput);
+ VectorSlotPair pair =
+ CreateVectorSlotPair(property->PropertyFeedbackSlot());
+ old_value = NewNode(javascript()->LoadNamed(name, pair), object);
+ PrepareFrameState(old_value, property->LoadId(),
+ OutputFrameStateCombine::Push());
break;
}
case KEYED_PROPERTY: {
Node* key = environment()->Top();
Node* object = environment()->Peek(1);
- old_value = NewNode(javascript()->LoadProperty(), object, key);
- PrepareFrameState(old_value, property->LoadId(), kPushOutput);
+ VectorSlotPair pair =
+ CreateVectorSlotPair(property->PropertyFeedbackSlot());
+ old_value = NewNode(javascript()->LoadProperty(pair), object, key);
+ PrepareFrameState(old_value, property->LoadId(),
+ OutputFrameStateCombine::Push());
break;
}
}
Node* right = environment()->Pop();
Node* left = environment()->Pop();
Node* value = BuildBinaryOp(left, right, expr->binary_op());
- PrepareFrameState(value, expr->binary_operation()->id(), kPushOutput);
+ PrepareFrameState(value, expr->binary_operation()->id(),
+ OutputFrameStateCombine::Push());
environment()->Push(value);
} else {
VisitForValue(expr->value());
switch (assign_type) {
case VARIABLE: {
Variable* variable = expr->target()->AsVariableProxy()->var();
- BuildVariableAssignment(variable, value, expr->op(),
- expr->AssignmentId());
+ BuildVariableAssignment(variable, value, expr->op(), expr->AssignmentId(),
+ ast_context()->GetStateCombine());
break;
}
case NAMED_PROPERTY: {
MakeUnique(property->key()->AsLiteral()->AsPropertyName());
Node* store =
NewNode(javascript()->StoreNamed(strict_mode(), name), object, value);
- PrepareFrameState(store, expr->AssignmentId());
+ PrepareFrameState(store, expr->AssignmentId(),
+ ast_context()->GetStateCombine());
break;
}
case KEYED_PROPERTY: {
Node* object = environment()->Pop();
Node* store = NewNode(javascript()->StoreProperty(strict_mode()), object,
key, value);
- PrepareFrameState(store, expr->AssignmentId());
+ PrepareFrameState(store, expr->AssignmentId(),
+ ast_context()->GetStateCombine());
break;
}
}
void AstGraphBuilder::VisitThrow(Throw* expr) {
VisitForValue(expr->exception());
Node* exception = environment()->Pop();
- const Operator* op = javascript()->Runtime(Runtime::kThrow, 1);
+ const Operator* op = javascript()->CallRuntime(Runtime::kThrow, 1);
Node* value = NewNode(op, exception);
+ PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
}
void AstGraphBuilder::VisitProperty(Property* expr) {
Node* value;
+ VectorSlotPair pair = CreateVectorSlotPair(expr->PropertyFeedbackSlot());
if (expr->key()->IsPropertyName()) {
VisitForValue(expr->obj());
Node* object = environment()->Pop();
Unique<Name> name = MakeUnique(expr->key()->AsLiteral()->AsPropertyName());
- value = NewNode(javascript()->LoadNamed(name), object);
+ value = NewNode(javascript()->LoadNamed(name, pair), object);
} else {
VisitForValue(expr->obj());
VisitForValue(expr->key());
Node* key = environment()->Pop();
Node* object = environment()->Pop();
- value = NewNode(javascript()->LoadProperty(), object, key);
+ value = NewNode(javascript()->LoadProperty(pair), object, key);
}
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
bool possibly_eval = false;
switch (call_type) {
case Call::GLOBAL_CALL: {
- Variable* variable = callee->AsVariableProxy()->var();
- callee_value = BuildVariableLoad(variable, expr->expression()->id());
+ VariableProxy* proxy = callee->AsVariableProxy();
+ VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
+ callee_value =
+ BuildVariableLoad(proxy->var(), expr->expression()->id(), pair);
receiver_value = jsgraph()->UndefinedConstant();
break;
}
Variable* variable = callee->AsVariableProxy()->var();
DCHECK(variable->location() == Variable::LOOKUP);
Node* name = jsgraph()->Constant(variable->name());
- const Operator* op = javascript()->Runtime(Runtime::kLoadLookupSlot, 2);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kLoadLookupSlot, 2);
Node* pair = NewNode(op, current_context(), name);
callee_value = NewNode(common()->Projection(0), pair);
receiver_value = NewNode(common()->Projection(1), pair);
+
+ PrepareFrameState(pair, expr->EvalOrLookupId(),
+ OutputFrameStateCombine::Push(2));
break;
}
case Call::PROPERTY_CALL: {
Property* property = callee->AsProperty();
VisitForValue(property->obj());
Node* object = environment()->Top();
+ VectorSlotPair pair =
+ CreateVectorSlotPair(property->PropertyFeedbackSlot());
if (property->key()->IsPropertyName()) {
Unique<Name> name =
MakeUnique(property->key()->AsLiteral()->AsPropertyName());
- callee_value = NewNode(javascript()->LoadNamed(name), object);
+ callee_value = NewNode(javascript()->LoadNamed(name, pair), object);
} else {
VisitForValue(property->key());
Node* key = environment()->Pop();
- callee_value = NewNode(javascript()->LoadProperty(), object, key);
+ callee_value = NewNode(javascript()->LoadProperty(pair), object, key);
}
- PrepareFrameState(callee_value, property->LoadId(), kPushOutput);
+ PrepareFrameState(callee_value, property->LoadId(),
+ OutputFrameStateCombine::Push());
receiver_value = environment()->Pop();
// Note that a PROPERTY_CALL requires the receiver to be wrapped into an
// object for sloppy callees. This could also be modeled explicitly here,
flags = CALL_AS_METHOD;
break;
}
+ case Call::SUPER_CALL: {
+ // todo(dslomov): implement super calls in turbofan.
+ UNIMPLEMENTED();
+ break;
+ }
case Call::POSSIBLY_EVAL_CALL:
possibly_eval = true;
// Fall through.
// Create node to ask for help resolving potential eval call. This will
// provide a fully resolved callee and the corresponding receiver.
+ Node* function = GetFunctionClosure();
Node* receiver = environment()->Lookup(info()->scope()->receiver());
Node* strict = jsgraph()->Constant(strict_mode());
Node* position = jsgraph()->Constant(info()->scope()->start_position());
const Operator* op =
- javascript()->Runtime(Runtime::kResolvePossiblyDirectEval, 5);
- Node* pair = NewNode(op, callee, source, receiver, strict, position);
+ javascript()->CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+ Node* pair =
+ NewNode(op, callee, source, function, receiver, strict, position);
+ PrepareFrameState(pair, expr->EvalOrLookupId(),
+ OutputFrameStateCombine::PokeAt(arg_count + 1));
Node* new_callee = NewNode(common()->Projection(0), pair);
Node* new_receiver = NewNode(common()->Projection(1), pair);
}
// Create node to perform the function call.
- const Operator* call = javascript()->Call(args->length() + 2, flags);
+ const Operator* call = javascript()->CallFunction(args->length() + 2, flags);
Node* value = ProcessArguments(call, args->length() + 2);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
VisitForValues(args);
// Create node to perform the construct call.
- const Operator* call = javascript()->CallNew(args->length() + 1);
+ const Operator* call = javascript()->CallConstruct(args->length() + 1);
Node* value = ProcessArguments(call, args->length() + 1);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS;
Node* receiver_value = BuildLoadBuiltinsObject();
Unique<String> unique = MakeUnique(name);
- Node* callee_value = NewNode(javascript()->LoadNamed(unique), receiver_value);
+ VectorSlotPair pair = CreateVectorSlotPair(expr->CallRuntimeFeedbackSlot());
+ Node* callee_value =
+ NewNode(javascript()->LoadNamed(unique, pair), receiver_value);
// TODO(jarin): Find/create a bailout id to deoptimize to (crankshaft
// refuses to optimize functions with jsruntime calls).
- PrepareFrameState(callee_value, BailoutId::None(), kPushOutput);
+ PrepareFrameState(callee_value, BailoutId::None(),
+ OutputFrameStateCombine::Push());
environment()->Push(callee_value);
environment()->Push(receiver_value);
VisitForValues(args);
// Create node to perform the JS runtime call.
- const Operator* call = javascript()->Call(args->length() + 2, flags);
+ const Operator* call = javascript()->CallFunction(args->length() + 2, flags);
Node* value = ProcessArguments(call, args->length() + 2);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
// Create node to perform the runtime call.
Runtime::FunctionId functionId = function->function_id;
- const Operator* call = javascript()->Runtime(functionId, args->length());
+ const Operator* call = javascript()->CallRuntime(functionId, args->length());
Node* value = ProcessArguments(call, args->length());
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
int stack_depth = -1;
switch (assign_type) {
case VARIABLE: {
- Variable* variable = expr->expression()->AsVariableProxy()->var();
- old_value = BuildVariableLoad(variable, expr->expression()->id());
+ VariableProxy* proxy = expr->expression()->AsVariableProxy();
+ VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
+ old_value =
+ BuildVariableLoad(proxy->var(), expr->expression()->id(), pair);
stack_depth = 0;
break;
}
Node* object = environment()->Top();
Unique<Name> name =
MakeUnique(property->key()->AsLiteral()->AsPropertyName());
- old_value = NewNode(javascript()->LoadNamed(name), object);
- PrepareFrameState(old_value, property->LoadId(), kPushOutput);
+ VectorSlotPair pair =
+ CreateVectorSlotPair(property->PropertyFeedbackSlot());
+ old_value = NewNode(javascript()->LoadNamed(name, pair), object);
+ PrepareFrameState(old_value, property->LoadId(),
+ OutputFrameStateCombine::Push());
stack_depth = 1;
break;
}
VisitForValue(property->key());
Node* key = environment()->Top();
Node* object = environment()->Peek(1);
- old_value = NewNode(javascript()->LoadProperty(), object, key);
- PrepareFrameState(old_value, property->LoadId(), kPushOutput);
+ VectorSlotPair pair =
+ CreateVectorSlotPair(property->PropertyFeedbackSlot());
+ old_value = NewNode(javascript()->LoadProperty(pair), object, key);
+ PrepareFrameState(old_value, property->LoadId(),
+ OutputFrameStateCombine::Push());
stack_depth = 2;
break;
}
DeclareGlobalsStrictMode::encode(strict_mode());
Node* flags = jsgraph()->Constant(encoded_flags);
Node* pairs = jsgraph()->Constant(data);
- const Operator* op = javascript()->Runtime(Runtime::kDeclareGlobals, 3);
+ const Operator* op = javascript()->CallRuntime(Runtime::kDeclareGlobals, 3);
NewNode(op, current_context(), pairs, flags);
globals()->Rewind(0);
}
// deleting "this" is allowed in all language modes.
Variable* variable = expr->expression()->AsVariableProxy()->var();
DCHECK(strict_mode() == SLOPPY || variable->is_this());
- value = BuildVariableDelete(variable);
+ value = BuildVariableDelete(variable, expr->id(),
+ ast_context()->GetStateCombine());
} else if (expr->expression()->IsProperty()) {
Property* property = expr->expression()->AsProperty();
VisitForValue(property->obj());
Node* key = environment()->Pop();
Node* object = environment()->Pop();
value = NewNode(javascript()->DeleteProperty(strict_mode()), object, key);
+ PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
} else {
VisitForEffect(expr->expression());
value = jsgraph()->TrueConstant();
if (expr->expression()->IsVariableProxy()) {
// Typeof does not throw a reference error on global variables, hence we
// perform a non-contextual load in case the operand is a variable proxy.
- Variable* variable = expr->expression()->AsVariableProxy()->var();
- operand =
- BuildVariableLoad(variable, expr->expression()->id(), NOT_CONTEXTUAL);
+ VariableProxy* proxy = expr->expression()->AsVariableProxy();
+ VectorSlotPair pair = CreateVectorSlotPair(proxy->VariableFeedbackSlot());
+ operand = BuildVariableLoad(proxy->var(), expr->expression()->id(), pair,
+ NOT_CONTEXTUAL);
} else {
VisitForValue(expr->expression());
operand = environment()->Pop();
}
+StrictMode AstGraphBuilder::strict_mode() const {
+ return info()->strict_mode();
+}
+
+
+VectorSlotPair AstGraphBuilder::CreateVectorSlotPair(
+ FeedbackVectorICSlot slot) const {
+ return VectorSlotPair(handle(info()->shared_info()->feedback_vector()), slot);
+}
+
+
Node* AstGraphBuilder::ProcessArguments(const Operator* op, int arity) {
DCHECK(environment()->stack_height() >= arity);
Node** all = info()->zone()->NewArray<Node*>(arity);
// Allocate and initialize a new arguments object.
Node* callee = GetFunctionClosure();
- const Operator* op = javascript()->Runtime(Runtime::kNewArguments, 1);
+ const Operator* op = javascript()->CallRuntime(Runtime::kNewArguments, 1);
Node* object = NewNode(op, callee);
// Assign the object to the arguments variable.
Node* AstGraphBuilder::BuildHoleCheckThrow(Node* value, Variable* variable,
- Node* not_hole) {
+ Node* not_hole,
+ BailoutId bailout_id) {
IfBuilder hole_check(this);
Node* the_hole = jsgraph()->TheHoleConstant();
Node* check = NewNode(javascript()->StrictEqual(), value, the_hole);
hole_check.If(check);
hole_check.Then();
- environment()->Push(BuildThrowReferenceError(variable));
+ environment()->Push(BuildThrowReferenceError(variable, bailout_id));
hole_check.Else();
environment()->Push(not_hole);
hole_check.End();
Node* AstGraphBuilder::BuildVariableLoad(Variable* variable,
BailoutId bailout_id,
+ const VectorSlotPair& feedback,
ContextualMode contextual_mode) {
Node* the_hole = jsgraph()->TheHoleConstant();
VariableMode mode = variable->mode();
// Global var, const, or let variable.
Node* global = BuildLoadGlobalObject();
Unique<Name> name = MakeUnique(variable->name());
- const Operator* op = javascript()->LoadNamed(name, contextual_mode);
+ const Operator* op =
+ javascript()->LoadNamed(name, feedback, contextual_mode);
Node* node = NewNode(op, global);
- PrepareFrameState(node, bailout_id, kPushOutput);
+ PrepareFrameState(node, bailout_id, OutputFrameStateCombine::Push());
return node;
}
case Variable::PARAMETER:
} else if (mode == LET || mode == CONST) {
// Perform check for uninitialized let/const variables.
if (value->op() == the_hole->op()) {
- value = BuildThrowReferenceError(variable);
+ value = BuildThrowReferenceError(variable, bailout_id);
} else if (value->opcode() == IrOpcode::kPhi) {
- value = BuildHoleCheckThrow(value, variable, value);
+ value = BuildHoleCheckThrow(value, variable, value, bailout_id);
}
}
return value;
value = BuildHoleCheckSilent(value, undefined, value);
} else if (mode == LET || mode == CONST) {
// Perform check for uninitialized let/const variables.
- value = BuildHoleCheckThrow(value, variable, value);
+ value = BuildHoleCheckThrow(value, variable, value, bailout_id);
}
return value;
}
(contextual_mode == CONTEXTUAL)
? Runtime::kLoadLookupSlot
: Runtime::kLoadLookupSlotNoReferenceError;
- const Operator* op = javascript()->Runtime(function_id, 2);
+ const Operator* op = javascript()->CallRuntime(function_id, 2);
Node* pair = NewNode(op, current_context(), name);
+ PrepareFrameState(pair, bailout_id, OutputFrameStateCombine::Push(1));
return NewNode(common()->Projection(0), pair);
}
}
}
-Node* AstGraphBuilder::BuildVariableDelete(Variable* variable) {
+Node* AstGraphBuilder::BuildVariableDelete(
+ Variable* variable, BailoutId bailout_id,
+ OutputFrameStateCombine state_combine) {
switch (variable->location()) {
case Variable::UNALLOCATED: {
// Global var, const, or let variable.
Node* global = BuildLoadGlobalObject();
Node* name = jsgraph()->Constant(variable->name());
const Operator* op = javascript()->DeleteProperty(strict_mode());
- return NewNode(op, global, name);
+ Node* result = NewNode(op, global, name);
+ PrepareFrameState(result, bailout_id, state_combine);
+ return result;
}
case Variable::PARAMETER:
case Variable::LOCAL:
case Variable::CONTEXT:
// Local var, const, or let variable or context variable.
- return variable->is_this() ? jsgraph()->TrueConstant()
- : jsgraph()->FalseConstant();
+ return jsgraph()->BooleanConstant(variable->is_this());
case Variable::LOOKUP: {
// Dynamic lookup of context variable (anywhere in the chain).
Node* name = jsgraph()->Constant(variable->name());
- const Operator* op = javascript()->Runtime(Runtime::kDeleteLookupSlot, 2);
- return NewNode(op, current_context(), name);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kDeleteLookupSlot, 2);
+ Node* result = NewNode(op, current_context(), name);
+ PrepareFrameState(result, bailout_id, state_combine);
+ return result;
}
}
UNREACHABLE();
}
-Node* AstGraphBuilder::BuildVariableAssignment(Variable* variable, Node* value,
- Token::Value op,
- BailoutId bailout_id) {
+Node* AstGraphBuilder::BuildVariableAssignment(
+ Variable* variable, Node* value, Token::Value op, BailoutId bailout_id,
+ OutputFrameStateCombine combine) {
Node* the_hole = jsgraph()->TheHoleConstant();
VariableMode mode = variable->mode();
switch (variable->location()) {
Unique<Name> name = MakeUnique(variable->name());
const Operator* op = javascript()->StoreNamed(strict_mode(), name);
Node* store = NewNode(op, global, value);
- PrepareFrameState(store, bailout_id);
+ PrepareFrameState(store, bailout_id, combine);
return store;
}
case Variable::PARAMETER:
// temporal dead zone of a let declared variable.
Node* current = environment()->Lookup(variable);
if (current->op() == the_hole->op()) {
- value = BuildThrowReferenceError(variable);
+ value = BuildThrowReferenceError(variable, bailout_id);
} else if (value->opcode() == IrOpcode::kPhi) {
- value = BuildHoleCheckThrow(current, variable, value);
+ value = BuildHoleCheckThrow(current, variable, value, bailout_id);
}
} else if (mode == CONST && op != Token::INIT_CONST) {
// All assignments to const variables are early errors.
const Operator* op =
javascript()->LoadContext(depth, variable->index(), false);
Node* current = NewNode(op, current_context());
- value = BuildHoleCheckThrow(current, variable, value);
+ value = BuildHoleCheckThrow(current, variable, value, bailout_id);
} else if (mode == CONST && op != Token::INIT_CONST) {
// All assignments to const variables are early errors.
UNREACHABLE();
Node* strict = jsgraph()->Constant(strict_mode());
// TODO(mstarzinger): Use Runtime::kInitializeLegacyConstLookupSlot for
// initializations of const declarations.
- const Operator* op = javascript()->Runtime(Runtime::kStoreLookupSlot, 4);
- return NewNode(op, value, current_context(), name, strict);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kStoreLookupSlot, 4);
+ Node* store = NewNode(op, value, current_context(), name, strict);
+ PrepareFrameState(store, bailout_id, combine);
+ return store;
}
}
UNREACHABLE();
Node* AstGraphBuilder::BuildLoadObjectField(Node* object, int offset) {
- // TODO(sigurds) Use simplified load here once it is ready.
Node* field_load = NewNode(jsgraph()->machine()->Load(kMachAnyTagged), object,
jsgraph()->Int32Constant(offset - kHeapObjectTag));
return field_load;
}
-Node* AstGraphBuilder::BuildToBoolean(Node* value) {
- // TODO(mstarzinger): Possible optimization is to NOP for boolean values.
- return NewNode(javascript()->ToBoolean(), value);
+Node* AstGraphBuilder::BuildToBoolean(Node* input) {
+ // TODO(titzer): this should be in a JSOperatorReducer.
+ switch (input->opcode()) {
+ case IrOpcode::kInt32Constant:
+ return jsgraph_->BooleanConstant(!Int32Matcher(input).Is(0));
+ case IrOpcode::kFloat64Constant:
+ return jsgraph_->BooleanConstant(!Float64Matcher(input).Is(0));
+ case IrOpcode::kNumberConstant:
+ return jsgraph_->BooleanConstant(!NumberMatcher(input).Is(0));
+ case IrOpcode::kHeapConstant: {
+ Handle<Object> object = HeapObjectMatcher<Object>(input).Value().handle();
+ if (object->IsTrue()) return jsgraph_->TrueConstant();
+ if (object->IsFalse()) return jsgraph_->FalseConstant();
+ // TODO(turbofan): other constants.
+ break;
+ }
+ default:
+ break;
+ }
+ if (NodeProperties::IsTyped(input)) {
+ Type* upper = NodeProperties::GetBounds(input).upper;
+ if (upper->Is(Type::Boolean())) return input;
+ }
+
+ return NewNode(javascript()->ToBoolean(), input);
}
-Node* AstGraphBuilder::BuildThrowReferenceError(Variable* variable) {
+Node* AstGraphBuilder::BuildThrowReferenceError(Variable* variable,
+ BailoutId bailout_id) {
// TODO(mstarzinger): Should be unified with the VisitThrow implementation.
Node* variable_name = jsgraph()->Constant(variable->name());
- const Operator* op = javascript()->Runtime(Runtime::kThrowReferenceError, 1);
- return NewNode(op, variable_name);
+ const Operator* op =
+ javascript()->CallRuntime(Runtime::kThrowReferenceError, 1);
+ Node* call = NewNode(op, variable_name);
+ PrepareFrameState(call, bailout_id);
+ return call;
}
}
+Node* AstGraphBuilder::BuildStackCheck() {
+ IfBuilder stack_check(this);
+ Node* limit =
+ NewNode(jsgraph()->machine()->Load(kMachPtr),
+ jsgraph()->ExternalConstant(
+ ExternalReference::address_of_stack_limit(isolate())),
+ jsgraph()->ZeroConstant());
+ Node* stack = NewNode(jsgraph()->machine()->LoadStackPointer());
+ Node* tag = NewNode(jsgraph()->machine()->UintLessThan(), limit, stack);
+ stack_check.If(tag, BranchHint::kTrue);
+ stack_check.Then();
+ stack_check.Else();
+ Node* guard = NewNode(javascript()->CallRuntime(Runtime::kStackGuard, 0));
+ stack_check.End();
+ return guard;
+}
+
+
void AstGraphBuilder::PrepareFrameState(Node* node, BailoutId ast_id,
OutputFrameStateCombine combine) {
if (OperatorProperties::HasFrameStateInput(node->op())) {
}
}
+
+BitVector* AstGraphBuilder::GetVariablesAssignedInLoop(
+ IterationStatement* stmt) {
+ if (loop_assignment_analysis_ == NULL) return NULL;
+ return loop_assignment_analysis_->GetVariablesAssignedInLoop(stmt);
}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
namespace compiler {
class ControlBuilder;
-class LoopBuilder;
class Graph;
+class LoopAssignmentAnalysis;
+class LoopBuilder;
// The AstGraphBuilder produces a high-level IR graph, based on an
// underlying AST. The produced graph can either be compiled into a
// of function inlining.
class AstGraphBuilder : public StructuredGraphBuilder, public AstVisitor {
public:
- AstGraphBuilder(CompilationInfo* info, JSGraph* jsgraph);
+ AstGraphBuilder(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph);
// Creates a graph by visiting the entire AST.
bool CreateGraph();
// Support for control flow builders. The concrete type of the environment
// depends on the graph builder, but environments themselves are not virtual.
typedef StructuredGraphBuilder::Environment BaseEnvironment;
- virtual BaseEnvironment* CopyEnvironment(BaseEnvironment* env);
+ virtual BaseEnvironment* CopyEnvironment(BaseEnvironment* env) OVERRIDE;
// TODO(mstarzinger): The pipeline only needs to be a friend to access the
// function context. Remove as soon as the context is a parameter.
// Builders for variable load and assignment.
Node* BuildVariableAssignment(Variable* var, Node* value, Token::Value op,
- BailoutId bailout_id);
- Node* BuildVariableDelete(Variable* var);
+ BailoutId bailout_id,
+ OutputFrameStateCombine state_combine =
+ OutputFrameStateCombine::Ignore());
+ Node* BuildVariableDelete(Variable* var, BailoutId bailout_id,
+ OutputFrameStateCombine state_combine);
Node* BuildVariableLoad(Variable* var, BailoutId bailout_id,
+ const VectorSlotPair& feedback,
ContextualMode mode = CONTEXTUAL);
// Builders for accessing the function context.
Node* BuildToBoolean(Node* value);
// Builders for error reporting at runtime.
- Node* BuildThrowReferenceError(Variable* var);
+ Node* BuildThrowReferenceError(Variable* var, BailoutId bailout_id);
// Builders for dynamic hole-checks at runtime.
Node* BuildHoleCheckSilent(Node* value, Node* for_hole, Node* not_hole);
- Node* BuildHoleCheckThrow(Node* value, Variable* var, Node* not_hole);
+ Node* BuildHoleCheckThrow(Node* value, Variable* var, Node* not_hole,
+ BailoutId bailout_id);
// Builders for binary operations.
Node* BuildBinaryOp(Node* left, Node* right, Token::Value op);
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+ // Builder for stack-check guards.
+ Node* BuildStackCheck();
+
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
// Visiting functions for AST nodes make this an AstVisitor.
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
// Visiting function for declarations list is overridden.
- virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
+ virtual void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
private:
CompilationInfo* info_;
SetOncePointer<Node> function_closure_;
SetOncePointer<Node> function_context_;
- CompilationInfo* info() { return info_; }
- StrictMode strict_mode() { return info()->strict_mode(); }
+ // Result of loop assignment analysis performed before graph creation.
+ LoopAssignmentAnalysis* loop_assignment_analysis_;
+
+ CompilationInfo* info() const { return info_; }
+ inline StrictMode strict_mode() const;
JSGraph* jsgraph() { return jsgraph_; }
JSOperatorBuilder* javascript() { return jsgraph_->javascript(); }
ZoneList<Handle<Object> >* globals() { return &globals_; }
// Current scope during visitation.
inline Scope* current_scope() const;
+ // Named and keyed loads require a VectorSlotPair for successful lowering.
+ VectorSlotPair CreateVectorSlotPair(FeedbackVectorICSlot slot) const;
+
// Process arguments to a call by popping {arity} elements off the operand
// stack and build a call node using the given call operator.
Node* ProcessArguments(const Operator* op, int arity);
void VisitIfNotNull(Statement* stmt);
// Visit expressions.
+ void Visit(Expression* expr);
void VisitForTest(Expression* expr);
void VisitForEffect(Expression* expr);
void VisitForValue(Expression* expr);
void VisitForInAssignment(Expression* expr, Node* value);
// Builds deoptimization for a given node.
- void PrepareFrameState(Node* node, BailoutId ast_id,
- OutputFrameStateCombine combine = kIgnoreOutput);
+ void PrepareFrameState(
+ Node* node, BailoutId ast_id,
+ OutputFrameStateCombine combine = OutputFrameStateCombine::Ignore());
- OutputFrameStateCombine StateCombineFromAstContext();
+ BitVector* GetVariablesAssignedInLoop(IterationStatement* stmt);
DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
DISALLOW_COPY_AND_ASSIGN(AstGraphBuilder);
// Determines how to combine the frame state with the value
// that is about to be plugged into this AstContext.
OutputFrameStateCombine GetStateCombine() {
- return IsEffect() ? kIgnoreOutput : kPushOutput;
+ return IsEffect() ? OutputFrameStateCombine::Ignore()
+ : OutputFrameStateCombine::Push();
}
// Plug a node into this expression context. Call this function in tail
Scope* AstGraphBuilder::current_scope() const {
return execution_context_->scope();
}
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_AST_GRAPH_BUILDER_H_
--- /dev/null
+// 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/ast-loop-assignment-analyzer.h"
+#include "src/parser.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+typedef class AstLoopAssignmentAnalyzer ALAA; // for code shortitude.
+
+ALAA::AstLoopAssignmentAnalyzer(Zone* zone, CompilationInfo* info)
+ : info_(info), loop_stack_(zone) {
+ InitializeAstVisitor(zone);
+}
+
+
+LoopAssignmentAnalysis* ALAA::Analyze() {
+ LoopAssignmentAnalysis* a = new (zone()) LoopAssignmentAnalysis(zone());
+ result_ = a;
+ VisitStatements(info()->function()->body());
+ result_ = NULL;
+ return a;
+}
+
+
+void ALAA::Enter(IterationStatement* loop) {
+ int num_variables = 1 + info()->scope()->num_parameters() +
+ info()->scope()->num_stack_slots();
+ BitVector* bits = new (zone()) BitVector(num_variables, zone());
+ loop_stack_.push_back(bits);
+}
+
+
+void ALAA::Exit(IterationStatement* loop) {
+ DCHECK(loop_stack_.size() > 0);
+ BitVector* bits = loop_stack_.back();
+ loop_stack_.pop_back();
+ if (!loop_stack_.empty()) {
+ loop_stack_.back()->Union(*bits);
+ }
+ result_->list_.push_back(
+ std::pair<IterationStatement*, BitVector*>(loop, bits));
+}
+
+
+// ---------------------------------------------------------------------------
+// -- Leaf nodes -------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+void ALAA::VisitVariableDeclaration(VariableDeclaration* leaf) {}
+void ALAA::VisitFunctionDeclaration(FunctionDeclaration* leaf) {}
+void ALAA::VisitModuleDeclaration(ModuleDeclaration* leaf) {}
+void ALAA::VisitImportDeclaration(ImportDeclaration* leaf) {}
+void ALAA::VisitExportDeclaration(ExportDeclaration* leaf) {}
+void ALAA::VisitModuleVariable(ModuleVariable* leaf) {}
+void ALAA::VisitModulePath(ModulePath* leaf) {}
+void ALAA::VisitModuleUrl(ModuleUrl* leaf) {}
+void ALAA::VisitEmptyStatement(EmptyStatement* leaf) {}
+void ALAA::VisitContinueStatement(ContinueStatement* leaf) {}
+void ALAA::VisitBreakStatement(BreakStatement* leaf) {}
+void ALAA::VisitDebuggerStatement(DebuggerStatement* leaf) {}
+void ALAA::VisitFunctionLiteral(FunctionLiteral* leaf) {}
+void ALAA::VisitNativeFunctionLiteral(NativeFunctionLiteral* leaf) {}
+void ALAA::VisitVariableProxy(VariableProxy* leaf) {}
+void ALAA::VisitLiteral(Literal* leaf) {}
+void ALAA::VisitRegExpLiteral(RegExpLiteral* leaf) {}
+void ALAA::VisitThisFunction(ThisFunction* leaf) {}
+void ALAA::VisitSuperReference(SuperReference* leaf) {}
+
+
+// ---------------------------------------------------------------------------
+// -- Pass-through nodes------------------------------------------------------
+// ---------------------------------------------------------------------------
+void ALAA::VisitModuleLiteral(ModuleLiteral* e) { Visit(e->body()); }
+
+
+void ALAA::VisitBlock(Block* stmt) { VisitStatements(stmt->statements()); }
+
+
+void ALAA::VisitExpressionStatement(ExpressionStatement* stmt) {
+ Visit(stmt->expression());
+}
+
+
+void ALAA::VisitIfStatement(IfStatement* stmt) {
+ Visit(stmt->condition());
+ Visit(stmt->then_statement());
+ Visit(stmt->else_statement());
+}
+
+
+void ALAA::VisitReturnStatement(ReturnStatement* stmt) {
+ Visit(stmt->expression());
+}
+
+
+void ALAA::VisitWithStatement(WithStatement* stmt) {
+ Visit(stmt->expression());
+ Visit(stmt->statement());
+}
+
+
+void ALAA::VisitSwitchStatement(SwitchStatement* stmt) {
+ Visit(stmt->tag());
+ ZoneList<CaseClause*>* clauses = stmt->cases();
+ for (int i = 0; i < clauses->length(); i++) {
+ Visit(clauses->at(i));
+ }
+}
+
+
+void ALAA::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
+ Visit(stmt->try_block());
+ Visit(stmt->finally_block());
+}
+
+
+void ALAA::VisitClassLiteral(ClassLiteral* e) {
+ VisitIfNotNull(e->extends());
+ VisitIfNotNull(e->constructor());
+ ZoneList<ObjectLiteralProperty*>* properties = e->properties();
+ for (int i = 0; i < properties->length(); i++) {
+ Visit(properties->at(i)->value());
+ }
+}
+
+
+void ALAA::VisitConditional(Conditional* e) {
+ Visit(e->condition());
+ Visit(e->then_expression());
+ Visit(e->else_expression());
+}
+
+
+void ALAA::VisitObjectLiteral(ObjectLiteral* e) {
+ ZoneList<ObjectLiteralProperty*>* properties = e->properties();
+ for (int i = 0; i < properties->length(); i++) {
+ Visit(properties->at(i)->value());
+ }
+}
+
+
+void ALAA::VisitArrayLiteral(ArrayLiteral* e) { VisitExpressions(e->values()); }
+
+
+void ALAA::VisitYield(Yield* stmt) {
+ Visit(stmt->generator_object());
+ Visit(stmt->expression());
+}
+
+
+void ALAA::VisitThrow(Throw* stmt) { Visit(stmt->exception()); }
+
+
+void ALAA::VisitProperty(Property* e) {
+ Visit(e->obj());
+ Visit(e->key());
+}
+
+
+void ALAA::VisitCall(Call* e) {
+ Visit(e->expression());
+ VisitExpressions(e->arguments());
+}
+
+
+void ALAA::VisitCallNew(CallNew* e) {
+ Visit(e->expression());
+ VisitExpressions(e->arguments());
+}
+
+
+void ALAA::VisitCallRuntime(CallRuntime* e) {
+ VisitExpressions(e->arguments());
+}
+
+
+void ALAA::VisitUnaryOperation(UnaryOperation* e) { Visit(e->expression()); }
+
+
+void ALAA::VisitBinaryOperation(BinaryOperation* e) {
+ Visit(e->left());
+ Visit(e->right());
+}
+
+
+void ALAA::VisitCompareOperation(CompareOperation* e) {
+ Visit(e->left());
+ Visit(e->right());
+}
+
+
+void ALAA::VisitCaseClause(CaseClause* cc) {
+ if (!cc->is_default()) Visit(cc->label());
+ VisitStatements(cc->statements());
+}
+
+
+// ---------------------------------------------------------------------------
+// -- Interesting nodes-------------------------------------------------------
+// ---------------------------------------------------------------------------
+void ALAA::VisitModuleStatement(ModuleStatement* stmt) {
+ Visit(stmt->body());
+ // TODO(turbofan): can a module appear in a loop?
+ AnalyzeAssignment(stmt->proxy()->var());
+}
+
+
+void ALAA::VisitTryCatchStatement(TryCatchStatement* stmt) {
+ Visit(stmt->try_block());
+ Visit(stmt->catch_block());
+ // TODO(turbofan): are catch variables well-scoped?
+ AnalyzeAssignment(stmt->variable());
+}
+
+
+void ALAA::VisitDoWhileStatement(DoWhileStatement* loop) {
+ Enter(loop);
+ Visit(loop->body());
+ Visit(loop->cond());
+ Exit(loop);
+}
+
+
+void ALAA::VisitWhileStatement(WhileStatement* loop) {
+ Enter(loop);
+ Visit(loop->cond());
+ Visit(loop->body());
+ Exit(loop);
+}
+
+
+void ALAA::VisitForStatement(ForStatement* loop) {
+ VisitIfNotNull(loop->init());
+ Enter(loop);
+ VisitIfNotNull(loop->cond());
+ Visit(loop->body());
+ VisitIfNotNull(loop->next());
+ Exit(loop);
+}
+
+
+void ALAA::VisitForInStatement(ForInStatement* loop) {
+ Enter(loop);
+ Visit(loop->each());
+ Visit(loop->subject());
+ Visit(loop->body());
+ Exit(loop);
+}
+
+
+void ALAA::VisitForOfStatement(ForOfStatement* loop) {
+ Enter(loop);
+ Visit(loop->each());
+ Visit(loop->subject());
+ Visit(loop->body());
+ Exit(loop);
+}
+
+
+void ALAA::VisitAssignment(Assignment* stmt) {
+ Expression* l = stmt->target();
+ Visit(l);
+ Visit(stmt->value());
+ if (l->IsVariableProxy()) AnalyzeAssignment(l->AsVariableProxy()->var());
+}
+
+
+void ALAA::VisitCountOperation(CountOperation* e) {
+ Expression* l = e->expression();
+ Visit(l);
+ if (l->IsVariableProxy()) AnalyzeAssignment(l->AsVariableProxy()->var());
+}
+
+
+void ALAA::AnalyzeAssignment(Variable* var) {
+ if (!loop_stack_.empty() && var->IsStackAllocated()) {
+ loop_stack_.back()->Add(GetVariableIndex(info()->scope(), var));
+ }
+}
+
+
+int ALAA::GetVariableIndex(Scope* scope, Variable* var) {
+ CHECK(var->IsStackAllocated());
+ if (var->is_this()) return 0;
+ if (var->IsParameter()) return 1 + var->index();
+ return 1 + scope->num_parameters() + var->index();
+}
+
+
+int LoopAssignmentAnalysis::GetAssignmentCountForTesting(Scope* scope,
+ Variable* var) {
+ int count = 0;
+ int var_index = AstLoopAssignmentAnalyzer::GetVariableIndex(scope, var);
+ for (size_t i = 0; i < list_.size(); i++) {
+ if (list_[i].second->Contains(var_index)) count++;
+ }
+ return count;
+}
+}
+}
+} // namespace v8::internal::compiler
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_AST_LOOP_ASSIGNMENT_ANALYZER_H_
+#define V8_COMPILER_AST_LOOP_ASSIGNMENT_ANALYZER_H_
+
+#include "src/ast.h"
+#include "src/bit-vector.h"
+#include "src/v8.h"
+#include "src/zone-containers.h"
+
+namespace v8 {
+namespace internal {
+
+class Variable;
+class Scope;
+
+namespace compiler {
+
+// The result of analyzing loop assignments.
+class LoopAssignmentAnalysis : public ZoneObject {
+ public:
+ BitVector* GetVariablesAssignedInLoop(IterationStatement* loop) {
+ for (size_t i = 0; i < list_.size(); i++) {
+ // TODO(turbofan): hashmap or binary search for loop assignments.
+ if (list_[i].first == loop) return list_[i].second;
+ }
+ UNREACHABLE(); // should never ask for loops that aren't here!
+ return NULL;
+ }
+
+ int GetAssignmentCountForTesting(Scope* scope, Variable* var);
+
+ private:
+ friend class AstLoopAssignmentAnalyzer;
+ explicit LoopAssignmentAnalysis(Zone* zone) : list_(zone) {}
+ ZoneVector<std::pair<IterationStatement*, BitVector*>> list_;
+};
+
+
+// The class that performs loop assignment analysis by walking the AST.
+class AstLoopAssignmentAnalyzer : public AstVisitor {
+ public:
+ AstLoopAssignmentAnalyzer(Zone* zone, CompilationInfo* info);
+
+ LoopAssignmentAnalysis* Analyze();
+
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+ AST_NODE_LIST(DECLARE_VISIT)
+#undef DECLARE_VISIT
+
+ static int GetVariableIndex(Scope* scope, Variable* var);
+
+ private:
+ CompilationInfo* info_;
+ ZoneDeque<BitVector*> loop_stack_;
+ LoopAssignmentAnalysis* result_;
+
+ CompilationInfo* info() { return info_; }
+
+ void Enter(IterationStatement* loop);
+ void Exit(IterationStatement* loop);
+
+ void VisitIfNotNull(AstNode* node) {
+ if (node != NULL) Visit(node);
+ }
+
+ void AnalyzeAssignment(Variable* var);
+
+ DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
+ DISALLOW_COPY_AND_ASSIGN(AstLoopAssignmentAnalyzer);
+};
+}
+}
+} // namespace v8::internal::compiler
+
+#endif // V8_COMPILER_AST_LOOP_ASSIGNMENT_ANALYZER_H_
// found in the LICENSE file.
#include "src/compiler/basic-block-instrumentor.h"
+
+#include <sstream>
+
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/machine-operator.h"
// Find the first place to insert new nodes in a block that's already been
// scheduled that won't upset the register allocator.
-static NodeVector::iterator FindInsertionPoint(NodeVector* nodes) {
- NodeVector::iterator i = nodes->begin();
- for (; i != nodes->end(); ++i) {
+static NodeVector::iterator FindInsertionPoint(BasicBlock* block) {
+ NodeVector::iterator i = block->begin();
+ for (; i != block->end(); ++i) {
const Operator* op = (*i)->op();
if (OperatorProperties::IsBasicBlockBegin(op)) continue;
switch (op->opcode()) {
// Set the function name.
if (!info->shared_info().is_null() &&
info->shared_info()->name()->IsString()) {
- OStringStream os;
+ std::ostringstream os;
String::cast(info->shared_info()->name())->PrintUC16(os);
data->SetFunctionName(&os);
}
// Capture the schedule string before instrumentation.
{
- OStringStream os;
+ std::ostringstream os;
os << *schedule;
data->SetSchedule(&os);
}
for (BasicBlockVector::iterator it = blocks->begin(); block_number < n_blocks;
++it, ++block_number) {
BasicBlock* block = (*it);
- data->SetBlockId(block_number, block->id());
+ data->SetBlockId(block_number, block->id().ToSize());
// TODO(dcarney): wire effect and control deps for load and store.
// Construct increment operation.
Node* base = graph->NewNode(
static const int kArraySize = 6;
Node* to_insert[kArraySize] = {zero, one, base, load, inc, store};
int insertion_start = block_number == 0 ? 0 : 2;
- NodeVector* nodes = &block->nodes_;
- NodeVector::iterator insertion_point = FindInsertionPoint(nodes);
- nodes->insert(insertion_point, &to_insert[insertion_start],
- &to_insert[kArraySize]);
+ NodeVector::iterator insertion_point = FindInsertionPoint(block);
+ block->InsertNodes(insertion_point, &to_insert[insertion_start],
+ &to_insert[kArraySize]);
// Tell the scheduler about the new nodes.
for (int i = insertion_start; i < kArraySize; ++i) {
schedule->SetBlockForNode(block, to_insert[i]);
// found in the LICENSE file.
#include "src/compiler/change-lowering.h"
-#include "src/compiler/machine-operator.h"
+#include "src/code-factory.h"
+#include "src/compiler/diamond.h"
#include "src/compiler/js-graph.h"
+#include "src/compiler/linkage.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/node-properties-inl.h"
namespace v8 {
namespace internal {
STATIC_ASSERT(HeapNumber::kValueOffset % kPointerSize == 0);
const int heap_number_value_offset =
((HeapNumber::kValueOffset / kPointerSize) * (machine()->Is64() ? 8 : 4));
- return jsgraph()->Int32Constant(heap_number_value_offset - kHeapObjectTag);
+ return jsgraph()->IntPtrConstant(heap_number_value_offset - kHeapObjectTag);
}
Node* ChangeLowering::SmiShiftBitsConstant() {
const int smi_shift_size = machine()->Is32() ? SmiTagging<4>::SmiShiftSize()
: SmiTagging<8>::SmiShiftSize();
- return jsgraph()->Int32Constant(smi_shift_size + kSmiTagSize);
+ return jsgraph()->IntPtrConstant(smi_shift_size + kSmiTagSize);
}
Node* ChangeLowering::AllocateHeapNumberWithValue(Node* value, Node* control) {
- // The AllocateHeapNumber() runtime function does not use the context, so we
- // can safely pass in Smi zero here.
+ // The AllocateHeapNumberStub does not use the context, so we can safely pass
+ // in Smi zero here.
+ Callable callable = CodeFactory::AllocateHeapNumber(isolate());
+ CallDescriptor* descriptor = linkage()->GetStubCallDescriptor(
+ callable.descriptor(), 0, CallDescriptor::kNoFlags);
+ Node* target = jsgraph()->HeapConstant(callable.code());
Node* context = jsgraph()->ZeroConstant();
Node* effect = graph()->NewNode(common()->ValueEffect(1), value);
- const Runtime::Function* function =
- Runtime::FunctionForId(Runtime::kAllocateHeapNumber);
- DCHECK_EQ(0, function->nargs);
- CallDescriptor* desc = linkage()->GetRuntimeCallDescriptor(
- function->function_id, 0, Operator::kNoProperties);
- Node* heap_number = graph()->NewNode(
- common()->Call(desc), jsgraph()->CEntryStubConstant(),
- jsgraph()->ExternalConstant(ExternalReference(function, isolate())),
- jsgraph()->Int32Constant(function->nargs), context, effect, control);
+ Node* heap_number = graph()->NewNode(common()->Call(descriptor), target,
+ context, effect, control);
Node* store = graph()->NewNode(
machine()->Store(StoreRepresentation(kMachFloat64, kNoWriteBarrier)),
heap_number, HeapNumberValueIndexConstant(), value, heap_number, control);
}
+Node* ChangeLowering::ChangeInt32ToFloat64(Node* value) {
+ return graph()->NewNode(machine()->ChangeInt32ToFloat64(), value);
+}
+
+
+Node* ChangeLowering::ChangeSmiToFloat64(Node* value) {
+ return ChangeInt32ToFloat64(ChangeSmiToInt32(value));
+}
+
+
Node* ChangeLowering::ChangeSmiToInt32(Node* value) {
value = graph()->NewNode(machine()->WordSar(), value, SmiShiftBitsConstant());
if (machine()->Is64()) {
}
+Node* ChangeLowering::ChangeUint32ToFloat64(Node* value) {
+ return graph()->NewNode(machine()->ChangeUint32ToFloat64(), value);
+}
+
+
+Node* ChangeLowering::ChangeUint32ToSmi(Node* value) {
+ if (machine()->Is64()) {
+ value = graph()->NewNode(machine()->ChangeUint32ToUint64(), value);
+ }
+ return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
+}
+
+
Node* ChangeLowering::LoadHeapNumberValue(Node* value, Node* control) {
return graph()->NewNode(machine()->Load(kMachFloat64), value,
- HeapNumberValueIndexConstant(),
- graph()->NewNode(common()->ControlEffect(), control));
+ HeapNumberValueIndexConstant(), graph()->start(),
+ control);
}
-Reduction ChangeLowering::ChangeBitToBool(Node* val, Node* control) {
- Node* branch = graph()->NewNode(common()->Branch(), val, control);
+Node* ChangeLowering::TestNotSmi(Node* value) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagMask == 1);
+ return graph()->NewNode(machine()->WordAnd(), value,
+ jsgraph()->IntPtrConstant(kSmiTagMask));
+}
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* true_value = jsgraph()->TrueConstant();
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* false_value = jsgraph()->FalseConstant();
+Node* ChangeLowering::Uint32LessThanOrEqual(Node* lhs, Node* rhs) {
+ return graph()->NewNode(machine()->Uint32LessThanOrEqual(), lhs, rhs);
+}
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(
- common()->Phi(static_cast<MachineType>(kTypeBool | kRepTagged), 2),
- true_value, false_value, merge);
- return Replace(phi);
+Reduction ChangeLowering::ChangeBitToBool(Node* val, Node* control) {
+ MachineType const type = static_cast<MachineType>(kTypeBool | kRepTagged);
+ return Replace(graph()->NewNode(common()->Select(type), val,
+ jsgraph()->TrueConstant(),
+ jsgraph()->FalseConstant()));
}
}
-Reduction ChangeLowering::ChangeInt32ToTagged(Node* val, Node* control) {
+Reduction ChangeLowering::ChangeInt32ToTagged(Node* value, Node* control) {
if (machine()->Is64()) {
- return Replace(
- graph()->NewNode(machine()->Word64Shl(),
- graph()->NewNode(machine()->ChangeInt32ToInt64(), val),
- SmiShiftBitsConstant()));
+ return Replace(graph()->NewNode(
+ machine()->Word64Shl(),
+ graph()->NewNode(machine()->ChangeInt32ToInt64(), value),
+ SmiShiftBitsConstant()));
}
- Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), val, val);
+ Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), value, value);
Node* ovf = graph()->NewNode(common()->Projection(1), add);
- Node* branch = graph()->NewNode(common()->Branch(), ovf, control);
-
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* heap_number = AllocateHeapNumberWithValue(
- graph()->NewNode(machine()->ChangeInt32ToFloat64(), val), if_true);
-
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* smi = graph()->NewNode(common()->Projection(0), add);
-
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), heap_number,
- smi, merge);
-
- return Replace(phi);
+ Diamond d(graph(), common(), ovf, BranchHint::kFalse);
+ d.Chain(control);
+ return Replace(
+ d.Phi(kMachAnyTagged,
+ AllocateHeapNumberWithValue(ChangeInt32ToFloat64(value), d.if_true),
+ graph()->NewNode(common()->Projection(0), add)));
}
-Reduction ChangeLowering::ChangeTaggedToUI32(Node* val, Node* control,
+Reduction ChangeLowering::ChangeTaggedToUI32(Node* value, Node* control,
Signedness signedness) {
- STATIC_ASSERT(kSmiTag == 0);
- STATIC_ASSERT(kSmiTagMask == 1);
-
- Node* tag = graph()->NewNode(machine()->WordAnd(), val,
- jsgraph()->Int32Constant(kSmiTagMask));
- Node* branch = graph()->NewNode(common()->Branch(), tag, control);
-
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
+ const MachineType type = (signedness == kSigned) ? kMachInt32 : kMachUint32;
const Operator* op = (signedness == kSigned)
? machine()->ChangeFloat64ToInt32()
: machine()->ChangeFloat64ToUint32();
- Node* change = graph()->NewNode(op, LoadHeapNumberValue(val, if_true));
-
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* number = ChangeSmiToInt32(val);
-
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(
- common()->Phi((signedness == kSigned) ? kMachInt32 : kMachUint32, 2),
- change, number, merge);
-
- return Replace(phi);
+ Diamond d(graph(), common(), TestNotSmi(value), BranchHint::kFalse);
+ d.Chain(control);
+ return Replace(
+ d.Phi(type, graph()->NewNode(op, LoadHeapNumberValue(value, d.if_true)),
+ ChangeSmiToInt32(value)));
}
-Reduction ChangeLowering::ChangeTaggedToFloat64(Node* val, Node* control) {
- STATIC_ASSERT(kSmiTag == 0);
- STATIC_ASSERT(kSmiTagMask == 1);
-
- Node* tag = graph()->NewNode(machine()->WordAnd(), val,
- jsgraph()->Int32Constant(kSmiTagMask));
- Node* branch = graph()->NewNode(common()->Branch(), tag, control);
-
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* load = LoadHeapNumberValue(val, if_true);
-
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* number = graph()->NewNode(machine()->ChangeInt32ToFloat64(),
- ChangeSmiToInt32(val));
+namespace {
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi =
- graph()->NewNode(common()->Phi(kMachFloat64, 2), load, number, merge);
-
- return Replace(phi);
+bool CanCover(Node* value, IrOpcode::Value opcode) {
+ if (value->opcode() != opcode) return false;
+ bool first = true;
+ for (auto i = value->uses().begin(); i != value->uses().end(); ++i) {
+ if (NodeProperties::IsEffectEdge(i.edge())) continue;
+ DCHECK(NodeProperties::IsValueEdge(i.edge()));
+ if (!first) return false;
+ first = false;
+ }
+ return true;
}
+} // namespace
+
+
+Reduction ChangeLowering::ChangeTaggedToFloat64(Node* value, Node* control) {
+ if (CanCover(value, IrOpcode::kJSToNumber)) {
+ // ChangeTaggedToFloat64(JSToNumber(x)) =>
+ // if IsSmi(x) then ChangeSmiToFloat64(x)
+ // else let y = JSToNumber(x) in
+ // if IsSmi(y) then ChangeSmiToFloat64(y)
+ // else LoadHeapNumberValue(y)
+ Node* const object = NodeProperties::GetValueInput(value, 0);
+ Node* const context = NodeProperties::GetContextInput(value);
+ Node* const effect = NodeProperties::GetEffectInput(value);
+ Node* const control = NodeProperties::GetControlInput(value);
+
+ Diamond d1(graph(), common(), TestNotSmi(object), BranchHint::kFalse);
+ d1.Chain(control);
+
+ Node* number =
+ graph()->NewNode(value->op(), object, context, effect, d1.if_true);
+ Diamond d2(graph(), common(), TestNotSmi(number));
+ d2.Nest(d1, true);
+ Node* phi2 = d2.Phi(kMachFloat64, LoadHeapNumberValue(number, d2.if_true),
+ ChangeSmiToFloat64(number));
+
+ Node* phi1 = d1.Phi(kMachFloat64, phi2, ChangeSmiToFloat64(object));
+ Node* ephi1 = d1.EffectPhi(number, effect);
+
+ for (auto i = value->uses().begin(); i != value->uses().end();) {
+ if (NodeProperties::IsEffectEdge(i.edge())) {
+ i.UpdateToAndIncrement(ephi1);
+ } else {
+ ++i;
+ }
+ }
+ return Replace(phi1);
+ }
-Reduction ChangeLowering::ChangeUint32ToTagged(Node* val, Node* control) {
- STATIC_ASSERT(kSmiTag == 0);
- STATIC_ASSERT(kSmiTagMask == 1);
-
- Node* cmp = graph()->NewNode(machine()->Uint32LessThanOrEqual(), val,
- SmiMaxValueConstant());
- Node* branch = graph()->NewNode(common()->Branch(), cmp, control);
-
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* smi = graph()->NewNode(
- machine()->WordShl(),
- machine()->Is64()
- ? graph()->NewNode(machine()->ChangeUint32ToUint64(), val)
- : val,
- SmiShiftBitsConstant());
-
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* heap_number = AllocateHeapNumberWithValue(
- graph()->NewNode(machine()->ChangeUint32ToFloat64(), val), if_false);
+ Diamond d(graph(), common(), TestNotSmi(value), BranchHint::kFalse);
+ d.Chain(control);
+ Node* load = LoadHeapNumberValue(value, d.if_true);
+ Node* number = ChangeSmiToFloat64(value);
+ return Replace(d.Phi(kMachFloat64, load, number));
+}
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), smi,
- heap_number, merge);
- return Replace(phi);
+Reduction ChangeLowering::ChangeUint32ToTagged(Node* value, Node* control) {
+ Diamond d(graph(), common(),
+ Uint32LessThanOrEqual(value, SmiMaxValueConstant()),
+ BranchHint::kTrue);
+ d.Chain(control);
+ return Replace(d.Phi(
+ kMachAnyTagged, ChangeUint32ToSmi(value),
+ AllocateHeapNumberWithValue(ChangeUint32ToFloat64(value), d.if_false)));
}
Node* SmiShiftBitsConstant();
Node* AllocateHeapNumberWithValue(Node* value, Node* control);
+ Node* ChangeInt32ToFloat64(Node* value);
+ Node* ChangeSmiToFloat64(Node* value);
Node* ChangeSmiToInt32(Node* value);
+ Node* ChangeUint32ToFloat64(Node* value);
+ Node* ChangeUint32ToSmi(Node* value);
Node* LoadHeapNumberValue(Node* value, Node* control);
+ Node* TestNotSmi(Node* value);
+ Node* Uint32LessThanOrEqual(Node* lhs, Node* rhs);
- Reduction ChangeBitToBool(Node* val, Node* control);
- Reduction ChangeBoolToBit(Node* val);
- Reduction ChangeFloat64ToTagged(Node* val, Node* control);
- Reduction ChangeInt32ToTagged(Node* val, Node* control);
- Reduction ChangeTaggedToFloat64(Node* val, Node* control);
- Reduction ChangeTaggedToUI32(Node* val, Node* control, Signedness signedness);
- Reduction ChangeUint32ToTagged(Node* val, Node* control);
+ Reduction ChangeBitToBool(Node* value, Node* control);
+ Reduction ChangeBoolToBit(Node* value);
+ Reduction ChangeFloat64ToTagged(Node* value, Node* control);
+ Reduction ChangeInt32ToTagged(Node* value, Node* control);
+ Reduction ChangeTaggedToFloat64(Node* value, Node* control);
+ Reduction ChangeTaggedToUI32(Node* value, Node* control,
+ Signedness signedness);
+ Reduction ChangeUint32ToTagged(Node* value, Node* control);
Graph* graph() const;
Isolate* isolate() const;
#ifndef V8_COMPILER_CODE_GENERATOR_IMPL_H_
#define V8_COMPILER_CODE_GENERATOR_IMPL_H_
+#include "src/code-stubs.h"
#include "src/compiler/code-generator.h"
-#include "src/compiler/common-operator.h"
-#include "src/compiler/generic-graph.h"
#include "src/compiler/instruction.h"
#include "src/compiler/linkage.h"
-#include "src/compiler/machine-operator.h"
-#include "src/compiler/node.h"
#include "src/compiler/opcodes.h"
-#include "src/compiler/operator.h"
+#include "src/macro-assembler.h"
namespace v8 {
namespace internal {
return ToHeapObject(instr_->InputAt(index));
}
- Label* InputLabel(int index) {
- return gen_->code()->GetLabel(InputBlock(index));
- }
+ Label* InputLabel(int index) { return gen_->GetLabel(InputRpo(index)); }
- BasicBlock* InputBlock(int index) {
- NodeId block_id = static_cast<NodeId>(InputInt32(index));
- // operand should be a block id.
- DCHECK(block_id >= 0);
- DCHECK(block_id < gen_->schedule()->BasicBlockCount());
- return gen_->schedule()->GetBlockById(block_id);
+ BasicBlock::RpoNumber InputRpo(int index) {
+ int rpo_number = InputInt32(index);
+ return BasicBlock::RpoNumber::FromInt(rpo_number);
}
Register OutputRegister(int index = 0) {
namespace internal {
namespace compiler {
-CodeGenerator::CodeGenerator(InstructionSequence* code)
- : code_(code),
- current_block_(NULL),
+CodeGenerator::CodeGenerator(Frame* frame, Linkage* linkage,
+ InstructionSequence* code, CompilationInfo* info)
+ : frame_(frame),
+ linkage_(linkage),
+ code_(code),
+ info_(info),
+ labels_(zone()->NewArray<Label>(code->InstructionBlockCount())),
+ current_block_(BasicBlock::RpoNumber::Invalid()),
current_source_position_(SourcePosition::Invalid()),
masm_(code->zone()->isolate(), NULL, 0),
resolver_(this),
deoptimization_states_(code->zone()),
deoptimization_literals_(code->zone()),
translations_(code->zone()),
- last_lazy_deopt_pc_(0) {}
+ last_lazy_deopt_pc_(0) {
+ for (int i = 0; i < code->InstructionBlockCount(); ++i) {
+ new (&labels_[i]) Label;
+ }
+}
Handle<Code> CodeGenerator::GenerateCode() {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
// Emit a code line info recording start event.
PositionsRecorder* recorder = masm()->positions_recorder();
info->set_prologue_offset(masm()->pc_offset());
AssemblePrologue();
- // Assemble all instructions.
- for (InstructionSequence::const_iterator i = code()->begin();
- i != code()->end(); ++i) {
- AssembleInstruction(*i);
+ // Assemble all non-deferred blocks, followed by deferred ones.
+ for (int deferred = 0; deferred < 2; ++deferred) {
+ for (auto const block : code()->instruction_blocks()) {
+ if (block->IsDeferred() == (deferred == 0)) {
+ continue;
+ }
+ // Bind a label for a block.
+ current_block_ = block->rpo_number();
+ if (FLAG_code_comments) {
+ // TODO(titzer): these code comments are a giant memory leak.
+ Vector<char> buffer = Vector<char>::New(32);
+ SNPrintF(buffer, "-- B%d start --", block->id().ToInt());
+ masm()->RecordComment(buffer.start());
+ }
+ masm()->bind(GetLabel(current_block_));
+ for (int i = block->code_start(); i < block->code_end(); ++i) {
+ AssembleInstruction(code()->InstructionAt(i));
+ }
+ }
}
FinishCode(masm());
}
+bool CodeGenerator::IsNextInAssemblyOrder(BasicBlock::RpoNumber block) const {
+ return code()->InstructionBlockAt(current_block_)->ao_number().IsNext(
+ code()->InstructionBlockAt(block)->ao_number());
+}
+
+
void CodeGenerator::RecordSafepoint(PointerMap* pointers, Safepoint::Kind kind,
int arguments,
Safepoint::DeoptMode deopt_mode) {
void CodeGenerator::AssembleInstruction(Instruction* instr) {
- if (instr->IsBlockStart()) {
- // Bind a label for a block start and handle parallel moves.
- BlockStartInstruction* block_start = BlockStartInstruction::cast(instr);
- current_block_ = block_start->block();
- if (FLAG_code_comments) {
- // TODO(titzer): these code comments are a giant memory leak.
- Vector<char> buffer = Vector<char>::New(32);
- SNPrintF(buffer, "-- B%d start --", block_start->block()->id());
- masm()->RecordComment(buffer.start());
- }
- masm()->bind(block_start->label());
- }
if (instr->IsGapMoves()) {
// Handle parallel moves associated with the gap instruction.
AssembleGap(GapInstruction::cast(instr));
masm()->positions_recorder()->WriteRecordedPositions();
if (FLAG_code_comments) {
Vector<char> buffer = Vector<char>::New(256);
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
int ln = Script::GetLineNumber(info->script(), code_pos);
int cn = Script::GetColumnNumber(info->script(), code_pos);
if (info->script()->name()->IsString()) {
void CodeGenerator::PopulateDeoptimizationData(Handle<Code> code_object) {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
int deopt_count = static_cast<int>(deoptimization_states_.size());
if (deopt_count == 0) return;
Handle<DeoptimizationInputData> data =
// because it is only used to get locals and arguments (by the debugger and
// f.arguments), and those are the same in the pre-call and post-call
// states.
- if (descriptor->state_combine() != kIgnoreOutput) {
- deopt_state_id =
- BuildTranslation(instr, -1, frame_state_offset, kIgnoreOutput);
+ if (!descriptor->state_combine().IsOutputIgnored()) {
+ deopt_state_id = BuildTranslation(instr, -1, frame_state_offset,
+ OutputFrameStateCombine::Ignore());
}
#if DEBUG
// Make sure all the values live in stack slots or they are immediates.
// (The values should not live in register because registers are clobbered
// by calls.)
- for (size_t i = 0; i < descriptor->size(); i++) {
+ for (size_t i = 0; i < descriptor->GetSize(); i++) {
InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
- CHECK(op->IsStackSlot() || op->IsImmediate());
+ CHECK(op->IsStackSlot() || op->IsDoubleStackSlot() || op->IsImmediate());
}
#endif
safepoints()->RecordLazyDeoptimizationIndex(deopt_state_id);
return code()->GetFrameStateDescriptor(state_id);
}
+struct OperandAndType {
+ OperandAndType(InstructionOperand* operand, MachineType type)
+ : operand_(operand), type_(type) {}
+
+ InstructionOperand* operand_;
+ MachineType type_;
+};
+
+static OperandAndType TypedOperandForFrameState(
+ FrameStateDescriptor* descriptor, Instruction* instr,
+ size_t frame_state_offset, size_t index, OutputFrameStateCombine combine) {
+ DCHECK(index < descriptor->GetSize(combine));
+ switch (combine.kind()) {
+ case OutputFrameStateCombine::kPushOutput: {
+ DCHECK(combine.GetPushCount() <= instr->OutputCount());
+ size_t size_without_output =
+ descriptor->GetSize(OutputFrameStateCombine::Ignore());
+ // If the index is past the existing stack items, return the output.
+ if (index >= size_without_output) {
+ return OperandAndType(instr->OutputAt(index - size_without_output),
+ kMachAnyTagged);
+ }
+ break;
+ }
+ case OutputFrameStateCombine::kPokeAt:
+ size_t index_from_top =
+ descriptor->GetSize(combine) - 1 - combine.GetOffsetToPokeAt();
+ if (index >= index_from_top &&
+ index < index_from_top + instr->OutputCount()) {
+ return OperandAndType(instr->OutputAt(index - index_from_top),
+ kMachAnyTagged);
+ }
+ break;
+ }
+ return OperandAndType(instr->InputAt(frame_state_offset + index),
+ descriptor->GetType(index));
+}
+
void CodeGenerator::BuildTranslationForFrameStateDescriptor(
FrameStateDescriptor* descriptor, Instruction* instr,
if (descriptor->outer_state() != NULL) {
BuildTranslationForFrameStateDescriptor(descriptor->outer_state(), instr,
translation, frame_state_offset,
- kIgnoreOutput);
+ OutputFrameStateCombine::Ignore());
}
int id = Translation::kSelfLiteralId;
case JS_FRAME:
translation->BeginJSFrame(
descriptor->bailout_id(), id,
- static_cast<unsigned int>(descriptor->GetHeight(state_combine)));
+ static_cast<unsigned int>(descriptor->GetSize(state_combine) -
+ descriptor->parameters_count()));
break;
case ARGUMENTS_ADAPTOR:
translation->BeginArgumentsAdaptorFrame(
}
frame_state_offset += descriptor->outer_state()->GetTotalSize();
- for (size_t i = 0; i < descriptor->size(); i++) {
- AddTranslationForOperand(
- translation, instr,
- instr->InputAt(static_cast<int>(frame_state_offset + i)));
- }
-
- switch (state_combine) {
- case kPushOutput:
- DCHECK(instr->OutputCount() == 1);
- AddTranslationForOperand(translation, instr, instr->OutputAt(0));
- break;
- case kIgnoreOutput:
- break;
+ for (size_t i = 0; i < descriptor->GetSize(state_combine); i++) {
+ OperandAndType op = TypedOperandForFrameState(
+ descriptor, instr, frame_state_offset, i, state_combine);
+ AddTranslationForOperand(translation, instr, op.operand_, op.type_);
}
}
void CodeGenerator::AddTranslationForOperand(Translation* translation,
Instruction* instr,
- InstructionOperand* op) {
+ InstructionOperand* op,
+ MachineType type) {
if (op->IsStackSlot()) {
- translation->StoreStackSlot(op->index());
+ if (type == kMachBool || type == kMachInt32 || type == kMachInt8 ||
+ type == kMachInt16) {
+ translation->StoreInt32StackSlot(op->index());
+ } else if (type == kMachUint32) {
+ translation->StoreUint32StackSlot(op->index());
+ } else if ((type & kRepMask) == kRepTagged) {
+ translation->StoreStackSlot(op->index());
+ } else {
+ CHECK(false);
+ }
} else if (op->IsDoubleStackSlot()) {
+ DCHECK((type & (kRepFloat32 | kRepFloat64)) != 0);
translation->StoreDoubleStackSlot(op->index());
} else if (op->IsRegister()) {
InstructionOperandConverter converter(this, instr);
- translation->StoreRegister(converter.ToRegister(op));
+ if (type == kMachBool || type == kMachInt32 || type == kMachInt8 ||
+ type == kMachInt16) {
+ translation->StoreInt32Register(converter.ToRegister(op));
+ } else if (type == kMachUint32) {
+ translation->StoreUint32Register(converter.ToRegister(op));
+ } else if ((type & kRepMask) == kRepTagged) {
+ translation->StoreRegister(converter.ToRegister(op));
+ } else {
+ CHECK(false);
+ }
} else if (op->IsDoubleRegister()) {
+ DCHECK((type & (kRepFloat32 | kRepFloat64)) != 0);
InstructionOperandConverter converter(this, instr);
translation->StoreDoubleRegister(converter.ToDoubleRegister(op));
} else if (op->IsImmediate()) {
Handle<Object> constant_object;
switch (constant.type()) {
case Constant::kInt32:
+ DCHECK(type == kMachInt32 || type == kMachUint32);
constant_object =
isolate()->factory()->NewNumberFromInt(constant.ToInt32());
break;
case Constant::kFloat64:
+ DCHECK(type == kMachFloat64 || type == kMachAnyTagged);
constant_object = isolate()->factory()->NewNumber(constant.ToFloat64());
break;
case Constant::kHeapObject:
+ DCHECK((type & kRepMask) == kRepTagged);
constant_object = constant.ToHeapObject();
break;
default:
- UNREACHABLE();
+ CHECK(false);
}
int literal_id = DefineDeoptimizationLiteral(constant_object);
translation->StoreLiteral(literal_id);
} else {
- UNREACHABLE();
+ CHECK(false);
}
}
namespace internal {
namespace compiler {
+class Linkage;
+
// Generates native code for a sequence of instructions.
class CodeGenerator FINAL : public GapResolver::Assembler {
public:
- explicit CodeGenerator(InstructionSequence* code);
+ explicit CodeGenerator(Frame* frame, Linkage* linkage,
+ InstructionSequence* code, CompilationInfo* info);
// Generate native code.
Handle<Code> GenerateCode();
InstructionSequence* code() const { return code_; }
- Frame* frame() const { return code()->frame(); }
- Graph* graph() const { return code()->graph(); }
+ Frame* frame() const { return frame_; }
Isolate* isolate() const { return zone()->isolate(); }
- Linkage* linkage() const { return code()->linkage(); }
- Schedule* schedule() const { return code()->schedule(); }
+ Linkage* linkage() const { return linkage_; }
+
+ Label* GetLabel(BasicBlock::RpoNumber rpo) { return &labels_[rpo.ToSize()]; }
private:
MacroAssembler* masm() { return &masm_; }
GapResolver* resolver() { return &resolver_; }
SafepointTableBuilder* safepoints() { return &safepoints_; }
Zone* zone() const { return code()->zone(); }
+ CompilationInfo* info() const { return info_; }
// Checks if {block} will appear directly after {current_block_} when
// assembling code, in which case, a fall-through can be used.
- bool IsNextInAssemblyOrder(const BasicBlock* block) const {
- return block->rpo_number_ == (current_block_->rpo_number_ + 1) &&
- block->deferred_ == current_block_->deferred_;
- }
+ bool IsNextInAssemblyOrder(BasicBlock::RpoNumber block) const;
// Record a safepoint with the given pointer map.
void RecordSafepoint(PointerMap* pointers, Safepoint::Kind kind,
Translation* translation, size_t frame_state_offset,
OutputFrameStateCombine state_combine);
void AddTranslationForOperand(Translation* translation, Instruction* instr,
- InstructionOperand* op);
+ InstructionOperand* op, MachineType type);
void AddNopForSmiCodeInlining();
void EnsureSpaceForLazyDeopt();
void MarkLazyDeoptSite();
int pc_offset_;
};
- InstructionSequence* code_;
- BasicBlock* current_block_;
+ Frame* const frame_;
+ Linkage* const linkage_;
+ InstructionSequence* const code_;
+ CompilationInfo* const info_;
+ Label* const labels_;
+ BasicBlock::RpoNumber current_block_;
SourcePosition current_source_position_;
MacroAssembler masm_;
GapResolver resolver_;
return int32_constants_.Find(zone_, value);
}
+ Node** FindInt64Constant(int64_t value) {
+ return int64_constants_.Find(zone_, value);
+ }
+
Node** FindFloat64Constant(double value) {
// We canonicalize double constants at the bit representation level.
return float64_constants_.Find(zone_, bit_cast<int64_t>(value));
Zone* zone() const { return zone_; }
+ void GetCachedNodes(NodeVector* nodes) {
+ int32_constants_.GetCachedNodes(nodes);
+ int64_constants_.GetCachedNodes(nodes);
+ float64_constants_.GetCachedNodes(nodes);
+ external_constants_.GetCachedNodes(nodes);
+ number_constants_.GetCachedNodes(nodes);
+ }
+
private:
Int32NodeCache int32_constants_;
+ Int64NodeCache int64_constants_;
Int64NodeCache float64_constants_;
PtrNodeCache external_constants_;
Int64NodeCache number_constants_;
Zone* zone_;
};
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_COMMON_NODE_CACHE_H_
+++ /dev/null
-// 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/common-operator.h"
-
-#include <limits>
-
-#include "src/compiler/operator-properties-inl.h"
-#include "src/test/test-utils.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-
-// -----------------------------------------------------------------------------
-// Shared operators.
-
-
-namespace {
-
-struct SharedOperator {
- const Operator* (CommonOperatorBuilder::*constructor)();
- IrOpcode::Value opcode;
- Operator::Properties properties;
- int value_input_count;
- int effect_input_count;
- int control_input_count;
- int effect_output_count;
- int control_output_count;
-};
-
-
-std::ostream& operator<<(std::ostream& os, const SharedOperator& fop) {
- return os << IrOpcode::Mnemonic(fop.opcode);
-}
-
-
-const SharedOperator kSharedOperators[] = {
-#define SHARED(Name, properties, value_input_count, effect_input_count, \
- control_input_count, effect_output_count, control_output_count) \
- { \
- &CommonOperatorBuilder::Name, IrOpcode::k##Name, properties, \
- value_input_count, effect_input_count, control_input_count, \
- effect_output_count, control_output_count \
- }
- SHARED(Dead, Operator::kFoldable, 0, 0, 0, 0, 1),
- SHARED(End, Operator::kFoldable, 0, 0, 1, 0, 0),
- SHARED(Branch, Operator::kFoldable, 1, 0, 1, 0, 2),
- SHARED(IfTrue, Operator::kFoldable, 0, 0, 1, 0, 1),
- SHARED(IfFalse, Operator::kFoldable, 0, 0, 1, 0, 1),
- SHARED(Throw, Operator::kFoldable, 1, 0, 1, 0, 1),
- SHARED(Return, Operator::kNoProperties, 1, 1, 1, 1, 1),
- SHARED(ControlEffect, Operator::kPure, 0, 0, 1, 1, 0)
-#undef SHARED
-};
-
-
-class CommonSharedOperatorTest
- : public TestWithZone,
- public ::testing::WithParamInterface<SharedOperator> {};
-
-} // namespace
-
-
-TEST_P(CommonSharedOperatorTest, InstancesAreGloballyShared) {
- const SharedOperator& sop = GetParam();
- CommonOperatorBuilder common1(zone());
- CommonOperatorBuilder common2(zone());
- EXPECT_EQ((common1.*sop.constructor)(), (common2.*sop.constructor)());
-}
-
-
-TEST_P(CommonSharedOperatorTest, NumberOfInputsAndOutputs) {
- CommonOperatorBuilder common(zone());
- const SharedOperator& sop = GetParam();
- const Operator* op = (common.*sop.constructor)();
-
- EXPECT_EQ(sop.value_input_count, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(sop.effect_input_count,
- OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(sop.control_input_count,
- OperatorProperties::GetControlInputCount(op));
- EXPECT_EQ(
- sop.value_input_count + sop.effect_input_count + sop.control_input_count,
- OperatorProperties::GetTotalInputCount(op));
-
- EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(sop.effect_output_count,
- OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(sop.control_output_count,
- OperatorProperties::GetControlOutputCount(op));
-}
-
-
-TEST_P(CommonSharedOperatorTest, OpcodeIsCorrect) {
- CommonOperatorBuilder common(zone());
- const SharedOperator& sop = GetParam();
- const Operator* op = (common.*sop.constructor)();
- EXPECT_EQ(sop.opcode, op->opcode());
-}
-
-
-TEST_P(CommonSharedOperatorTest, Properties) {
- CommonOperatorBuilder common(zone());
- const SharedOperator& sop = GetParam();
- const Operator* op = (common.*sop.constructor)();
- EXPECT_EQ(sop.properties, op->properties());
-}
-
-
-INSTANTIATE_TEST_CASE_P(CommonOperatorTest, CommonSharedOperatorTest,
- ::testing::ValuesIn(kSharedOperators));
-
-
-// -----------------------------------------------------------------------------
-// Other operators.
-
-
-namespace {
-
-class CommonOperatorTest : public TestWithZone {
- public:
- CommonOperatorTest() : common_(zone()) {}
- virtual ~CommonOperatorTest() {}
-
- CommonOperatorBuilder* common() { return &common_; }
-
- private:
- CommonOperatorBuilder common_;
-};
-
-
-const int kArguments[] = {1, 5, 6, 42, 100, 10000, kMaxInt};
-
-const float kFloat32Values[] = {
- std::numeric_limits<float>::min(), -1.0f, -0.0f, 0.0f, 1.0f,
- std::numeric_limits<float>::max()};
-
-} // namespace
-
-
-TEST_F(CommonOperatorTest, Float32Constant) {
- TRACED_FOREACH(float, value, kFloat32Values) {
- const Operator* op = common()->Float32Constant(value);
- EXPECT_FLOAT_EQ(value, OpParameter<float>(op));
- EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
- }
-}
-
-
-TEST_F(CommonOperatorTest, ValueEffect) {
- TRACED_FOREACH(int, arguments, kArguments) {
- const Operator* op = common()->ValueEffect(arguments);
- EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
- }
-}
-
-
-TEST_F(CommonOperatorTest, Finish) {
- TRACED_FOREACH(int, arguments, kArguments) {
- const Operator* op = common()->Finish(arguments);
- EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
- }
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
#include "src/assembler.h"
#include "src/base/lazy-instance.h"
#include "src/compiler/linkage.h"
+#include "src/compiler/opcodes.h"
+#include "src/compiler/operator.h"
#include "src/unique.h"
#include "src/zone.h"
namespace internal {
namespace compiler {
-namespace {
+std::ostream& operator<<(std::ostream& os, BranchHint hint) {
+ switch (hint) {
+ case BranchHint::kNone:
+ return os << "None";
+ case BranchHint::kTrue:
+ return os << "True";
+ case BranchHint::kFalse:
+ return os << "False";
+ }
+ UNREACHABLE();
+ return os;
+}
-// TODO(turbofan): Use size_t instead of int here.
-class ControlOperator : public Operator1<int> {
- public:
- ControlOperator(IrOpcode::Value opcode, Properties properties, int inputs,
- int outputs, int controls, const char* mnemonic)
- : Operator1<int>(opcode, properties, inputs, outputs, mnemonic,
- controls) {}
- virtual OStream& PrintParameter(OStream& os) const FINAL { return os; }
-};
+BranchHint BranchHintOf(const Operator* const op) {
+ DCHECK_EQ(IrOpcode::kBranch, op->opcode());
+ return OpParameter<BranchHint>(op);
+}
-} // namespace
+bool operator==(SelectParameters const& lhs, SelectParameters const& rhs) {
+ return lhs.type() == rhs.type() && lhs.hint() == rhs.hint();
+}
-// Specialization for static parameters of type {ExternalReference}.
-template <>
-struct StaticParameterTraits<ExternalReference> {
- static OStream& PrintTo(OStream& os, ExternalReference reference) {
- os << reference.address();
- // TODO(bmeurer): Move to operator<<(os, ExternalReference)
- const Runtime::Function* function =
- Runtime::FunctionForEntry(reference.address());
- if (function) {
- os << " <" << function->name << ".entry>";
- }
- return os;
- }
- static int HashCode(ExternalReference reference) {
- return bit_cast<int>(static_cast<uint32_t>(
- reinterpret_cast<uintptr_t>(reference.address())));
- }
- static bool Equals(ExternalReference lhs, ExternalReference rhs) {
- return lhs == rhs;
+
+bool operator!=(SelectParameters const& lhs, SelectParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(SelectParameters const& p) {
+ return base::hash_combine(p.type(), p.hint());
+}
+
+
+std::ostream& operator<<(std::ostream& os, SelectParameters const& p) {
+ return os << p.type() << "|" << p.hint();
+}
+
+
+SelectParameters const& SelectParametersOf(const Operator* const op) {
+ DCHECK_EQ(IrOpcode::kSelect, op->opcode());
+ return OpParameter<SelectParameters>(op);
+}
+
+
+size_t hash_value(OutputFrameStateCombine const& sc) {
+ return base::hash_combine(sc.kind_, sc.parameter_);
+}
+
+
+std::ostream& operator<<(std::ostream& os, OutputFrameStateCombine const& sc) {
+ switch (sc.kind_) {
+ case OutputFrameStateCombine::kPushOutput:
+ if (sc.parameter_ == 0) return os << "Ignore";
+ return os << "Push(" << sc.parameter_ << ")";
+ case OutputFrameStateCombine::kPokeAt:
+ return os << "PokeAt(" << sc.parameter_ << ")";
}
-};
+ UNREACHABLE();
+ return os;
+}
-#define SHARED_OP_LIST(V) \
- V(Dead, Operator::kFoldable, 0, 0) \
- V(End, Operator::kFoldable, 0, 1) \
- V(Branch, Operator::kFoldable, 1, 1) \
- V(IfTrue, Operator::kFoldable, 0, 1) \
- V(IfFalse, Operator::kFoldable, 0, 1) \
- V(Throw, Operator::kFoldable, 1, 1) \
- V(Return, Operator::kNoProperties, 1, 1)
+bool operator==(FrameStateCallInfo const& lhs, FrameStateCallInfo const& rhs) {
+ return lhs.type() == rhs.type() && lhs.bailout_id() == rhs.bailout_id() &&
+ lhs.state_combine() == rhs.state_combine();
+}
-struct CommonOperatorBuilderImpl FINAL {
-#define SHARED(Name, properties, value_input_count, control_input_count) \
- struct Name##Operator FINAL : public ControlOperator { \
- Name##Operator() \
- : ControlOperator(IrOpcode::k##Name, properties, value_input_count, 0, \
- control_input_count, #Name) {} \
- }; \
- Name##Operator k##Name##Operator;
- SHARED_OP_LIST(SHARED)
-#undef SHARED
+bool operator!=(FrameStateCallInfo const& lhs, FrameStateCallInfo const& rhs) {
+ return !(lhs == rhs);
+}
- struct ControlEffectOperator FINAL : public SimpleOperator {
- ControlEffectOperator()
- : SimpleOperator(IrOpcode::kControlEffect, Operator::kPure, 0, 0,
- "ControlEffect") {}
- };
- ControlEffectOperator kControlEffectOperator;
+
+size_t hash_value(FrameStateCallInfo const& info) {
+ return base::hash_combine(info.type(), info.bailout_id(),
+ info.state_combine());
+}
+
+
+std::ostream& operator<<(std::ostream& os, FrameStateCallInfo const& info) {
+ return os << info.type() << ", " << info.bailout_id() << ", "
+ << info.state_combine();
+}
+
+
+#define CACHED_OP_LIST(V) \
+ V(Dead, Operator::kFoldable, 0, 0, 0, 1) \
+ V(End, Operator::kFoldable, 0, 0, 1, 0) \
+ V(IfTrue, Operator::kFoldable, 0, 0, 1, 1) \
+ V(IfFalse, Operator::kFoldable, 0, 0, 1, 1) \
+ V(Throw, Operator::kFoldable, 1, 1, 1, 1) \
+ V(Return, Operator::kNoProperties, 1, 1, 1, 1)
+
+
+struct CommonOperatorGlobalCache FINAL {
+#define CACHED(Name, properties, value_input_count, effect_input_count, \
+ control_input_count, control_output_count) \
+ struct Name##Operator FINAL : public Operator { \
+ Name##Operator() \
+ : Operator(IrOpcode::k##Name, properties, #Name, value_input_count, \
+ effect_input_count, control_input_count, 0, 0, \
+ control_output_count) {} \
+ }; \
+ Name##Operator k##Name##Operator;
+ CACHED_OP_LIST(CACHED)
+#undef CACHED
};
-static base::LazyInstance<CommonOperatorBuilderImpl>::type kImpl =
+static base::LazyInstance<CommonOperatorGlobalCache>::type kCache =
LAZY_INSTANCE_INITIALIZER;
CommonOperatorBuilder::CommonOperatorBuilder(Zone* zone)
- : impl_(kImpl.Get()), zone_(zone) {}
+ : cache_(kCache.Get()), zone_(zone) {}
-#define SHARED(Name, properties, value_input_count, control_input_count) \
- const Operator* CommonOperatorBuilder::Name() { \
- return &impl_.k##Name##Operator; \
+#define CACHED(Name, properties, value_input_count, effect_input_count, \
+ control_input_count, control_output_count) \
+ const Operator* CommonOperatorBuilder::Name() { \
+ return &cache_.k##Name##Operator; \
}
-SHARED_OP_LIST(SHARED)
-#undef SHARED
+CACHED_OP_LIST(CACHED)
+#undef CACHED
+
+
+const Operator* CommonOperatorBuilder::Branch(BranchHint hint) {
+ return new (zone()) Operator1<BranchHint>(
+ IrOpcode::kBranch, Operator::kFoldable, "Branch", 1, 0, 1, 0, 0, 2, hint);
+}
const Operator* CommonOperatorBuilder::Start(int num_formal_parameters) {
// Outputs are formal parameters, plus context, receiver, and JSFunction.
const int value_output_count = num_formal_parameters + 3;
- return new (zone()) ControlOperator(IrOpcode::kStart, Operator::kFoldable, 0,
- value_output_count, 0, "Start");
+ return new (zone()) Operator( // --
+ IrOpcode::kStart, Operator::kFoldable, // opcode
+ "Start", // name
+ 0, 0, 0, value_output_count, 1, 1); // counts
}
const Operator* CommonOperatorBuilder::Merge(int controls) {
- return new (zone()) ControlOperator(IrOpcode::kMerge, Operator::kFoldable, 0,
- 0, controls, "Merge");
+ return new (zone()) Operator( // --
+ IrOpcode::kMerge, Operator::kFoldable, // opcode
+ "Merge", // name
+ 0, 0, controls, 0, 0, 1); // counts
}
const Operator* CommonOperatorBuilder::Loop(int controls) {
- return new (zone()) ControlOperator(IrOpcode::kLoop, Operator::kFoldable, 0,
- 0, controls, "Loop");
+ return new (zone()) Operator( // --
+ IrOpcode::kLoop, Operator::kFoldable, // opcode
+ "Loop", // name
+ 0, 0, controls, 0, 0, 1); // counts
+}
+
+
+const Operator* CommonOperatorBuilder::Terminate(int effects) {
+ return new (zone()) Operator( // --
+ IrOpcode::kTerminate, Operator::kPure, // opcode
+ "Terminate", // name
+ 0, effects, 1, 0, 0, 1); // counts
}
const Operator* CommonOperatorBuilder::Parameter(int index) {
- return new (zone()) Operator1<int>(IrOpcode::kParameter, Operator::kPure, 1,
- 1, "Parameter", index);
+ return new (zone()) Operator1<int>( // --
+ IrOpcode::kParameter, Operator::kPure, // opcode
+ "Parameter", // name
+ 1, 0, 0, 1, 0, 0, // counts
+ index); // parameter
}
const Operator* CommonOperatorBuilder::Int32Constant(int32_t value) {
- return new (zone()) Operator1<int32_t>(
- IrOpcode::kInt32Constant, Operator::kPure, 0, 1, "Int32Constant", value);
+ return new (zone()) Operator1<int32_t>( // --
+ IrOpcode::kInt32Constant, Operator::kPure, // opcode
+ "Int32Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Int64Constant(int64_t value) {
- return new (zone()) Operator1<int64_t>(
- IrOpcode::kInt64Constant, Operator::kPure, 0, 1, "Int64Constant", value);
+ return new (zone()) Operator1<int64_t>( // --
+ IrOpcode::kInt64Constant, Operator::kPure, // opcode
+ "Int64Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Float32Constant(volatile float value) {
return new (zone())
- Operator1<float>(IrOpcode::kFloat32Constant, Operator::kPure, 0, 1,
- "Float32Constant", value);
+ Operator1<float, base::bit_equal_to<float>, base::bit_hash<float>>( // --
+ IrOpcode::kFloat32Constant, Operator::kPure, // opcode
+ "Float32Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::Float64Constant(volatile double value) {
- return new (zone())
- Operator1<double>(IrOpcode::kFloat64Constant, Operator::kPure, 0, 1,
- "Float64Constant", value);
+ return new (zone()) Operator1<double, base::bit_equal_to<double>,
+ base::bit_hash<double>>( // --
+ IrOpcode::kFloat64Constant, Operator::kPure, // opcode
+ "Float64Constant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::ExternalConstant(
const ExternalReference& value) {
- return new (zone())
- Operator1<ExternalReference>(IrOpcode::kExternalConstant, Operator::kPure,
- 0, 1, "ExternalConstant", value);
+ return new (zone()) Operator1<ExternalReference>( // --
+ IrOpcode::kExternalConstant, Operator::kPure, // opcode
+ "ExternalConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::NumberConstant(volatile double value) {
- return new (zone())
- Operator1<double>(IrOpcode::kNumberConstant, Operator::kPure, 0, 1,
- "NumberConstant", value);
+ return new (zone()) Operator1<double, base::bit_equal_to<double>,
+ base::bit_hash<double>>( // --
+ IrOpcode::kNumberConstant, Operator::kPure, // opcode
+ "NumberConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
const Operator* CommonOperatorBuilder::HeapConstant(
- const Unique<Object>& value) {
- return new (zone()) Operator1<Unique<Object> >(
- IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value);
+ const Unique<HeapObject>& value) {
+ return new (zone()) Operator1<Unique<HeapObject>>( // --
+ IrOpcode::kHeapConstant, Operator::kPure, // opcode
+ "HeapConstant", // name
+ 0, 0, 0, 1, 0, 0, // counts
+ value); // parameter
}
-const Operator* CommonOperatorBuilder::Phi(MachineType type, int arguments) {
- DCHECK(arguments > 0); // Disallow empty phis.
- return new (zone()) Operator1<MachineType>(IrOpcode::kPhi, Operator::kPure,
- arguments, 1, "Phi", type);
+const Operator* CommonOperatorBuilder::Select(MachineType type,
+ BranchHint hint) {
+ return new (zone()) Operator1<SelectParameters>( // --
+ IrOpcode::kSelect, Operator::kPure, // opcode
+ "Select", // name
+ 3, 0, 0, 1, 0, 0, // counts
+ SelectParameters(type, hint)); // parameter
}
-const Operator* CommonOperatorBuilder::EffectPhi(int arguments) {
- DCHECK(arguments > 0); // Disallow empty phis.
- return new (zone()) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
- 0, "EffectPhi", arguments);
+const Operator* CommonOperatorBuilder::Phi(MachineType type, int arguments) {
+ DCHECK(arguments > 0); // Disallow empty phis.
+ return new (zone()) Operator1<MachineType>( // --
+ IrOpcode::kPhi, Operator::kPure, // opcode
+ "Phi", // name
+ arguments, 0, 1, 1, 0, 0, // counts
+ type); // parameter
}
-const Operator* CommonOperatorBuilder::ControlEffect() {
- return &impl_.kControlEffectOperator;
+const Operator* CommonOperatorBuilder::EffectPhi(int arguments) {
+ DCHECK(arguments > 0); // Disallow empty phis.
+ return new (zone()) Operator( // --
+ IrOpcode::kEffectPhi, Operator::kPure, // opcode
+ "EffectPhi", // name
+ 0, arguments, 1, 0, 1, 0); // counts
}
const Operator* CommonOperatorBuilder::ValueEffect(int arguments) {
- DCHECK(arguments > 0); // Disallow empty value effects.
- return new (zone()) SimpleOperator(IrOpcode::kValueEffect, Operator::kPure,
- arguments, 0, "ValueEffect");
+ DCHECK(arguments > 0); // Disallow empty value effects.
+ return new (zone()) Operator( // --
+ IrOpcode::kValueEffect, Operator::kPure, // opcode
+ "ValueEffect", // name
+ arguments, 0, 0, 0, 1, 0); // counts
}
const Operator* CommonOperatorBuilder::Finish(int arguments) {
- DCHECK(arguments > 0); // Disallow empty finishes.
- return new (zone()) Operator1<int>(IrOpcode::kFinish, Operator::kPure, 1, 1,
- "Finish", arguments);
+ DCHECK(arguments > 0); // Disallow empty finishes.
+ return new (zone()) Operator( // --
+ IrOpcode::kFinish, Operator::kPure, // opcode
+ "Finish", // name
+ 1, arguments, 0, 1, 0, 0); // counts
}
const Operator* CommonOperatorBuilder::StateValues(int arguments) {
- return new (zone()) Operator1<int>(IrOpcode::kStateValues, Operator::kPure,
- arguments, 1, "StateValues", arguments);
+ return new (zone()) Operator( // --
+ IrOpcode::kStateValues, Operator::kPure, // opcode
+ "StateValues", // name
+ arguments, 0, 0, 1, 0, 0); // counts
}
const Operator* CommonOperatorBuilder::FrameState(
FrameStateType type, BailoutId bailout_id,
OutputFrameStateCombine state_combine, MaybeHandle<JSFunction> jsfunction) {
- return new (zone()) Operator1<FrameStateCallInfo>(
- IrOpcode::kFrameState, Operator::kPure, 4, 1, "FrameState",
+ return new (zone()) Operator1<FrameStateCallInfo>( // --
+ IrOpcode::kFrameState, Operator::kPure, // opcode
+ "FrameState", // name
+ 4, 0, 0, 1, 0, 0, // counts
FrameStateCallInfo(type, bailout_id, state_combine, jsfunction));
}
const Operator* CommonOperatorBuilder::Call(const CallDescriptor* descriptor) {
class CallOperator FINAL : public Operator1<const CallDescriptor*> {
public:
- // TODO(titzer): Operator still uses int, whereas CallDescriptor uses
- // size_t.
CallOperator(const CallDescriptor* descriptor, const char* mnemonic)
: Operator1<const CallDescriptor*>(
- IrOpcode::kCall, descriptor->properties(),
- static_cast<int>(descriptor->InputCount() +
- descriptor->FrameStateCount()),
- static_cast<int>(descriptor->ReturnCount()), mnemonic,
- descriptor) {}
-
- virtual OStream& PrintParameter(OStream& os) const OVERRIDE {
- return os << "[" << *parameter() << "]";
+ IrOpcode::kCall, descriptor->properties(), mnemonic,
+ descriptor->InputCount() + descriptor->FrameStateCount(),
+ Operator::ZeroIfPure(descriptor->properties()),
+ Operator::ZeroIfPure(descriptor->properties()),
+ descriptor->ReturnCount(),
+ Operator::ZeroIfPure(descriptor->properties()), 0, descriptor) {}
+
+ virtual void PrintParameter(std::ostream& os) const OVERRIDE {
+ os << "[" << *parameter() << "]";
}
};
return new (zone()) CallOperator(descriptor, "Call");
const Operator* CommonOperatorBuilder::Projection(size_t index) {
- return new (zone()) Operator1<size_t>(IrOpcode::kProjection, Operator::kPure,
- 1, 1, "Projection", index);
+ return new (zone()) Operator1<size_t>( // --
+ IrOpcode::kProjection, Operator::kPure, // opcode
+ "Projection", // name
+ 1, 0, 0, 1, 0, 0, // counts
+ index); // parameter
}
} // namespace compiler
// Forward declarations.
class ExternalReference;
-class OStream;
namespace compiler {
// Forward declarations.
class CallDescriptor;
-struct CommonOperatorBuilderImpl;
+struct CommonOperatorGlobalCache;
class Operator;
+// Prediction hint for branches.
+enum class BranchHint : uint8_t { kNone, kTrue, kFalse };
+
+inline size_t hash_value(BranchHint hint) { return static_cast<size_t>(hint); }
+
+std::ostream& operator<<(std::ostream&, BranchHint);
+
+BranchHint BranchHintOf(const Operator* const);
+
+
+class SelectParameters FINAL {
+ public:
+ explicit SelectParameters(MachineType type,
+ BranchHint hint = BranchHint::kNone)
+ : type_(type), hint_(hint) {}
+
+ MachineType type() const { return type_; }
+ BranchHint hint() const { return hint_; }
+
+ private:
+ const MachineType type_;
+ const BranchHint hint_;
+};
+
+bool operator==(SelectParameters const&, SelectParameters const&);
+bool operator!=(SelectParameters const&, SelectParameters const&);
+
+size_t hash_value(SelectParameters const& p);
+
+std::ostream& operator<<(std::ostream&, SelectParameters const& p);
+
+SelectParameters const& SelectParametersOf(const Operator* const);
+
+
// Flag that describes how to combine the current environment with
// the output of a node to obtain a framestate for lazy bailout.
-enum OutputFrameStateCombine {
- kPushOutput, // Push the output on the expression stack.
- kIgnoreOutput // Use the frame state as-is.
+class OutputFrameStateCombine {
+ public:
+ enum Kind {
+ kPushOutput, // Push the output on the expression stack.
+ kPokeAt // Poke at the given environment location,
+ // counting from the top of the stack.
+ };
+
+ static OutputFrameStateCombine Ignore() {
+ return OutputFrameStateCombine(kPushOutput, 0);
+ }
+ static OutputFrameStateCombine Push(size_t count = 1) {
+ return OutputFrameStateCombine(kPushOutput, count);
+ }
+ static OutputFrameStateCombine PokeAt(size_t index) {
+ return OutputFrameStateCombine(kPokeAt, index);
+ }
+
+ Kind kind() const { return kind_; }
+ size_t GetPushCount() const {
+ DCHECK_EQ(kPushOutput, kind());
+ return parameter_;
+ }
+ size_t GetOffsetToPokeAt() const {
+ DCHECK_EQ(kPokeAt, kind());
+ return parameter_;
+ }
+
+ bool IsOutputIgnored() const {
+ return kind_ == kPushOutput && parameter_ == 0;
+ }
+
+ size_t ConsumedOutputCount() const {
+ return kind_ == kPushOutput ? GetPushCount() : 1;
+ }
+
+ bool operator==(OutputFrameStateCombine const& other) const {
+ return kind_ == other.kind_ && parameter_ == other.parameter_;
+ }
+ bool operator!=(OutputFrameStateCombine const& other) const {
+ return !(*this == other);
+ }
+
+ friend size_t hash_value(OutputFrameStateCombine const&);
+ friend std::ostream& operator<<(std::ostream&,
+ OutputFrameStateCombine const&);
+
+ private:
+ OutputFrameStateCombine(Kind kind, size_t parameter)
+ : kind_(kind), parameter_(parameter) {}
+
+ Kind const kind_;
+ size_t const parameter_;
};
MaybeHandle<JSFunction> jsfunction_;
};
+bool operator==(FrameStateCallInfo const&, FrameStateCallInfo const&);
+bool operator!=(FrameStateCallInfo const&, FrameStateCallInfo const&);
+
+size_t hash_value(FrameStateCallInfo const&);
+
+std::ostream& operator<<(std::ostream&, FrameStateCallInfo const&);
+
// Interface for building common operators that can be used at any level of IR,
// including JavaScript, mid-level, and low-level.
-class CommonOperatorBuilder FINAL {
+class CommonOperatorBuilder FINAL : public ZoneObject {
public:
explicit CommonOperatorBuilder(Zone* zone);
const Operator* Dead();
const Operator* End();
- const Operator* Branch();
+ const Operator* Branch(BranchHint = BranchHint::kNone);
const Operator* IfTrue();
const Operator* IfFalse();
const Operator* Throw();
+ const Operator* Terminate(int effects);
const Operator* Return();
const Operator* Start(int num_formal_parameters);
const Operator* Float64Constant(volatile double);
const Operator* ExternalConstant(const ExternalReference&);
const Operator* NumberConstant(volatile double);
- const Operator* HeapConstant(const Unique<Object>&);
+ const Operator* HeapConstant(const Unique<HeapObject>&);
+ const Operator* Select(MachineType, BranchHint = BranchHint::kNone);
const Operator* Phi(MachineType type, int arguments);
const Operator* EffectPhi(int arguments);
- const Operator* ControlEffect();
const Operator* ValueEffect(int arguments);
const Operator* Finish(int arguments);
const Operator* StateValues(int arguments);
private:
Zone* zone() const { return zone_; }
- const CommonOperatorBuilderImpl& impl_;
+ const CommonOperatorGlobalCache& cache_;
Zone* const zone_;
+
+ DISALLOW_COPY_AND_ASSIGN(CommonOperatorBuilder);
};
} // namespace compiler
+++ /dev/null
-# 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.
-
-{
- 'variables': {
- 'v8_code': 1,
- },
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
- 'targets': [
- {
- 'target_name': 'compiler-unittests',
- 'type': 'executable',
- 'dependencies': [
- '../test/test.gyp:run-all-unittests',
- ],
- 'include_dirs': [
- '../..',
- ],
- 'sources': [ ### gcmole(all) ###
- 'change-lowering-unittest.cc',
- 'common-operator-unittest.cc',
- 'compiler-test-utils.h',
- 'graph-reducer-unittest.cc',
- 'graph-unittest.cc',
- 'graph-unittest.h',
- 'instruction-selector-unittest.cc',
- 'instruction-selector-unittest.h',
- 'js-builtin-reducer-unittest.cc',
- 'machine-operator-reducer-unittest.cc',
- 'machine-operator-unittest.cc',
- 'simplified-operator-reducer-unittest.cc',
- 'simplified-operator-unittest.cc',
- 'value-numbering-reducer-unittest.cc',
- ],
- 'conditions': [
- ['v8_target_arch=="arm"', {
- 'sources': [ ### gcmole(arch:arm) ###
- 'arm/instruction-selector-arm-unittest.cc',
- ],
- }],
- ['v8_target_arch=="arm64"', {
- 'sources': [ ### gcmole(arch:arm64) ###
- 'arm64/instruction-selector-arm64-unittest.cc',
- ],
- }],
- ['v8_target_arch=="ia32"', {
- 'sources': [ ### gcmole(arch:ia32) ###
- 'ia32/instruction-selector-ia32-unittest.cc',
- ],
- }],
- ['v8_target_arch=="x64"', {
- 'sources': [ ### gcmole(arch:x64) ###
- 'x64/instruction-selector-x64-unittest.cc',
- ],
- }],
- ],
- },
- ],
-}
namespace compiler {
-void IfBuilder::If(Node* condition) {
- builder_->NewBranch(condition);
+void IfBuilder::If(Node* condition, BranchHint hint) {
+ builder_->NewBranch(condition, hint);
else_environment_ = environment()->CopyForConditional();
}
}
-void LoopBuilder::BeginLoop() {
+void LoopBuilder::BeginLoop(BitVector* assigned) {
builder_->NewLoop();
- loop_environment_ = environment()->CopyForLoop();
+ loop_environment_ = environment()->CopyForLoop(assigned);
continue_environment_ = environment()->CopyAsUnreachable();
break_environment_ = environment()->CopyAsUnreachable();
}
namespace internal {
namespace compiler {
-
// Base class for all control builders. Also provides a common interface for
// control builders to handle 'break' and 'continue' statements when they are
// used to model breakable statements.
typedef StructuredGraphBuilder Builder;
typedef StructuredGraphBuilder::Environment Environment;
- Zone* zone() const { return builder_->zone(); }
+ Zone* zone() const { return builder_->local_zone(); }
Environment* environment() { return builder_->environment(); }
void set_environment(Environment* env) { builder_->set_environment(env); }
else_environment_(NULL) {}
// Primitive control commands.
- void If(Node* condition);
+ void If(Node* condition, BranchHint hint = BranchHint::kNone);
void Then();
void Else();
void End();
break_environment_(NULL) {}
// Primitive control commands.
- void BeginLoop();
+ void BeginLoop(BitVector* assigned);
void EndBody();
void EndLoop();
--- /dev/null
+// 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/common-operator.h"
+#include "src/compiler/control-reducer.h"
+#include "src/compiler/graph.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/node-matchers.h"
+#include "src/compiler/node-properties-inl.h"
+#include "src/zone-containers.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+enum VisitState { kUnvisited = 0, kOnStack = 1, kRevisit = 2, kVisited = 3 };
+enum Reachability { kFromStart = 8 };
+
+#define TRACE(x) \
+ if (FLAG_trace_turbo_reduction) PrintF x
+
+class ControlReducerImpl {
+ public:
+ ControlReducerImpl(Zone* zone, JSGraph* jsgraph,
+ CommonOperatorBuilder* common)
+ : zone_(zone),
+ jsgraph_(jsgraph),
+ common_(common),
+ state_(jsgraph->graph()->NodeCount(), kUnvisited, zone_),
+ stack_(zone_),
+ revisit_(zone_),
+ dead_(NULL) {}
+
+ Zone* zone_;
+ JSGraph* jsgraph_;
+ CommonOperatorBuilder* common_;
+ ZoneVector<VisitState> state_;
+ ZoneDeque<Node*> stack_;
+ ZoneDeque<Node*> revisit_;
+ Node* dead_;
+
+ void Reduce() {
+ Push(graph()->end());
+ do {
+ // Process the node on the top of the stack, potentially pushing more
+ // or popping the node off the stack.
+ ReduceTop();
+ // If the stack becomes empty, revisit any nodes in the revisit queue.
+ // If no nodes in the revisit queue, try removing dead loops.
+ // If no dead loops, then finish.
+ } while (!stack_.empty() || TryRevisit() || RepairAndRemoveLoops());
+ }
+
+ bool TryRevisit() {
+ while (!revisit_.empty()) {
+ Node* n = revisit_.back();
+ revisit_.pop_back();
+ if (state_[n->id()] == kRevisit) { // state can change while in queue.
+ Push(n);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // Repair the graph after the possible creation of non-terminating or dead
+ // loops. Removing dead loops can produce more opportunities for reduction.
+ bool RepairAndRemoveLoops() {
+ // TODO(turbofan): we can skip this if the graph has no loops, but
+ // we have to be careful about proper loop detection during reduction.
+
+ // Gather all nodes backwards-reachable from end (through inputs).
+ state_.assign(graph()->NodeCount(), kUnvisited);
+ NodeVector nodes(zone_);
+ AddNodesReachableFromEnd(nodes);
+
+ // Walk forward through control nodes, looking for back edges to nodes
+ // that are not connected to end. Those are non-terminating loops (NTLs).
+ Node* start = graph()->start();
+ ZoneVector<byte> fw_reachability(graph()->NodeCount(), 0, zone_);
+ fw_reachability[start->id()] = kFromStart | kOnStack;
+
+ // We use a stack of (Node, UseIter) pairs to avoid O(n^2) traversal.
+ typedef std::pair<Node*, UseIter> FwIter;
+ ZoneDeque<FwIter> fw_stack(zone_);
+ fw_stack.push_back(FwIter(start, start->uses().begin()));
+
+ while (!fw_stack.empty()) {
+ Node* node = fw_stack.back().first;
+ TRACE(("ControlFw: #%d:%s\n", node->id(), node->op()->mnemonic()));
+ bool pop = true;
+ while (fw_stack.back().second != node->uses().end()) {
+ Node* succ = *(fw_stack.back().second);
+ byte reach = fw_reachability[succ->id()];
+ if ((reach & kOnStack) != 0 && state_[succ->id()] != kVisited) {
+ // {succ} is on stack and not reachable from end.
+ ConnectNTL(nodes, succ);
+ fw_reachability.resize(graph()->NodeCount(), 0);
+ // The use list of {succ} might have changed.
+ fw_stack[fw_stack.size() - 1] = FwIter(succ, succ->uses().begin());
+ pop = false; // restart traversing successors of this node.
+ break;
+ }
+ if ((reach & kFromStart) == 0 &&
+ IrOpcode::IsControlOpcode(succ->opcode())) {
+ // {succ} is a control node and not yet reached from start.
+ fw_reachability[succ->id()] |= kFromStart | kOnStack;
+ fw_stack.push_back(FwIter(succ, succ->uses().begin()));
+ pop = false; // "recurse" into successor control node.
+ break;
+ }
+ ++fw_stack.back().second;
+ }
+ if (pop) {
+ fw_reachability[node->id()] &= ~kOnStack;
+ fw_stack.pop_back();
+ }
+ }
+
+ // Trim references from dead nodes to live nodes first.
+ jsgraph_->GetCachedNodes(&nodes);
+ TrimNodes(nodes);
+
+ // Any control nodes not reachable from start are dead, even loops.
+ for (size_t i = 0; i < nodes.size(); i++) {
+ Node* node = nodes[i];
+ byte reach = fw_reachability[node->id()];
+ if ((reach & kFromStart) == 0 &&
+ IrOpcode::IsControlOpcode(node->opcode())) {
+ ReplaceNode(node, dead()); // uses will be added to revisit queue.
+ }
+ }
+ return TryRevisit(); // try to push a node onto the stack.
+ }
+
+ // Connect {loop}, the header of a non-terminating loop, to the end node.
+ void ConnectNTL(NodeVector& nodes, Node* loop) {
+ TRACE(("ConnectNTL: #%d:%s\n", loop->id(), loop->op()->mnemonic()));
+
+ if (loop->opcode() != IrOpcode::kTerminate) {
+ // Insert a {Terminate} node if the loop has effects.
+ ZoneDeque<Node*> effects(zone_);
+ for (Node* const use : loop->uses()) {
+ if (use->opcode() == IrOpcode::kEffectPhi) effects.push_back(use);
+ }
+ int count = static_cast<int>(effects.size());
+ if (count > 0) {
+ Node** inputs = zone_->NewArray<Node*>(1 + count);
+ for (int i = 0; i < count; i++) inputs[i] = effects[i];
+ inputs[count] = loop;
+ loop = graph()->NewNode(common_->Terminate(count), 1 + count, inputs);
+ TRACE(("AddTerminate: #%d:%s[%d]\n", loop->id(), loop->op()->mnemonic(),
+ count));
+ }
+ }
+
+ Node* to_add = loop;
+ Node* end = graph()->end();
+ CHECK_EQ(IrOpcode::kEnd, end->opcode());
+ Node* merge = end->InputAt(0);
+ if (merge == NULL || merge->opcode() == IrOpcode::kDead) {
+ // The end node died; just connect end to {loop}.
+ end->ReplaceInput(0, loop);
+ } else if (merge->opcode() != IrOpcode::kMerge) {
+ // Introduce a final merge node for {end->InputAt(0)} and {loop}.
+ merge = graph()->NewNode(common_->Merge(2), merge, loop);
+ end->ReplaceInput(0, merge);
+ to_add = merge;
+ } else {
+ // Append a new input to the final merge at the end.
+ merge->AppendInput(graph()->zone(), loop);
+ merge->set_op(common_->Merge(merge->InputCount()));
+ }
+ nodes.push_back(to_add);
+ state_.resize(graph()->NodeCount(), kUnvisited);
+ state_[to_add->id()] = kVisited;
+ AddBackwardsReachableNodes(nodes, nodes.size() - 1);
+ }
+
+ void AddNodesReachableFromEnd(NodeVector& nodes) {
+ Node* end = graph()->end();
+ state_[end->id()] = kVisited;
+ if (!end->IsDead()) {
+ nodes.push_back(end);
+ AddBackwardsReachableNodes(nodes, nodes.size() - 1);
+ }
+ }
+
+ void AddBackwardsReachableNodes(NodeVector& nodes, size_t cursor) {
+ while (cursor < nodes.size()) {
+ Node* node = nodes[cursor++];
+ for (Node* const input : node->inputs()) {
+ if (state_[input->id()] != kVisited) {
+ state_[input->id()] = kVisited;
+ nodes.push_back(input);
+ }
+ }
+ }
+ }
+
+ void Trim() {
+ // Gather all nodes backwards-reachable from end through inputs.
+ state_.assign(graph()->NodeCount(), kUnvisited);
+ NodeVector nodes(zone_);
+ AddNodesReachableFromEnd(nodes);
+
+ // Process cached nodes in the JSGraph too.
+ jsgraph_->GetCachedNodes(&nodes);
+ TrimNodes(nodes);
+ }
+
+ void TrimNodes(NodeVector& nodes) {
+ // Remove dead->live edges.
+ for (size_t j = 0; j < nodes.size(); j++) {
+ Node* node = nodes[j];
+ for (UseIter i = node->uses().begin(); i != node->uses().end();) {
+ size_t id = static_cast<size_t>((*i)->id());
+ if (state_[id] != kVisited) {
+ TRACE(("DeadLink: #%d:%s(%d) -> #%d:%s\n", (*i)->id(),
+ (*i)->op()->mnemonic(), i.index(), node->id(),
+ node->op()->mnemonic()));
+ i.UpdateToAndIncrement(NULL);
+ } else {
+ ++i;
+ }
+ }
+ }
+#if DEBUG
+ // Verify that no inputs to live nodes are NULL.
+ for (size_t j = 0; j < nodes.size(); j++) {
+ Node* node = nodes[j];
+ for (Node* const input : node->inputs()) {
+ CHECK_NE(NULL, input);
+ }
+ for (Node* const use : node->uses()) {
+ size_t id = static_cast<size_t>(use->id());
+ CHECK_EQ(kVisited, state_[id]);
+ }
+ }
+#endif
+ }
+
+ // Reduce the node on the top of the stack.
+ // If an input {i} is not yet visited or needs to be revisited, push {i} onto
+ // the stack and return. Otherwise, all inputs are visited, so apply
+ // reductions for {node} and pop it off the stack.
+ void ReduceTop() {
+ size_t height = stack_.size();
+ Node* node = stack_.back();
+
+ if (node->IsDead()) return Pop(); // Node was killed while on stack.
+
+ TRACE(("ControlReduce: #%d:%s\n", node->id(), node->op()->mnemonic()));
+
+ // Recurse on an input if necessary.
+ for (Node* const input : node->inputs()) {
+ if (Recurse(input)) return;
+ }
+
+ // All inputs should be visited or on stack. Apply reductions to node.
+ Node* replacement = ReduceNode(node);
+ if (replacement != node) ReplaceNode(node, replacement);
+
+ // After reducing the node, pop it off the stack.
+ CHECK_EQ(static_cast<int>(height), static_cast<int>(stack_.size()));
+ Pop();
+
+ // If there was a replacement, reduce it after popping {node}.
+ if (replacement != node) Recurse(replacement);
+ }
+
+ // Push a node onto the stack if its state is {kUnvisited} or {kRevisit}.
+ bool Recurse(Node* node) {
+ size_t id = static_cast<size_t>(node->id());
+ if (id < state_.size()) {
+ if (state_[id] != kRevisit && state_[id] != kUnvisited) return false;
+ } else {
+ state_.resize((3 * id) / 2, kUnvisited);
+ }
+ Push(node);
+ return true;
+ }
+
+ void Push(Node* node) {
+ state_[node->id()] = kOnStack;
+ stack_.push_back(node);
+ }
+
+ void Pop() {
+ int pos = static_cast<int>(stack_.size()) - 1;
+ DCHECK_GE(pos, 0);
+ DCHECK_EQ(kOnStack, state_[stack_[pos]->id()]);
+ state_[stack_[pos]->id()] = kVisited;
+ stack_.pop_back();
+ }
+
+ // Queue a node to be revisited if it has been visited once already.
+ void Revisit(Node* node) {
+ size_t id = static_cast<size_t>(node->id());
+ if (id < state_.size() && state_[id] == kVisited) {
+ TRACE((" Revisit #%d:%s\n", node->id(), node->op()->mnemonic()));
+ state_[id] = kRevisit;
+ revisit_.push_back(node);
+ }
+ }
+
+ Node* dead() {
+ if (dead_ == NULL) dead_ = graph()->NewNode(common_->Dead());
+ return dead_;
+ }
+
+ //===========================================================================
+ // Reducer implementation: perform reductions on a node.
+ //===========================================================================
+ Node* ReduceNode(Node* node) {
+ if (node->op()->ControlInputCount() == 1) {
+ // If a node has only one control input and it is dead, replace with dead.
+ Node* control = NodeProperties::GetControlInput(node);
+ if (control->opcode() == IrOpcode::kDead) {
+ TRACE(("ControlDead: #%d:%s\n", node->id(), node->op()->mnemonic()));
+ return control;
+ }
+ }
+
+ // Reduce branches, phis, and merges.
+ switch (node->opcode()) {
+ case IrOpcode::kBranch:
+ return ReduceBranch(node);
+ case IrOpcode::kLoop:
+ case IrOpcode::kMerge:
+ return ReduceMerge(node);
+ case IrOpcode::kSelect:
+ return ReduceSelect(node);
+ case IrOpcode::kPhi:
+ case IrOpcode::kEffectPhi:
+ return ReducePhi(node);
+ default:
+ return node;
+ }
+ }
+
+ // Reduce redundant selects.
+ Node* ReduceSelect(Node* const node) {
+ Node* const cond = node->InputAt(0);
+ Node* const tvalue = node->InputAt(1);
+ Node* const fvalue = node->InputAt(2);
+ if (tvalue == fvalue) return tvalue;
+ switch (cond->opcode()) {
+ case IrOpcode::kInt32Constant:
+ return Int32Matcher(cond).Is(0) ? fvalue : tvalue;
+ case IrOpcode::kInt64Constant:
+ return Int64Matcher(cond).Is(0) ? fvalue : tvalue;
+ case IrOpcode::kNumberConstant:
+ return NumberMatcher(cond).Is(0) ? fvalue : tvalue;
+ case IrOpcode::kHeapConstant: {
+ Handle<Object> object =
+ HeapObjectMatcher<Object>(cond).Value().handle();
+ if (object->IsTrue()) return tvalue;
+ if (object->IsFalse()) return fvalue;
+ break;
+ }
+ default:
+ break;
+ }
+ return node;
+ }
+
+ // Reduce redundant phis.
+ Node* ReducePhi(Node* node) {
+ int n = node->InputCount();
+ if (n <= 1) return dead(); // No non-control inputs.
+ if (n == 2) return node->InputAt(0); // Only one non-control input.
+
+ Node* replacement = NULL;
+ Node::Inputs inputs = node->inputs();
+ for (InputIter it = inputs.begin(); n > 1; --n, ++it) {
+ Node* input = *it;
+ if (input->opcode() == IrOpcode::kDead) continue; // ignore dead inputs.
+ if (input != node && input != replacement) { // non-redundant input.
+ if (replacement != NULL) return node;
+ replacement = input;
+ }
+ }
+ return replacement == NULL ? dead() : replacement;
+ }
+
+ // Reduce merges by trimming away dead inputs from the merge and phis.
+ Node* ReduceMerge(Node* node) {
+ // Count the number of live inputs.
+ int live = 0;
+ int index = 0;
+ int live_index = 0;
+ for (Node* const input : node->inputs()) {
+ if (input->opcode() != IrOpcode::kDead) {
+ live++;
+ live_index = index;
+ }
+ index++;
+ }
+
+ if (live > 1 && live == node->InputCount()) return node; // nothing to do.
+
+ TRACE(("ReduceMerge: #%d:%s (%d live)\n", node->id(),
+ node->op()->mnemonic(), live));
+
+ if (live == 0) return dead(); // no remaining inputs.
+
+ // Gather phis and effect phis to be edited.
+ ZoneVector<Node*> phis(zone_);
+ for (Node* const use : node->uses()) {
+ if (use->opcode() == IrOpcode::kPhi ||
+ use->opcode() == IrOpcode::kEffectPhi) {
+ phis.push_back(use);
+ }
+ }
+
+ if (live == 1) {
+ // All phis are redundant. Replace them with their live input.
+ for (Node* const phi : phis) ReplaceNode(phi, phi->InputAt(live_index));
+ // The merge itself is redundant.
+ return node->InputAt(live_index);
+ }
+
+ // Edit phis in place, removing dead inputs and revisiting them.
+ for (Node* const phi : phis) {
+ TRACE((" PhiInMerge: #%d:%s (%d live)\n", phi->id(),
+ phi->op()->mnemonic(), live));
+ RemoveDeadInputs(node, phi);
+ Revisit(phi);
+ }
+ // Edit the merge in place, removing dead inputs.
+ RemoveDeadInputs(node, node);
+ return node;
+ }
+
+ // Reduce branches if they have constant inputs.
+ Node* ReduceBranch(Node* node) {
+ Node* cond = node->InputAt(0);
+ bool is_true;
+ switch (cond->opcode()) {
+ case IrOpcode::kInt32Constant:
+ is_true = !Int32Matcher(cond).Is(0);
+ break;
+ case IrOpcode::kInt64Constant:
+ is_true = !Int64Matcher(cond).Is(0);
+ break;
+ case IrOpcode::kNumberConstant:
+ is_true = !NumberMatcher(cond).Is(0);
+ break;
+ case IrOpcode::kHeapConstant: {
+ Handle<Object> object =
+ HeapObjectMatcher<Object>(cond).Value().handle();
+ if (object->IsTrue())
+ is_true = true;
+ else if (object->IsFalse())
+ is_true = false;
+ else
+ return node; // TODO(turbofan): fold branches on strings, objects.
+ break;
+ }
+ default:
+ return node;
+ }
+
+ TRACE(("BranchReduce: #%d:%s = %s\n", node->id(), node->op()->mnemonic(),
+ is_true ? "true" : "false"));
+
+ // Replace IfTrue and IfFalse projections from this branch.
+ Node* control = NodeProperties::GetControlInput(node);
+ for (UseIter i = node->uses().begin(); i != node->uses().end();) {
+ Node* to = *i;
+ if (to->opcode() == IrOpcode::kIfTrue) {
+ TRACE((" IfTrue: #%d:%s\n", to->id(), to->op()->mnemonic()));
+ i.UpdateToAndIncrement(NULL);
+ ReplaceNode(to, is_true ? control : dead());
+ } else if (to->opcode() == IrOpcode::kIfFalse) {
+ TRACE((" IfFalse: #%d:%s\n", to->id(), to->op()->mnemonic()));
+ i.UpdateToAndIncrement(NULL);
+ ReplaceNode(to, is_true ? dead() : control);
+ } else {
+ ++i;
+ }
+ }
+ return control;
+ }
+
+ // Remove inputs to {node} corresponding to the dead inputs to {merge}
+ // and compact the remaining inputs, updating the operator.
+ void RemoveDeadInputs(Node* merge, Node* node) {
+ int pos = 0;
+ for (int i = 0; i < node->InputCount(); i++) {
+ // skip dead inputs.
+ if (i < merge->InputCount() &&
+ merge->InputAt(i)->opcode() == IrOpcode::kDead)
+ continue;
+ // compact live inputs.
+ if (pos != i) node->ReplaceInput(pos, node->InputAt(i));
+ pos++;
+ }
+ node->TrimInputCount(pos);
+ if (node->opcode() == IrOpcode::kPhi) {
+ node->set_op(common_->Phi(OpParameter<MachineType>(node->op()), pos - 1));
+ } else if (node->opcode() == IrOpcode::kEffectPhi) {
+ node->set_op(common_->EffectPhi(pos - 1));
+ } else if (node->opcode() == IrOpcode::kMerge) {
+ node->set_op(common_->Merge(pos));
+ } else if (node->opcode() == IrOpcode::kLoop) {
+ node->set_op(common_->Loop(pos));
+ } else {
+ UNREACHABLE();
+ }
+ }
+
+ // Replace uses of {node} with {replacement} and revisit the uses.
+ void ReplaceNode(Node* node, Node* replacement) {
+ if (node == replacement) return;
+ TRACE((" Replace: #%d:%s with #%d:%s\n", node->id(),
+ node->op()->mnemonic(), replacement->id(),
+ replacement->op()->mnemonic()));
+ for (Node* const use : node->uses()) {
+ // Don't revisit this node if it refers to itself.
+ if (use != node) Revisit(use);
+ }
+ node->ReplaceUses(replacement);
+ node->Kill();
+ }
+
+ Graph* graph() { return jsgraph_->graph(); }
+};
+
+
+void ControlReducer::ReduceGraph(Zone* zone, JSGraph* jsgraph,
+ CommonOperatorBuilder* common) {
+ ControlReducerImpl impl(zone, jsgraph, common);
+ impl.Reduce();
+ impl.Trim();
+}
+
+
+void ControlReducer::TrimGraph(Zone* zone, JSGraph* jsgraph) {
+ ControlReducerImpl impl(zone, jsgraph, NULL);
+ impl.Trim();
+}
+
+
+Node* ControlReducer::ReducePhiForTesting(JSGraph* jsgraph,
+ CommonOperatorBuilder* common,
+ Node* node) {
+ Zone zone(jsgraph->graph()->zone()->isolate());
+ ControlReducerImpl impl(&zone, jsgraph, common);
+ return impl.ReducePhi(node);
+}
+
+
+Node* ControlReducer::ReduceMergeForTesting(JSGraph* jsgraph,
+ CommonOperatorBuilder* common,
+ Node* node) {
+ Zone zone(jsgraph->graph()->zone()->isolate());
+ ControlReducerImpl impl(&zone, jsgraph, common);
+ return impl.ReduceMerge(node);
+}
+
+
+Node* ControlReducer::ReduceBranchForTesting(JSGraph* jsgraph,
+ CommonOperatorBuilder* common,
+ Node* node) {
+ Zone zone(jsgraph->graph()->zone()->isolate());
+ ControlReducerImpl impl(&zone, jsgraph, common);
+ return impl.ReduceBranch(node);
+}
+}
+}
+} // namespace v8::internal::compiler
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_CONTROL_REDUCER_H_
+#define V8_COMPILER_CONTROL_REDUCER_H_
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class JSGraph;
+class CommonOperatorBuilder;
+class Node;
+
+class ControlReducer {
+ public:
+ // Perform branch folding and dead code elimination on the graph.
+ static void ReduceGraph(Zone* zone, JSGraph* graph,
+ CommonOperatorBuilder* builder);
+
+ // Trim nodes in the graph that are not reachable from end.
+ static void TrimGraph(Zone* zone, JSGraph* graph);
+
+ // Testing interface.
+ static Node* ReducePhiForTesting(JSGraph* graph,
+ CommonOperatorBuilder* builder, Node* node);
+ static Node* ReduceBranchForTesting(JSGraph* graph,
+ CommonOperatorBuilder* builder,
+ Node* node);
+ static Node* ReduceMergeForTesting(JSGraph* graph,
+ CommonOperatorBuilder* builder,
+ Node* node);
+};
+}
+}
+} // namespace v8::internal::compiler
+
+#endif // V8_COMPILER_CONTROL_REDUCER_H_
--- /dev/null
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_COMPILER_DIAMOND_H_
+#define V8_COMPILER_DIAMOND_H_
+
+#include "src/v8.h"
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/graph-inl.h"
+#include "src/compiler/node.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// A helper to make it easier to build diamond-shaped control patterns.
+struct Diamond {
+ Graph* graph;
+ CommonOperatorBuilder* common;
+ Node* branch;
+ Node* if_true;
+ Node* if_false;
+ Node* merge;
+
+ Diamond(Graph* g, CommonOperatorBuilder* b, Node* cond,
+ BranchHint hint = BranchHint::kNone) {
+ graph = g;
+ common = b;
+ branch = graph->NewNode(common->Branch(hint), cond, graph->start());
+ if_true = graph->NewNode(common->IfTrue(), branch);
+ if_false = graph->NewNode(common->IfFalse(), branch);
+ merge = graph->NewNode(common->Merge(2), if_true, if_false);
+ }
+
+ // Place {this} after {that} in control flow order.
+ void Chain(Diamond& that) { branch->ReplaceInput(1, that.merge); }
+
+ // Place {this} after {that} in control flow order.
+ void Chain(Node* that) { branch->ReplaceInput(1, that); }
+
+ // Nest {this} into either the if_true or if_false branch of {that}.
+ void Nest(Diamond& that, bool if_true) {
+ if (if_true) {
+ branch->ReplaceInput(1, that.if_true);
+ that.merge->ReplaceInput(0, merge);
+ } else {
+ branch->ReplaceInput(1, that.if_false);
+ that.merge->ReplaceInput(1, merge);
+ }
+ }
+
+ Node* Phi(MachineType machine_type, Node* tv, Node* fv) {
+ return graph->NewNode(common->Phi(machine_type, 2), tv, fv, merge);
+ }
+
+ Node* EffectPhi(Node* tv, Node* fv) {
+ return graph->NewNode(common->EffectPhi(2), tv, fv, merge);
+ }
+
+ void OverwriteWithPhi(Node* node, MachineType machine_type, Node* tv,
+ Node* fv) {
+ DCHECK(node->InputCount() >= 3);
+ node->set_op(common->Phi(machine_type, 2));
+ node->ReplaceInput(0, tv);
+ node->ReplaceInput(1, fv);
+ node->ReplaceInput(2, merge);
+ node->TrimInputCount(3);
+ }
+
+ void OverwriteWithEffectPhi(Node* node, Node* te, Node* fe) {
+ DCHECK(node->InputCount() >= 3);
+ node->set_op(common->EffectPhi(2));
+ node->ReplaceInput(0, te);
+ node->ReplaceInput(1, fe);
+ node->ReplaceInput(2, merge);
+ node->TrimInputCount(3);
+ }
+};
+}
+}
+} // namespace v8::internal::compiler
+
+#endif // V8_COMPILER_DIAMOND_H_
#include "src/v8.h"
-#include "src/data-flow.h"
+#include "src/bit-vector.h"
namespace v8 {
namespace internal {
// by specifying custom traits.
class GenericGraphVisit {
public:
- enum Control {
- CONTINUE = 0x0, // Continue depth-first normally
- SKIP = 0x1, // Skip this node and its successors
- REENTER = 0x2, // Allow reentering this node
- DEFER = SKIP | REENTER
- };
-
// struct Visitor {
- // Control Pre(Traits::Node* current);
- // Control Post(Traits::Node* current);
+ // void Pre(Traits::Node* current);
+ // void Post(Traits::Node* current);
// void PreEdge(Traits::Node* from, int index, Traits::Node* to);
// void PostEdge(Traits::Node* from, int index, Traits::Node* to);
// }
DCHECK(id < Traits::max_id(graph)); // Must be a valid id.
bool visit = !GetVisited(&visited, id);
if (visit) {
- Control control = visitor->Pre(current);
- visit = !IsSkip(control);
- if (!IsReenter(control)) SetVisited(&visited, id, true);
+ visitor->Pre(current);
+ SetVisited(&visited, id);
}
Iterator begin(visit ? Traits::begin(current) : Traits::end(current));
Iterator end(Traits::end(current));
NodeState top = stack.top();
if (top.first == top.second) {
if (visit) {
- Control control = visitor->Post(post_order_node);
- DCHECK(!IsSkip(control));
- SetVisited(&visited, post_order_node->id(), !IsReenter(control));
+ visitor->Post(post_order_node);
+ SetVisited(&visited, post_order_node->id());
}
stack.pop();
if (stack.empty()) {
template <class B, class S>
struct NullNodeVisitor {
- Control Pre(GenericNode<B, S>* node) { return CONTINUE; }
- Control Post(GenericNode<B, S>* node) { return CONTINUE; }
+ void Pre(GenericNode<B, S>* node) {}
+ void Post(GenericNode<B, S>* node) {}
void PreEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
void PostEdge(GenericNode<B, S>* from, int index, GenericNode<B, S>* to) {}
};
private:
- static bool IsSkip(Control c) { return c & SKIP; }
- static bool IsReenter(Control c) { return c & REENTER; }
-
- // TODO(turbofan): resizing could be optionally templatized away.
- static void SetVisited(BoolVector* visited, int id, bool value) {
+ static void SetVisited(BoolVector* visited, int id) {
if (id >= static_cast<int>(visited->size())) {
// Resize and set all values to unvisited.
visited->resize((3 * id) / 2, false);
}
- visited->at(id) = value;
+ visited->at(id) = true;
}
static bool GetVisited(BoolVector* visited, int id) {
explicit GenericGraph(Zone* zone)
: GenericGraphBase(zone), start_(NULL), end_(NULL) {}
- V* start() { return start_; }
- V* end() { return end_; }
+ V* start() const { return start_; }
+ V* end() const { return end_; }
void SetStart(V* start) { start_ = start; }
void SetEnd(V* end) { end_ = end; }
namespace compiler {
template <class B, class S>
-GenericNode<B, S>::GenericNode(GenericGraphBase* graph, int input_count)
+GenericNode<B, S>::GenericNode(GenericGraphBase* graph, int input_count,
+ int reserve_input_count)
: BaseClass(graph->zone()),
input_count_(input_count),
+ reserve_input_count_(reserve_input_count),
has_appendable_inputs_(false),
use_count_(0),
first_use_(NULL),
last_use_(NULL) {
- inputs_.static_ = reinterpret_cast<Input*>(this + 1), AssignUniqueID(graph);
+ DCHECK(reserve_input_count <= kMaxReservedInputs);
+ inputs_.static_ = reinterpret_cast<Input*>(this + 1);
+ AssignUniqueID(graph);
}
template <class B, class S>
template <class B, class S>
void GenericNode<B, S>::AppendInput(Zone* zone, GenericNode<B, S>* to_append) {
- EnsureAppendableInputs(zone);
Use* new_use = new (zone) Use;
Input new_input;
new_input.to = to_append;
new_input.use = new_use;
- inputs_.appendable_->push_back(new_input);
+ if (reserve_input_count_ > 0) {
+ DCHECK(!has_appendable_inputs_);
+ reserve_input_count_--;
+ inputs_.static_[input_count_] = new_input;
+ } else {
+ EnsureAppendableInputs(zone);
+ inputs_.appendable_->push_back(new_input);
+ }
new_use->input_index = input_count_;
new_use->from = this;
to_append->AppendUse(new_use);
}
template <class B, class S>
-S* GenericNode<B, S>::New(GenericGraphBase* graph, int input_count,
- S** inputs) {
+S* GenericNode<B, S>::New(GenericGraphBase* graph, int input_count, S** inputs,
+ bool has_extensible_inputs) {
size_t node_size = sizeof(GenericNode);
- size_t inputs_size = input_count * sizeof(Input);
+ int reserve_input_count = has_extensible_inputs ? kDefaultReservedInputs : 0;
+ size_t inputs_size = (input_count + reserve_input_count) * sizeof(Input);
size_t uses_size = input_count * sizeof(Use);
int size = static_cast<int>(node_size + inputs_size + uses_size);
Zone* zone = graph->zone();
void* buffer = zone->New(size);
- S* result = new (buffer) S(graph, input_count);
+ S* result = new (buffer) S(graph, input_count, reserve_input_count);
Input* input =
reinterpret_cast<Input*>(reinterpret_cast<char*>(buffer) + node_size);
Use* use =
bool OwnedBy(GenericNode* owner) const;
- static S* New(GenericGraphBase* graph, int input_count, S** inputs);
+ static S* New(GenericGraphBase* graph, int input_count, S** inputs,
+ bool has_extensible_inputs);
protected:
friend class GenericGraphBase;
void* operator new(size_t, void* location) { return location; }
- GenericNode(GenericGraphBase* graph, int input_count);
+ GenericNode(GenericGraphBase* graph, int input_count,
+ int reserved_input_count);
private:
void AssignUniqueID(GenericGraphBase* graph);
typedef ZoneDeque<Input> InputDeque;
+ static const int kReservedInputCountBits = 2;
+ static const int kMaxReservedInputs = (1 << kReservedInputCountBits) - 1;
+ static const int kDefaultReservedInputs = kMaxReservedInputs;
+
NodeId id_;
- int input_count_ : 31;
+ int input_count_ : 29;
+ unsigned int reserve_input_count_ : kReservedInputCountBits;
bool has_appendable_inputs_ : 1;
union {
// When a node is initially allocated, it uses a static buffer to hold its
namespace compiler {
-StructuredGraphBuilder::StructuredGraphBuilder(Graph* graph,
+StructuredGraphBuilder::StructuredGraphBuilder(Zone* local_zone, Graph* graph,
CommonOperatorBuilder* common)
: GraphBuilder(graph),
common_(common),
environment_(NULL),
+ local_zone_(local_zone),
+ input_buffer_size_(0),
+ input_buffer_(NULL),
current_context_(NULL),
- exit_control_(NULL) {}
+ exit_control_(NULL) {
+ EnsureInputBufferSize(kInputBufferSizeIncrement);
+}
+
+
+Node** StructuredGraphBuilder::EnsureInputBufferSize(int size) {
+ if (size > input_buffer_size_) {
+ size += kInputBufferSizeIncrement;
+ input_buffer_ = local_zone()->NewArray<Node*>(size);
+ }
+ return input_buffer_;
+}
Node* StructuredGraphBuilder::MakeNode(const Operator* op,
int value_input_count,
- Node** value_inputs) {
+ Node** value_inputs, bool incomplete) {
DCHECK(op->InputCount() == value_input_count);
bool has_context = OperatorProperties::HasContextInput(op);
bool has_framestate = OperatorProperties::HasFrameStateInput(op);
- bool has_control = OperatorProperties::GetControlInputCount(op) == 1;
- bool has_effect = OperatorProperties::GetEffectInputCount(op) == 1;
+ bool has_control = op->ControlInputCount() == 1;
+ bool has_effect = op->EffectInputCount() == 1;
- DCHECK(OperatorProperties::GetControlInputCount(op) < 2);
- DCHECK(OperatorProperties::GetEffectInputCount(op) < 2);
+ DCHECK(op->ControlInputCount() < 2);
+ DCHECK(op->EffectInputCount() < 2);
Node* result = NULL;
if (!has_context && !has_framestate && !has_control && !has_effect) {
- result = graph()->NewNode(op, value_input_count, value_inputs);
+ result = graph()->NewNode(op, value_input_count, value_inputs, incomplete);
} else {
int input_count_with_deps = value_input_count;
if (has_context) ++input_count_with_deps;
if (has_framestate) ++input_count_with_deps;
if (has_control) ++input_count_with_deps;
if (has_effect) ++input_count_with_deps;
- Node** buffer = zone()->NewArray<Node*>(input_count_with_deps);
+ Node** buffer = EnsureInputBufferSize(input_count_with_deps);
memcpy(buffer, value_inputs, kPointerSize * value_input_count);
Node** current_input = buffer + value_input_count;
if (has_context) {
if (has_control) {
*current_input++ = environment_->GetControlDependency();
}
- result = graph()->NewNode(op, input_count_with_deps, buffer);
+ result = graph()->NewNode(op, input_count_with_deps, buffer, incomplete);
if (has_effect) {
environment_->UpdateEffectDependency(result);
}
- if (OperatorProperties::HasControlOutput(result->op()) &&
+ if (result->op()->ControlOutputCount() > 0 &&
!environment()->IsMarkedAsUnreachable()) {
environment_->UpdateControlDependency(result);
}
StructuredGraphBuilder::Environment* StructuredGraphBuilder::CopyEnvironment(
Environment* env) {
- return new (zone()) Environment(*env);
+ return new (local_zone()) Environment(*env);
}
: builder_(copy.builder()),
control_dependency_(copy.control_dependency_),
effect_dependency_(copy.effect_dependency_),
- values_(copy.values_) {}
+ values_(copy.zone()) {
+ const size_t kStackEstimate = 7; // optimum from experimentation!
+ values_.reserve(copy.values_.size() + kStackEstimate);
+ values_.insert(values_.begin(), copy.values_.begin(), copy.values_.end());
+}
void StructuredGraphBuilder::Environment::Merge(Environment* other) {
// placing a singleton merge as the new control dependency.
if (this->IsMarkedAsUnreachable()) {
Node* other_control = other->control_dependency_;
- control_dependency_ = graph()->NewNode(common()->Merge(1), other_control);
+ Node* inputs[] = {other_control};
+ control_dependency_ =
+ graph()->NewNode(common()->Merge(1), arraysize(inputs), inputs, true);
effect_dependency_ = other->effect_dependency_;
values_ = other->values_;
return;
}
-void StructuredGraphBuilder::Environment::PrepareForLoop() {
+void StructuredGraphBuilder::Environment::PrepareForLoop(BitVector* assigned) {
Node* control = GetControlDependency();
- for (int i = 0; i < static_cast<int>(values()->size()); ++i) {
- Node* phi = builder_->NewPhi(1, values()->at(i), control);
- values()->at(i) = phi;
+ int size = static_cast<int>(values()->size());
+ if (assigned == NULL) {
+ // Assume that everything is updated in the loop.
+ for (int i = 0; i < size; ++i) {
+ Node* phi = builder_->NewPhi(1, values()->at(i), control);
+ values()->at(i) = phi;
+ }
+ } else {
+ // Only build phis for those locals assigned in this loop.
+ for (int i = 0; i < size; ++i) {
+ if (i < assigned->length() && !assigned->Contains(i)) continue;
+ Node* phi = builder_->NewPhi(1, values()->at(i), control);
+ values()->at(i) = phi;
+ }
}
Node* effect = builder_->NewEffectPhi(1, GetEffectDependency(), control);
UpdateEffectDependency(effect);
Node* StructuredGraphBuilder::NewPhi(int count, Node* input, Node* control) {
const Operator* phi_op = common()->Phi(kMachAnyTagged, count);
- Node** buffer = zone()->NewArray<Node*>(count + 1);
+ Node** buffer = EnsureInputBufferSize(count + 1);
MemsetPointer(buffer, input, count);
buffer[count] = control;
- return graph()->NewNode(phi_op, count + 1, buffer);
+ return graph()->NewNode(phi_op, count + 1, buffer, true);
}
Node* StructuredGraphBuilder::NewEffectPhi(int count, Node* input,
Node* control) {
const Operator* phi_op = common()->EffectPhi(count);
- Node** buffer = zone()->NewArray<Node*>(count + 1);
+ Node** buffer = EnsureInputBufferSize(count + 1);
MemsetPointer(buffer, input, count);
buffer[count] = control;
- return graph()->NewNode(phi_op, count + 1, buffer);
+ return graph()->NewNode(phi_op, count + 1, buffer, true);
}
Node* StructuredGraphBuilder::MergeControl(Node* control, Node* other) {
- int inputs = OperatorProperties::GetControlInputCount(control->op()) + 1;
+ int inputs = control->op()->ControlInputCount() + 1;
if (control->opcode() == IrOpcode::kLoop) {
// Control node for loop exists, add input.
const Operator* op = common()->Loop(inputs);
- control->AppendInput(zone(), other);
+ control->AppendInput(graph_zone(), other);
control->set_op(op);
} else if (control->opcode() == IrOpcode::kMerge) {
// Control node for merge exists, add input.
const Operator* op = common()->Merge(inputs);
- control->AppendInput(zone(), other);
+ control->AppendInput(graph_zone(), other);
control->set_op(op);
} else {
// Control node is a singleton, introduce a merge.
const Operator* op = common()->Merge(inputs);
- control = graph()->NewNode(op, control, other);
+ Node* inputs[] = {control, other};
+ control = graph()->NewNode(op, arraysize(inputs), inputs, true);
}
return control;
}
Node* StructuredGraphBuilder::MergeEffect(Node* value, Node* other,
Node* control) {
- int inputs = OperatorProperties::GetControlInputCount(control->op());
+ int inputs = control->op()->ControlInputCount();
if (value->opcode() == IrOpcode::kEffectPhi &&
NodeProperties::GetControlInput(value) == control) {
// Phi already exists, add input.
value->set_op(common()->EffectPhi(inputs));
- value->InsertInput(zone(), inputs - 1, other);
+ value->InsertInput(graph_zone(), inputs - 1, other);
} else if (value != other) {
// Phi does not exist yet, introduce one.
value = NewEffectPhi(inputs, value, control);
Node* StructuredGraphBuilder::MergeValue(Node* value, Node* other,
Node* control) {
- int inputs = OperatorProperties::GetControlInputCount(control->op());
+ int inputs = control->op()->ControlInputCount();
if (value->opcode() == IrOpcode::kPhi &&
NodeProperties::GetControlInput(value) == control) {
// Phi already exists, add input.
value->set_op(common()->Phi(kMachAnyTagged, inputs));
- value->InsertInput(zone(), inputs - 1, other);
+ value->InsertInput(graph_zone(), inputs - 1, other);
} else if (value != other) {
// Phi does not exist yet, introduce one.
value = NewPhi(inputs, value, control);
namespace v8 {
namespace internal {
+
+class BitVector;
+
namespace compiler {
class Node;
explicit GraphBuilder(Graph* graph) : graph_(graph) {}
virtual ~GraphBuilder() {}
- Node* NewNode(const Operator* op) {
- return MakeNode(op, 0, static_cast<Node**>(NULL));
+ Node* NewNode(const Operator* op, bool incomplete = false) {
+ return MakeNode(op, 0, static_cast<Node**>(NULL), incomplete);
}
- Node* NewNode(const Operator* op, Node* n1) { return MakeNode(op, 1, &n1); }
+ Node* NewNode(const Operator* op, Node* n1) {
+ return MakeNode(op, 1, &n1, false);
+ }
Node* NewNode(const Operator* op, Node* n1, Node* n2) {
Node* buffer[] = {n1, n2};
- return MakeNode(op, arraysize(buffer), buffer);
+ return MakeNode(op, arraysize(buffer), buffer, false);
}
Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
Node* buffer[] = {n1, n2, n3};
- return MakeNode(op, arraysize(buffer), buffer);
+ return MakeNode(op, arraysize(buffer), buffer, false);
}
Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
Node* buffer[] = {n1, n2, n3, n4};
- return MakeNode(op, arraysize(buffer), buffer);
+ return MakeNode(op, arraysize(buffer), buffer, false);
}
Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
Node* n5) {
Node* buffer[] = {n1, n2, n3, n4, n5};
- return MakeNode(op, arraysize(buffer), buffer);
+ return MakeNode(op, arraysize(buffer), buffer, false);
}
Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
Node* n5, Node* n6) {
Node* nodes[] = {n1, n2, n3, n4, n5, n6};
- return MakeNode(op, arraysize(nodes), nodes);
+ return MakeNode(op, arraysize(nodes), nodes, false);
}
- Node* NewNode(const Operator* op, int value_input_count,
- Node** value_inputs) {
- return MakeNode(op, value_input_count, value_inputs);
+ Node* NewNode(const Operator* op, int value_input_count, Node** value_inputs,
+ bool incomplete = false) {
+ return MakeNode(op, value_input_count, value_inputs, incomplete);
}
Graph* graph() const { return graph_; }
protected:
// Base implementation used by all factory methods.
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs) = 0;
+ Node** value_inputs, bool incomplete) = 0;
private:
Graph* graph_;
// StubGraphBuilder).
class StructuredGraphBuilder : public GraphBuilder {
public:
- StructuredGraphBuilder(Graph* graph, CommonOperatorBuilder* common);
+ StructuredGraphBuilder(Zone* zone, Graph* graph,
+ CommonOperatorBuilder* common);
virtual ~StructuredGraphBuilder() {}
// Creates a new Phi node having {count} input values.
// Helpers to create new control nodes.
Node* NewIfTrue() { return NewNode(common()->IfTrue()); }
Node* NewIfFalse() { return NewNode(common()->IfFalse()); }
- Node* NewMerge() { return NewNode(common()->Merge(1)); }
- Node* NewLoop() { return NewNode(common()->Loop(1)); }
- Node* NewBranch(Node* condition) {
- return NewNode(common()->Branch(), condition);
+ Node* NewMerge() { return NewNode(common()->Merge(1), true); }
+ Node* NewLoop() { return NewNode(common()->Loop(1), true); }
+ Node* NewBranch(Node* condition, BranchHint hint = BranchHint::kNone) {
+ return NewNode(common()->Branch(hint), condition);
}
protected:
// ensures effect and control dependencies are wired up. The dependencies
// tracked by the environment might be mutated.
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs) FINAL;
+ Node** value_inputs, bool incomplete) FINAL;
Environment* environment() const { return environment_; }
void set_environment(Environment* env) { environment_ = env; }
Node* dead_control();
- // TODO(mstarzinger): Use phase-local zone instead!
- Zone* zone() const { return graph()->zone(); }
- Isolate* isolate() const { return zone()->isolate(); }
+ Zone* graph_zone() const { return graph()->zone(); }
+ Zone* local_zone() const { return local_zone_; }
+ Isolate* isolate() const { return graph_zone()->isolate(); }
CommonOperatorBuilder* common() const { return common_; }
// Helper to wrap a Handle<T> into a Unique<T>.
CommonOperatorBuilder* common_;
Environment* environment_;
+ // Zone local to the builder for data not leaking into the graph.
+ Zone* local_zone_;
+
+ // Temporary storage for building node input lists.
+ int input_buffer_size_;
+ Node** input_buffer_;
+
// Node representing the control dependency for dead code.
SetOncePointer<Node> dead_control_;
// Merge of all control nodes that exit the function body.
Node* exit_control_;
+ // Growth increment for the temporary buffer used to construct input lists to
+ // new nodes.
+ static const int kInputBufferSizeIncrement = 64;
+
+ Node** EnsureInputBufferSize(int size);
+
DISALLOW_COPY_AND_ASSIGN(StructuredGraphBuilder);
};
}
// Copies this environment at a loop header control-flow point.
- Environment* CopyForLoop() {
- PrepareForLoop();
+ Environment* CopyForLoop(BitVector* assigned) {
+ PrepareForLoop(assigned);
return builder()->CopyEnvironment(this);
}
Node* GetContext() { return builder_->current_context(); }
protected:
- // TODO(mstarzinger): Use phase-local zone instead!
- Zone* zone() const { return graph()->zone(); }
+ Zone* zone() const { return builder_->local_zone(); }
Graph* graph() const { return builder_->graph(); }
StructuredGraphBuilder* builder() const { return builder_; }
CommonOperatorBuilder* common() { return builder_->common(); }
NodeVector* values() { return &values_; }
// Prepare environment to be used as loop header.
- void PrepareForLoop();
+ void PrepareForLoop(BitVector* assigned);
private:
StructuredGraphBuilder* builder_;
// A helper class to reuse the node traversal algorithm.
struct GraphReducerVisitor FINAL : public NullNodeVisitor {
explicit GraphReducerVisitor(GraphReducer* reducer) : reducer_(reducer) {}
- GenericGraphVisit::Control Post(Node* node) {
- reducer_->ReduceNode(node);
- return GenericGraphVisit::CONTINUE;
- }
+ void Post(Node* node) { reducer_->ReduceNode(node); }
GraphReducer* reducer_;
};
}
-GenericGraphVisit::Control GraphReplayPrinter::Pre(Node* node) {
+void GraphReplayPrinter::Pre(Node* node) {
PrintReplayOpCreator(node->op());
PrintF(" Node* n%d = graph.NewNode(op", node->id());
for (int i = 0; i < node->InputCount(); ++i) {
PrintF(", nil");
}
PrintF("); USE(n%d);\n", node->id());
- return GenericGraphVisit::CONTINUE;
}
PrintF("%d", op->InputCount());
break;
case IrOpcode::kEffectPhi:
- PrintF("%d", OperatorProperties::GetEffectInputCount(op));
+ PrintF("%d", op->EffectInputCount());
break;
case IrOpcode::kLoop:
case IrOpcode::kMerge:
- PrintF("%d", OperatorProperties::GetControlInputCount(op));
+ PrintF("%d", op->ControlInputCount());
break;
default:
break;
static void PrintReplay(Graph* graph) {}
#endif
- GenericGraphVisit::Control Pre(Node* node);
+ void Pre(Node* node);
void PostEdge(Node* from, int index, Node* to);
private:
#include "src/compiler/graph-visualizer.h"
-#include "src/compiler/generic-algorithm.h"
+#include <sstream>
+#include <string>
+
+#include "src/code-stubs.h"
#include "src/compiler/generic-node.h"
#include "src/compiler/generic-node-inl.h"
#include "src/compiler/graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
+#include "src/compiler/register-allocator.h"
+#include "src/compiler/schedule.h"
+#include "src/compiler/scheduler.h"
#include "src/ostreams.h"
namespace v8 {
namespace internal {
namespace compiler {
+static int SafeId(Node* node) { return node == NULL ? -1 : node->id(); }
+
#define DEAD_COLOR "#999999"
-class Escaped {
+class AllNodes {
public:
- explicit Escaped(const OStringStream& os, const char* escaped_chars = "<>|{}")
- : str_(os.c_str()), escaped_chars_(escaped_chars) {}
+ enum State { kDead, kGray, kLive };
+
+ AllNodes(Zone* local_zone, const Graph* graph)
+ : state(graph->NodeCount(), kDead, local_zone),
+ live(local_zone),
+ gray(local_zone) {
+ Node* end = graph->end();
+ state[end->id()] = kLive;
+ live.push_back(end);
+ // Find all live nodes reachable from end.
+ for (size_t i = 0; i < live.size(); i++) {
+ for (Node* const input : live[i]->inputs()) {
+ if (input == NULL) {
+ // TODO(titzer): print a warning.
+ continue;
+ }
+ if (input->id() >= graph->NodeCount()) {
+ // TODO(titzer): print a warning.
+ continue;
+ }
+ if (state[input->id()] != kLive) {
+ live.push_back(input);
+ state[input->id()] = kLive;
+ }
+ }
+ }
+
+ // Find all nodes that are not reachable from end that use live nodes.
+ for (size_t i = 0; i < live.size(); i++) {
+ for (Node* const use : live[i]->uses()) {
+ if (state[use->id()] == kDead) {
+ gray.push_back(use);
+ state[use->id()] = kGray;
+ }
+ }
+ }
+ }
+
+ bool IsLive(Node* node) {
+ return node != NULL && node->id() < static_cast<int>(state.size()) &&
+ state[node->id()] == kLive;
+ }
+
+ ZoneVector<State> state;
+ NodeVector live;
+ NodeVector gray;
+};
+
- friend OStream& operator<<(OStream& os, const Escaped& e) {
- for (const char* s = e.str_; *s != '\0'; ++s) {
- if (e.needs_escape(*s)) os << "\\";
- os << *s;
+class Escaped {
+ public:
+ explicit Escaped(const std::ostringstream& os,
+ const char* escaped_chars = "<>|{}")
+ : str_(os.str()), escaped_chars_(escaped_chars) {}
+
+ friend std::ostream& operator<<(std::ostream& os, const Escaped& e) {
+ for (std::string::const_iterator i = e.str_.begin(); i != e.str_.end();
+ ++i) {
+ if (e.needs_escape(*i)) os << "\\";
+ os << *i;
}
return os;
}
return false;
}
- const char* const str_;
+ const std::string str_;
const char* const escaped_chars_;
};
-class JSONGraphNodeWriter : public NullNodeVisitor {
+class JSONGraphNodeWriter {
public:
- JSONGraphNodeWriter(OStream& os, Zone* zone, const Graph* graph) // NOLINT
- : os_(os),
- graph_(graph),
- first_node_(true) {}
+ JSONGraphNodeWriter(std::ostream& os, Zone* zone, const Graph* graph)
+ : os_(os), all_(zone, graph), first_node_(true) {}
- void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
+ void Print() {
+ for (Node* const node : all_.live) PrintNode(node);
+ }
- GenericGraphVisit::Control Pre(Node* node);
+ void PrintNode(Node* node) {
+ if (first_node_) {
+ first_node_ = false;
+ } else {
+ os_ << ",";
+ }
+ std::ostringstream label;
+ label << *node->op();
+ os_ << "{\"id\":" << SafeId(node) << ",\"label\":\"" << Escaped(label, "\"")
+ << "\"";
+ IrOpcode::Value opcode = node->opcode();
+ if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
+ os_ << ",\"rankInputs\":[0," << NodeProperties::FirstControlIndex(node)
+ << "]";
+ os_ << ",\"rankWithInput\":[" << NodeProperties::FirstControlIndex(node)
+ << "]";
+ } else if (opcode == IrOpcode::kIfTrue || opcode == IrOpcode::kIfFalse ||
+ opcode == IrOpcode::kLoop) {
+ os_ << ",\"rankInputs\":[" << NodeProperties::FirstControlIndex(node)
+ << "]";
+ }
+ if (opcode == IrOpcode::kBranch) {
+ os_ << ",\"rankInputs\":[0]";
+ }
+ os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\"";
+ os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true"
+ : "false");
+ os_ << "}";
+ }
private:
- OStream& os_;
- const Graph* const graph_;
+ std::ostream& os_;
+ AllNodes all_;
bool first_node_;
DISALLOW_COPY_AND_ASSIGN(JSONGraphNodeWriter);
};
-GenericGraphVisit::Control JSONGraphNodeWriter::Pre(Node* node) {
- if (first_node_) {
- first_node_ = false;
- } else {
- os_ << ",";
- }
- OStringStream label;
- label << *node->op();
- os_ << "{\"id\":" << node->id() << ",\"label\":\"" << Escaped(label, "\"")
- << "\"";
- IrOpcode::Value opcode = node->opcode();
- if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
- os_ << ",\"rankInputs\":[0," << NodeProperties::FirstControlIndex(node)
- << "]";
- os_ << ",\"rankWithInput\":[" << NodeProperties::FirstControlIndex(node)
- << "]";
- } else if (opcode == IrOpcode::kIfTrue || opcode == IrOpcode::kIfFalse ||
- opcode == IrOpcode::kLoop) {
- os_ << ",\"rankInputs\":[" << NodeProperties::FirstControlIndex(node)
- << "]";
- }
- if (opcode == IrOpcode::kBranch) {
- os_ << ",\"rankInputs\":[0]";
- }
- os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\"";
- os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true"
- : "false");
- os_ << "}";
- return GenericGraphVisit::CONTINUE;
-}
-
-
-class JSONGraphEdgeWriter : public NullNodeVisitor {
+class JSONGraphEdgeWriter {
public:
- JSONGraphEdgeWriter(OStream& os, Zone* zone, const Graph* graph) // NOLINT
- : os_(os),
- graph_(graph),
- first_edge_(true) {}
+ JSONGraphEdgeWriter(std::ostream& os, Zone* zone, const Graph* graph)
+ : os_(os), all_(zone, graph), first_edge_(true) {}
+
+ void Print() {
+ for (Node* const node : all_.live) PrintEdges(node);
+ }
- void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
+ void PrintEdges(Node* node) {
+ for (int i = 0; i < node->InputCount(); i++) {
+ Node* input = node->InputAt(i);
+ if (input == NULL) continue;
+ PrintEdge(node, i, input);
+ }
+ }
- GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
+ void PrintEdge(Node* from, int index, Node* to) {
+ if (first_edge_) {
+ first_edge_ = false;
+ } else {
+ os_ << ",";
+ }
+ const char* edge_type = NULL;
+ if (index < NodeProperties::FirstValueIndex(from)) {
+ edge_type = "unknown";
+ } else if (index < NodeProperties::FirstContextIndex(from)) {
+ edge_type = "value";
+ } else if (index < NodeProperties::FirstFrameStateIndex(from)) {
+ edge_type = "context";
+ } else if (index < NodeProperties::FirstEffectIndex(from)) {
+ edge_type = "frame-state";
+ } else if (index < NodeProperties::FirstControlIndex(from)) {
+ edge_type = "effect";
+ } else {
+ edge_type = "control";
+ }
+ os_ << "{\"source\":" << SafeId(to) << ",\"target\":" << SafeId(from)
+ << ",\"index\":" << index << ",\"type\":\"" << edge_type << "\"}";
+ }
private:
- OStream& os_;
- const Graph* const graph_;
+ std::ostream& os_;
+ AllNodes all_;
bool first_edge_;
DISALLOW_COPY_AND_ASSIGN(JSONGraphEdgeWriter);
};
-GenericGraphVisit::Control JSONGraphEdgeWriter::PreEdge(Node* from, int index,
- Node* to) {
- if (first_edge_) {
- first_edge_ = false;
- } else {
- os_ << ",";
- }
- const char* edge_type = NULL;
- if (index < NodeProperties::FirstValueIndex(from)) {
- edge_type = "unknown";
- } else if (index < NodeProperties::FirstContextIndex(from)) {
- edge_type = "value";
- } else if (index < NodeProperties::FirstFrameStateIndex(from)) {
- edge_type = "context";
- } else if (index < NodeProperties::FirstEffectIndex(from)) {
- edge_type = "frame-state";
- } else if (index < NodeProperties::FirstControlIndex(from)) {
- edge_type = "effect";
- } else {
- edge_type = "control";
- }
- os_ << "{\"source\":" << to->id() << ",\"target\":" << from->id()
- << ",\"index\":" << index << ",\"type\":\"" << edge_type << "\"}";
- return GenericGraphVisit::CONTINUE;
-}
-
-
-OStream& operator<<(OStream& os, const AsJSON& ad) {
+std::ostream& operator<<(std::ostream& os, const AsJSON& ad) {
Zone tmp_zone(ad.graph.zone()->isolate());
os << "{\"nodes\":[";
JSONGraphNodeWriter(os, &tmp_zone, &ad.graph).Print();
}
-class GraphVisualizer : public NullNodeVisitor {
+class GraphVisualizer {
public:
- GraphVisualizer(OStream& os, Zone* zone, const Graph* graph); // NOLINT
+ GraphVisualizer(std::ostream& os, Zone* zone, const Graph* graph)
+ : all_(zone, graph), os_(os) {}
void Print();
- GenericGraphVisit::Control Pre(Node* node);
- GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
+ void PrintNode(Node* node, bool gray);
private:
- void AnnotateNode(Node* node);
void PrintEdge(Node::Edge edge);
- Zone* zone_;
- NodeSet all_nodes_;
- NodeSet white_nodes_;
- bool use_to_def_;
- OStream& os_;
- const Graph* const graph_;
+ AllNodes all_;
+ std::ostream& os_;
DISALLOW_COPY_AND_ASSIGN(GraphVisualizer);
};
static Node* GetControlCluster(Node* node) {
if (OperatorProperties::IsBasicBlockBegin(node->op())) {
return node;
- } else if (OperatorProperties::GetControlInputCount(node->op()) == 1) {
+ } else if (node->op()->ControlInputCount() == 1) {
Node* control = NodeProperties::GetControlInput(node, 0);
- return OperatorProperties::IsBasicBlockBegin(control->op()) ? control
- : NULL;
+ return control != NULL &&
+ OperatorProperties::IsBasicBlockBegin(control->op())
+ ? control
+ : NULL;
} else {
return NULL;
}
}
-GenericGraphVisit::Control GraphVisualizer::Pre(Node* node) {
- if (all_nodes_.count(node) == 0) {
- Node* control_cluster = GetControlCluster(node);
- if (control_cluster != NULL) {
- os_ << " subgraph cluster_BasicBlock" << control_cluster->id() << " {\n";
- }
- os_ << " ID" << node->id() << " [\n";
- AnnotateNode(node);
- os_ << " ]\n";
- if (control_cluster != NULL) os_ << " }\n";
- all_nodes_.insert(node);
- if (use_to_def_) white_nodes_.insert(node);
- }
- return GenericGraphVisit::CONTINUE;
-}
-
-
-GenericGraphVisit::Control GraphVisualizer::PreEdge(Node* from, int index,
- Node* to) {
- if (use_to_def_) return GenericGraphVisit::CONTINUE;
- // When going from def to use, only consider white -> other edges, which are
- // the dead nodes that use live nodes. We're probably not interested in
- // dead nodes that only use other dead nodes.
- if (white_nodes_.count(from) > 0) return GenericGraphVisit::CONTINUE;
- return GenericGraphVisit::SKIP;
-}
-
-
-static bool IsLikelyBackEdge(Node* from, int index, Node* to) {
- if (from->opcode() == IrOpcode::kPhi ||
- from->opcode() == IrOpcode::kEffectPhi) {
- Node* control = NodeProperties::GetControlInput(from, 0);
- return control->opcode() != IrOpcode::kMerge && control != to && index != 0;
- } else if (from->opcode() == IrOpcode::kLoop) {
- return index != 0;
- } else {
- return false;
- }
-}
-
-
-void GraphVisualizer::AnnotateNode(Node* node) {
- if (!use_to_def_) {
- os_ << " style=\"filled\"\n"
- << " fillcolor=\"" DEAD_COLOR "\"\n";
+void GraphVisualizer::PrintNode(Node* node, bool gray) {
+ Node* control_cluster = GetControlCluster(node);
+ if (control_cluster != NULL) {
+ os_ << " subgraph cluster_BasicBlock" << control_cluster->id() << " {\n";
}
+ os_ << " ID" << SafeId(node) << " [\n";
os_ << " shape=\"record\"\n";
switch (node->opcode()) {
break;
}
- OStringStream label;
+ if (gray) {
+ os_ << " style=\"filled\"\n"
+ << " fillcolor=\"" DEAD_COLOR "\"\n";
+ }
+
+ std::ostringstream label;
label << *node->op();
- os_ << " label=\"{{#" << node->id() << ":" << Escaped(label);
+ os_ << " label=\"{{#" << SafeId(node) << ":" << Escaped(label);
InputIter i = node->inputs().begin();
- for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
- ++i, j--) {
- os_ << "|<I" << i.index() << ">#" << (*i)->id();
+ for (int j = node->op()->ValueInputCount(); j > 0; ++i, j--) {
+ os_ << "|<I" << i.index() << ">#" << SafeId(*i);
}
for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
++i, j--) {
- os_ << "|<I" << i.index() << ">X #" << (*i)->id();
+ os_ << "|<I" << i.index() << ">X #" << SafeId(*i);
}
for (int j = OperatorProperties::GetFrameStateInputCount(node->op()); j > 0;
++i, j--) {
- os_ << "|<I" << i.index() << ">F #" << (*i)->id();
+ os_ << "|<I" << i.index() << ">F #" << SafeId(*i);
}
- for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
- ++i, j--) {
- os_ << "|<I" << i.index() << ">E #" << (*i)->id();
+ for (int j = node->op()->EffectInputCount(); j > 0; ++i, j--) {
+ os_ << "|<I" << i.index() << ">E #" << SafeId(*i);
}
- if (!use_to_def_ || OperatorProperties::IsBasicBlockBegin(node->op()) ||
+ if (OperatorProperties::IsBasicBlockBegin(node->op()) ||
GetControlCluster(node) == NULL) {
- for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
- ++i, j--) {
- os_ << "|<I" << i.index() << ">C #" << (*i)->id();
+ for (int j = node->op()->ControlInputCount(); j > 0; ++i, j--) {
+ os_ << "|<I" << i.index() << ">C #" << SafeId(*i);
}
}
os_ << "}";
- if (FLAG_trace_turbo_types && !NodeProperties::IsControl(node)) {
+ if (FLAG_trace_turbo_types && NodeProperties::IsTyped(node)) {
Bounds bounds = NodeProperties::GetBounds(node);
- OStringStream upper;
+ std::ostringstream upper;
bounds.upper->PrintTo(upper);
- OStringStream lower;
+ std::ostringstream lower;
bounds.lower->PrintTo(lower);
os_ << "|" << Escaped(upper) << "|" << Escaped(lower);
}
os_ << "}\"\n";
+
+ os_ << " ]\n";
+ if (control_cluster != NULL) os_ << " }\n";
+}
+
+
+static bool IsLikelyBackEdge(Node* from, int index, Node* to) {
+ if (from->opcode() == IrOpcode::kPhi ||
+ from->opcode() == IrOpcode::kEffectPhi) {
+ Node* control = NodeProperties::GetControlInput(from, 0);
+ return control != NULL && control->opcode() != IrOpcode::kMerge &&
+ control != to && index != 0;
+ } else if (from->opcode() == IrOpcode::kLoop) {
+ return index != 0;
+ } else {
+ return false;
+ }
}
Node* from = edge.from();
int index = edge.index();
Node* to = edge.to();
+
+ if (!all_.IsLive(to)) return; // skip inputs that point to dead or NULL.
+
bool unconstrained = IsLikelyBackEdge(from, index, to);
- os_ << " ID" << from->id();
- if (all_nodes_.count(to) == 0) {
- os_ << ":I" << index << ":n -> DEAD_INPUT";
- } else if (OperatorProperties::IsBasicBlockBegin(from->op()) ||
- GetControlCluster(from) == NULL ||
- (OperatorProperties::GetControlInputCount(from->op()) > 0 &&
- NodeProperties::GetControlInput(from) != to)) {
- os_ << ":I" << index << ":n -> ID" << to->id() << ":s"
+ os_ << " ID" << SafeId(from);
+
+ if (OperatorProperties::IsBasicBlockBegin(from->op()) ||
+ GetControlCluster(from) == NULL ||
+ (from->op()->ControlInputCount() > 0 &&
+ NodeProperties::GetControlInput(from) != to)) {
+ os_ << ":I" << index << ":n -> ID" << SafeId(to) << ":s"
<< "[" << (unconstrained ? "constraint=false, " : "")
<< (NodeProperties::IsControlEdge(edge) ? "style=bold, " : "")
<< (NodeProperties::IsEffectEdge(edge) ? "style=dotted, " : "")
<< (NodeProperties::IsContextEdge(edge) ? "style=dashed, " : "") << "]";
} else {
- os_ << " -> ID" << to->id() << ":s [color=transparent, "
+ os_ << " -> ID" << SafeId(to) << ":s [color=transparent, "
<< (unconstrained ? "constraint=false, " : "")
<< (NodeProperties::IsControlEdge(edge) ? "style=dashed, " : "") << "]";
}
<< " \n";
// Make sure all nodes have been output before writing out the edges.
- use_to_def_ = true;
- // TODO(svenpanne) Remove the need for the const_casts.
- const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this);
- white_nodes_.insert(const_cast<Graph*>(graph_)->start());
-
- // Visit all uses of white nodes.
- use_to_def_ = false;
- GenericGraphVisit::Visit<GraphVisualizer, NodeUseIterationTraits<Node> >(
- const_cast<Graph*>(graph_), zone_, white_nodes_.begin(),
- white_nodes_.end(), this);
-
- os_ << " DEAD_INPUT [\n"
- << " style=\"filled\" \n"
- << " fillcolor=\"" DEAD_COLOR "\"\n"
- << " ]\n"
- << "\n";
+ for (Node* const node : all_.live) PrintNode(node, false);
+ for (Node* const node : all_.gray) PrintNode(node, true);
// With all the nodes written, add the edges.
- for (NodeSetIter i = all_nodes_.begin(); i != all_nodes_.end(); ++i) {
- Node::Inputs inputs = (*i)->inputs();
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter) {
- PrintEdge(iter.edge());
+ for (Node* const node : all_.live) {
+ for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
+ PrintEdge(i.edge());
}
}
os_ << "}\n";
}
-GraphVisualizer::GraphVisualizer(OStream& os, Zone* zone,
- const Graph* graph) // NOLINT
- : zone_(zone),
- all_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
- white_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
- use_to_def_(true),
- os_(os),
- graph_(graph) {}
-
-
-OStream& operator<<(OStream& os, const AsDOT& ad) {
+std::ostream& operator<<(std::ostream& os, const AsDOT& ad) {
Zone tmp_zone(ad.graph.zone()->isolate());
GraphVisualizer(os, &tmp_zone, &ad.graph).Print();
return os;
}
+
+
+class GraphC1Visualizer {
+ public:
+ GraphC1Visualizer(std::ostream& os, Zone* zone); // NOLINT
+
+ void PrintCompilation(const CompilationInfo* info);
+ void PrintSchedule(const char* phase, const Schedule* schedule,
+ const SourcePositionTable* positions,
+ const InstructionSequence* instructions);
+ void PrintAllocator(const char* phase, const RegisterAllocator* allocator);
+ Zone* zone() const { return zone_; }
+
+ private:
+ void PrintIndent();
+ void PrintStringProperty(const char* name, const char* value);
+ void PrintLongProperty(const char* name, int64_t value);
+ void PrintIntProperty(const char* name, int value);
+ void PrintBlockProperty(const char* name, BasicBlock::Id block_id);
+ void PrintNodeId(Node* n);
+ void PrintNode(Node* n);
+ void PrintInputs(Node* n);
+ void PrintInputs(InputIter* i, int count, const char* prefix);
+ void PrintType(Node* node);
+
+ void PrintLiveRange(LiveRange* range, const char* type);
+ class Tag FINAL BASE_EMBEDDED {
+ public:
+ Tag(GraphC1Visualizer* visualizer, const char* name) {
+ name_ = name;
+ visualizer_ = visualizer;
+ visualizer->PrintIndent();
+ visualizer_->os_ << "begin_" << name << "\n";
+ visualizer->indent_++;
+ }
+
+ ~Tag() {
+ visualizer_->indent_--;
+ visualizer_->PrintIndent();
+ visualizer_->os_ << "end_" << name_ << "\n";
+ DCHECK(visualizer_->indent_ >= 0);
+ }
+
+ private:
+ GraphC1Visualizer* visualizer_;
+ const char* name_;
+ };
+
+ std::ostream& os_;
+ int indent_;
+ Zone* zone_;
+
+ DISALLOW_COPY_AND_ASSIGN(GraphC1Visualizer);
+};
+
+
+void GraphC1Visualizer::PrintIndent() {
+ for (int i = 0; i < indent_; i++) {
+ os_ << " ";
+ }
+}
+
+
+GraphC1Visualizer::GraphC1Visualizer(std::ostream& os, Zone* zone)
+ : os_(os), indent_(0), zone_(zone) {}
+
+
+void GraphC1Visualizer::PrintStringProperty(const char* name,
+ const char* value) {
+ PrintIndent();
+ os_ << name << " \"" << value << "\"\n";
+}
+
+
+void GraphC1Visualizer::PrintLongProperty(const char* name, int64_t value) {
+ PrintIndent();
+ os_ << name << " " << static_cast<int>(value / 1000) << "\n";
+}
+
+
+void GraphC1Visualizer::PrintBlockProperty(const char* name,
+ BasicBlock::Id block_id) {
+ PrintIndent();
+ os_ << name << " \"B" << block_id << "\"\n";
+}
+
+
+void GraphC1Visualizer::PrintIntProperty(const char* name, int value) {
+ PrintIndent();
+ os_ << name << " " << value << "\n";
+}
+
+
+void GraphC1Visualizer::PrintCompilation(const CompilationInfo* info) {
+ Tag tag(this, "compilation");
+ if (info->IsOptimizing()) {
+ Handle<String> name = info->function()->debug_name();
+ PrintStringProperty("name", name->ToCString().get());
+ PrintIndent();
+ os_ << "method \"" << name->ToCString().get() << ":"
+ << info->optimization_id() << "\"\n";
+ } else {
+ CodeStub::Major major_key = info->code_stub()->MajorKey();
+ PrintStringProperty("name", CodeStub::MajorName(major_key, false));
+ PrintStringProperty("method", "stub");
+ }
+ PrintLongProperty("date",
+ static_cast<int64_t>(base::OS::TimeCurrentMillis()));
+}
+
+
+void GraphC1Visualizer::PrintNodeId(Node* n) { os_ << "n" << SafeId(n); }
+
+
+void GraphC1Visualizer::PrintNode(Node* n) {
+ PrintNodeId(n);
+ os_ << " " << *n->op() << " ";
+ PrintInputs(n);
+}
+
+
+void GraphC1Visualizer::PrintInputs(InputIter* i, int count,
+ const char* prefix) {
+ if (count > 0) {
+ os_ << prefix;
+ }
+ while (count > 0) {
+ os_ << " ";
+ PrintNodeId(**i);
+ ++(*i);
+ count--;
+ }
+}
+
+
+void GraphC1Visualizer::PrintInputs(Node* node) {
+ InputIter i = node->inputs().begin();
+ PrintInputs(&i, node->op()->ValueInputCount(), " ");
+ PrintInputs(&i, OperatorProperties::GetContextInputCount(node->op()),
+ " Ctx:");
+ PrintInputs(&i, OperatorProperties::GetFrameStateInputCount(node->op()),
+ " FS:");
+ PrintInputs(&i, node->op()->EffectInputCount(), " Eff:");
+ PrintInputs(&i, node->op()->ControlInputCount(), " Ctrl:");
+}
+
+
+void GraphC1Visualizer::PrintType(Node* node) {
+ if (NodeProperties::IsTyped(node)) {
+ Bounds bounds = NodeProperties::GetBounds(node);
+ os_ << " type:";
+ bounds.upper->PrintTo(os_);
+ os_ << "..";
+ bounds.lower->PrintTo(os_);
+ }
+}
+
+
+void GraphC1Visualizer::PrintSchedule(const char* phase,
+ const Schedule* schedule,
+ const SourcePositionTable* positions,
+ const InstructionSequence* instructions) {
+ Tag tag(this, "cfg");
+ PrintStringProperty("name", phase);
+ const BasicBlockVector* rpo = schedule->rpo_order();
+ for (size_t i = 0; i < rpo->size(); i++) {
+ BasicBlock* current = (*rpo)[i];
+ Tag block_tag(this, "block");
+ PrintBlockProperty("name", current->id());
+ PrintIntProperty("from_bci", -1);
+ PrintIntProperty("to_bci", -1);
+
+ PrintIndent();
+ os_ << "predecessors";
+ for (BasicBlock::Predecessors::iterator j = current->predecessors_begin();
+ j != current->predecessors_end(); ++j) {
+ os_ << " \"B" << (*j)->id() << "\"";
+ }
+ os_ << "\n";
+
+ PrintIndent();
+ os_ << "successors";
+ for (BasicBlock::Successors::iterator j = current->successors_begin();
+ j != current->successors_end(); ++j) {
+ os_ << " \"B" << (*j)->id() << "\"";
+ }
+ os_ << "\n";
+
+ PrintIndent();
+ os_ << "xhandlers\n";
+
+ PrintIndent();
+ os_ << "flags\n";
+
+ if (current->dominator() != NULL) {
+ PrintBlockProperty("dominator", current->dominator()->id());
+ }
+
+ PrintIntProperty("loop_depth", current->loop_depth());
+
+ const InstructionBlock* instruction_block =
+ instructions->InstructionBlockAt(current->GetRpoNumber());
+ if (instruction_block->code_start() >= 0) {
+ int first_index = instruction_block->first_instruction_index();
+ int last_index = instruction_block->last_instruction_index();
+ PrintIntProperty("first_lir_id", LifetimePosition::FromInstructionIndex(
+ first_index).Value());
+ PrintIntProperty("last_lir_id", LifetimePosition::FromInstructionIndex(
+ last_index).Value());
+ }
+
+ {
+ Tag states_tag(this, "states");
+ Tag locals_tag(this, "locals");
+ int total = 0;
+ for (BasicBlock::const_iterator i = current->begin(); i != current->end();
+ ++i) {
+ if ((*i)->opcode() == IrOpcode::kPhi) total++;
+ }
+ PrintIntProperty("size", total);
+ PrintStringProperty("method", "None");
+ int index = 0;
+ for (BasicBlock::const_iterator i = current->begin(); i != current->end();
+ ++i) {
+ if ((*i)->opcode() != IrOpcode::kPhi) continue;
+ PrintIndent();
+ os_ << index << " ";
+ PrintNodeId(*i);
+ os_ << " [";
+ PrintInputs(*i);
+ os_ << "]\n";
+ index++;
+ }
+ }
+
+ {
+ Tag HIR_tag(this, "HIR");
+ for (BasicBlock::const_iterator i = current->begin(); i != current->end();
+ ++i) {
+ Node* node = *i;
+ if (node->opcode() == IrOpcode::kPhi) continue;
+ int uses = node->UseCount();
+ PrintIndent();
+ os_ << "0 " << uses << " ";
+ PrintNode(node);
+ if (FLAG_trace_turbo_types) {
+ os_ << " ";
+ PrintType(node);
+ }
+ if (positions != NULL) {
+ SourcePosition position = positions->GetSourcePosition(node);
+ if (!position.IsUnknown()) {
+ DCHECK(!position.IsInvalid());
+ os_ << " pos:" << position.raw();
+ }
+ }
+ os_ << " <|@\n";
+ }
+
+ BasicBlock::Control control = current->control();
+ if (control != BasicBlock::kNone) {
+ PrintIndent();
+ os_ << "0 0 ";
+ if (current->control_input() != NULL) {
+ PrintNode(current->control_input());
+ } else {
+ os_ << -1 - current->id().ToInt() << " Goto";
+ }
+ os_ << " ->";
+ for (BasicBlock::Successors::iterator j = current->successors_begin();
+ j != current->successors_end(); ++j) {
+ os_ << " B" << (*j)->id();
+ }
+ if (FLAG_trace_turbo_types && current->control_input() != NULL) {
+ os_ << " ";
+ PrintType(current->control_input());
+ }
+ os_ << " <|@\n";
+ }
+ }
+
+ if (instructions != NULL) {
+ Tag LIR_tag(this, "LIR");
+ for (int j = instruction_block->first_instruction_index();
+ j <= instruction_block->last_instruction_index(); j++) {
+ PrintIndent();
+ PrintableInstruction printable = {RegisterConfiguration::ArchDefault(),
+ instructions->InstructionAt(j)};
+ os_ << j << " " << printable << " <|@\n";
+ }
+ }
+ }
+}
+
+
+void GraphC1Visualizer::PrintAllocator(const char* phase,
+ const RegisterAllocator* allocator) {
+ Tag tag(this, "intervals");
+ PrintStringProperty("name", phase);
+
+ for (auto range : allocator->fixed_double_live_ranges()) {
+ PrintLiveRange(range, "fixed");
+ }
+
+ for (auto range : allocator->fixed_live_ranges()) {
+ PrintLiveRange(range, "fixed");
+ }
+
+ for (auto range : allocator->live_ranges()) {
+ PrintLiveRange(range, "object");
+ }
+}
+
+
+void GraphC1Visualizer::PrintLiveRange(LiveRange* range, const char* type) {
+ if (range != NULL && !range->IsEmpty()) {
+ PrintIndent();
+ os_ << range->id() << " " << type;
+ if (range->HasRegisterAssigned()) {
+ InstructionOperand* op = range->CreateAssignedOperand(zone());
+ int assigned_reg = op->index();
+ if (op->IsDoubleRegister()) {
+ os_ << " \"" << DoubleRegister::AllocationIndexToString(assigned_reg)
+ << "\"";
+ } else {
+ DCHECK(op->IsRegister());
+ os_ << " \"" << Register::AllocationIndexToString(assigned_reg) << "\"";
+ }
+ } else if (range->IsSpilled()) {
+ InstructionOperand* op = range->TopLevel()->GetSpillOperand();
+ if (op->IsDoubleStackSlot()) {
+ os_ << " \"double_stack:" << op->index() << "\"";
+ } else if (op->IsStackSlot()) {
+ os_ << " \"stack:" << op->index() << "\"";
+ } else {
+ DCHECK(op->IsConstant());
+ os_ << " \"const(nostack):" << op->index() << "\"";
+ }
+ }
+ int parent_index = -1;
+ if (range->IsChild()) {
+ parent_index = range->parent()->id();
+ } else {
+ parent_index = range->id();
+ }
+ InstructionOperand* op = range->FirstHint();
+ int hint_index = -1;
+ if (op != NULL && op->IsUnallocated()) {
+ hint_index = UnallocatedOperand::cast(op)->virtual_register();
+ }
+ os_ << " " << parent_index << " " << hint_index;
+ UseInterval* cur_interval = range->first_interval();
+ while (cur_interval != NULL && range->Covers(cur_interval->start())) {
+ os_ << " [" << cur_interval->start().Value() << ", "
+ << cur_interval->end().Value() << "[";
+ cur_interval = cur_interval->next();
+ }
+
+ UsePosition* current_pos = range->first_pos();
+ while (current_pos != NULL) {
+ if (current_pos->RegisterIsBeneficial() || FLAG_trace_all_uses) {
+ os_ << " " << current_pos->pos().Value() << " M";
+ }
+ current_pos = current_pos->next();
+ }
+
+ os_ << " \"\"\n";
+ }
+}
+
+
+std::ostream& operator<<(std::ostream& os, const AsC1VCompilation& ac) {
+ Zone tmp_zone(ac.info_->isolate());
+ GraphC1Visualizer(os, &tmp_zone).PrintCompilation(ac.info_);
+ return os;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const AsC1V& ac) {
+ Zone tmp_zone(ac.schedule_->zone()->isolate());
+ GraphC1Visualizer(os, &tmp_zone)
+ .PrintSchedule(ac.phase_, ac.schedule_, ac.positions_, ac.instructions_);
+ return os;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const AsC1VAllocator& ac) {
+ Zone tmp_zone(ac.allocator_->code()->zone()->isolate());
+ GraphC1Visualizer(os, &tmp_zone).PrintAllocator(ac.phase_, ac.allocator_);
+ return os;
+}
}
}
} // namespace v8::internal::compiler
#ifndef V8_COMPILER_GRAPH_VISUALIZER_H_
#define V8_COMPILER_GRAPH_VISUALIZER_H_
-#include "src/v8.h"
+#include <iosfwd>
namespace v8 {
namespace internal {
-class OStream;
+class CompilationInfo;
namespace compiler {
class Graph;
+class InstructionSequence;
+class RegisterAllocator;
+class Schedule;
+class SourcePositionTable;
+
struct AsDOT {
explicit AsDOT(const Graph& g) : graph(g) {}
const Graph& graph;
};
-OStream& operator<<(OStream& os, const AsDOT& ad);
+std::ostream& operator<<(std::ostream& os, const AsDOT& ad);
+
struct AsJSON {
explicit AsJSON(const Graph& g) : graph(g) {}
const Graph& graph;
};
-OStream& operator<<(OStream& os, const AsJSON& ad);
-}
-}
-} // namespace v8::internal::compiler
+std::ostream& operator<<(std::ostream& os, const AsJSON& ad);
+
+struct AsC1VCompilation {
+ explicit AsC1VCompilation(const CompilationInfo* info) : info_(info) {}
+ const CompilationInfo* info_;
+};
+
+
+struct AsC1V {
+ AsC1V(const char* phase, const Schedule* schedule,
+ const SourcePositionTable* positions = NULL,
+ const InstructionSequence* instructions = NULL)
+ : schedule_(schedule),
+ instructions_(instructions),
+ positions_(positions),
+ phase_(phase) {}
+ const Schedule* schedule_;
+ const InstructionSequence* instructions_;
+ const SourcePositionTable* positions_;
+ const char* phase_;
+};
+
+struct AsC1VAllocator {
+ explicit AsC1VAllocator(const char* phase,
+ const RegisterAllocator* allocator = NULL)
+ : phase_(phase), allocator_(allocator) {}
+ const char* phase_;
+ const RegisterAllocator* allocator_;
+};
+
+std::ostream& operator<<(std::ostream& os, const AsDOT& ad);
+std::ostream& operator<<(std::ostream& os, const AsC1VCompilation& ac);
+std::ostream& operator<<(std::ostream& os, const AsC1V& ac);
+std::ostream& operator<<(std::ostream& os, const AsC1VAllocator& ac);
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_GRAPH_VISUALIZER_H_
#include "src/compiler/node-aux-data-inl.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/opcodes.h"
#include "src/compiler/operator-properties.h"
#include "src/compiler/operator-properties-inl.h"
Graph::Graph(Zone* zone) : GenericGraph<Node>(zone), decorators_(zone) {}
-Node* Graph::NewNode(const Operator* op, int input_count, Node** inputs) {
- DCHECK_LE(op->InputCount(), input_count);
- Node* result = Node::New(this, input_count, inputs);
- result->Initialize(op);
+void Graph::Decorate(Node* node) {
for (ZoneVector<GraphDecorator*>::iterator i = decorators_.begin();
i != decorators_.end(); ++i) {
- (*i)->Decorate(result);
+ (*i)->Decorate(node);
+ }
+}
+
+
+Node* Graph::NewNode(const Operator* op, int input_count, Node** inputs,
+ bool incomplete) {
+ DCHECK_LE(op->InputCount(), input_count);
+ Node* result = Node::New(this, input_count, inputs, incomplete);
+ result->Initialize(op);
+ if (!incomplete) {
+ Decorate(result);
}
return result;
}
explicit Graph(Zone* zone);
// Base implementation used by all factory methods.
- Node* NewNode(const Operator* op, int input_count, Node** inputs);
+ Node* NewNode(const Operator* op, int input_count, Node** inputs,
+ bool incomplete = false);
// Factories for nodes with static input counts.
Node* NewNode(const Operator* op) {
Node* nodes[] = {n1, n2, n3, n4, n5, n6};
return NewNode(op, arraysize(nodes), nodes);
}
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+ Node* n5, Node* n6, Node* n7) {
+ Node* nodes[] = {n1, n2, n3, n4, n5, n6, n7};
+ return NewNode(op, arraysize(nodes), nodes);
+ }
template <class Visitor>
void VisitNodeUsesFrom(Node* node, Visitor* visitor);
template <class Visitor>
void VisitNodeInputsFromEnd(Visitor* visitor);
+ void Decorate(Node* node);
+
void AddDecorator(GraphDecorator* decorator) {
decorators_.push_back(decorator);
}
Operand OutputOperand() { return ToOperand(instr_->Output()); }
- Operand TempOperand(int index) { return ToOperand(instr_->TempAt(index)); }
-
Operand ToOperand(InstructionOperand* op, int extra = 0) {
if (op->IsRegister()) {
DCHECK(extra == 0);
break;
}
case kArchJmp:
- __ jmp(code()->GetLabel(i.InputBlock(0)));
+ __ jmp(GetLabel(i.InputRpo(0)));
break;
case kArchNop:
// don't emit code for nops.
case kArchRet:
AssembleReturn();
break;
+ case kArchStackPointer:
+ __ mov(i.OutputRegister(), esp);
+ break;
case kArchTruncateDoubleToI:
__ TruncateDoubleToI(i.OutputRegister(), i.InputDoubleRegister(0));
break;
__ imul(i.OutputRegister(), i.InputOperand(1));
}
break;
+ case kIA32ImulHigh:
+ __ imul(i.InputRegister(1));
+ break;
+ case kIA32UmulHigh:
+ __ mul(i.InputRegister(1));
+ break;
case kIA32Idiv:
__ cdq();
__ idiv(i.InputOperand(1));
break;
case kIA32Udiv:
- __ xor_(edx, edx);
+ __ Move(edx, Immediate(0));
__ div(i.InputOperand(1));
break;
case kIA32Not:
break;
case kIA32Shl:
if (HasImmediateInput(instr, 1)) {
- __ shl(i.OutputRegister(), i.InputInt5(1));
+ __ shl(i.OutputOperand(), i.InputInt5(1));
} else {
- __ shl_cl(i.OutputRegister());
+ __ shl_cl(i.OutputOperand());
}
break;
case kIA32Shr:
if (HasImmediateInput(instr, 1)) {
- __ shr(i.OutputRegister(), i.InputInt5(1));
+ __ shr(i.OutputOperand(), i.InputInt5(1));
} else {
- __ shr_cl(i.OutputRegister());
+ __ shr_cl(i.OutputOperand());
}
break;
case kIA32Sar:
if (HasImmediateInput(instr, 1)) {
- __ sar(i.OutputRegister(), i.InputInt5(1));
+ __ sar(i.OutputOperand(), i.InputInt5(1));
} else {
- __ sar_cl(i.OutputRegister());
+ __ sar_cl(i.OutputOperand());
}
break;
case kIA32Ror:
if (HasImmediateInput(instr, 1)) {
- __ ror(i.OutputRegister(), i.InputInt5(1));
+ __ ror(i.OutputOperand(), i.InputInt5(1));
} else {
- __ ror_cl(i.OutputRegister());
+ __ ror_cl(i.OutputOperand());
}
break;
case kSSEFloat64Cmp:
__ ucomisd(i.InputDoubleRegister(0), i.InputOperand(1));
break;
case kSSEFloat64Add:
- __ addsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ __ addsd(i.InputDoubleRegister(0), i.InputOperand(1));
break;
case kSSEFloat64Sub:
- __ subsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ __ subsd(i.InputDoubleRegister(0), i.InputOperand(1));
break;
case kSSEFloat64Mul:
- __ mulsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ __ mulsd(i.InputDoubleRegister(0), i.InputOperand(1));
break;
case kSSEFloat64Div:
- __ divsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ __ divsd(i.InputDoubleRegister(0), i.InputOperand(1));
break;
case kSSEFloat64Mod: {
// TODO(dcarney): alignment is wrong.
case kSSEFloat64Sqrt:
__ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
break;
+ case kSSEFloat64Floor: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundDown);
+ break;
+ }
+ case kSSEFloat64Ceil: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundUp);
+ break;
+ }
+ case kSSEFloat64RoundTruncate: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundToZero);
+ break;
+ }
case kSSECvtss2sd:
- __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
break;
case kSSECvtsd2ss:
- __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
break;
case kSSEFloat64ToInt32:
__ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
__ cvtsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
break;
case kSSEUint32ToFloat64:
- // TODO(turbofan): IA32 SSE LoadUint32() should take an operand.
- __ LoadUint32(i.OutputDoubleRegister(), i.InputRegister(0));
+ __ LoadUint32(i.OutputDoubleRegister(), i.InputOperand(0));
break;
case kIA32Movsxbl:
__ movsx_b(i.OutputRegister(), i.MemoryOperand());
__ movss(operand, i.InputDoubleRegister(index));
}
break;
+ case kIA32Lea:
+ __ lea(i.OutputRegister(), i.MemoryOperand());
+ break;
case kIA32Push:
if (HasImmediateInput(instr, 0)) {
__ push(i.InputImmediate(0));
Register value = i.InputRegister(2);
__ mov(Operand(object, index, times_1, 0), value);
__ lea(index, Operand(object, index, times_1, 0));
- SaveFPRegsMode mode = code_->frame()->DidAllocateDoubleRegisters()
- ? kSaveFPRegs
- : kDontSaveFPRegs;
+ SaveFPRegsMode mode =
+ frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
__ RecordWrite(object, index, value, mode);
break;
}
// Emit a branch. The true and false targets are always the last two inputs
// to the instruction.
- BasicBlock* tblock = i.InputBlock(instr->InputCount() - 2);
- BasicBlock* fblock = i.InputBlock(instr->InputCount() - 1);
+ BasicBlock::RpoNumber tblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
+ BasicBlock::RpoNumber fblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
bool fallthru = IsNextInAssemblyOrder(fblock);
- Label* tlabel = code()->GetLabel(tblock);
- Label* flabel = fallthru ? &done : code()->GetLabel(fblock);
+ Label* tlabel = GetLabel(tblock);
+ Label* flabel = fallthru ? &done : GetLabel(fblock);
Label::Distance flabel_distance = fallthru ? Label::kNear : Label::kFar;
switch (condition) {
case kUnorderedEqual:
switch (condition) {
case kUnorderedEqual:
__ j(parity_odd, &check, Label::kNear);
- __ mov(reg, Immediate(0));
+ __ Move(reg, Immediate(0));
__ jmp(&done, Label::kNear);
// Fall through.
case kEqual:
break;
case kUnorderedLessThan:
__ j(parity_odd, &check, Label::kNear);
- __ mov(reg, Immediate(0));
+ __ Move(reg, Immediate(0));
__ jmp(&done, Label::kNear);
// Fall through.
case kUnsignedLessThan:
break;
case kUnorderedLessThanOrEqual:
__ j(parity_odd, &check, Label::kNear);
- __ mov(reg, Immediate(0));
+ __ Move(reg, Immediate(0));
__ jmp(&done, Label::kNear);
// Fall through.
case kUnsignedLessThanOrEqual:
// Emit a branch to set a register to either 1 or 0.
Label set;
__ j(cc, &set, Label::kNear);
- __ mov(reg, Immediate(0));
+ __ Move(reg, Immediate(0));
__ jmp(&done, Label::kNear);
__ bind(&set);
__ mov(reg, Immediate(1));
void CodeGenerator::AssemblePrologue() {
CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
- Frame* frame = code_->frame();
+ Frame* frame = this->frame();
int stack_slots = frame->GetSpillSlotCount();
if (descriptor->kind() == CallDescriptor::kCallAddress) {
// Assemble a prologue similar the to cdecl calling convention.
frame->SetRegisterSaveAreaSize(register_save_area_size);
}
} else if (descriptor->IsJSFunctionCall()) {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
__ Prologue(info->IsCodePreAgingActive());
frame->SetRegisterSaveAreaSize(
StandardFrameConstants::kFixedFrameSizeFromFp);
}
} else if (destination->IsRegister()) {
Register dst = g.ToRegister(destination);
- __ mov(dst, g.ToImmediate(source));
+ __ Move(dst, g.ToImmediate(source));
} else if (destination->IsStackSlot()) {
Operand dst = g.ToOperand(destination);
- __ mov(dst, g.ToImmediate(source));
+ __ Move(dst, g.ToImmediate(source));
} else if (src_constant.type() == Constant::kFloat32) {
// TODO(turbofan): Can we do better here?
- Immediate src(bit_cast<int32_t>(src_constant.ToFloat32()));
+ uint32_t src = bit_cast<uint32_t>(src_constant.ToFloat32());
if (destination->IsDoubleRegister()) {
XMMRegister dst = g.ToDoubleRegister(destination);
- __ push(Immediate(src));
- __ movss(dst, Operand(esp, 0));
- __ add(esp, Immediate(kDoubleSize / 2));
+ __ Move(dst, src);
} else {
DCHECK(destination->IsDoubleStackSlot());
Operand dst = g.ToOperand(destination);
- __ mov(dst, src);
+ __ Move(dst, Immediate(src));
}
} else {
DCHECK_EQ(Constant::kFloat64, src_constant.type());
- double v = src_constant.ToFloat64();
- uint64_t int_val = bit_cast<uint64_t, double>(v);
- int32_t lower = static_cast<int32_t>(int_val);
- int32_t upper = static_cast<int32_t>(int_val >> kBitsPerInt);
+ uint64_t src = bit_cast<uint64_t>(src_constant.ToFloat64());
+ uint32_t lower = static_cast<uint32_t>(src);
+ uint32_t upper = static_cast<uint32_t>(src >> 32);
if (destination->IsDoubleRegister()) {
XMMRegister dst = g.ToDoubleRegister(destination);
- __ Move(dst, v);
+ __ Move(dst, src);
} else {
DCHECK(destination->IsDoubleStackSlot());
Operand dst0 = g.ToOperand(destination);
Operand dst1 = g.HighOperand(destination);
- __ mov(dst0, Immediate(lower));
- __ mov(dst1, Immediate(upper));
+ __ Move(dst0, Immediate(lower));
+ __ Move(dst1, Immediate(upper));
}
}
} else if (source->IsDoubleRegister()) {
__ movaps(xmm0, src);
__ movaps(src, dst);
__ movaps(dst, xmm0);
- } else if (source->IsDoubleRegister() && source->IsDoubleStackSlot()) {
+ } else if (source->IsDoubleRegister() && destination->IsDoubleStackSlot()) {
// XMM register-memory swap. We rely on having xmm0
// available as a fixed scratch register.
XMMRegister reg = g.ToDoubleRegister(source);
void CodeGenerator::EnsureSpaceForLazyDeopt() {
int space_needed = Deoptimizer::patch_size();
- if (!linkage()->info()->IsStub()) {
+ if (!info()->IsStub()) {
// Ensure that we have enough space after the previous lazy-bailout
// instruction for patching the code here.
int current_pc = masm()->pc_offset();
V(IA32Xor) \
V(IA32Sub) \
V(IA32Imul) \
+ V(IA32ImulHigh) \
+ V(IA32UmulHigh) \
V(IA32Idiv) \
V(IA32Udiv) \
V(IA32Not) \
V(SSEFloat64Div) \
V(SSEFloat64Mod) \
V(SSEFloat64Sqrt) \
+ V(SSEFloat64Floor) \
+ V(SSEFloat64Ceil) \
+ V(SSEFloat64RoundTruncate) \
V(SSECvtss2sd) \
V(SSECvtsd2ss) \
V(SSEFloat64ToInt32) \
V(IA32Movl) \
V(IA32Movss) \
V(IA32Movsd) \
+ V(IA32Lea) \
V(IA32Push) \
V(IA32StoreWriteBarrier)
};
+// Get the AddressingMode of scale factor N from the AddressingMode of scale
+// factor 1.
+static AddressingMode AdjustAddressingMode(AddressingMode base_mode,
+ int power) {
+ DCHECK(0 <= power && power < 4);
+ return static_cast<AddressingMode>(static_cast<int>(base_mode) + power);
+}
+
+
+// Fairly intel-specify node matcher used for matching scale factors in
+// addressing modes.
+// Matches nodes of form [x * N] for N in {1,2,4,8}
+class ScaleFactorMatcher : public NodeMatcher {
+ public:
+ static const int kMatchedFactors[4];
+
+ explicit ScaleFactorMatcher(Node* node);
+
+ bool Matches() const { return left_ != NULL; }
+ int Power() const {
+ DCHECK(Matches());
+ return power_;
+ }
+ Node* Left() const {
+ DCHECK(Matches());
+ return left_;
+ }
+
+ private:
+ Node* left_;
+ int power_;
+};
+
+
+// Fairly intel-specify node matcher used for matching index and displacement
+// operands in addressing modes.
+// Matches nodes of form:
+// [x * N]
+// [x * N + K]
+// [x + K]
+// [x] -- fallback case
+// for N in {1,2,4,8} and K int32_t
+class IndexAndDisplacementMatcher : public NodeMatcher {
+ public:
+ explicit IndexAndDisplacementMatcher(Node* node);
+
+ Node* index_node() const { return index_node_; }
+ int displacement() const { return displacement_; }
+ int power() const { return power_; }
+
+ private:
+ Node* index_node_;
+ int displacement_;
+ int power_;
+};
+
+
+// Fairly intel-specify node matcher used for matching multiplies that can be
+// transformed to lea instructions.
+// Matches nodes of form:
+// [x * N]
+// for N in {1,2,3,4,5,8,9}
+class LeaMultiplyMatcher : public NodeMatcher {
+ public:
+ static const int kMatchedFactors[7];
+
+ explicit LeaMultiplyMatcher(Node* node);
+
+ bool Matches() const { return left_ != NULL; }
+ int Power() const {
+ DCHECK(Matches());
+ return power_;
+ }
+ Node* Left() const {
+ DCHECK(Matches());
+ return left_;
+ }
+ // Displacement will be either 0 or 1.
+ int32_t Displacement() const {
+ DCHECK(Matches());
+ return displacement_;
+ }
+
+ private:
+ Node* left_;
+ int power_;
+ int displacement_;
+};
+
+
+const int ScaleFactorMatcher::kMatchedFactors[] = {1, 2, 4, 8};
+
+
+ScaleFactorMatcher::ScaleFactorMatcher(Node* node)
+ : NodeMatcher(node), left_(NULL), power_(0) {
+ if (opcode() != IrOpcode::kInt32Mul) return;
+ // TODO(dcarney): should test 64 bit ints as well.
+ Int32BinopMatcher m(this->node());
+ if (!m.right().HasValue()) return;
+ int32_t value = m.right().Value();
+ switch (value) {
+ case 8:
+ power_++; // Fall through.
+ case 4:
+ power_++; // Fall through.
+ case 2:
+ power_++; // Fall through.
+ case 1:
+ break;
+ default:
+ return;
+ }
+ left_ = m.left().node();
+}
+
+
+IndexAndDisplacementMatcher::IndexAndDisplacementMatcher(Node* node)
+ : NodeMatcher(node), index_node_(node), displacement_(0), power_(0) {
+ if (opcode() == IrOpcode::kInt32Add) {
+ Int32BinopMatcher m(this->node());
+ if (m.right().HasValue()) {
+ displacement_ = m.right().Value();
+ index_node_ = m.left().node();
+ }
+ }
+ // Test scale factor.
+ ScaleFactorMatcher scale_matcher(index_node_);
+ if (scale_matcher.Matches()) {
+ index_node_ = scale_matcher.Left();
+ power_ = scale_matcher.Power();
+ }
+}
+
+
+const int LeaMultiplyMatcher::kMatchedFactors[7] = {1, 2, 3, 4, 5, 8, 9};
+
+
+LeaMultiplyMatcher::LeaMultiplyMatcher(Node* node)
+ : NodeMatcher(node), left_(NULL), power_(0), displacement_(0) {
+ if (opcode() != IrOpcode::kInt32Mul && opcode() != IrOpcode::kInt64Mul) {
+ return;
+ }
+ int64_t value;
+ Node* left = NULL;
+ {
+ Int32BinopMatcher m(this->node());
+ if (m.right().HasValue()) {
+ value = m.right().Value();
+ left = m.left().node();
+ } else {
+ Int64BinopMatcher m(this->node());
+ if (m.right().HasValue()) {
+ value = m.right().Value();
+ left = m.left().node();
+ } else {
+ return;
+ }
+ }
+ }
+ switch (value) {
+ case 9:
+ case 8:
+ power_++; // Fall through.
+ case 5:
+ case 4:
+ power_++; // Fall through.
+ case 3:
+ case 2:
+ power_++; // Fall through.
+ case 1:
+ break;
+ default:
+ return;
+ }
+ if (!base::bits::IsPowerOfTwo64(value)) {
+ displacement_ = 1;
+ }
+ left_ = left;
+}
+
+
class AddressingModeMatcher {
public:
AddressingModeMatcher(IA32OperandGenerator* g, Node* base, Node* index)
}
}
// Adjust mode to actual scale factor.
- mode_ = GetMode(mode_, matcher.power());
- // Don't emit instructions with scale factor 1 if there's no base.
- if (mode_ == kMode_M1) {
- mode_ = kMode_MR;
- } else if (mode_ == kMode_M1I) {
- mode_ = kMode_MRI;
- }
+ mode_ = AdjustAddressingMode(mode_, matcher.power());
}
DCHECK_NE(kMode_None, mode_);
}
- AddressingMode GetMode(AddressingMode one, int power) {
- return static_cast<AddressingMode>(static_cast<int>(one) + power);
- }
-
size_t SetInputs(InstructionOperand** inputs) {
size_t input_count = 0;
// Compute inputs_ and input_count.
};
+static void VisitRRFloat64(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ IA32OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)));
+}
+
+
void InstructionSelector::VisitLoad(Node* node) {
MachineType rep = RepresentationOf(OpParameter<LoadRepresentation>(node));
MachineType typ = TypeOf(OpParameter<LoadRepresentation>(node));
size_t output_count = 0;
// TODO(turbofan): match complex addressing modes.
- if (g.CanBeImmediate(right)) {
- inputs[input_count++] = g.Use(left);
+ if (left == right) {
+ // If both inputs refer to the same operand, enforce allocating a register
+ // for both of them to ensure that we don't end up generating code like
+ // this:
+ //
+ // mov eax, [ebp-0x10]
+ // add eax, [ebp-0x10]
+ // jo label
+ InstructionOperand* const input = g.UseRegister(left);
+ inputs[input_count++] = input;
+ inputs[input_count++] = input;
+ } else if (g.CanBeImmediate(right)) {
+ inputs[input_count++] = g.UseRegister(left);
inputs[input_count++] = g.UseImmediate(right);
} else {
if (node->op()->HasProperty(Operator::kCommutative) &&
IA32OperandGenerator g(this);
Int32BinopMatcher m(node);
if (m.right().Is(-1)) {
- Emit(kIA32Not, g.DefineSameAsFirst(node), g.Use(m.left().node()));
+ Emit(kIA32Not, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
} else {
VisitBinop(this, node, kIA32Xor);
}
Node* left = node->InputAt(0);
Node* right = node->InputAt(1);
- // TODO(turbofan): assembler only supports some addressing modes for shifts.
if (g.CanBeImmediate(right)) {
selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
g.UseImmediate(right));
}
+static bool TryEmitLeaMultAdd(InstructionSelector* selector, Node* node) {
+ Int32BinopMatcher m(node);
+ if (!m.right().HasValue()) return false;
+ int32_t displacement_value = m.right().Value();
+ Node* left = m.left().node();
+ LeaMultiplyMatcher lmm(left);
+ if (!lmm.Matches()) return false;
+ AddressingMode mode;
+ size_t input_count;
+ IA32OperandGenerator g(selector);
+ InstructionOperand* index = g.UseRegister(lmm.Left());
+ InstructionOperand* displacement = g.TempImmediate(displacement_value);
+ InstructionOperand* inputs[] = {index, displacement, displacement};
+ if (lmm.Displacement() != 0) {
+ input_count = 3;
+ inputs[1] = index;
+ mode = kMode_MR1I;
+ } else {
+ input_count = 2;
+ mode = kMode_M1I;
+ }
+ mode = AdjustAddressingMode(mode, lmm.Power());
+ InstructionOperand* outputs[] = {g.DefineAsRegister(node)};
+ selector->Emit(kIA32Lea | AddressingModeField::encode(mode), 1, outputs,
+ input_count, inputs);
+ return true;
+}
+
+
void InstructionSelector::VisitInt32Add(Node* node) {
+ if (TryEmitLeaMultAdd(this, node)) return;
VisitBinop(this, node, kIA32Add);
}
}
+static bool TryEmitLeaMult(InstructionSelector* selector, Node* node) {
+ LeaMultiplyMatcher lea(node);
+ // Try to match lea.
+ if (!lea.Matches()) return false;
+ AddressingMode mode;
+ size_t input_count;
+ IA32OperandGenerator g(selector);
+ InstructionOperand* left = g.UseRegister(lea.Left());
+ InstructionOperand* inputs[] = {left, left};
+ if (lea.Displacement() != 0) {
+ input_count = 2;
+ mode = kMode_MR1;
+ } else {
+ input_count = 1;
+ mode = kMode_M1;
+ }
+ mode = AdjustAddressingMode(mode, lea.Power());
+ InstructionOperand* outputs[] = {g.DefineAsRegister(node)};
+ selector->Emit(kIA32Lea | AddressingModeField::encode(mode), 1, outputs,
+ input_count, inputs);
+ return true;
+}
+
+
void InstructionSelector::VisitInt32Mul(Node* node) {
+ if (TryEmitLeaMult(this, node)) return;
IA32OperandGenerator g(this);
Int32BinopMatcher m(node);
Node* left = m.left().node();
}
-static inline void VisitDiv(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
+namespace {
+
+void VisitMulHigh(InstructionSelector* selector, Node* node,
+ ArchOpcode opcode) {
+ IA32OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsFixed(node, edx),
+ g.UseFixed(node->InputAt(0), eax),
+ g.UseUniqueRegister(node->InputAt(1)));
+}
+
+
+void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
IA32OperandGenerator g(selector);
InstructionOperand* temps[] = {g.TempRegister(edx)};
- size_t temp_count = arraysize(temps);
selector->Emit(opcode, g.DefineAsFixed(node, eax),
g.UseFixed(node->InputAt(0), eax),
- g.UseUnique(node->InputAt(1)), temp_count, temps);
+ g.UseUnique(node->InputAt(1)), arraysize(temps), temps);
}
-void InstructionSelector::VisitInt32Div(Node* node) {
- VisitDiv(this, node, kIA32Idiv);
+void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
+ IA32OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsFixed(node, edx),
+ g.UseFixed(node->InputAt(0), eax),
+ g.UseUnique(node->InputAt(1)));
}
+} // namespace
-void InstructionSelector::VisitInt32UDiv(Node* node) {
- VisitDiv(this, node, kIA32Udiv);
+
+void InstructionSelector::VisitInt32MulHigh(Node* node) {
+ VisitMulHigh(this, node, kIA32ImulHigh);
}
-static inline void VisitMod(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
- IA32OperandGenerator g(selector);
- InstructionOperand* temps[] = {g.TempRegister(eax), g.TempRegister(edx)};
- size_t temp_count = arraysize(temps);
- selector->Emit(opcode, g.DefineAsFixed(node, edx),
- g.UseFixed(node->InputAt(0), eax),
- g.UseUnique(node->InputAt(1)), temp_count, temps);
+void InstructionSelector::VisitUint32MulHigh(Node* node) {
+ VisitMulHigh(this, node, kIA32UmulHigh);
+}
+
+
+void InstructionSelector::VisitInt32Div(Node* node) {
+ VisitDiv(this, node, kIA32Idiv);
+}
+
+
+void InstructionSelector::VisitUint32Div(Node* node) {
+ VisitDiv(this, node, kIA32Udiv);
}
}
-void InstructionSelector::VisitInt32UMod(Node* node) {
+void InstructionSelector::VisitUint32Mod(Node* node) {
VisitMod(this, node, kIA32Udiv);
}
void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
IA32OperandGenerator g(this);
- // TODO(turbofan): IA32 SSE conversions should take an operand.
- Emit(kSSECvtss2sd, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+ Emit(kSSECvtss2sd, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
IA32OperandGenerator g(this);
- // TODO(turbofan): IA32 SSE LoadUint32() should take an operand.
- Emit(kSSEUint32ToFloat64, g.DefineAsRegister(node),
- g.UseRegister(node->InputAt(0)));
+ Emit(kSSEUint32ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
IA32OperandGenerator g(this);
- // TODO(turbofan): IA32 SSE conversions should take an operand.
- Emit(kSSECvtsd2ss, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+ Emit(kSSECvtsd2ss, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitFloat64Add(Node* node) {
IA32OperandGenerator g(this);
Emit(kSSEFloat64Add, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Sub(Node* node) {
IA32OperandGenerator g(this);
Emit(kSSEFloat64Sub, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Mul(Node* node) {
IA32OperandGenerator g(this);
Emit(kSSEFloat64Mul, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Div(Node* node) {
IA32OperandGenerator g(this);
Emit(kSSEFloat64Div, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
}
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kIA32Add, cont);
+void InstructionSelector::VisitFloat64Floor(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64Floor, node);
+}
+
+
+void InstructionSelector::VisitFloat64Ceil(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64Ceil, node);
}
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kIA32Sub, cont);
+void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64RoundTruncate, node);
+}
+
+
+void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
+ UNREACHABLE();
+}
+
+
+void InstructionSelector::VisitCall(Node* node) {
+ IA32OperandGenerator g(this);
+ CallDescriptor* descriptor = OpParameter<CallDescriptor*>(node);
+
+ FrameStateDescriptor* frame_state_descriptor = NULL;
+
+ if (descriptor->NeedsFrameState()) {
+ frame_state_descriptor =
+ GetFrameStateDescriptor(node->InputAt(descriptor->InputCount()));
+ }
+
+ CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
+
+ // Compute InstructionOperands for inputs and outputs.
+ InitializeCallBuffer(node, &buffer, true, true);
+
+ // Push any stack arguments.
+ for (NodeVectorRIter input = buffer.pushed_nodes.rbegin();
+ input != buffer.pushed_nodes.rend(); input++) {
+ // TODO(titzer): handle pushing double parameters.
+ Emit(kIA32Push, NULL,
+ g.CanBeImmediate(*input) ? g.UseImmediate(*input) : g.Use(*input));
+ }
+
+ // Select the appropriate opcode based on the call type.
+ InstructionCode opcode;
+ switch (descriptor->kind()) {
+ case CallDescriptor::kCallCodeObject: {
+ opcode = kArchCallCodeObject;
+ break;
+ }
+ case CallDescriptor::kCallJSFunction:
+ opcode = kArchCallJSFunction;
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+ opcode |= MiscField::encode(descriptor->flags());
+
+ // Emit the call instruction.
+ InstructionOperand** first_output =
+ buffer.outputs.size() > 0 ? &buffer.outputs.front() : NULL;
+ Instruction* call_instr =
+ Emit(opcode, buffer.outputs.size(), first_output,
+ buffer.instruction_args.size(), &buffer.instruction_args.front());
+ call_instr->MarkAsCall();
}
+namespace {
+
// Shared routine for multiple compare operations.
-static inline void VisitCompare(InstructionSelector* selector,
- InstructionCode opcode,
- InstructionOperand* left,
- InstructionOperand* right,
- FlagsContinuation* cont) {
+void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
+ InstructionOperand* left, InstructionOperand* right,
+ FlagsContinuation* cont) {
IA32OperandGenerator g(selector);
if (cont->IsBranch()) {
selector->Emit(cont->Encode(opcode), NULL, left, right,
}
+// Shared routine for multiple compare operations.
+void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
+ Node* left, Node* right, FlagsContinuation* cont,
+ bool commutative) {
+ IA32OperandGenerator g(selector);
+ if (commutative && g.CanBeBetterLeftOperand(right)) {
+ std::swap(left, right);
+ }
+ VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
+}
+
+
+// Shared routine for multiple float compare operations.
+void VisitFloat64Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitCompare(selector, kSSEFloat64Cmp, node->InputAt(0), node->InputAt(1),
+ cont, node->op()->HasProperty(Operator::kCommutative));
+}
+
+
// Shared routine for multiple word compare operations.
-static inline void VisitWordCompare(InstructionSelector* selector, Node* node,
- InstructionCode opcode,
- FlagsContinuation* cont, bool commutative) {
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont) {
IA32OperandGenerator g(selector);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
+ Node* const left = node->InputAt(0);
+ Node* const right = node->InputAt(1);
// Match immediates on left or right side of comparison.
if (g.CanBeImmediate(right)) {
VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right), cont);
} else if (g.CanBeImmediate(left)) {
- if (!commutative) cont->Commute();
+ if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
VisitCompare(selector, opcode, g.Use(right), g.UseImmediate(left), cont);
} else {
- VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
+ VisitCompare(selector, opcode, left, right, cont,
+ node->op()->HasProperty(Operator::kCommutative));
}
}
-void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kInt32Sub:
- return VisitWordCompare(this, node, kIA32Cmp, cont, false);
- case IrOpcode::kWord32And:
- return VisitWordCompare(this, node, kIA32Test, cont, true);
- default:
- break;
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordCompare(selector, node, kIA32Cmp, cont);
+}
+
+
+// Shared routine for word comparison with zero.
+void VisitWordCompareZero(InstructionSelector* selector, Node* user,
+ Node* value, FlagsContinuation* cont) {
+ // Try to combine the branch with a comparison.
+ while (selector->CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord32Equal: {
+ // Try to combine with comparisons against 0 by simply inverting the
+ // continuation.
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont->Negate();
+ continue;
+ }
+ cont->OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(selector, value, cont);
+ }
+ case IrOpcode::kInt32LessThan:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kInt32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kFloat64Equal:
+ cont->OverwriteAndNegateIfEqual(kUnorderedEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThan);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kProjection:
+ // Check if this is the overflow output projection of an
+ // <Operation>WithOverflow node.
+ if (OpParameter<size_t>(value) == 1u) {
+ // We cannot combine the <Operation>WithOverflow with this branch
+ // unless the 0th projection (the use of the actual value of the
+ // <Operation> is either NULL, which means there's no use of the
+ // actual value, or was already defined, which means it is scheduled
+ // *AFTER* this branch).
+ Node* node = value->InputAt(0);
+ Node* result = node->FindProjection(0);
+ if (result == NULL || selector->IsDefined(result)) {
+ switch (node->opcode()) {
+ case IrOpcode::kInt32AddWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kIA32Add, cont);
+ case IrOpcode::kInt32SubWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kIA32Sub, cont);
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(selector, value, kIA32Test, cont);
+ default:
+ break;
+ }
+ break;
}
- IA32OperandGenerator g(this);
- VisitCompare(this, kIA32Test, g.Use(node), g.TempImmediate(-1), cont);
+ // Continuation could not be combined with a compare, emit compare against 0.
+ IA32OperandGenerator g(selector);
+ VisitCompare(selector, kIA32Cmp, g.Use(value), g.TempImmediate(0), cont);
}
+} // namespace
-void InstructionSelector::VisitWord32Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kIA32Cmp, cont, false);
+
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
+ FlagsContinuation cont(kNotEqual, tbranch, fbranch);
+ if (IsNextInAssemblyOrder(tbranch)) { // We can fallthru to the true block.
+ cont.Negate();
+ cont.SwapBlocks();
+ }
+ VisitWordCompareZero(this, branch, branch->InputAt(0), &cont);
}
-void InstructionSelector::VisitFloat64Compare(Node* node,
- FlagsContinuation* cont) {
- IA32OperandGenerator g(this);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
- VisitCompare(this, kSSEFloat64Cmp, g.UseRegister(left), g.Use(right), cont);
+void InstructionSelector::VisitWord32Equal(Node* const node) {
+ FlagsContinuation cont(kEqual, node);
+ Int32BinopMatcher m(node);
+ if (m.right().Is(0)) {
+ return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
+ }
+ VisitWordCompare(this, node, &cont);
}
-void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization) {
- IA32OperandGenerator g(this);
- CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call);
+void InstructionSelector::VisitInt32LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
- FrameStateDescriptor* frame_state_descriptor = NULL;
- if (descriptor->NeedsFrameState()) {
- frame_state_descriptor =
- GetFrameStateDescriptor(call->InputAt(descriptor->InputCount()));
- }
+void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
- CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
- // Compute InstructionOperands for inputs and outputs.
- InitializeCallBuffer(call, &buffer, true, true);
+void InstructionSelector::VisitUint32LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
- // Push any stack arguments.
- for (NodeVectorRIter input = buffer.pushed_nodes.rbegin();
- input != buffer.pushed_nodes.rend(); input++) {
- // TODO(titzer): handle pushing double parameters.
- Emit(kIA32Push, NULL,
- g.CanBeImmediate(*input) ? g.UseImmediate(*input) : g.Use(*input));
- }
- // Select the appropriate opcode based on the call type.
- InstructionCode opcode;
- switch (descriptor->kind()) {
- case CallDescriptor::kCallCodeObject: {
- opcode = kArchCallCodeObject;
- break;
- }
- case CallDescriptor::kCallJSFunction:
- opcode = kArchCallJSFunction;
- break;
- default:
- UNREACHABLE();
- return;
+void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kIA32Add, &cont);
}
- opcode |= MiscField::encode(descriptor->flags());
+ FlagsContinuation cont;
+ VisitBinop(this, node, kIA32Add, &cont);
+}
- // Emit the call instruction.
- Instruction* call_instr =
- Emit(opcode, buffer.outputs.size(), &buffer.outputs.front(),
- buffer.instruction_args.size(), &buffer.instruction_args.front());
- call_instr->MarkAsCall();
- if (deoptimization != NULL) {
- DCHECK(continuation != NULL);
- call_instr->MarkAsControl();
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kIA32Sub, &cont);
}
+ FlagsContinuation cont;
+ VisitBinop(this, node, kIA32Sub, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64Equal(Node* node) {
+ FlagsContinuation cont(kUnorderedEqual, node);
+ VisitFloat64Compare(this, node, &cont);
}
+
+void InstructionSelector::VisitFloat64LessThan(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThan, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ if (CpuFeatures::IsSupported(SSE4_1)) {
+ return MachineOperatorBuilder::kFloat64Floor |
+ MachineOperatorBuilder::kFloat64Ceil |
+ MachineOperatorBuilder::kFloat64RoundTruncate;
+ }
+ return MachineOperatorBuilder::Flag::kNoFlags;
+}
} // namespace compiler
} // namespace internal
} // namespace v8
typedef LinkageHelper<IA32LinkageHelperTraits> LH;
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone) {
- return LH::GetJSCallDescriptor(zone, parameter_count);
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
+ return LH::GetJSCallDescriptor(zone, parameter_count, flags);
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone) {
return LH::GetStubCallDescriptor(zone, descriptor, stack_parameter_count,
flags);
#ifndef V8_COMPILER_INSTRUCTION_CODES_H_
#define V8_COMPILER_INSTRUCTION_CODES_H_
+#include <iosfwd>
+
#if V8_TARGET_ARCH_ARM
#include "src/compiler/arm/instruction-codes-arm.h"
#elif V8_TARGET_ARCH_ARM64
#include "src/compiler/arm64/instruction-codes-arm64.h"
#elif V8_TARGET_ARCH_IA32
#include "src/compiler/ia32/instruction-codes-ia32.h"
+#elif V8_TARGET_ARCH_MIPS
+#include "src/compiler/mips/instruction-codes-mips.h"
#elif V8_TARGET_ARCH_X64
#include "src/compiler/x64/instruction-codes-x64.h"
#else
namespace v8 {
namespace internal {
-
-class OStream;
-
namespace compiler {
// Target-specific opcodes that specify which assembly sequence to emit.
V(ArchJmp) \
V(ArchNop) \
V(ArchRet) \
+ V(ArchStackPointer) \
V(ArchTruncateDoubleToI) \
TARGET_ARCH_OPCODE_LIST(V)
#undef COUNT_ARCH_OPCODE
};
-OStream& operator<<(OStream& os, const ArchOpcode& ao);
+std::ostream& operator<<(std::ostream& os, const ArchOpcode& ao);
// Addressing modes represent the "shape" of inputs to an instruction.
// Many instructions support multiple addressing modes. Addressing modes
#undef COUNT_ADDRESSING_MODE
};
-OStream& operator<<(OStream& os, const AddressingMode& am);
+std::ostream& operator<<(std::ostream& os, const AddressingMode& am);
// The mode of the flags continuation (see below).
enum FlagsMode { kFlags_none = 0, kFlags_branch = 1, kFlags_set = 2 };
-OStream& operator<<(OStream& os, const FlagsMode& fm);
+std::ostream& operator<<(std::ostream& os, const FlagsMode& fm);
// The condition of flags continuation (see below).
enum FlagsCondition {
kNotOverflow
};
-OStream& operator<<(OStream& os, const FlagsCondition& fc);
+std::ostream& operator<<(std::ostream& os, const FlagsCondition& fc);
// The InstructionCode is an opaque, target-specific integer that encodes
// what code to emit for an instruction in the code generator. It is not
#ifndef V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
#define V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
+#include "src/compiler/generic-node-inl.h"
#include "src/compiler/instruction.h"
#include "src/compiler/instruction-selector.h"
#include "src/compiler/linkage.h"
+#include "src/macro-assembler.h"
namespace v8 {
namespace internal {
InstructionOperand* DefineAsConstant(Node* node) {
selector()->MarkAsDefined(node);
- sequence()->AddConstant(node->id(), ToConstant(node));
- return ConstantOperand::Create(node->id(), zone());
+ int virtual_register = selector_->GetVirtualRegister(node);
+ sequence()->AddConstant(virtual_register, ToConstant(node));
+ return ConstantOperand::Create(virtual_register, zone());
}
InstructionOperand* DefineAsLocation(Node* node, LinkageLocation location,
}
InstructionOperand* Use(Node* node) {
- return Use(node,
- new (zone()) UnallocatedOperand(
- UnallocatedOperand::ANY, UnallocatedOperand::USED_AT_START));
+ return Use(
+ node, new (zone()) UnallocatedOperand(
+ UnallocatedOperand::NONE, UnallocatedOperand::USED_AT_START));
}
InstructionOperand* UseRegister(Node* node) {
// Use register or operand for the node. If a register is chosen, it won't
// alias any temporary or output registers.
InstructionOperand* UseUnique(Node* node) {
- return Use(node, new (zone()) UnallocatedOperand(UnallocatedOperand::ANY));
+ return Use(node, new (zone()) UnallocatedOperand(UnallocatedOperand::NONE));
}
// Use a unique register for the node that does not alias any temporary or
return ImmediateOperand::Create(index, zone());
}
+ InstructionOperand* TempLocation(LinkageLocation location, MachineType type) {
+ UnallocatedOperand* op = ToUnallocatedOperand(location, type);
+ op->set_virtual_register(sequence()->NextVirtualRegister());
+ return op;
+ }
+
InstructionOperand* Label(BasicBlock* block) {
// TODO(bmeurer): We misuse ImmediateOperand here.
- return TempImmediate(block->id());
+ return TempImmediate(block->rpo_number());
}
protected:
- Graph* graph() const { return selector()->graph(); }
InstructionSelector* selector() const { return selector_; }
InstructionSequence* sequence() const { return selector()->sequence(); }
Isolate* isolate() const { return zone()->isolate(); }
UnallocatedOperand* Define(Node* node, UnallocatedOperand* operand) {
DCHECK_NOT_NULL(node);
DCHECK_NOT_NULL(operand);
- operand->set_virtual_register(node->id());
+ operand->set_virtual_register(selector_->GetVirtualRegister(node));
selector()->MarkAsDefined(node);
return operand;
}
UnallocatedOperand* Use(Node* node, UnallocatedOperand* operand) {
DCHECK_NOT_NULL(node);
DCHECK_NOT_NULL(operand);
- operand->set_virtual_register(node->id());
+ operand->set_virtual_register(selector_->GetVirtualRegister(node));
selector()->MarkAsUsed(node);
return operand;
}
#include "src/compiler/instruction-selector.h"
+#include "src/compiler/graph.h"
#include "src/compiler/instruction-selector-impl.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
namespace internal {
namespace compiler {
-InstructionSelector::InstructionSelector(InstructionSequence* sequence,
+InstructionSelector::InstructionSelector(Zone* local_zone, Graph* graph,
+ Linkage* linkage,
+ InstructionSequence* sequence,
+ Schedule* schedule,
SourcePositionTable* source_positions,
Features features)
- : zone_(sequence->isolate()),
+ : zone_(local_zone),
+ linkage_(linkage),
sequence_(sequence),
source_positions_(source_positions),
features_(features),
+ schedule_(schedule),
+ node_map_(graph->NodeCount(), kNodeUnmapped, zone()),
current_block_(NULL),
instructions_(zone()),
- defined_(graph()->NodeCount(), false, zone()),
- used_(graph()->NodeCount(), false, zone()) {}
+ defined_(graph->NodeCount(), false, zone()),
+ used_(graph->NodeCount(), false, zone()) {}
void InstructionSelector::SelectInstructions() {
for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
BasicBlock* block = *i;
if (!block->IsLoopHeader()) continue;
- DCHECK_NE(0, block->PredecessorCount());
- DCHECK_NE(1, block->PredecessorCount());
+ DCHECK_NE(0, static_cast<int>(block->PredecessorCount()));
+ DCHECK_NE(1, static_cast<int>(block->PredecessorCount()));
for (BasicBlock::const_iterator j = block->begin(); j != block->end();
++j) {
Node* phi = *j;
// Schedule the selected instructions.
for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
BasicBlock* block = *i;
- size_t end = block->code_end_;
- size_t start = block->code_start_;
- sequence()->StartBlock(block);
+ InstructionBlock* instruction_block =
+ sequence()->InstructionBlockAt(block->GetRpoNumber());
+ size_t end = instruction_block->code_end();
+ size_t start = instruction_block->code_start();
+ sequence()->StartBlock(block->GetRpoNumber());
while (start-- > end) {
- sequence()->AddInstruction(instructions_[start], block);
+ sequence()->AddInstruction(instructions_[start]);
}
- sequence()->EndBlock(block);
+ sequence()->EndBlock(block->GetRpoNumber());
}
}
bool InstructionSelector::IsNextInAssemblyOrder(const BasicBlock* block) const {
- return block->rpo_number_ == (current_block_->rpo_number_ + 1) &&
- block->deferred_ == current_block_->deferred_;
+ return current_block_->GetAoNumber().IsNext(block->GetAoNumber());
}
}
+int InstructionSelector::GetVirtualRegister(const Node* node) {
+ if (node_map_[node->id()] == kNodeUnmapped) {
+ node_map_[node->id()] = sequence()->NextVirtualRegister();
+ }
+ return node_map_[node->id()];
+}
+
+
+int InstructionSelector::GetMappedVirtualRegister(const Node* node) const {
+ return node_map_[node->id()];
+}
+
+
bool InstructionSelector::IsDefined(Node* node) const {
DCHECK_NOT_NULL(node);
NodeId id = node->id();
bool InstructionSelector::IsDouble(const Node* node) const {
DCHECK_NOT_NULL(node);
- return sequence()->IsDouble(node->id());
+ int virtual_register = GetMappedVirtualRegister(node);
+ if (virtual_register == kNodeUnmapped) return false;
+ return sequence()->IsDouble(virtual_register);
}
void InstructionSelector::MarkAsDouble(Node* node) {
DCHECK_NOT_NULL(node);
DCHECK(!IsReference(node));
- sequence()->MarkAsDouble(node->id());
+ sequence()->MarkAsDouble(GetVirtualRegister(node));
}
bool InstructionSelector::IsReference(const Node* node) const {
DCHECK_NOT_NULL(node);
- return sequence()->IsReference(node->id());
+ int virtual_register = GetMappedVirtualRegister(node);
+ if (virtual_register == kNodeUnmapped) return false;
+ return sequence()->IsReference(virtual_register);
}
void InstructionSelector::MarkAsReference(Node* node) {
DCHECK_NOT_NULL(node);
DCHECK(!IsDouble(node));
- sequence()->MarkAsReference(node->id());
+ sequence()->MarkAsReference(GetVirtualRegister(node));
+}
+
+
+void InstructionSelector::MarkAsRepresentation(MachineType rep,
+ InstructionOperand* op) {
+ UnallocatedOperand* unalloc = UnallocatedOperand::cast(op);
+ switch (RepresentationOf(rep)) {
+ case kRepFloat32:
+ case kRepFloat64:
+ sequence()->MarkAsDouble(unalloc->virtual_register());
+ break;
+ case kRepTagged:
+ sequence()->MarkAsReference(unalloc->virtual_register());
+ break;
+ default:
+ break;
+ }
}
bool call_code_immediate,
bool call_address_immediate) {
OperandGenerator g(this);
- DCHECK_EQ(call->op()->OutputCount(), buffer->descriptor->ReturnCount());
- DCHECK_EQ(OperatorProperties::GetValueInputCount(call->op()),
- buffer->input_count() + buffer->frame_state_count());
+ DCHECK_EQ(call->op()->OutputCount(),
+ static_cast<int>(buffer->descriptor->ReturnCount()));
+ DCHECK_EQ(
+ call->op()->ValueInputCount(),
+ static_cast<int>(buffer->input_count() + buffer->frame_state_count()));
if (buffer->descriptor->ReturnCount() > 0) {
// Collect the projections that represent multiple outputs from this call.
}
// Filter out the outputs that aren't live because no projection uses them.
+ size_t outputs_needed_by_framestate =
+ buffer->frame_state_descriptor == NULL
+ ? 0
+ : buffer->frame_state_descriptor->state_combine()
+ .ConsumedOutputCount();
for (size_t i = 0; i < buffer->output_nodes.size(); i++) {
- if (buffer->output_nodes[i] != NULL) {
- Node* output = buffer->output_nodes[i];
+ bool output_is_live =
+ buffer->output_nodes[i] != NULL || i < outputs_needed_by_framestate;
+ if (output_is_live) {
MachineType type =
buffer->descriptor->GetReturnType(static_cast<int>(i));
LinkageLocation location =
buffer->descriptor->GetReturnLocation(static_cast<int>(i));
- MarkAsRepresentation(type, output);
- buffer->outputs.push_back(g.DefineAsLocation(output, location, type));
+
+ Node* output = buffer->output_nodes[i];
+ InstructionOperand* op =
+ output == NULL ? g.TempLocation(location, type)
+ : g.DefineAsLocation(output, location, type);
+ MarkAsRepresentation(type, op);
+
+ buffer->outputs.push_back(op);
}
}
}
buffer->descriptor->GetInputType(0)));
break;
}
- DCHECK_EQ(1, buffer->instruction_args.size());
+ DCHECK_EQ(1, static_cast<int>(buffer->instruction_args.size()));
// If the call needs a frame state, we insert the state information as
// follows (n is the number of value inputs to the frame state):
}
// We're done with the block.
- // TODO(bmeurer): We should not mutate the schedule.
- block->code_end_ = current_block_end;
- block->code_start_ = static_cast<int>(instructions_.size());
+ InstructionBlock* instruction_block =
+ sequence()->InstructionBlockAt(block->GetRpoNumber());
+ instruction_block->set_code_start(static_cast<int>(instructions_.size()));
+ instruction_block->set_code_end(current_block_end);
current_block_ = NULL;
}
void InstructionSelector::VisitControl(BasicBlock* block) {
- Node* input = block->control_input_;
- switch (block->control_) {
- case BasicBlockData::kGoto:
+ Node* input = block->control_input();
+ switch (block->control()) {
+ case BasicBlock::kGoto:
return VisitGoto(block->SuccessorAt(0));
- case BasicBlockData::kBranch: {
+ case BasicBlock::kBranch: {
DCHECK_EQ(IrOpcode::kBranch, input->opcode());
BasicBlock* tbranch = block->SuccessorAt(0);
BasicBlock* fbranch = block->SuccessorAt(1);
if (tbranch == fbranch) return VisitGoto(tbranch);
return VisitBranch(input, tbranch, fbranch);
}
- case BasicBlockData::kReturn: {
+ case BasicBlock::kReturn: {
// If the result itself is a return, return its input.
Node* value = (input != NULL && input->opcode() == IrOpcode::kReturn)
? input->InputAt(0)
: input;
return VisitReturn(value);
}
- case BasicBlockData::kThrow:
+ case BasicBlock::kThrow:
return VisitThrow(input);
- case BasicBlockData::kNone: {
+ case BasicBlock::kNone: {
// TODO(titzer): exit block doesn't have control.
DCHECK(input == NULL);
break;
}
+MachineType InstructionSelector::GetMachineType(Node* node) {
+ DCHECK_NOT_NULL(schedule()->block(node)); // should only use scheduled nodes.
+ switch (node->opcode()) {
+ case IrOpcode::kStart:
+ case IrOpcode::kLoop:
+ case IrOpcode::kEnd:
+ case IrOpcode::kBranch:
+ case IrOpcode::kIfTrue:
+ case IrOpcode::kIfFalse:
+ case IrOpcode::kEffectPhi:
+ case IrOpcode::kMerge:
+ case IrOpcode::kTerminate:
+ // No code needed for these graph artifacts.
+ return kMachNone;
+ case IrOpcode::kFinish:
+ return kMachAnyTagged;
+ case IrOpcode::kParameter:
+ return linkage()->GetParameterType(OpParameter<int>(node));
+ case IrOpcode::kPhi:
+ return OpParameter<MachineType>(node);
+ case IrOpcode::kProjection:
+ // TODO(jarin) Really project from outputs.
+ return kMachAnyTagged;
+ case IrOpcode::kInt32Constant:
+ return kMachInt32;
+ case IrOpcode::kInt64Constant:
+ return kMachInt64;
+ case IrOpcode::kExternalConstant:
+ return kMachPtr;
+ case IrOpcode::kFloat64Constant:
+ return kMachFloat64;
+ case IrOpcode::kHeapConstant:
+ case IrOpcode::kNumberConstant:
+ return kMachAnyTagged;
+ case IrOpcode::kCall:
+ return kMachAnyTagged;
+ case IrOpcode::kFrameState:
+ case IrOpcode::kStateValues:
+ return kMachNone;
+ case IrOpcode::kLoad:
+ return OpParameter<LoadRepresentation>(node);
+ case IrOpcode::kStore:
+ return kMachNone;
+ case IrOpcode::kWord32And:
+ case IrOpcode::kWord32Or:
+ case IrOpcode::kWord32Xor:
+ case IrOpcode::kWord32Shl:
+ case IrOpcode::kWord32Shr:
+ case IrOpcode::kWord32Sar:
+ case IrOpcode::kWord32Ror:
+ return kMachInt32;
+ case IrOpcode::kWord32Equal:
+ return kMachBool;
+ case IrOpcode::kWord64And:
+ case IrOpcode::kWord64Or:
+ case IrOpcode::kWord64Xor:
+ case IrOpcode::kWord64Shl:
+ case IrOpcode::kWord64Shr:
+ case IrOpcode::kWord64Sar:
+ case IrOpcode::kWord64Ror:
+ return kMachInt64;
+ case IrOpcode::kWord64Equal:
+ return kMachBool;
+ case IrOpcode::kInt32Add:
+ case IrOpcode::kInt32AddWithOverflow:
+ case IrOpcode::kInt32Sub:
+ case IrOpcode::kInt32SubWithOverflow:
+ case IrOpcode::kInt32Mul:
+ case IrOpcode::kInt32Div:
+ case IrOpcode::kInt32Mod:
+ return kMachInt32;
+ case IrOpcode::kInt32LessThan:
+ case IrOpcode::kInt32LessThanOrEqual:
+ case IrOpcode::kUint32LessThan:
+ case IrOpcode::kUint32LessThanOrEqual:
+ return kMachBool;
+ case IrOpcode::kInt64Add:
+ case IrOpcode::kInt64Sub:
+ case IrOpcode::kInt64Mul:
+ case IrOpcode::kInt64Div:
+ case IrOpcode::kInt64Mod:
+ return kMachInt64;
+ case IrOpcode::kInt64LessThan:
+ case IrOpcode::kInt64LessThanOrEqual:
+ return kMachBool;
+ case IrOpcode::kChangeFloat32ToFloat64:
+ case IrOpcode::kChangeInt32ToFloat64:
+ case IrOpcode::kChangeUint32ToFloat64:
+ return kMachFloat64;
+ case IrOpcode::kChangeFloat64ToInt32:
+ return kMachInt32;
+ case IrOpcode::kChangeFloat64ToUint32:
+ return kMachUint32;
+ case IrOpcode::kChangeInt32ToInt64:
+ return kMachInt64;
+ case IrOpcode::kChangeUint32ToUint64:
+ return kMachUint64;
+ case IrOpcode::kTruncateFloat64ToFloat32:
+ return kMachFloat32;
+ case IrOpcode::kTruncateFloat64ToInt32:
+ case IrOpcode::kTruncateInt64ToInt32:
+ return kMachInt32;
+ case IrOpcode::kFloat64Add:
+ case IrOpcode::kFloat64Sub:
+ case IrOpcode::kFloat64Mul:
+ case IrOpcode::kFloat64Div:
+ case IrOpcode::kFloat64Mod:
+ case IrOpcode::kFloat64Sqrt:
+ case IrOpcode::kFloat64Floor:
+ case IrOpcode::kFloat64Ceil:
+ case IrOpcode::kFloat64RoundTruncate:
+ case IrOpcode::kFloat64RoundTiesAway:
+ return kMachFloat64;
+ case IrOpcode::kFloat64Equal:
+ case IrOpcode::kFloat64LessThan:
+ case IrOpcode::kFloat64LessThanOrEqual:
+ return kMachBool;
+ default:
+ V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
+ node->opcode(), node->op()->mnemonic(), node->id());
+ }
+ return kMachNone;
+}
+
+
void InstructionSelector::VisitNode(Node* node) {
DCHECK_NOT_NULL(schedule()->block(node)); // should only use scheduled nodes.
SourcePosition source_position = source_positions_->GetSourcePosition(node);
// TODO(turbofan): only mark non-smis as references.
return MarkAsReference(node), VisitConstant(node);
case IrOpcode::kCall:
- return VisitCall(node, NULL, NULL);
+ return VisitCall(node);
case IrOpcode::kFrameState:
case IrOpcode::kStateValues:
return;
return VisitInt32SubWithOverflow(node);
case IrOpcode::kInt32Mul:
return VisitInt32Mul(node);
+ case IrOpcode::kInt32MulHigh:
+ return VisitInt32MulHigh(node);
case IrOpcode::kInt32Div:
return VisitInt32Div(node);
- case IrOpcode::kInt32UDiv:
- return VisitInt32UDiv(node);
case IrOpcode::kInt32Mod:
return VisitInt32Mod(node);
- case IrOpcode::kInt32UMod:
- return VisitInt32UMod(node);
case IrOpcode::kInt32LessThan:
return VisitInt32LessThan(node);
case IrOpcode::kInt32LessThanOrEqual:
return VisitInt32LessThanOrEqual(node);
+ case IrOpcode::kUint32Div:
+ return VisitUint32Div(node);
case IrOpcode::kUint32LessThan:
return VisitUint32LessThan(node);
case IrOpcode::kUint32LessThanOrEqual:
return VisitUint32LessThanOrEqual(node);
+ case IrOpcode::kUint32Mod:
+ return VisitUint32Mod(node);
+ case IrOpcode::kUint32MulHigh:
+ return VisitUint32MulHigh(node);
case IrOpcode::kInt64Add:
return VisitInt64Add(node);
case IrOpcode::kInt64Sub:
return VisitInt64Mul(node);
case IrOpcode::kInt64Div:
return VisitInt64Div(node);
- case IrOpcode::kInt64UDiv:
- return VisitInt64UDiv(node);
case IrOpcode::kInt64Mod:
return VisitInt64Mod(node);
- case IrOpcode::kInt64UMod:
- return VisitInt64UMod(node);
case IrOpcode::kInt64LessThan:
return VisitInt64LessThan(node);
case IrOpcode::kInt64LessThanOrEqual:
return VisitInt64LessThanOrEqual(node);
+ case IrOpcode::kUint64Div:
+ return VisitUint64Div(node);
+ case IrOpcode::kUint64LessThan:
+ return VisitUint64LessThan(node);
+ case IrOpcode::kUint64Mod:
+ return VisitUint64Mod(node);
case IrOpcode::kChangeFloat32ToFloat64:
return MarkAsDouble(node), VisitChangeFloat32ToFloat64(node);
case IrOpcode::kChangeInt32ToFloat64:
return VisitFloat64LessThan(node);
case IrOpcode::kFloat64LessThanOrEqual:
return VisitFloat64LessThanOrEqual(node);
+ case IrOpcode::kFloat64Floor:
+ return MarkAsDouble(node), VisitFloat64Floor(node);
+ case IrOpcode::kFloat64Ceil:
+ return MarkAsDouble(node), VisitFloat64Ceil(node);
+ case IrOpcode::kFloat64RoundTruncate:
+ return MarkAsDouble(node), VisitFloat64RoundTruncate(node);
+ case IrOpcode::kFloat64RoundTiesAway:
+ return MarkAsDouble(node), VisitFloat64RoundTiesAway(node);
+ case IrOpcode::kLoadStackPointer:
+ return VisitLoadStackPointer(node);
default:
V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
node->opcode(), node->op()->mnemonic(), node->id());
+ break;
}
}
#if V8_TURBOFAN_BACKEND
-void InstructionSelector::VisitWord32Equal(Node* node) {
- FlagsContinuation cont(kEqual, node);
- Int32BinopMatcher m(node);
- if (m.right().Is(0)) {
- return VisitWord32Test(m.left().node(), &cont);
- }
- VisitWord32Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt32LessThan(Node* node) {
- FlagsContinuation cont(kSignedLessThan, node);
- VisitWord32Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
- FlagsContinuation cont(kSignedLessThanOrEqual, node);
- VisitWord32Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitUint32LessThan(Node* node) {
- FlagsContinuation cont(kUnsignedLessThan, node);
- VisitWord32Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
- FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
- VisitWord32Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitWord64Equal(Node* node) {
- FlagsContinuation cont(kEqual, node);
- Int64BinopMatcher m(node);
- if (m.right().Is(0)) {
- return VisitWord64Test(m.left().node(), &cont);
- }
- VisitWord64Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
- if (Node* ovf = node->FindProjection(1)) {
- FlagsContinuation cont(kOverflow, ovf);
- return VisitInt32AddWithOverflow(node, &cont);
- }
- FlagsContinuation cont;
- VisitInt32AddWithOverflow(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
- if (Node* ovf = node->FindProjection(1)) {
- FlagsContinuation cont(kOverflow, ovf);
- return VisitInt32SubWithOverflow(node, &cont);
- }
- FlagsContinuation cont;
- VisitInt32SubWithOverflow(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt64LessThan(Node* node) {
- FlagsContinuation cont(kSignedLessThan, node);
- VisitWord64Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
- FlagsContinuation cont(kSignedLessThanOrEqual, node);
- VisitWord64Compare(node, &cont);
-}
-
-
void InstructionSelector::VisitTruncateFloat64ToInt32(Node* node) {
OperandGenerator g(this);
Emit(kArchTruncateDoubleToI, g.DefineAsRegister(node),
}
-void InstructionSelector::VisitFloat64Equal(Node* node) {
- FlagsContinuation cont(kUnorderedEqual, node);
- VisitFloat64Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitFloat64LessThan(Node* node) {
- FlagsContinuation cont(kUnorderedLessThan, node);
- VisitFloat64Compare(node, &cont);
-}
-
-
-void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
- FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
- VisitFloat64Compare(node, &cont);
+void InstructionSelector::VisitLoadStackPointer(Node* node) {
+ OperandGenerator g(this);
+ Emit(kArchStackPointer, g.DefineAsRegister(node));
}
#endif // V8_TURBOFAN_BACKEND
void InstructionSelector::VisitWord64Ror(Node* node) { UNIMPLEMENTED(); }
+void InstructionSelector::VisitWord64Equal(Node* node) { UNIMPLEMENTED(); }
+
+
void InstructionSelector::VisitInt64Add(Node* node) { UNIMPLEMENTED(); }
void InstructionSelector::VisitInt64Div(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitInt64UDiv(Node* node) { UNIMPLEMENTED(); }
+void InstructionSelector::VisitInt64LessThan(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitInt64Mod(Node* node) { UNIMPLEMENTED(); }
+void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
+ UNIMPLEMENTED();
+}
-void InstructionSelector::VisitInt64UMod(Node* node) { UNIMPLEMENTED(); }
+void InstructionSelector::VisitUint64Div(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
- UNIMPLEMENTED();
-}
+void InstructionSelector::VisitInt64Mod(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
- UNIMPLEMENTED();
-}
+void InstructionSelector::VisitUint64LessThan(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
- UNIMPLEMENTED();
-}
+void InstructionSelector::VisitUint64Mod(Node* node) { UNIMPLEMENTED(); }
-#endif // V8_TARGET_ARCH_32_BIT && V8_TURBOFAN_BACKEND
+void InstructionSelector::VisitChangeInt32ToInt64(Node* node) {
+ UNIMPLEMENTED();
+}
-// 32-bit targets and unsupported architectures need dummy implementations of
-// selected 64-bit ops.
-#if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_X64 || !V8_TURBOFAN_BACKEND
-void InstructionSelector::VisitWord64Test(Node* node, FlagsContinuation* cont) {
+void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
UNIMPLEMENTED();
}
-void InstructionSelector::VisitWord64Compare(Node* node,
- FlagsContinuation* cont) {
+void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
UNIMPLEMENTED();
}
-#endif // V8_TARGET_ARCH_32_BIT || !V8_TURBOFAN_BACKEND
+#endif // V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_X64 && V8_TURBOFAN_BACKEND
void InstructionSelector::VisitFinish(Node* node) {
void InstructionSelector::VisitPhi(Node* node) {
// TODO(bmeurer): Emit a PhiInstruction here.
- for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
- MarkAsUsed(*i);
+ PhiInstruction* phi = new (instruction_zone())
+ PhiInstruction(instruction_zone(), GetVirtualRegister(node));
+ sequence()->InstructionBlockAt(current_block_->GetRpoNumber())->AddPhi(phi);
+ const int input_count = node->op()->InputCount();
+ phi->operands().reserve(static_cast<size_t>(input_count));
+ for (int i = 0; i < input_count; ++i) {
+ Node* const input = node->InputAt(i);
+ MarkAsUsed(input);
+ phi->operands().push_back(GetVirtualRegister(input));
}
}
}
-void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
- BasicBlock* fbranch) {
- OperandGenerator g(this);
- Node* user = branch;
- Node* value = branch->InputAt(0);
-
- FlagsContinuation cont(kNotEqual, tbranch, fbranch);
-
- // If we can fall through to the true block, invert the branch.
- if (IsNextInAssemblyOrder(tbranch)) {
- cont.Negate();
- cont.SwapBlocks();
- }
-
- // Try to combine with comparisons against 0 by simply inverting the branch.
- while (CanCover(user, value)) {
- if (value->opcode() == IrOpcode::kWord32Equal) {
- Int32BinopMatcher m(value);
- if (m.right().Is(0)) {
- user = value;
- value = m.left().node();
- cont.Negate();
- } else {
- break;
- }
- } else if (value->opcode() == IrOpcode::kWord64Equal) {
- Int64BinopMatcher m(value);
- if (m.right().Is(0)) {
- user = value;
- value = m.left().node();
- cont.Negate();
- } else {
- break;
- }
- } else {
- break;
- }
- }
-
- // Try to combine the branch with a comparison.
- if (CanCover(user, value)) {
- switch (value->opcode()) {
- case IrOpcode::kWord32Equal:
- cont.OverwriteAndNegateIfEqual(kEqual);
- return VisitWord32Compare(value, &cont);
- case IrOpcode::kInt32LessThan:
- cont.OverwriteAndNegateIfEqual(kSignedLessThan);
- return VisitWord32Compare(value, &cont);
- case IrOpcode::kInt32LessThanOrEqual:
- cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
- return VisitWord32Compare(value, &cont);
- case IrOpcode::kUint32LessThan:
- cont.OverwriteAndNegateIfEqual(kUnsignedLessThan);
- return VisitWord32Compare(value, &cont);
- case IrOpcode::kUint32LessThanOrEqual:
- cont.OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
- return VisitWord32Compare(value, &cont);
- case IrOpcode::kWord64Equal:
- cont.OverwriteAndNegateIfEqual(kEqual);
- return VisitWord64Compare(value, &cont);
- case IrOpcode::kInt64LessThan:
- cont.OverwriteAndNegateIfEqual(kSignedLessThan);
- return VisitWord64Compare(value, &cont);
- case IrOpcode::kInt64LessThanOrEqual:
- cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
- return VisitWord64Compare(value, &cont);
- case IrOpcode::kFloat64Equal:
- cont.OverwriteAndNegateIfEqual(kUnorderedEqual);
- return VisitFloat64Compare(value, &cont);
- case IrOpcode::kFloat64LessThan:
- cont.OverwriteAndNegateIfEqual(kUnorderedLessThan);
- return VisitFloat64Compare(value, &cont);
- case IrOpcode::kFloat64LessThanOrEqual:
- cont.OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
- return VisitFloat64Compare(value, &cont);
- case IrOpcode::kProjection:
- // Check if this is the overflow output projection of an
- // <Operation>WithOverflow node.
- if (OpParameter<size_t>(value) == 1u) {
- // We cannot combine the <Operation>WithOverflow with this branch
- // unless the 0th projection (the use of the actual value of the
- // <Operation> is either NULL, which means there's no use of the
- // actual value, or was already defined, which means it is scheduled
- // *AFTER* this branch).
- Node* node = value->InputAt(0);
- Node* result = node->FindProjection(0);
- if (result == NULL || IsDefined(result)) {
- switch (node->opcode()) {
- case IrOpcode::kInt32AddWithOverflow:
- cont.OverwriteAndNegateIfEqual(kOverflow);
- return VisitInt32AddWithOverflow(node, &cont);
- case IrOpcode::kInt32SubWithOverflow:
- cont.OverwriteAndNegateIfEqual(kOverflow);
- return VisitInt32SubWithOverflow(node, &cont);
- default:
- break;
- }
- }
- }
- break;
- default:
- break;
- }
- }
-
- // Branch could not be combined with a compare, emit compare against 0.
- VisitWord32Test(value, &cont);
-}
-
-
void InstructionSelector::VisitReturn(Node* value) {
OperandGenerator g(this);
if (value != NULL) {
}
+void InstructionSelector::FillTypeVectorFromStateValues(
+ ZoneVector<MachineType>* types, Node* state_values) {
+ DCHECK(state_values->opcode() == IrOpcode::kStateValues);
+ int count = state_values->InputCount();
+ types->reserve(static_cast<size_t>(count));
+ for (int i = 0; i < count; i++) {
+ types->push_back(GetMachineType(state_values->InputAt(i)));
+ }
+}
+
+
FrameStateDescriptor* InstructionSelector::GetFrameStateDescriptor(
Node* state) {
DCHECK(state->opcode() == IrOpcode::kFrameState);
DCHECK_EQ(5, state->InputCount());
+ DCHECK_EQ(IrOpcode::kStateValues, state->InputAt(0)->opcode());
+ DCHECK_EQ(IrOpcode::kStateValues, state->InputAt(1)->opcode());
+ DCHECK_EQ(IrOpcode::kStateValues, state->InputAt(2)->opcode());
FrameStateCallInfo state_info = OpParameter<FrameStateCallInfo>(state);
- int parameters = OpParameter<int>(state->InputAt(0));
- int locals = OpParameter<int>(state->InputAt(1));
- int stack = OpParameter<int>(state->InputAt(2));
+
+ int parameters = state->InputAt(0)->InputCount();
+ int locals = state->InputAt(1)->InputCount();
+ int stack = state->InputAt(2)->InputCount();
FrameStateDescriptor* outer_state = NULL;
Node* outer_node = state->InputAt(4);
outer_state = GetFrameStateDescriptor(outer_node);
}
- return new (instruction_zone())
- FrameStateDescriptor(state_info, parameters, locals, stack, outer_state);
+ return new (instruction_zone()) FrameStateDescriptor(
+ instruction_zone(), state_info, parameters, locals, stack, outer_state);
}
DCHECK_EQ(IrOpcode::kStateValues, locals->op()->opcode());
DCHECK_EQ(IrOpcode::kStateValues, stack->op()->opcode());
- DCHECK_EQ(descriptor->parameters_count(), parameters->InputCount());
- DCHECK_EQ(descriptor->locals_count(), locals->InputCount());
- DCHECK_EQ(descriptor->stack_count(), stack->InputCount());
+ DCHECK_EQ(static_cast<int>(descriptor->parameters_count()),
+ parameters->InputCount());
+ DCHECK_EQ(static_cast<int>(descriptor->locals_count()), locals->InputCount());
+ DCHECK_EQ(static_cast<int>(descriptor->stack_count()), stack->InputCount());
+
+ ZoneVector<MachineType> types(instruction_zone());
+ types.reserve(descriptor->GetSize());
OperandGenerator g(this);
+ size_t value_index = 0;
for (int i = 0; i < static_cast<int>(descriptor->parameters_count()); i++) {
- inputs->push_back(UseOrImmediate(&g, parameters->InputAt(i)));
+ Node* input_node = parameters->InputAt(i);
+ inputs->push_back(UseOrImmediate(&g, input_node));
+ descriptor->SetType(value_index++, GetMachineType(input_node));
}
if (descriptor->HasContext()) {
inputs->push_back(UseOrImmediate(&g, context));
+ descriptor->SetType(value_index++, kMachAnyTagged);
}
for (int i = 0; i < static_cast<int>(descriptor->locals_count()); i++) {
- inputs->push_back(UseOrImmediate(&g, locals->InputAt(i)));
+ Node* input_node = locals->InputAt(i);
+ inputs->push_back(UseOrImmediate(&g, input_node));
+ descriptor->SetType(value_index++, GetMachineType(input_node));
}
for (int i = 0; i < static_cast<int>(descriptor->stack_count()); i++) {
- inputs->push_back(UseOrImmediate(&g, stack->InputAt(i)));
+ Node* input_node = stack->InputAt(i);
+ inputs->push_back(UseOrImmediate(&g, input_node));
+ descriptor->SetType(value_index++, GetMachineType(input_node));
}
+ DCHECK(value_index == descriptor->GetSize());
}
#undef DECLARE_UNIMPLEMENTED_SELECTOR
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
- FlagsContinuation* cont) {
- UNIMPLEMENTED();
-}
-
-
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
- FlagsContinuation* cont) {
- UNIMPLEMENTED();
-}
+void InstructionSelector::VisitCall(Node* node) { UNIMPLEMENTED(); }
-void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
- UNIMPLEMENTED();
-}
-
-
-void InstructionSelector::VisitWord32Compare(Node* node,
- FlagsContinuation* cont) {
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
UNIMPLEMENTED();
}
-void InstructionSelector::VisitFloat64Compare(Node* node,
- FlagsContinuation* cont) {
- UNIMPLEMENTED();
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ return MachineOperatorBuilder::Flag::kNoFlags;
}
-
-void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization) {}
-
#endif // !V8_TURBOFAN_BACKEND
} // namespace compiler
// Forward declarations.
struct CallBuffer; // TODO(bmeurer): Remove this.
class FlagsContinuation;
+class Linkage;
+
+typedef IntVector NodeToVregMap;
class InstructionSelector FINAL {
public:
+ static const int kNodeUnmapped = -1;
+
// Forward declarations.
class Features;
- InstructionSelector(InstructionSequence* sequence,
+ // TODO(dcarney): pass in vreg mapping instead of graph.
+ InstructionSelector(Zone* local_zone, Graph* graph, Linkage* linkage,
+ InstructionSequence* sequence, Schedule* schedule,
SourcePositionTable* source_positions,
Features features = SupportedFeatures());
return Features(CpuFeatures::SupportedFeatures());
}
- // Checks if {node} is currently live.
- bool IsLive(Node* node) const { return !IsDefined(node) && IsUsed(node); }
-
- private:
- friend class OperandGenerator;
+ // TODO(sigurds) This should take a CpuFeatures argument.
+ static MachineOperatorBuilder::Flags SupportedMachineOperatorFlags();
// ===========================================================================
// ============ Architecture-independent graph covering methods. =============
// ===========================================================================
- // Checks if {block} will appear directly after {current_block_} when
- // assembling code, in which case, a fall-through can be used.
- bool IsNextInAssemblyOrder(const BasicBlock* block) const;
-
// Used in pattern matching during code generation.
// Check if {node} can be covered while generating code for the current
// instruction. A node can be covered if the {user} of the node has the only
// generated for it.
bool IsDefined(Node* node) const;
- // Inform the instruction selection that {node} was just defined.
- void MarkAsDefined(Node* node);
-
// Checks if {node} has any uses, and therefore code has to be generated for
// it.
bool IsUsed(Node* node) const;
+ // Checks if {node} is currently live.
+ bool IsLive(Node* node) const { return !IsDefined(node) && IsUsed(node); }
+
+ int GetVirtualRegister(const Node* node);
+ // Gets the current mapping if it exists, kNodeUnmapped otherwise.
+ int GetMappedVirtualRegister(const Node* node) const;
+ const NodeToVregMap& GetNodeMapForTesting() const { return node_map_; }
+
+ private:
+ friend class OperandGenerator;
+
+ // Checks if {block} will appear directly after {current_block_} when
+ // assembling code, in which case, a fall-through can be used.
+ bool IsNextInAssemblyOrder(const BasicBlock* block) const;
+
+ // Inform the instruction selection that {node} was just defined.
+ void MarkAsDefined(Node* node);
+
// Inform the instruction selection that {node} has at least one use and we
// will need to generate code for it.
void MarkAsUsed(Node* node);
// by {node}.
void MarkAsRepresentation(MachineType rep, Node* node);
+ // Inform the register allocation of the representation of the unallocated
+ // operand {op}.
+ void MarkAsRepresentation(MachineType rep, InstructionOperand* op);
+
// Initialize the call buffer with the InstructionOperands, nodes, etc,
// corresponding
// to the inputs and outputs of the call.
bool call_address_immediate);
FrameStateDescriptor* GetFrameStateDescriptor(Node* node);
+ void FillTypeVectorFromStateValues(ZoneVector<MachineType>* parameters,
+ Node* state_values);
void AddFrameStateInputs(Node* state, InstructionOperandVector* inputs,
FrameStateDescriptor* descriptor);
+ MachineType GetMachineType(Node* node);
// ===========================================================================
// ============= Architecture-specific graph covering methods. ===============
MACHINE_OP_LIST(DECLARE_GENERATOR)
#undef DECLARE_GENERATOR
- void VisitInt32AddWithOverflow(Node* node, FlagsContinuation* cont);
- void VisitInt32SubWithOverflow(Node* node, FlagsContinuation* cont);
-
- void VisitWord32Test(Node* node, FlagsContinuation* cont);
- void VisitWord64Test(Node* node, FlagsContinuation* cont);
- void VisitWord32Compare(Node* node, FlagsContinuation* cont);
- void VisitWord64Compare(Node* node, FlagsContinuation* cont);
- void VisitFloat64Compare(Node* node, FlagsContinuation* cont);
-
void VisitFinish(Node* node);
void VisitParameter(Node* node);
void VisitPhi(Node* node);
void VisitProjection(Node* node);
void VisitConstant(Node* node);
- void VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization);
+ void VisitCall(Node* call);
void VisitGoto(BasicBlock* target);
void VisitBranch(Node* input, BasicBlock* tbranch, BasicBlock* fbranch);
void VisitReturn(Node* value);
// ===========================================================================
- Graph* graph() const { return sequence()->graph(); }
- Linkage* linkage() const { return sequence()->linkage(); }
- Schedule* schedule() const { return sequence()->schedule(); }
+ Schedule* schedule() const { return schedule_; }
+ Linkage* linkage() const { return linkage_; }
InstructionSequence* sequence() const { return sequence_; }
Zone* instruction_zone() const { return sequence()->zone(); }
- Zone* zone() { return &zone_; }
+ Zone* zone() const { return zone_; }
// ===========================================================================
- Zone zone_;
- InstructionSequence* sequence_;
- SourcePositionTable* source_positions_;
+ Zone* const zone_;
+ Linkage* const linkage_;
+ InstructionSequence* const sequence_;
+ SourcePositionTable* const source_positions_;
Features features_;
+ Schedule* const schedule_;
+ NodeToVregMap node_map_;
BasicBlock* current_block_;
ZoneDeque<Instruction*> instructions_;
BoolVector defined_;
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/instruction.h"
-
#include "src/compiler/common-operator.h"
+#include "src/compiler/generic-node-inl.h"
+#include "src/compiler/graph.h"
+#include "src/compiler/instruction.h"
namespace v8 {
namespace internal {
namespace compiler {
-OStream& operator<<(OStream& os, const InstructionOperand& op) {
+std::ostream& operator<<(std::ostream& os,
+ const PrintableInstructionOperand& printable) {
+ const InstructionOperand& op = *printable.op_;
+ const RegisterConfiguration* conf = printable.register_configuration_;
switch (op.kind()) {
case InstructionOperand::INVALID:
return os << "(0)";
case UnallocatedOperand::NONE:
return os;
case UnallocatedOperand::FIXED_REGISTER:
- return os << "(=" << Register::AllocationIndexToString(
+ return os << "(=" << conf->general_register_name(
unalloc->fixed_register_index()) << ")";
case UnallocatedOperand::FIXED_DOUBLE_REGISTER:
- return os << "(=" << DoubleRegister::AllocationIndexToString(
+ return os << "(=" << conf->double_register_name(
unalloc->fixed_register_index()) << ")";
case UnallocatedOperand::MUST_HAVE_REGISTER:
return os << "(R)";
case InstructionOperand::DOUBLE_STACK_SLOT:
return os << "[double_stack:" << op.index() << "]";
case InstructionOperand::REGISTER:
- return os << "[" << Register::AllocationIndexToString(op.index())
- << "|R]";
+ return os << "[" << conf->general_register_name(op.index()) << "|R]";
case InstructionOperand::DOUBLE_REGISTER:
- return os << "[" << DoubleRegister::AllocationIndexToString(op.index())
- << "|R]";
+ return os << "[" << conf->double_register_name(op.index()) << "|R]";
}
UNREACHABLE();
return os;
}
-OStream& operator<<(OStream& os, const MoveOperands& mo) {
- os << *mo.destination();
- if (!mo.source()->Equals(mo.destination())) os << " = " << *mo.source();
+std::ostream& operator<<(std::ostream& os,
+ const PrintableMoveOperands& printable) {
+ const MoveOperands& mo = *printable.move_operands_;
+ PrintableInstructionOperand printable_op = {printable.register_configuration_,
+ mo.destination()};
+
+ os << printable_op;
+ if (!mo.source()->Equals(mo.destination())) {
+ printable_op.op_ = mo.source();
+ os << " = " << printable_op;
+ }
return os << ";";
}
}
-OStream& operator<<(OStream& os, const ParallelMove& pm) {
+std::ostream& operator<<(std::ostream& os,
+ const PrintableParallelMove& printable) {
+ const ParallelMove& pm = *printable.parallel_move_;
bool first = true;
for (ZoneList<MoveOperands>::iterator move = pm.move_operands()->begin();
move != pm.move_operands()->end(); ++move) {
if (move->IsEliminated()) continue;
if (!first) os << " ";
first = false;
- os << *move;
+ PrintableMoveOperands pmo = {printable.register_configuration_, move};
+ os << pmo;
}
return os;
}
}
-OStream& operator<<(OStream& os, const PointerMap& pm) {
+std::ostream& operator<<(std::ostream& os, const PointerMap& pm) {
os << "{";
for (ZoneList<InstructionOperand*>::iterator op =
pm.pointer_operands_.begin();
}
-OStream& operator<<(OStream& os, const ArchOpcode& ao) {
+std::ostream& operator<<(std::ostream& os, const ArchOpcode& ao) {
switch (ao) {
#define CASE(Name) \
case k##Name: \
}
-OStream& operator<<(OStream& os, const AddressingMode& am) {
+std::ostream& operator<<(std::ostream& os, const AddressingMode& am) {
switch (am) {
case kMode_None:
return os;
}
-OStream& operator<<(OStream& os, const FlagsMode& fm) {
+std::ostream& operator<<(std::ostream& os, const FlagsMode& fm) {
switch (fm) {
case kFlags_none:
return os;
}
-OStream& operator<<(OStream& os, const FlagsCondition& fc) {
+std::ostream& operator<<(std::ostream& os, const FlagsCondition& fc) {
switch (fc) {
case kEqual:
return os << "equal";
}
-OStream& operator<<(OStream& os, const Instruction& instr) {
+std::ostream& operator<<(std::ostream& os,
+ const PrintableInstruction& printable) {
+ const Instruction& instr = *printable.instr_;
+ PrintableInstructionOperand printable_op = {printable.register_configuration_,
+ NULL};
if (instr.OutputCount() > 1) os << "(";
for (size_t i = 0; i < instr.OutputCount(); i++) {
if (i > 0) os << ", ";
- os << *instr.OutputAt(i);
+ printable_op.op_ = instr.OutputAt(i);
+ os << printable_op;
}
if (instr.OutputCount() > 1) os << ") = ";
for (int i = GapInstruction::FIRST_INNER_POSITION;
i <= GapInstruction::LAST_INNER_POSITION; i++) {
os << "(";
- if (gap->parallel_moves_[i] != NULL) os << *gap->parallel_moves_[i];
+ if (gap->parallel_moves_[i] != NULL) {
+ PrintableParallelMove ppm = {printable.register_configuration_,
+ gap->parallel_moves_[i]};
+ os << ppm;
+ }
os << ") ";
}
} else if (instr.IsSourcePosition()) {
}
if (instr.InputCount() > 0) {
for (size_t i = 0; i < instr.InputCount(); i++) {
- os << " " << *instr.InputAt(i);
+ printable_op.op_ = instr.InputAt(i);
+ os << " " << printable_op;
}
}
- return os << "\n";
+ return os;
}
-OStream& operator<<(OStream& os, const Constant& constant) {
+std::ostream& operator<<(std::ostream& os, const Constant& constant) {
switch (constant.type()) {
case Constant::kInt32:
return os << constant.ToInt32();
case Constant::kFloat64:
return os << constant.ToFloat64();
case Constant::kExternalReference:
- return os << constant.ToExternalReference().address();
+ return os << static_cast<const void*>(
+ constant.ToExternalReference().address());
case Constant::kHeapObject:
return os << Brief(*constant.ToHeapObject());
}
}
-Label* InstructionSequence::GetLabel(BasicBlock* block) {
- return GetBlockStart(block)->label();
+InstructionBlock::InstructionBlock(Zone* zone, BasicBlock::Id id,
+ BasicBlock::RpoNumber ao_number,
+ BasicBlock::RpoNumber rpo_number,
+ BasicBlock::RpoNumber loop_header,
+ BasicBlock::RpoNumber loop_end,
+ bool deferred)
+ : successors_(zone),
+ predecessors_(zone),
+ phis_(zone),
+ id_(id),
+ ao_number_(ao_number),
+ rpo_number_(rpo_number),
+ loop_header_(loop_header),
+ loop_end_(loop_end),
+ code_start_(-1),
+ code_end_(-1),
+ deferred_(deferred) {}
+
+
+size_t InstructionBlock::PredecessorIndexOf(
+ BasicBlock::RpoNumber rpo_number) const {
+ size_t j = 0;
+ for (InstructionBlock::Predecessors::const_iterator i = predecessors_.begin();
+ i != predecessors_.end(); ++i, ++j) {
+ if (*i == rpo_number) break;
+ }
+ return j;
+}
+
+
+static BasicBlock::RpoNumber GetRpo(BasicBlock* block) {
+ if (block == NULL) return BasicBlock::RpoNumber::Invalid();
+ return block->GetRpoNumber();
+}
+
+
+static BasicBlock::RpoNumber GetLoopEndRpo(const BasicBlock* block) {
+ if (!block->IsLoopHeader()) return BasicBlock::RpoNumber::Invalid();
+ return block->loop_end()->GetRpoNumber();
}
-BlockStartInstruction* InstructionSequence::GetBlockStart(BasicBlock* block) {
- return BlockStartInstruction::cast(InstructionAt(block->code_start_));
+static InstructionBlock* InstructionBlockFor(Zone* zone,
+ const BasicBlock* block) {
+ InstructionBlock* instr_block = new (zone) InstructionBlock(
+ zone, block->id(), block->GetAoNumber(), block->GetRpoNumber(),
+ GetRpo(block->loop_header()), GetLoopEndRpo(block), block->deferred());
+ // Map successors and precessors
+ instr_block->successors().reserve(block->SuccessorCount());
+ for (auto it = block->successors_begin(); it != block->successors_end();
+ ++it) {
+ instr_block->successors().push_back((*it)->GetRpoNumber());
+ }
+ instr_block->predecessors().reserve(block->PredecessorCount());
+ for (auto it = block->predecessors_begin(); it != block->predecessors_end();
+ ++it) {
+ instr_block->predecessors().push_back((*it)->GetRpoNumber());
+ }
+ return instr_block;
+}
+
+
+InstructionBlocks* InstructionSequence::InstructionBlocksFor(
+ Zone* zone, const Schedule* schedule) {
+ InstructionBlocks* blocks = zone->NewArray<InstructionBlocks>(1);
+ new (blocks) InstructionBlocks(
+ static_cast<int>(schedule->rpo_order()->size()), NULL, zone);
+ size_t rpo_number = 0;
+ for (BasicBlockVector::const_iterator it = schedule->rpo_order()->begin();
+ it != schedule->rpo_order()->end(); ++it, ++rpo_number) {
+ DCHECK_EQ(NULL, (*blocks)[rpo_number]);
+ DCHECK((*it)->GetRpoNumber().ToSize() == rpo_number);
+ (*blocks)[rpo_number] = InstructionBlockFor(zone, *it);
+ }
+ return blocks;
+}
+
+
+InstructionSequence::InstructionSequence(Zone* instruction_zone,
+ InstructionBlocks* instruction_blocks)
+ : zone_(instruction_zone),
+ instruction_blocks_(instruction_blocks),
+ block_starts_(zone()),
+ constants_(ConstantMap::key_compare(),
+ ConstantMap::allocator_type(zone())),
+ immediates_(zone()),
+ instructions_(zone()),
+ next_virtual_register_(0),
+ pointer_maps_(zone()),
+ doubles_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
+ references_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
+ deoptimization_entries_(zone()) {
+ block_starts_.reserve(instruction_blocks_->size());
}
-void InstructionSequence::StartBlock(BasicBlock* block) {
- block->code_start_ = static_cast<int>(instructions_.size());
- BlockStartInstruction* block_start =
- BlockStartInstruction::New(zone(), block);
- AddInstruction(block_start, block);
+BlockStartInstruction* InstructionSequence::GetBlockStart(
+ BasicBlock::RpoNumber rpo) {
+ InstructionBlock* block = InstructionBlockAt(rpo);
+ return BlockStartInstruction::cast(InstructionAt(block->code_start()));
}
-void InstructionSequence::EndBlock(BasicBlock* block) {
+void InstructionSequence::StartBlock(BasicBlock::RpoNumber rpo) {
+ DCHECK(block_starts_.size() == rpo.ToSize());
+ InstructionBlock* block = InstructionBlockAt(rpo);
+ int code_start = static_cast<int>(instructions_.size());
+ block->set_code_start(code_start);
+ block_starts_.push_back(code_start);
+ BlockStartInstruction* block_start = BlockStartInstruction::New(zone());
+ AddInstruction(block_start);
+}
+
+
+void InstructionSequence::EndBlock(BasicBlock::RpoNumber rpo) {
int end = static_cast<int>(instructions_.size());
- DCHECK(block->code_start_ >= 0 && block->code_start_ < end);
- block->code_end_ = end;
+ InstructionBlock* block = InstructionBlockAt(rpo);
+ DCHECK(block->code_start() >= 0 && block->code_start() < end);
+ block->set_code_end(end);
}
-int InstructionSequence::AddInstruction(Instruction* instr, BasicBlock* block) {
+int InstructionSequence::AddInstruction(Instruction* instr) {
// TODO(titzer): the order of these gaps is a holdover from Lithium.
GapInstruction* gap = GapInstruction::New(zone());
if (instr->IsControl()) instructions_.push_back(gap);
}
-BasicBlock* InstructionSequence::GetBasicBlock(int instruction_index) {
- // TODO(turbofan): Optimize this.
- for (;;) {
- DCHECK_LE(0, instruction_index);
- Instruction* instruction = InstructionAt(instruction_index--);
- if (instruction->IsBlockStart()) {
- return BlockStartInstruction::cast(instruction)->block();
- }
- }
+const InstructionBlock* InstructionSequence::GetInstructionBlock(
+ int instruction_index) const {
+ DCHECK(instruction_blocks_->size() == block_starts_.size());
+ auto begin = block_starts_.begin();
+ auto end = std::lower_bound(begin, block_starts_.end(), instruction_index,
+ std::less_equal<int>());
+ size_t index = std::distance(begin, end) - 1;
+ auto block = instruction_blocks_->at(index);
+ DCHECK(block->code_start() <= instruction_index &&
+ instruction_index < block->code_end());
+ return block;
}
}
-OStream& operator<<(OStream& os, const InstructionSequence& code) {
+FrameStateDescriptor::FrameStateDescriptor(
+ Zone* zone, const FrameStateCallInfo& state_info, size_t parameters_count,
+ size_t locals_count, size_t stack_count, FrameStateDescriptor* outer_state)
+ : type_(state_info.type()),
+ bailout_id_(state_info.bailout_id()),
+ frame_state_combine_(state_info.state_combine()),
+ parameters_count_(parameters_count),
+ locals_count_(locals_count),
+ stack_count_(stack_count),
+ types_(zone),
+ outer_state_(outer_state),
+ jsfunction_(state_info.jsfunction()) {
+ types_.resize(GetSize(), kMachNone);
+}
+
+size_t FrameStateDescriptor::GetSize(OutputFrameStateCombine combine) const {
+ size_t size = parameters_count() + locals_count() + stack_count() +
+ (HasContext() ? 1 : 0);
+ switch (combine.kind()) {
+ case OutputFrameStateCombine::kPushOutput:
+ size += combine.GetPushCount();
+ break;
+ case OutputFrameStateCombine::kPokeAt:
+ break;
+ }
+ return size;
+}
+
+
+size_t FrameStateDescriptor::GetTotalSize() const {
+ size_t total_size = 0;
+ for (const FrameStateDescriptor* iter = this; iter != NULL;
+ iter = iter->outer_state_) {
+ total_size += iter->GetSize();
+ }
+ return total_size;
+}
+
+
+size_t FrameStateDescriptor::GetFrameCount() const {
+ size_t count = 0;
+ for (const FrameStateDescriptor* iter = this; iter != NULL;
+ iter = iter->outer_state_) {
+ ++count;
+ }
+ return count;
+}
+
+
+size_t FrameStateDescriptor::GetJSFrameCount() const {
+ size_t count = 0;
+ for (const FrameStateDescriptor* iter = this; iter != NULL;
+ iter = iter->outer_state_) {
+ if (iter->type_ == JS_FRAME) {
+ ++count;
+ }
+ }
+ return count;
+}
+
+
+MachineType FrameStateDescriptor::GetType(size_t index) const {
+ return types_[index];
+}
+
+
+void FrameStateDescriptor::SetType(size_t index, MachineType type) {
+ DCHECK(index < GetSize());
+ types_[index] = type;
+}
+
+
+std::ostream& operator<<(std::ostream& os,
+ const PrintableInstructionSequence& printable) {
+ const InstructionSequence& code = *printable.sequence_;
for (size_t i = 0; i < code.immediates_.size(); ++i) {
Constant constant = code.immediates_[i];
os << "IMM#" << i << ": " << constant << "\n";
it != code.constants_.end(); ++i, ++it) {
os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
}
- for (int i = 0; i < code.BasicBlockCount(); i++) {
- BasicBlock* block = code.BlockAt(i);
-
- int bid = block->id();
- os << "RPO#" << block->rpo_number_ << ": B" << bid;
- CHECK(block->rpo_number_ == i);
+ for (int i = 0; i < code.InstructionBlockCount(); i++) {
+ BasicBlock::RpoNumber rpo = BasicBlock::RpoNumber::FromInt(i);
+ const InstructionBlock* block = code.InstructionBlockAt(rpo);
+ CHECK(block->rpo_number() == rpo);
+
+ os << "RPO#" << block->rpo_number();
+ os << ": AO#" << block->ao_number();
+ os << ": B" << block->id();
+ if (block->IsDeferred()) os << " (deferred)";
if (block->IsLoopHeader()) {
- os << " loop blocks: [" << block->rpo_number_ << ", " << block->loop_end_
- << ")";
+ os << " loop blocks: [" << block->rpo_number() << ", "
+ << block->loop_end() << ")";
}
- os << " instructions: [" << block->code_start_ << ", " << block->code_end_
- << ")\n predecessors:";
+ os << " instructions: [" << block->code_start() << ", "
+ << block->code_end() << ")\n predecessors:";
- BasicBlock::Predecessors predecessors = block->predecessors();
- for (BasicBlock::Predecessors::iterator iter = predecessors.begin();
- iter != predecessors.end(); ++iter) {
- os << " B" << (*iter)->id();
+ for (auto pred : block->predecessors()) {
+ const InstructionBlock* pred_block = code.InstructionBlockAt(pred);
+ os << " B" << pred_block->id();
}
os << "\n";
- for (BasicBlock::const_iterator j = block->begin(); j != block->end();
- ++j) {
- Node* phi = *j;
- if (phi->opcode() != IrOpcode::kPhi) continue;
- os << " phi: v" << phi->id() << " =";
- Node::Inputs inputs = phi->inputs();
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter) {
- os << " v" << (*iter)->id();
+ for (auto phi : block->phis()) {
+ os << " phi: v" << phi->virtual_register() << " =";
+ for (auto op_vreg : phi->operands()) {
+ os << " v" << op_vreg;
}
os << "\n";
}
ScopedVector<char> buf(32);
+ PrintableInstruction printable_instr;
+ printable_instr.register_configuration_ = printable.register_configuration_;
for (int j = block->first_instruction_index();
j <= block->last_instruction_index(); j++) {
// TODO(svenpanne) Add some basic formatting to our streams.
SNPrintF(buf, "%5d", j);
- os << " " << buf.start() << ": " << *code.InstructionAt(j);
- }
-
- os << " " << block->control_;
-
- if (block->control_input_ != NULL) {
- os << " v" << block->control_input_->id();
+ printable_instr.instr_ = code.InstructionAt(j);
+ os << " " << buf.start() << ": " << printable_instr << "\n";
}
- BasicBlock::Successors successors = block->successors();
- for (BasicBlock::Successors::iterator iter = successors.begin();
- iter != successors.end(); ++iter) {
- os << " B" << (*iter)->id();
+ for (auto succ : block->successors()) {
+ const InstructionBlock* succ_block = code.InstructionBlockAt(succ);
+ os << " B" << succ_block->id();
}
os << "\n";
}
#define V8_COMPILER_INSTRUCTION_H_
#include <deque>
+#include <iosfwd>
#include <map>
#include <set>
#include "src/compiler/common-operator.h"
#include "src/compiler/frame.h"
-#include "src/compiler/graph.h"
#include "src/compiler/instruction-codes.h"
#include "src/compiler/opcodes.h"
+#include "src/compiler/register-configuration.h"
#include "src/compiler/schedule.h"
-// TODO(titzer): don't include the macro-assembler?
-#include "src/macro-assembler.h"
+#include "src/compiler/source-position.h"
#include "src/zone-allocator.h"
namespace v8 {
namespace internal {
-
-// Forward declarations.
-class OStream;
-
namespace compiler {
-// Forward declarations.
-class Linkage;
-
// A couple of reserved opcodes are used for internal use.
const InstructionCode kGapInstruction = -1;
const InstructionCode kBlockStartInstruction = -2;
const InstructionCode kSourcePositionInstruction = -3;
-
-#define INSTRUCTION_OPERAND_LIST(V) \
- V(Constant, CONSTANT, 128) \
- V(Immediate, IMMEDIATE, 128) \
- V(StackSlot, STACK_SLOT, 128) \
- V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128) \
- V(Register, REGISTER, Register::kNumRegisters) \
- V(DoubleRegister, DOUBLE_REGISTER, DoubleRegister::kMaxNumRegisters)
+#define INSTRUCTION_OPERAND_LIST(V) \
+ V(Constant, CONSTANT, 0) \
+ V(Immediate, IMMEDIATE, 0) \
+ V(StackSlot, STACK_SLOT, 128) \
+ V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128) \
+ V(Register, REGISTER, RegisterConfiguration::kMaxGeneralRegisters) \
+ V(DoubleRegister, DOUBLE_REGISTER, RegisterConfiguration::kMaxDoubleRegisters)
class InstructionOperand : public ZoneObject {
public:
typedef ZoneVector<InstructionOperand*> InstructionOperandVector;
-OStream& operator<<(OStream& os, const InstructionOperand& op);
+struct PrintableInstructionOperand {
+ const RegisterConfiguration* register_configuration_;
+ const InstructionOperand* op_;
+};
+
+std::ostream& operator<<(std::ostream& os,
+ const PrintableInstructionOperand& op);
class UnallocatedOperand : public InstructionOperand {
public:
}
// [lifetime]: Only for non-FIXED_SLOT.
- bool IsUsedAtStart() {
+ bool IsUsedAtStart() const {
DCHECK(basic_policy() == EXTENDED_POLICY);
return LifetimeField::decode(value_) == USED_AT_START;
}
InstructionOperand* destination_;
};
-OStream& operator<<(OStream& os, const MoveOperands& mo);
+
+struct PrintableMoveOperands {
+ const RegisterConfiguration* register_configuration_;
+ const MoveOperands* move_operands_;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const PrintableMoveOperands& mo);
+
template <InstructionOperand::Kind kOperandKind, int kNumCachedOperands>
class SubKindOperand FINAL : public InstructionOperand {
ZoneList<MoveOperands> move_operands_;
};
-OStream& operator<<(OStream& os, const ParallelMove& pm);
+
+struct PrintableParallelMove {
+ const RegisterConfiguration* register_configuration_;
+ const ParallelMove* parallel_move_;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const PrintableParallelMove& pm);
+
class PointerMap FINAL : public ZoneObject {
public:
void RecordUntagged(InstructionOperand* op, Zone* zone);
private:
- friend OStream& operator<<(OStream& os, const PointerMap& pm);
+ friend std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
ZoneList<InstructionOperand*> pointer_operands_;
ZoneList<InstructionOperand*> untagged_operands_;
int instruction_position_;
};
-OStream& operator<<(OStream& os, const PointerMap& pm);
+std::ostream& operator<<(std::ostream& os, const PointerMap& pm);
// TODO(titzer): s/PointerMap/ReferenceMap/
class Instruction : public ZoneObject {
InstructionOperand* operands_[1];
};
-OStream& operator<<(OStream& os, const Instruction& instr);
+
+struct PrintableInstruction {
+ const RegisterConfiguration* register_configuration_;
+ const Instruction* instr_;
+};
+std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
+
// Represents moves inserted before an instruction due to register allocation.
// TODO(titzer): squash GapInstruction back into Instruction, since essentially
}
private:
- friend OStream& operator<<(OStream& os, const Instruction& instr);
+ friend std::ostream& operator<<(std::ostream& os,
+ const PrintableInstruction& instr);
ParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
};
// This special kind of gap move instruction represents the beginning of a
// block of code.
-// TODO(titzer): move code_start and code_end from BasicBlock to here.
class BlockStartInstruction FINAL : public GapInstruction {
public:
- BasicBlock* block() const { return block_; }
- Label* label() { return &label_; }
-
- static BlockStartInstruction* New(Zone* zone, BasicBlock* block) {
+ static BlockStartInstruction* New(Zone* zone) {
void* buffer = zone->New(sizeof(BlockStartInstruction));
- return new (buffer) BlockStartInstruction(block);
+ return new (buffer) BlockStartInstruction();
}
static BlockStartInstruction* cast(Instruction* instr) {
}
private:
- explicit BlockStartInstruction(BasicBlock* block)
- : GapInstruction(kBlockStartInstruction), block_(block) {}
-
- BasicBlock* block_;
- Label label_;
+ BlockStartInstruction() : GapInstruction(kBlockStartInstruction) {}
};
Type type() const { return type_; }
int32_t ToInt32() const {
- DCHECK_EQ(kInt32, type());
- return static_cast<int32_t>(value_);
+ DCHECK(type() == kInt32 || type() == kInt64);
+ const int32_t value = static_cast<int32_t>(value_);
+ DCHECK_EQ(value_, static_cast<int64_t>(value));
+ return value;
}
int64_t ToInt64() const {
class FrameStateDescriptor : public ZoneObject {
public:
- FrameStateDescriptor(const FrameStateCallInfo& state_info,
+ FrameStateDescriptor(Zone* zone, const FrameStateCallInfo& state_info,
size_t parameters_count, size_t locals_count,
size_t stack_count,
- FrameStateDescriptor* outer_state = NULL)
- : type_(state_info.type()),
- bailout_id_(state_info.bailout_id()),
- frame_state_combine_(state_info.state_combine()),
- parameters_count_(parameters_count),
- locals_count_(locals_count),
- stack_count_(stack_count),
- outer_state_(outer_state),
- jsfunction_(state_info.jsfunction()) {}
+ FrameStateDescriptor* outer_state = NULL);
FrameStateType type() const { return type_; }
BailoutId bailout_id() const { return bailout_id_; }
size_t stack_count() const { return stack_count_; }
FrameStateDescriptor* outer_state() const { return outer_state_; }
MaybeHandle<JSFunction> jsfunction() const { return jsfunction_; }
+ bool HasContext() const { return type_ == JS_FRAME; }
- size_t size() const {
- return parameters_count_ + locals_count_ + stack_count_ +
- (HasContext() ? 1 : 0);
- }
-
- size_t GetTotalSize() const {
- size_t total_size = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
- iter = iter->outer_state_) {
- total_size += iter->size();
- }
- return total_size;
- }
-
- size_t GetHeight(OutputFrameStateCombine override) const {
- size_t height = size() - parameters_count();
- switch (override) {
- case kPushOutput:
- ++height;
- break;
- case kIgnoreOutput:
- break;
- }
- return height;
- }
-
- size_t GetFrameCount() const {
- size_t count = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
- iter = iter->outer_state_) {
- ++count;
- }
- return count;
- }
-
- size_t GetJSFrameCount() const {
- size_t count = 0;
- for (const FrameStateDescriptor* iter = this; iter != NULL;
- iter = iter->outer_state_) {
- if (iter->type_ == JS_FRAME) {
- ++count;
- }
- }
- return count;
- }
+ size_t GetSize(OutputFrameStateCombine combine =
+ OutputFrameStateCombine::Ignore()) const;
+ size_t GetTotalSize() const;
+ size_t GetFrameCount() const;
+ size_t GetJSFrameCount() const;
- bool HasContext() const { return type_ == JS_FRAME; }
+ MachineType GetType(size_t index) const;
+ void SetType(size_t index, MachineType type);
private:
FrameStateType type_;
size_t parameters_count_;
size_t locals_count_;
size_t stack_count_;
+ ZoneVector<MachineType> types_;
FrameStateDescriptor* outer_state_;
MaybeHandle<JSFunction> jsfunction_;
};
-OStream& operator<<(OStream& os, const Constant& constant);
+std::ostream& operator<<(std::ostream& os, const Constant& constant);
+
+
+// TODO(dcarney): this is a temporary hack. turn into an actual instruction.
+class PhiInstruction FINAL : public ZoneObject {
+ public:
+ PhiInstruction(Zone* zone, int virtual_register)
+ : virtual_register_(virtual_register), operands_(zone) {}
+
+ int virtual_register() const { return virtual_register_; }
+ const IntVector& operands() const { return operands_; }
+ IntVector& operands() { return operands_; }
+
+ private:
+ const int virtual_register_;
+ IntVector operands_;
+};
+
+
+// Analogue of BasicBlock for Instructions instead of Nodes.
+class InstructionBlock FINAL : public ZoneObject {
+ public:
+ InstructionBlock(Zone* zone, BasicBlock::Id id,
+ BasicBlock::RpoNumber ao_number,
+ BasicBlock::RpoNumber rpo_number,
+ BasicBlock::RpoNumber loop_header,
+ BasicBlock::RpoNumber loop_end, bool deferred);
+
+ // Instruction indexes (used by the register allocator).
+ int first_instruction_index() const {
+ DCHECK(code_start_ >= 0);
+ DCHECK(code_end_ > 0);
+ DCHECK(code_end_ >= code_start_);
+ return code_start_;
+ }
+ int last_instruction_index() const {
+ DCHECK(code_start_ >= 0);
+ DCHECK(code_end_ > 0);
+ DCHECK(code_end_ >= code_start_);
+ return code_end_ - 1;
+ }
+
+ int32_t code_start() const { return code_start_; }
+ void set_code_start(int32_t start) { code_start_ = start; }
+
+ int32_t code_end() const { return code_end_; }
+ void set_code_end(int32_t end) { code_end_ = end; }
+
+ bool IsDeferred() const { return deferred_; }
+
+ BasicBlock::Id id() const { return id_; }
+ BasicBlock::RpoNumber ao_number() const { return ao_number_; }
+ BasicBlock::RpoNumber rpo_number() const { return rpo_number_; }
+ BasicBlock::RpoNumber loop_header() const { return loop_header_; }
+ BasicBlock::RpoNumber loop_end() const {
+ DCHECK(IsLoopHeader());
+ return loop_end_;
+ }
+ inline bool IsLoopHeader() const { return loop_end_.IsValid(); }
+
+ typedef ZoneVector<BasicBlock::RpoNumber> Predecessors;
+ Predecessors& predecessors() { return predecessors_; }
+ const Predecessors& predecessors() const { return predecessors_; }
+ size_t PredecessorCount() const { return predecessors_.size(); }
+ size_t PredecessorIndexOf(BasicBlock::RpoNumber rpo_number) const;
+
+ typedef ZoneVector<BasicBlock::RpoNumber> Successors;
+ Successors& successors() { return successors_; }
+ const Successors& successors() const { return successors_; }
+ size_t SuccessorCount() const { return successors_.size(); }
+
+ typedef ZoneVector<PhiInstruction*> PhiInstructions;
+ const PhiInstructions& phis() const { return phis_; }
+ void AddPhi(PhiInstruction* phi) { phis_.push_back(phi); }
+
+ private:
+ Successors successors_;
+ Predecessors predecessors_;
+ PhiInstructions phis_;
+ const BasicBlock::Id id_;
+ const BasicBlock::RpoNumber ao_number_; // Assembly order number.
+ // TODO(dcarney): probably dont't need this.
+ const BasicBlock::RpoNumber rpo_number_;
+ const BasicBlock::RpoNumber loop_header_;
+ const BasicBlock::RpoNumber loop_end_;
+ int32_t code_start_; // start index of arch-specific code.
+ int32_t code_end_; // end index of arch-specific code.
+ const bool deferred_; // Block contains deferred code.
+};
typedef ZoneDeque<Constant> ConstantDeque;
typedef std::map<int, Constant, std::less<int>,
typedef ZoneDeque<Instruction*> InstructionDeque;
typedef ZoneDeque<PointerMap*> PointerMapDeque;
typedef ZoneVector<FrameStateDescriptor*> DeoptimizationVector;
+typedef ZoneVector<InstructionBlock*> InstructionBlocks;
+
+struct PrintableInstructionSequence;
+
// Represents architecture-specific generated code before, during, and after
// register allocation.
// TODO(titzer): s/IsDouble/IsFloat64/
class InstructionSequence FINAL {
public:
- InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule)
- : graph_(graph),
- linkage_(linkage),
- schedule_(schedule),
- constants_(ConstantMap::key_compare(),
- ConstantMap::allocator_type(zone())),
- immediates_(zone()),
- instructions_(zone()),
- next_virtual_register_(graph->NodeCount()),
- pointer_maps_(zone()),
- doubles_(std::less<int>(), VirtualRegisterSet::allocator_type(zone())),
- references_(std::less<int>(),
- VirtualRegisterSet::allocator_type(zone())),
- deoptimization_entries_(zone()) {}
+ static InstructionBlocks* InstructionBlocksFor(Zone* zone,
+ const Schedule* schedule);
+
+ InstructionSequence(Zone* zone, InstructionBlocks* instruction_blocks);
int NextVirtualRegister() { return next_virtual_register_++; }
int VirtualRegisterCount() const { return next_virtual_register_; }
- int ValueCount() const { return graph_->NodeCount(); }
-
- int BasicBlockCount() const {
- return static_cast<int>(schedule_->rpo_order()->size());
+ const InstructionBlocks& instruction_blocks() const {
+ return *instruction_blocks_;
}
- BasicBlock* BlockAt(int rpo_number) const {
- return (*schedule_->rpo_order())[rpo_number];
+ int InstructionBlockCount() const {
+ return static_cast<int>(instruction_blocks_->size());
}
- BasicBlock* GetContainingLoop(BasicBlock* block) {
- return block->loop_header_;
+ InstructionBlock* InstructionBlockAt(BasicBlock::RpoNumber rpo_number) {
+ return instruction_blocks_->at(rpo_number.ToSize());
}
- int GetLoopEnd(BasicBlock* block) const { return block->loop_end_; }
+ int LastLoopInstructionIndex(const InstructionBlock* block) {
+ return instruction_blocks_->at(block->loop_end().ToSize() - 1)
+ ->last_instruction_index();
+ }
- BasicBlock* GetBasicBlock(int instruction_index);
+ const InstructionBlock* InstructionBlockAt(
+ BasicBlock::RpoNumber rpo_number) const {
+ return instruction_blocks_->at(rpo_number.ToSize());
+ }
- int GetVirtualRegister(Node* node) const { return node->id(); }
+ const InstructionBlock* GetInstructionBlock(int instruction_index) const;
bool IsReference(int virtual_register) const;
bool IsDouble(int virtual_register) const;
void AddGapMove(int index, InstructionOperand* from, InstructionOperand* to);
- Label* GetLabel(BasicBlock* block);
- BlockStartInstruction* GetBlockStart(BasicBlock* block);
+ BlockStartInstruction* GetBlockStart(BasicBlock::RpoNumber rpo);
typedef InstructionDeque::const_iterator const_iterator;
const_iterator begin() const { return instructions_.begin(); }
return instructions_[index];
}
- Frame* frame() { return &frame_; }
- Graph* graph() const { return graph_; }
Isolate* isolate() const { return zone()->isolate(); }
- Linkage* linkage() const { return linkage_; }
- Schedule* schedule() const { return schedule_; }
const PointerMapDeque* pointer_maps() const { return &pointer_maps_; }
- Zone* zone() const { return graph_->zone(); }
+ Zone* zone() const { return zone_; }
- // Used by the code generator while adding instructions.
- int AddInstruction(Instruction* instr, BasicBlock* block);
- void StartBlock(BasicBlock* block);
- void EndBlock(BasicBlock* block);
+ // Used by the instruction selector while adding instructions.
+ int AddInstruction(Instruction* instr);
+ void StartBlock(BasicBlock::RpoNumber rpo);
+ void EndBlock(BasicBlock::RpoNumber rpo);
- void AddConstant(int virtual_register, Constant constant) {
+ int AddConstant(int virtual_register, Constant constant) {
+ DCHECK(virtual_register >= 0 && virtual_register < next_virtual_register_);
DCHECK(constants_.find(virtual_register) == constants_.end());
constants_.insert(std::make_pair(virtual_register, constant));
+ return virtual_register;
}
Constant GetConstant(int virtual_register) const {
ConstantMap::const_iterator it = constants_.find(virtual_register);
int GetFrameStateDescriptorCount();
private:
- friend OStream& operator<<(OStream& os, const InstructionSequence& code);
+ friend std::ostream& operator<<(std::ostream& os,
+ const PrintableInstructionSequence& code);
typedef std::set<int, std::less<int>, ZoneIntAllocator> VirtualRegisterSet;
- Graph* graph_;
- Linkage* linkage_;
- Schedule* schedule_;
+ Zone* const zone_;
+ InstructionBlocks* const instruction_blocks_;
+ IntVector block_starts_;
ConstantMap constants_;
ConstantDeque immediates_;
InstructionDeque instructions_;
PointerMapDeque pointer_maps_;
VirtualRegisterSet doubles_;
VirtualRegisterSet references_;
- Frame frame_;
DeoptimizationVector deoptimization_entries_;
};
-OStream& operator<<(OStream& os, const InstructionSequence& code);
+
+struct PrintableInstructionSequence {
+ const RegisterConfiguration* register_configuration_;
+ const InstructionSequence* sequence_;
+};
+
+
+std::ostream& operator<<(std::ostream& os,
+ const PrintableInstructionSequence& code);
} // namespace compiler
} // namespace internal
+++ /dev/null
-// 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/graph-unittest.h"
-#include "src/compiler/js-builtin-reducer.h"
-#include "src/compiler/js-graph.h"
-#include "src/compiler/node-properties-inl.h"
-#include "src/compiler/typer.h"
-#include "testing/gmock-support.h"
-
-using testing::Capture;
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class JSBuiltinReducerTest : public GraphTest {
- public:
- JSBuiltinReducerTest() : javascript_(zone()) {}
-
- protected:
- Reduction Reduce(Node* node) {
- Typer typer(zone());
- MachineOperatorBuilder machine;
- JSGraph jsgraph(graph(), common(), javascript(), &typer, &machine);
- JSBuiltinReducer reducer(&jsgraph);
- return reducer.Reduce(node);
- }
-
- Node* Parameter(Type* t, int32_t index = 0) {
- Node* n = graph()->NewNode(common()->Parameter(index), graph()->start());
- NodeProperties::SetBounds(n, Bounds(Type::None(), t));
- return n;
- }
-
- Node* UndefinedConstant() {
- return HeapConstant(
- Unique<HeapObject>::CreateImmovable(factory()->undefined_value()));
- }
-
- JSOperatorBuilder* javascript() { return &javascript_; }
-
- private:
- JSOperatorBuilder javascript_;
-};
-
-
-namespace {
-
-// TODO(mstarzinger): Find a common place and unify with test-js-typed-lowering.
-Type* const kNumberTypes[] = {
- Type::UnsignedSmall(), Type::OtherSignedSmall(), Type::OtherUnsigned31(),
- Type::OtherUnsigned32(), Type::OtherSigned32(), Type::SignedSmall(),
- Type::Signed32(), Type::Unsigned32(), Type::Integral32(),
- Type::MinusZero(), Type::NaN(), Type::OtherNumber(),
- Type::OrderedNumber(), Type::Number()};
-
-} // namespace
-
-
-// -----------------------------------------------------------------------------
-// Math.abs
-
-
-TEST_F(JSBuiltinReducerTest, MathAbs) {
- Handle<JSFunction> f(isolate()->context()->math_abs_fun());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
- fun, UndefinedConstant(), p0);
- Reduction r = Reduce(call);
-
- if (t0->Is(Type::Unsigned32())) {
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), p0);
- } else {
- Capture<Node*> branch;
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(
- r.replacement(),
- IsPhi(kMachNone, p0, IsNumberSubtract(IsNumberConstant(0), p0),
- IsMerge(IsIfTrue(CaptureEq(&branch)),
- IsIfFalse(AllOf(
- CaptureEq(&branch),
- IsBranch(IsNumberLessThan(IsNumberConstant(0), p0),
- graph()->start()))))));
- }
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Math.sqrt
-
-
-TEST_F(JSBuiltinReducerTest, MathSqrt) {
- Handle<JSFunction> f(isolate()->context()->math_sqrt_fun());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
- fun, UndefinedConstant(), p0);
- Reduction r = Reduce(call);
-
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsFloat64Sqrt(p0));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Math.max
-
-
-TEST_F(JSBuiltinReducerTest, MathMax0) {
- Handle<JSFunction> f(isolate()->context()->math_max_fun());
-
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call = graph()->NewNode(javascript()->Call(2, NO_CALL_FUNCTION_FLAGS),
- fun, UndefinedConstant());
- Reduction r = Reduce(call);
-
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsNumberConstant(-V8_INFINITY));
-}
-
-
-TEST_F(JSBuiltinReducerTest, MathMax1) {
- Handle<JSFunction> f(isolate()->context()->math_max_fun());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
- fun, UndefinedConstant(), p0);
- Reduction r = Reduce(call);
-
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), p0);
- }
-}
-
-
-TEST_F(JSBuiltinReducerTest, MathMax2) {
- Handle<JSFunction> f(isolate()->context()->math_max_fun());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- TRACED_FOREACH(Type*, t1, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* p1 = Parameter(t1, 1);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call =
- graph()->NewNode(javascript()->Call(4, NO_CALL_FUNCTION_FLAGS), fun,
- UndefinedConstant(), p0, p1);
- Reduction r = Reduce(call);
-
- if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
- Capture<Node*> branch;
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(
- r.replacement(),
- IsPhi(kMachNone, p1, p0,
- IsMerge(IsIfTrue(CaptureEq(&branch)),
- IsIfFalse(AllOf(CaptureEq(&branch),
- IsBranch(IsNumberLessThan(p0, p1),
- graph()->start()))))));
- } else {
- ASSERT_FALSE(r.Changed());
- EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
- }
- }
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Math.imul
-
-
-TEST_F(JSBuiltinReducerTest, MathImul) {
- Handle<JSFunction> f(isolate()->context()->math_imul_fun());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- TRACED_FOREACH(Type*, t1, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* p1 = Parameter(t1, 1);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call =
- graph()->NewNode(javascript()->Call(4, NO_CALL_FUNCTION_FLAGS), fun,
- UndefinedConstant(), p0, p1);
- Reduction r = Reduce(call);
-
- if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Mul(p0, p1));
- } else {
- ASSERT_FALSE(r.Changed());
- EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
- }
- }
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Math.fround
-
-
-TEST_F(JSBuiltinReducerTest, MathFround) {
- Handle<Object> m =
- JSObject::GetProperty(isolate()->global_object(),
- isolate()->factory()->NewStringFromAsciiChecked(
- "Math")).ToHandleChecked();
- Handle<JSFunction> f = Handle<JSFunction>::cast(
- JSObject::GetProperty(m, isolate()->factory()->NewStringFromAsciiChecked(
- "fround")).ToHandleChecked());
-
- TRACED_FOREACH(Type*, t0, kNumberTypes) {
- Node* p0 = Parameter(t0, 0);
- Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
- Node* call = graph()->NewNode(javascript()->Call(3, NO_CALL_FUNCTION_FLAGS),
- fun, UndefinedConstant(), p0);
- Reduction r = Reduce(call);
-
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsTruncateFloat64ToFloat32(p0));
- }
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/compiler/diamond.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/js-builtin-reducer.h"
#include "src/compiler/node-matchers.h"
int GetJSCallArity() {
DCHECK_EQ(IrOpcode::kJSCallFunction, node_->opcode());
// Skip first (i.e. callee) and second (i.e. receiver) operand.
- return OperatorProperties::GetValueInputCount(node_->op()) - 2;
+ return node_->op()->ValueInputCount() - 2;
}
Node* GetJSCallInput(int index) {
}
if (r.InputsMatchOne(Type::Number())) {
// Math.abs(a:number) -> (a > 0 ? a : 0 - a)
- Node* value = r.left();
- Node* zero = jsgraph()->ZeroConstant();
- Node* control = graph()->start();
- Node* tag = graph()->NewNode(simplified()->NumberLessThan(), zero, value);
-
- Node* branch = graph()->NewNode(common()->Branch(), tag, control);
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-
- Node* neg = graph()->NewNode(simplified()->NumberSubtract(), zero, value);
- value = graph()->NewNode(common()->Phi(kMachNone, 2), value, neg, merge);
- return Replace(value);
+ Node* const value = r.left();
+ Node* const zero = jsgraph()->ZeroConstant();
+ return Replace(graph()->NewNode(
+ common()->Select(kMachNone),
+ graph()->NewNode(simplified()->NumberLessThan(), zero, value), value,
+ graph()->NewNode(simplified()->NumberSubtract(), zero, value)));
}
return NoChange();
}
// Math.max(a:int32, b:int32, ...)
Node* value = r.GetJSCallInput(0);
for (int i = 1; i < r.GetJSCallArity(); i++) {
- Node* p = r.GetJSCallInput(i);
- Node* control = graph()->start();
- Node* tag = graph()->NewNode(simplified()->NumberLessThan(), value, p);
-
- Node* branch = graph()->NewNode(common()->Branch(), tag, control);
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-
- value = graph()->NewNode(common()->Phi(kMachNone, 2), p, value, merge);
+ Node* const input = r.GetJSCallInput(i);
+ value = graph()->NewNode(
+ common()->Select(kMachNone),
+ graph()->NewNode(simplified()->NumberLessThan(), input, value), input,
+ value);
}
return Replace(value);
}
}
+// ES6 draft 10-14-14, section 20.2.2.16.
+Reduction JSBuiltinReducer::ReduceMathFloor(Node* node) {
+ if (!machine()->HasFloat64Floor()) return NoChange();
+ JSCallReduction r(node);
+ if (r.InputsMatchOne(Type::Number())) {
+ // Math.floor(a:number) -> Float64Floor(a)
+ Node* value = graph()->NewNode(machine()->Float64Floor(), r.left());
+ return Replace(value);
+ }
+ return NoChange();
+}
+
+
+// ES6 draft 10-14-14, section 20.2.2.10.
+Reduction JSBuiltinReducer::ReduceMathCeil(Node* node) {
+ if (!machine()->HasFloat64Ceil()) return NoChange();
+ JSCallReduction r(node);
+ if (r.InputsMatchOne(Type::Number())) {
+ // Math.ceil(a:number) -> Float64Ceil(a)
+ Node* value = graph()->NewNode(machine()->Float64Ceil(), r.left());
+ return Replace(value);
+ }
+ return NoChange();
+}
+
+
Reduction JSBuiltinReducer::Reduce(Node* node) {
JSCallReduction r(node);
return ReplaceWithPureReduction(node, ReduceMathImul(node));
case kMathFround:
return ReplaceWithPureReduction(node, ReduceMathFround(node));
+ case kMathFloor:
+ return ReplaceWithPureReduction(node, ReduceMathFloor(node));
+ case kMathCeil:
+ return ReplaceWithPureReduction(node, ReduceMathCeil(node));
default:
break;
}
Reduction ReduceMathMax(Node* node);
Reduction ReduceMathImul(Node* node);
Reduction ReduceMathFround(Node* node);
+ Reduction ReduceMathFloor(Node* node);
+ Reduction ReduceMathCeil(Node* node);
JSGraph* jsgraph_;
SimplifiedOperatorBuilder simplified_;
explicit ContextSpecializationVisitor(JSContextSpecializer* spec)
: spec_(spec) {}
- GenericGraphVisit::Control Post(Node* node) {
+ void Post(Node* node) {
switch (node->opcode()) {
case IrOpcode::kJSLoadContext: {
Reduction r = spec_->ReduceJSLoadContext(node);
default:
break;
}
- return GenericGraphVisit::CONTINUE;
}
private:
return Reducer::NoChange();
}
- ContextAccess access = OpParameter<ContextAccess>(node);
+ const ContextAccess& access = ContextAccessOf(node->op());
// Find the right parent context.
Context* context = *m.Value().handle();
- for (int i = access.depth(); i > 0; --i) {
+ for (size_t i = access.depth(); i > 0; --i) {
context = context->previous();
}
node->ReplaceInput(0, jsgraph_->Constant(context_handle));
return Reducer::Changed(node);
}
- Handle<Object> value =
- Handle<Object>(context->get(access.index()), info_->isolate());
+ Handle<Object> value = Handle<Object>(
+ context->get(static_cast<int>(access.index())), info_->isolate());
// Even though the context slot is immutable, the context might have escaped
// before the function to which it belongs has initialized the slot.
return Reducer::NoChange();
}
- ContextAccess access = OpParameter<ContextAccess>(node);
+ const ContextAccess& access = ContextAccessOf(node->op());
// The access does not have to look up a parent, nothing to fold.
if (access.depth() == 0) {
// Find the right parent context.
Context* context = *m.Value().handle();
- for (int i = access.depth(); i > 0; --i) {
+ for (size_t i = access.depth(); i > 0; --i) {
context = context->previous();
}
#include "src/compiler/js-generic-lowering.h"
#include "src/compiler/machine-operator.h"
#include "src/compiler/node-aux-data-inl.h"
+#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
#include "src/unique.h"
JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph)
: info_(info),
jsgraph_(jsgraph),
- linkage_(new (jsgraph->zone()) Linkage(info)) {}
+ linkage_(new (jsgraph->zone()) Linkage(jsgraph->zone(), info)) {}
void JSGenericLowering::PatchOperator(Node* node, const Operator* op) {
int nargs) {
Callable callable =
CodeFactory::CallFunction(isolate(), nargs - 1, NO_CALL_FUNCTION_FLAGS);
- CallDescriptor* desc =
- linkage()->GetStubCallDescriptor(callable.descriptor(), nargs);
+ CallDescriptor* desc = linkage()->GetStubCallDescriptor(
+ callable.descriptor(), nargs, FlagsForNode(node));
// TODO(mstarzinger): Accessing the builtins object this way prevents sharing
// of code across native contexts. Fix this by loading from given context.
Handle<JSFunction> function(
linkage()->GetRuntimeCallDescriptor(f, nargs, properties);
Node* ref = ExternalConstant(ExternalReference(f, isolate()));
Node* arity = Int32Constant(nargs);
- if (!centrystub_constant_.is_set()) {
- centrystub_constant_.set(CodeConstant(CEntryStub(isolate(), 1).GetCode()));
- }
- PatchInsertInput(node, 0, centrystub_constant_.get());
+ PatchInsertInput(node, 0, jsgraph()->CEntryStubConstant());
PatchInsertInput(node, nargs + 1, ref);
PatchInsertInput(node, nargs + 2, arity);
PatchOperator(node, common()->Call(desc));
void JSGenericLowering::LowerJSToNumber(Node* node) {
Callable callable = CodeFactory::ToNumber(isolate());
- ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags);
+ ReplaceWithStubCall(node, callable, FlagsForNode(node));
}
void JSGenericLowering::LowerJSLoadProperty(Node* node) {
- Callable callable = CodeFactory::KeyedLoadIC(isolate());
+ const LoadPropertyParameters& p = LoadPropertyParametersOf(node->op());
+ Callable callable = CodeFactory::KeyedLoadICInOptimizedCode(isolate());
+ if (FLAG_vector_ics) {
+ PatchInsertInput(node, 2, jsgraph()->SmiConstant(p.feedback().index()));
+ PatchInsertInput(node, 3, jsgraph()->HeapConstant(p.feedback().vector()));
+ }
ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
}
void JSGenericLowering::LowerJSLoadNamed(Node* node) {
- LoadNamedParameters p = OpParameter<LoadNamedParameters>(node);
- Callable callable = CodeFactory::LoadIC(isolate(), p.contextual_mode);
- PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name));
+ const LoadNamedParameters& p = LoadNamedParametersOf(node->op());
+ Callable callable =
+ CodeFactory::LoadICInOptimizedCode(isolate(), p.contextual_mode());
+ PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name()));
+ if (FLAG_vector_ics) {
+ PatchInsertInput(node, 2, jsgraph()->SmiConstant(p.feedback().index()));
+ PatchInsertInput(node, 3, jsgraph()->HeapConstant(p.feedback().vector()));
+ }
ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
}
void JSGenericLowering::LowerJSStoreNamed(Node* node) {
- StoreNamedParameters params = OpParameter<StoreNamedParameters>(node);
- Callable callable = CodeFactory::StoreIC(isolate(), params.strict_mode);
- PatchInsertInput(node, 1, jsgraph()->HeapConstant(params.name));
+ const StoreNamedParameters& p = StoreNamedParametersOf(node->op());
+ Callable callable = CodeFactory::StoreIC(isolate(), p.strict_mode());
+ PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name()));
ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
}
InstanceofStub::kArgsInRegisters);
InstanceofStub stub(isolate(), flags);
CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
- CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, 0);
+ CallDescriptor* desc =
+ linkage()->GetStubCallDescriptor(d, 0, FlagsForNode(node));
Node* stub_code = CodeConstant(stub.GetCode());
PatchInsertInput(node, 0, stub_code);
PatchOperator(node, common()->Call(desc));
void JSGenericLowering::LowerJSLoadContext(Node* node) {
- ContextAccess access = OpParameter<ContextAccess>(node);
- // TODO(mstarzinger): Use simplified operators instead of machine operators
- // here so that load/store optimization can be applied afterwards.
- for (int i = 0; i < access.depth(); ++i) {
+ const ContextAccess& access = ContextAccessOf(node->op());
+ for (size_t i = 0; i < access.depth(); ++i) {
node->ReplaceInput(
0, graph()->NewNode(
machine()->Load(kMachAnyTagged),
NodeProperties::GetValueInput(node, 0),
Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
- NodeProperties::GetEffectInput(node)));
+ NodeProperties::GetEffectInput(node), graph()->start()));
}
- node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
+ node->ReplaceInput(
+ 1, Int32Constant(Context::SlotOffset(static_cast<int>(access.index()))));
+ node->AppendInput(zone(), graph()->start());
PatchOperator(node, machine()->Load(kMachAnyTagged));
}
void JSGenericLowering::LowerJSStoreContext(Node* node) {
- ContextAccess access = OpParameter<ContextAccess>(node);
- // TODO(mstarzinger): Use simplified operators instead of machine operators
- // here so that load/store optimization can be applied afterwards.
- for (int i = 0; i < access.depth(); ++i) {
+ const ContextAccess& access = ContextAccessOf(node->op());
+ for (size_t i = 0; i < access.depth(); ++i) {
node->ReplaceInput(
0, graph()->NewNode(
machine()->Load(kMachAnyTagged),
NodeProperties::GetValueInput(node, 0),
Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
- NodeProperties::GetEffectInput(node)));
+ NodeProperties::GetEffectInput(node), graph()->start()));
}
node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
- node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
+ node->ReplaceInput(
+ 1, Int32Constant(Context::SlotOffset(static_cast<int>(access.index()))));
PatchOperator(node, machine()->Store(StoreRepresentation(kMachAnyTagged,
kFullWriteBarrier)));
}
}
+bool JSGenericLowering::TryLowerDirectJSCall(Node* node) {
+ // Lower to a direct call to a constant JSFunction if legal.
+ const CallFunctionParameters& p = CallFunctionParametersOf(node->op());
+ int arg_count = static_cast<int>(p.arity() - 2);
+
+ // Check the function is a constant and is really a JSFunction.
+ HeapObjectMatcher<Object> function_const(node->InputAt(0));
+ if (!function_const.HasValue()) return false; // not a constant.
+ Handle<Object> func = function_const.Value().handle();
+ if (!func->IsJSFunction()) return false; // not a function.
+ Handle<JSFunction> function = Handle<JSFunction>::cast(func);
+ if (arg_count != function->shared()->formal_parameter_count()) return false;
+
+ // Check the receiver doesn't need to be wrapped.
+ Node* receiver = node->InputAt(1);
+ if (!NodeProperties::IsTyped(receiver)) return false;
+ Type* ok_receiver = Type::Union(Type::Undefined(), Type::Receiver(), zone());
+ if (!NodeProperties::GetBounds(receiver).upper->Is(ok_receiver)) return false;
+
+ int index = NodeProperties::FirstContextIndex(node);
+
+ // TODO(titzer): total hack to share function context constants.
+ // Remove this when the JSGraph canonicalizes heap constants.
+ Node* context = node->InputAt(index);
+ HeapObjectMatcher<Context> context_const(context);
+ if (!context_const.HasValue() ||
+ *(context_const.Value().handle()) != function->context()) {
+ context = jsgraph()->HeapConstant(Handle<Context>(function->context()));
+ }
+ node->ReplaceInput(index, context);
+ CallDescriptor* desc = linkage()->GetJSCallDescriptor(
+ 1 + arg_count, jsgraph()->zone(), FlagsForNode(node));
+ PatchOperator(node, common()->Call(desc));
+ return true;
+}
+
+
void JSGenericLowering::LowerJSCallFunction(Node* node) {
- CallParameters p = OpParameter<CallParameters>(node);
- CallFunctionStub stub(isolate(), p.arity - 2, p.flags);
+ // Fast case: call function directly.
+ if (TryLowerDirectJSCall(node)) return;
+
+ // General case: CallFunctionStub.
+ const CallFunctionParameters& p = CallFunctionParametersOf(node->op());
+ int arg_count = static_cast<int>(p.arity() - 2);
+ CallFunctionStub stub(isolate(), arg_count, p.flags());
CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
- CallDescriptor* desc =
- linkage()->GetStubCallDescriptor(d, p.arity - 1, FlagsForNode(node));
+ CallDescriptor* desc = linkage()->GetStubCallDescriptor(
+ d, static_cast<int>(p.arity() - 1), FlagsForNode(node));
Node* stub_code = CodeConstant(stub.GetCode());
PatchInsertInput(node, 0, stub_code);
PatchOperator(node, common()->Call(desc));
void JSGenericLowering::LowerJSCallRuntime(Node* node) {
- Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
- int arity = OperatorProperties::GetValueInputCount(node->op());
- ReplaceWithRuntimeCall(node, function, arity);
+ const CallRuntimeParameters& p = CallRuntimeParametersOf(node->op());
+ ReplaceWithRuntimeCall(node, p.id(), static_cast<int>(p.arity()));
}
} // namespace compiler
#ifndef V8_COMPILER_JS_GENERIC_LOWERING_H_
#define V8_COMPILER_JS_GENERIC_LOWERING_H_
-#include "src/v8.h"
-
#include "src/allocation.h"
#include "src/code-factory.h"
#include "src/compiler/graph.h"
#include "src/compiler/graph-reducer.h"
#include "src/compiler/js-graph.h"
+#include "src/compiler/linkage.h"
#include "src/compiler/opcodes.h"
namespace v8 {
CompilationInfo* info_;
JSGraph* jsgraph_;
Linkage* linkage_;
- SetOncePointer<Node> centrystub_constant_;
+
+ bool TryLowerDirectJSCall(Node* node);
};
} // namespace compiler
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/code-stubs.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/typer.h"
namespace internal {
namespace compiler {
-Node* JSGraph::ImmovableHeapConstant(Handle<Object> object) {
- Unique<Object> unique = Unique<Object>::CreateImmovable(object);
- return NewNode(common()->HeapConstant(unique));
-}
-
-
-Node* JSGraph::NewNode(const Operator* op) {
- Node* node = graph()->NewNode(op);
- typer_->Init(node);
- return node;
+Node* JSGraph::ImmovableHeapConstant(Handle<HeapObject> object) {
+ Unique<HeapObject> unique = Unique<HeapObject>::CreateImmovable(object);
+ return graph()->NewNode(common()->HeapConstant(unique));
}
}
-Node* JSGraph::HeapConstant(Unique<Object> value) {
+Node* JSGraph::HeapConstant(Unique<HeapObject> value) {
// TODO(turbofan): canonicalize heap constants using Unique<T>
- return NewNode(common()->HeapConstant(value));
+ return graph()->NewNode(common()->HeapConstant(value));
}
-Node* JSGraph::HeapConstant(Handle<Object> value) {
+Node* JSGraph::HeapConstant(Handle<HeapObject> value) {
// TODO(titzer): We could also match against the addresses of immortable
// immovables here, even without access to the heap, thus always
// canonicalizing references to them.
// TODO(turbofan): This is a work-around to make Unique::HashCode() work for
// value numbering. We need some sane way to compute a unique hash code for
// arbitrary handles here.
- Unique<Object> unique(reinterpret_cast<Address>(*value.location()), value);
+ Unique<HeapObject> unique(reinterpret_cast<Address>(*value.location()),
+ value);
return HeapConstant(unique);
}
} else if (value->IsTheHole()) {
return TheHoleConstant();
} else {
- return HeapConstant(value);
+ return HeapConstant(Handle<HeapObject>::cast(value));
}
}
Node* JSGraph::Int32Constant(int32_t value) {
Node** loc = cache_.FindInt32Constant(value);
if (*loc == NULL) {
- *loc = NewNode(common()->Int32Constant(value));
+ *loc = graph()->NewNode(common()->Int32Constant(value));
+ }
+ return *loc;
+}
+
+
+Node* JSGraph::Int64Constant(int64_t value) {
+ Node** loc = cache_.FindInt64Constant(value);
+ if (*loc == NULL) {
+ *loc = graph()->NewNode(common()->Int64Constant(value));
}
return *loc;
}
Node* JSGraph::NumberConstant(double value) {
Node** loc = cache_.FindNumberConstant(value);
if (*loc == NULL) {
- *loc = NewNode(common()->NumberConstant(value));
+ *loc = graph()->NewNode(common()->NumberConstant(value));
}
return *loc;
}
Node* JSGraph::Float32Constant(float value) {
// TODO(turbofan): cache float32 constants.
- return NewNode(common()->Float32Constant(value));
+ return graph()->NewNode(common()->Float32Constant(value));
}
Node* JSGraph::Float64Constant(double value) {
Node** loc = cache_.FindFloat64Constant(value);
if (*loc == NULL) {
- *loc = NewNode(common()->Float64Constant(value));
+ *loc = graph()->NewNode(common()->Float64Constant(value));
}
return *loc;
}
Node* JSGraph::ExternalConstant(ExternalReference reference) {
Node** loc = cache_.FindExternalConstant(reference);
if (*loc == NULL) {
- *loc = NewNode(common()->ExternalConstant(reference));
+ *loc = graph()->NewNode(common()->ExternalConstant(reference));
}
return *loc;
}
+
+
+void JSGraph::GetCachedNodes(NodeVector* nodes) {
+ cache_.GetCachedNodes(nodes);
+ SetOncePointer<Node>* ptrs[] = {
+ &c_entry_stub_constant_, &undefined_constant_, &the_hole_constant_,
+ &true_constant_, &false_constant_, &null_constant_,
+ &zero_constant_, &one_constant_, &nan_constant_};
+ for (size_t i = 0; i < arraysize(ptrs); i++) {
+ if (ptrs[i]->is_set()) nodes->push_back(ptrs[i]->get());
+ }
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
class JSGraph : public ZoneObject {
public:
JSGraph(Graph* graph, CommonOperatorBuilder* common,
- JSOperatorBuilder* javascript, Typer* typer,
- MachineOperatorBuilder* machine)
+ JSOperatorBuilder* javascript, MachineOperatorBuilder* machine)
: graph_(graph),
common_(common),
javascript_(javascript),
- typer_(typer),
machine_(machine),
cache_(zone()) {}
// Creates a HeapConstant node, possibly canonicalized, without inspecting the
// object.
- Node* HeapConstant(Unique<Object> value);
+ Node* HeapConstant(Unique<HeapObject> value);
// Creates a HeapConstant node, possibly canonicalized, and may access the
// heap to inspect the object.
- Node* HeapConstant(Handle<Object> value);
+ Node* HeapConstant(Handle<HeapObject> value);
// Creates a Constant node of the appropriate type for the given object.
// Accesses the heap to inspect the object and determine whether one of the
return Int32Constant(bit_cast<int32_t>(value));
}
+ // Creates a HeapConstant node for either true or false.
+ Node* BooleanConstant(bool is_true) {
+ return is_true ? TrueConstant() : FalseConstant();
+ }
+
+ // Creates a Int64Constant node, usually canonicalized.
+ Node* Int64Constant(int64_t value);
+ Node* Uint64Constant(uint64_t value) {
+ return Int64Constant(bit_cast<int64_t>(value));
+ }
+
+ // Creates a Int32Constant/Int64Constant node, depending on the word size of
+ // the target machine.
+ // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer
+ // constants is probably not serializable.
+ Node* IntPtrConstant(intptr_t value) {
+ return machine()->Is32() ? Int32Constant(static_cast<int32_t>(value))
+ : Int64Constant(static_cast<int64_t>(value));
+ }
+
// Creates a Float32Constant node, usually canonicalized.
Node* Float32Constant(float value);
Zone* zone() { return graph()->zone(); }
Isolate* isolate() { return zone()->isolate(); }
+ void GetCachedNodes(NodeVector* nodes);
+
private:
Graph* graph_;
CommonOperatorBuilder* common_;
JSOperatorBuilder* javascript_;
- Typer* typer_;
MachineOperatorBuilder* machine_;
+ // TODO(titzer): make this into a simple array.
SetOncePointer<Node> c_entry_stub_constant_;
SetOncePointer<Node> undefined_constant_;
SetOncePointer<Node> the_hole_constant_;
CommonNodeCache cache_;
- Node* ImmovableHeapConstant(Handle<Object> value);
+ Node* ImmovableHeapConstant(Handle<HeapObject> value);
Node* NumberConstant(double value);
- Node* NewNode(const Operator* op);
Factory* factory() { return isolate()->factory(); }
+
+ DISALLOW_COPY_AND_ASSIGN(JSGraph);
};
} // namespace compiler
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/ast.h"
+#include "src/ast-numbering.h"
#include "src/compiler/access-builder.h"
#include "src/compiler/ast-graph-builder.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/graph-visualizer.h"
#include "src/compiler/js-inlining.h"
+#include "src/compiler/js-intrinsic-builder.h"
#include "src/compiler/js-operator.h"
#include "src/compiler/node-aux-data-inl.h"
#include "src/compiler/node-matchers.h"
public:
explicit InlinerVisitor(JSInliner* inliner) : inliner_(inliner) {}
- GenericGraphVisit::Control Post(Node* node) {
+ void Post(Node* node) {
switch (node->opcode()) {
case IrOpcode::kJSCallFunction:
- inliner_->TryInlineCall(node);
+ inliner_->TryInlineJSCall(node);
+ break;
+ case IrOpcode::kJSCallRuntime:
+ if (FLAG_turbo_inlining_intrinsics) {
+ inliner_->TryInlineRuntimeCall(node);
+ }
break;
default:
break;
}
- return GenericGraphVisit::CONTINUE;
}
private:
}
-// TODO(sigurds) Find a home for this function and reuse it everywhere (esp. in
-// test cases, where similar code is currently duplicated).
-static void Parse(Handle<JSFunction> function, CompilationInfoWithZone* info) {
- CHECK(Parser::Parse(info));
- CHECK(Rewriter::Rewrite(info));
- CHECK(Scope::Analyze(info));
- CHECK(Compiler::EnsureDeoptimizationSupport(info));
-}
-
-
// A facade on a JSFunction's graph to facilitate inlining. It assumes the
// that the function graph has only one return statement, and provides
// {UnifyReturn} to convert a function graph to that end.
}
DCHECK_EQ(IrOpcode::kMerge, final_merge->opcode());
- int predecessors =
- OperatorProperties::GetControlInputCount(final_merge->op());
+ int predecessors = final_merge->op()->ControlInputCount();
const Operator* op_phi = jsgraph->common()->Phi(kMachAnyTagged, predecessors);
const Operator* op_ephi = jsgraph->common()->EffectPhi(predecessors);
source_graph_(source_graph),
target_graph_(target_graph),
temp_zone_(temp_zone),
- sentinel_op_(IrOpcode::kDead, Operator::kNoProperties, 0, 0,
- "sentinel") {}
+ sentinel_op_(IrOpcode::kDead, Operator::kNoProperties, "sentinel", 0, 0,
+ 0, 0, 0, 0) {}
- GenericGraphVisit::Control Post(Node* original) {
+ void Post(Node* original) {
NodeVector inputs(temp_zone_);
for (InputIter it = original->inputs().begin();
it != original->inputs().end(); ++it) {
target_graph_->NewNode(original->op(), static_cast<int>(inputs.size()),
(inputs.empty() ? NULL : &inputs.front()));
copies_[original->id()] = copy;
- return GenericGraphVisit::CONTINUE;
}
Node* GetCopy(Node* original) {
Graph* source_graph_;
Graph* target_graph_;
Zone* temp_zone_;
- SimpleOperator sentinel_op_;
+ Operator sentinel_op_;
};
Node* context = jsgraph->graph()->NewNode(
simplified.LoadField(AccessBuilder::ForJSFunctionContext()),
NodeProperties::GetValueInput(call, 0),
- NodeProperties::GetEffectInput(call));
+ NodeProperties::GetEffectInput(call), control);
// Context is last argument.
int inlinee_context_index = static_cast<int>(total_parameters()) - 1;
// {inliner_inputs} counts JSFunction, Receiver, arguments, but not
// context, effect, control.
- int inliner_inputs = OperatorProperties::GetValueInputCount(call->op());
+ int inliner_inputs = call->op()->ValueInputCount();
// Iterate over all uses of the start node.
UseIter iter = start_->uses().begin();
while (iter != start_->uses().end()) {
}
}
- // Iterate over all uses of the call node.
- iter = call->uses().begin();
- while (iter != call->uses().end()) {
- if (NodeProperties::IsEffectEdge(iter.edge())) {
- iter.UpdateToAndIncrement(effect_output());
- } else if (NodeProperties::IsControlEdge(iter.edge())) {
- UNREACHABLE();
- } else {
- DCHECK(NodeProperties::IsValueEdge(iter.edge()));
- iter.UpdateToAndIncrement(value_output());
- }
- }
+ NodeProperties::ReplaceWithValue(call, value_output(), effect_output());
call->RemoveAllInputs();
DCHECK_EQ(0, call->UseCount());
- // TODO(sigurds) Remove this once we copy.
- unique_return()->RemoveAllInputs();
}
size_t formal_arguments() {
// {value_inputs} includes jsfunction and receiver.
- size_t value_inputs = OperatorProperties::GetValueInputCount(call_->op());
+ size_t value_inputs = call_->op()->ValueInputCount();
DCHECK_GE(call_->InputCount(), 2);
return value_inputs - 2;
}
Node* JSInliner::CreateArgumentsAdaptorFrameState(JSCallFunctionAccessor* call,
Handle<JSFunction> jsfunction,
Zone* temp_zone) {
- const Operator* op =
- jsgraph_->common()->FrameState(FrameStateType::ARGUMENTS_ADAPTOR,
- BailoutId(-1), kIgnoreOutput, jsfunction);
+ const Operator* op = jsgraph_->common()->FrameState(
+ FrameStateType::ARGUMENTS_ADAPTOR, BailoutId(-1),
+ OutputFrameStateCombine::Ignore(), jsfunction);
const Operator* op0 = jsgraph_->common()->StateValues(0);
Node* node0 = jsgraph_->graph()->NewNode(op0);
NodeVector params(temp_zone);
}
-void JSInliner::TryInlineCall(Node* call_node) {
+void JSInliner::TryInlineJSCall(Node* call_node) {
JSCallFunctionAccessor call(call_node);
HeapObjectMatcher<JSFunction> match(call.jsfunction());
}
CompilationInfoWithZone info(function);
- Parse(function, &info);
+ // TODO(wingo): ParseAndAnalyze can fail due to stack overflow.
+ CHECK(Compiler::ParseAndAnalyze(&info));
+ CHECK(Compiler::EnsureDeoptimizationSupport(&info));
- if (info.scope()->arguments() != NULL) {
+ if (info.scope()->arguments() != NULL && info.strict_mode() != STRICT) {
// For now do not inline functions that use their arguments array.
SmartArrayPointer<char> name = function->shared()->DebugName()->ToCString();
if (FLAG_trace_turbo_inlining) {
}
Graph graph(info.zone());
- Typer typer(info.zone());
- JSGraph jsgraph(&graph, jsgraph_->common(), jsgraph_->javascript(), &typer,
+ JSGraph jsgraph(&graph, jsgraph_->common(), jsgraph_->javascript(),
jsgraph_->machine());
- AstGraphBuilder graph_builder(&info, &jsgraph);
+ AstGraphBuilder graph_builder(local_zone_, &info, &jsgraph);
graph_builder.CreateGraph();
Inlinee::UnifyReturn(&jsgraph);
inlinee.InlineAtCall(jsgraph_, call_node);
}
+
+
+class JSCallRuntimeAccessor {
+ public:
+ explicit JSCallRuntimeAccessor(Node* call) : call_(call) {
+ DCHECK_EQ(IrOpcode::kJSCallRuntime, call->opcode());
+ }
+
+ Node* formal_argument(size_t index) {
+ DCHECK(index < formal_arguments());
+ return call_->InputAt(static_cast<int>(index));
+ }
+
+ size_t formal_arguments() {
+ size_t value_inputs = call_->op()->ValueInputCount();
+ return value_inputs;
+ }
+
+ Node* frame_state() const {
+ return NodeProperties::GetFrameStateInput(call_);
+ }
+ Node* context() const { return NodeProperties::GetContextInput(call_); }
+ Node* control() const { return NodeProperties::GetControlInput(call_); }
+ Node* effect() const { return NodeProperties::GetEffectInput(call_); }
+
+ const Runtime::Function* function() const {
+ return Runtime::FunctionForId(CallRuntimeParametersOf(call_->op()).id());
+ }
+
+ NodeVector inputs(Zone* zone) const {
+ NodeVector inputs(zone);
+ for (InputIter it = call_->inputs().begin(); it != call_->inputs().end();
+ ++it) {
+ inputs.push_back(*it);
+ }
+ return inputs;
+ }
+
+ private:
+ Node* call_;
+};
+
+
+void JSInliner::TryInlineRuntimeCall(Node* call_node) {
+ JSCallRuntimeAccessor call(call_node);
+ const Runtime::Function* f = call.function();
+
+ if (f->intrinsic_type != Runtime::IntrinsicType::INLINE) {
+ return;
+ }
+
+ JSIntrinsicBuilder intrinsic_builder(jsgraph_);
+
+ ResultAndEffect r = intrinsic_builder.BuildGraphFor(
+ f->function_id, call.inputs(jsgraph_->zone()));
+
+ if (r.first != NULL) {
+ if (FLAG_trace_turbo_inlining) {
+ PrintF("Inlining %s into %s\n", f->name,
+ info_->shared_info()->DebugName()->ToCString().get());
+ }
+ NodeProperties::ReplaceWithValue(call_node, r.first, r.second);
+ call_node->RemoveAllInputs();
+ DCHECK_EQ(0, call_node->UseCount());
+ }
+}
}
}
} // namespace v8::internal::compiler
class JSInliner {
public:
- JSInliner(CompilationInfo* info, JSGraph* jsgraph)
- : info_(info), jsgraph_(jsgraph) {}
+ JSInliner(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph)
+ : local_zone_(local_zone), info_(info), jsgraph_(jsgraph) {}
void Inline();
- void TryInlineCall(Node* node);
+ void TryInlineJSCall(Node* node);
+ void TryInlineRuntimeCall(Node* node);
private:
friend class InlinerVisitor;
+ Zone* local_zone_;
CompilationInfo* info_;
JSGraph* jsgraph_;
--- /dev/null
+// 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/access-builder.h"
+#include "src/compiler/common-operator.h"
+#include "src/compiler/diamond.h"
+#include "src/compiler/generic-node-inl.h"
+#include "src/compiler/js-intrinsic-builder.h"
+#include "src/compiler/js-operator.h"
+#include "src/compiler/simplified-operator.h"
+
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+ResultAndEffect JSIntrinsicBuilder::BuildGraphFor(Runtime::FunctionId id,
+ const NodeVector& arguments) {
+ switch (id) {
+ case Runtime::kInlineIsSmi:
+ return BuildGraphFor_IsSmi(arguments);
+ case Runtime::kInlineIsNonNegativeSmi:
+ return BuildGraphFor_IsNonNegativeSmi(arguments);
+ case Runtime::kInlineIsArray:
+ return BuildMapCheck(arguments[0], arguments[2], JS_ARRAY_TYPE);
+ case Runtime::kInlineIsRegExp:
+ return BuildMapCheck(arguments[0], arguments[2], JS_REGEXP_TYPE);
+ case Runtime::kInlineIsFunction:
+ return BuildMapCheck(arguments[0], arguments[2], JS_FUNCTION_TYPE);
+ case Runtime::kInlineValueOf:
+ return BuildGraphFor_ValueOf(arguments);
+ default:
+ break;
+ }
+ return ResultAndEffect();
+}
+
+ResultAndEffect JSIntrinsicBuilder::BuildGraphFor_IsSmi(
+ const NodeVector& arguments) {
+ Node* object = arguments[0];
+ SimplifiedOperatorBuilder simplified(jsgraph_->zone());
+ Node* condition = graph()->NewNode(simplified.ObjectIsSmi(), object);
+
+ return ResultAndEffect(condition, arguments[2]);
+}
+
+
+ResultAndEffect JSIntrinsicBuilder::BuildGraphFor_IsNonNegativeSmi(
+ const NodeVector& arguments) {
+ Node* object = arguments[0];
+ SimplifiedOperatorBuilder simplified(jsgraph_->zone());
+ Node* condition =
+ graph()->NewNode(simplified.ObjectIsNonNegativeSmi(), object);
+
+ return ResultAndEffect(condition, arguments[2]);
+}
+
+
+/*
+ * if (_isSmi(object)) {
+ * return false
+ * } else {
+ * return %_GetMapInstanceType(object) == map_type
+ * }
+ */
+ResultAndEffect JSIntrinsicBuilder::BuildMapCheck(Node* object, Node* effect,
+ InstanceType map_type) {
+ SimplifiedOperatorBuilder simplified(jsgraph_->zone());
+
+ Node* is_smi = graph()->NewNode(simplified.ObjectIsSmi(), object);
+ Diamond d(graph(), common(), is_smi);
+
+ Node* map = graph()->NewNode(simplified.LoadField(AccessBuilder::ForMap()),
+ object, effect, d.if_false);
+
+ Node* instance_type = graph()->NewNode(
+ simplified.LoadField(AccessBuilder::ForMapInstanceType()), map, map,
+ d.if_false);
+
+ Node* has_map_type =
+ graph()->NewNode(jsgraph_->machine()->Word32Equal(), instance_type,
+ jsgraph_->Int32Constant(map_type));
+
+ Node* phi = d.Phi(static_cast<MachineType>(kTypeBool | kRepTagged),
+ jsgraph_->FalseConstant(), has_map_type);
+
+ Node* ephi = d.EffectPhi(effect, instance_type);
+
+ return ResultAndEffect(phi, ephi);
+}
+
+
+/*
+ * if (%_isSmi(object)) {
+ * return object;
+ * } else if (%_GetMapInstanceType(object) == JS_VALUE_TYPE) {
+ * return %_LoadValueField(object);
+ * } else {
+ * return object;
+ * }
+ */
+ResultAndEffect JSIntrinsicBuilder::BuildGraphFor_ValueOf(
+ const NodeVector& arguments) {
+ Node* object = arguments[0];
+ Node* effect = arguments[2];
+ SimplifiedOperatorBuilder simplified(jsgraph_->zone());
+
+ Node* is_smi = graph()->NewNode(simplified.ObjectIsSmi(), object);
+
+ Diamond if_is_smi(graph(), common(), is_smi);
+
+ Node* map = graph()->NewNode(simplified.LoadField(AccessBuilder::ForMap()),
+ object, effect, if_is_smi.if_false);
+
+ Node* instance_type = graph()->NewNode(
+ simplified.LoadField(AccessBuilder::ForMapInstanceType()), map, map,
+ if_is_smi.if_false);
+
+ Node* is_value =
+ graph()->NewNode(jsgraph_->machine()->Word32Equal(), instance_type,
+ jsgraph_->Constant(JS_VALUE_TYPE));
+
+ Diamond if_is_value(graph(), common(), is_value);
+ if_is_value.Nest(if_is_smi, false);
+
+ Node* value =
+ graph()->NewNode(simplified.LoadField(AccessBuilder::ForValue()), object,
+ instance_type, if_is_value.if_true);
+
+ Node* phi_is_value = if_is_value.Phi(kTypeAny, value, object);
+
+ Node* phi = if_is_smi.Phi(kTypeAny, object, phi_is_value);
+
+ Node* ephi = if_is_smi.EffectPhi(effect, instance_type);
+
+ return ResultAndEffect(phi, ephi);
+}
+}
+}
+} // namespace v8::internal::compiler
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_JS_INTRINSIC_BUILDER_H_
+#define V8_COMPILER_JS_INTRINSIC_BUILDER_H_
+
+#include "src/compiler/js-graph.h"
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+typedef std::pair<Node*, Node*> ResultAndEffect;
+
+class JSIntrinsicBuilder {
+ public:
+ explicit JSIntrinsicBuilder(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
+
+ ResultAndEffect BuildGraphFor(Runtime::FunctionId id,
+ const NodeVector& arguments);
+
+ private:
+ ResultAndEffect BuildMapCheck(Node* object, Node* effect,
+ InstanceType map_type);
+ ResultAndEffect BuildGraphFor_IsSmi(const NodeVector& arguments);
+ ResultAndEffect BuildGraphFor_IsNonNegativeSmi(const NodeVector& arguments);
+ ResultAndEffect BuildGraphFor_ValueOf(const NodeVector& arguments);
+
+
+ Graph* graph() const { return jsgraph_->graph(); }
+ CommonOperatorBuilder* common() const { return jsgraph_->common(); }
+ JSGraph* jsgraph_;
+};
+}
+}
+} // namespace v8::internal::compiler
+
+#endif // V8_COMPILER_JS_INTRINSIC_BUILDER_H_
--- /dev/null
+// 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/js-operator.h"
+
+#include <limits>
+
+#include "src/base/lazy-instance.h"
+#include "src/compiler/opcodes.h"
+#include "src/compiler/operator.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+bool operator==(CallFunctionParameters const& lhs,
+ CallFunctionParameters const& rhs) {
+ return lhs.arity() == rhs.arity() && lhs.flags() == rhs.flags();
+}
+
+
+bool operator!=(CallFunctionParameters const& lhs,
+ CallFunctionParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(CallFunctionParameters const& p) {
+ return base::hash_combine(p.arity(), p.flags());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CallFunctionParameters const& p) {
+ return os << p.arity() << ", " << p.flags();
+}
+
+
+const CallFunctionParameters& CallFunctionParametersOf(const Operator* op) {
+ DCHECK_EQ(IrOpcode::kJSCallFunction, op->opcode());
+ return OpParameter<CallFunctionParameters>(op);
+}
+
+
+bool operator==(CallRuntimeParameters const& lhs,
+ CallRuntimeParameters const& rhs) {
+ return lhs.id() == rhs.id() && lhs.arity() == rhs.arity();
+}
+
+
+bool operator!=(CallRuntimeParameters const& lhs,
+ CallRuntimeParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(CallRuntimeParameters const& p) {
+ return base::hash_combine(p.id(), p.arity());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CallRuntimeParameters const& p) {
+ return os << p.id() << ", " << p.arity();
+}
+
+
+const CallRuntimeParameters& CallRuntimeParametersOf(const Operator* op) {
+ DCHECK_EQ(IrOpcode::kJSCallRuntime, op->opcode());
+ return OpParameter<CallRuntimeParameters>(op);
+}
+
+
+ContextAccess::ContextAccess(size_t depth, size_t index, bool immutable)
+ : immutable_(immutable),
+ depth_(static_cast<uint16_t>(depth)),
+ index_(static_cast<uint32_t>(index)) {
+ DCHECK(depth <= std::numeric_limits<uint16_t>::max());
+ DCHECK(index <= std::numeric_limits<uint32_t>::max());
+}
+
+
+bool operator==(ContextAccess const& lhs, ContextAccess const& rhs) {
+ return lhs.depth() == rhs.depth() && lhs.index() == rhs.index() &&
+ lhs.immutable() == rhs.immutable();
+}
+
+
+bool operator!=(ContextAccess const& lhs, ContextAccess const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(ContextAccess const& access) {
+ return base::hash_combine(access.depth(), access.index(), access.immutable());
+}
+
+
+std::ostream& operator<<(std::ostream& os, ContextAccess const& access) {
+ return os << access.depth() << ", " << access.index() << ", "
+ << access.immutable();
+}
+
+
+ContextAccess const& ContextAccessOf(Operator const* op) {
+ DCHECK(op->opcode() == IrOpcode::kJSLoadContext ||
+ op->opcode() == IrOpcode::kJSStoreContext);
+ return OpParameter<ContextAccess>(op);
+}
+
+
+bool operator==(VectorSlotPair const& lhs, VectorSlotPair const& rhs) {
+ return lhs.slot().ToInt() == rhs.slot().ToInt() &&
+ lhs.vector().is_identical_to(rhs.vector());
+}
+
+
+size_t hash_value(VectorSlotPair const& p) {
+ // TODO(mvstanton): include the vector in the hash.
+ base::hash<int> h;
+ return h(p.slot().ToInt());
+}
+
+
+bool operator==(LoadNamedParameters const& lhs,
+ LoadNamedParameters const& rhs) {
+ return lhs.name() == rhs.name() &&
+ lhs.contextual_mode() == rhs.contextual_mode() &&
+ lhs.feedback() == rhs.feedback();
+}
+
+
+bool operator!=(LoadNamedParameters const& lhs,
+ LoadNamedParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(LoadNamedParameters const& p) {
+ return base::hash_combine(p.name(), p.contextual_mode(), p.feedback());
+}
+
+
+std::ostream& operator<<(std::ostream& os, LoadNamedParameters const& p) {
+ return os << Brief(*p.name().handle()) << ", " << p.contextual_mode();
+}
+
+
+std::ostream& operator<<(std::ostream& os, LoadPropertyParameters const& p) {
+ // Nothing special to print.
+ return os;
+}
+
+
+bool operator==(LoadPropertyParameters const& lhs,
+ LoadPropertyParameters const& rhs) {
+ return lhs.feedback() == rhs.feedback();
+}
+
+
+bool operator!=(LoadPropertyParameters const& lhs,
+ LoadPropertyParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+const LoadPropertyParameters& LoadPropertyParametersOf(const Operator* op) {
+ DCHECK_EQ(IrOpcode::kJSLoadProperty, op->opcode());
+ return OpParameter<LoadPropertyParameters>(op);
+}
+
+
+size_t hash_value(LoadPropertyParameters const& p) {
+ return hash_value(p.feedback());
+}
+
+
+const LoadNamedParameters& LoadNamedParametersOf(const Operator* op) {
+ DCHECK_EQ(IrOpcode::kJSLoadNamed, op->opcode());
+ return OpParameter<LoadNamedParameters>(op);
+}
+
+
+bool operator==(StoreNamedParameters const& lhs,
+ StoreNamedParameters const& rhs) {
+ return lhs.strict_mode() == rhs.strict_mode() && lhs.name() == rhs.name();
+}
+
+
+bool operator!=(StoreNamedParameters const& lhs,
+ StoreNamedParameters const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(StoreNamedParameters const& p) {
+ return base::hash_combine(p.strict_mode(), p.name());
+}
+
+
+std::ostream& operator<<(std::ostream& os, StoreNamedParameters const& p) {
+ return os << p.strict_mode() << ", " << Brief(*p.name().handle());
+}
+
+
+const StoreNamedParameters& StoreNamedParametersOf(const Operator* op) {
+ DCHECK_EQ(IrOpcode::kJSStoreNamed, op->opcode());
+ return OpParameter<StoreNamedParameters>(op);
+}
+
+
+#define CACHED_OP_LIST(V) \
+ V(Equal, Operator::kNoProperties, 2, 1) \
+ V(NotEqual, Operator::kNoProperties, 2, 1) \
+ V(StrictEqual, Operator::kPure, 2, 1) \
+ V(StrictNotEqual, Operator::kPure, 2, 1) \
+ V(LessThan, Operator::kNoProperties, 2, 1) \
+ V(GreaterThan, Operator::kNoProperties, 2, 1) \
+ V(LessThanOrEqual, Operator::kNoProperties, 2, 1) \
+ V(GreaterThanOrEqual, Operator::kNoProperties, 2, 1) \
+ V(BitwiseOr, Operator::kNoProperties, 2, 1) \
+ V(BitwiseXor, Operator::kNoProperties, 2, 1) \
+ V(BitwiseAnd, Operator::kNoProperties, 2, 1) \
+ V(ShiftLeft, Operator::kNoProperties, 2, 1) \
+ V(ShiftRight, Operator::kNoProperties, 2, 1) \
+ V(ShiftRightLogical, Operator::kNoProperties, 2, 1) \
+ V(Add, Operator::kNoProperties, 2, 1) \
+ V(Subtract, Operator::kNoProperties, 2, 1) \
+ V(Multiply, Operator::kNoProperties, 2, 1) \
+ V(Divide, Operator::kNoProperties, 2, 1) \
+ V(Modulus, Operator::kNoProperties, 2, 1) \
+ V(UnaryNot, Operator::kNoProperties, 1, 1) \
+ V(ToBoolean, Operator::kNoProperties, 1, 1) \
+ V(ToNumber, Operator::kNoProperties, 1, 1) \
+ V(ToString, Operator::kNoProperties, 1, 1) \
+ V(ToName, Operator::kNoProperties, 1, 1) \
+ V(ToObject, Operator::kNoProperties, 1, 1) \
+ V(Yield, Operator::kNoProperties, 1, 1) \
+ V(Create, Operator::kEliminatable, 0, 1) \
+ V(HasProperty, Operator::kNoProperties, 2, 1) \
+ V(TypeOf, Operator::kPure, 1, 1) \
+ V(InstanceOf, Operator::kNoProperties, 2, 1) \
+ V(Debugger, Operator::kNoProperties, 0, 0) \
+ V(CreateFunctionContext, Operator::kNoProperties, 1, 1) \
+ V(CreateWithContext, Operator::kNoProperties, 2, 1) \
+ V(CreateBlockContext, Operator::kNoProperties, 2, 1) \
+ V(CreateModuleContext, Operator::kNoProperties, 2, 1) \
+ V(CreateGlobalContext, Operator::kNoProperties, 2, 1)
+
+
+struct JSOperatorGlobalCache FINAL {
+#define CACHED(Name, properties, value_input_count, value_output_count) \
+ struct Name##Operator FINAL : public Operator { \
+ Name##Operator() \
+ : Operator(IrOpcode::kJS##Name, properties, "JS" #Name, \
+ value_input_count, Operator::ZeroIfPure(properties), \
+ Operator::ZeroIfPure(properties), value_output_count, \
+ Operator::ZeroIfPure(properties), 0) {} \
+ }; \
+ Name##Operator k##Name##Operator;
+ CACHED_OP_LIST(CACHED)
+#undef CACHED
+};
+
+
+static base::LazyInstance<JSOperatorGlobalCache>::type kCache =
+ LAZY_INSTANCE_INITIALIZER;
+
+
+JSOperatorBuilder::JSOperatorBuilder(Zone* zone)
+ : cache_(kCache.Get()), zone_(zone) {}
+
+
+#define CACHED(Name, properties, value_input_count, value_output_count) \
+ const Operator* JSOperatorBuilder::Name() { \
+ return &cache_.k##Name##Operator; \
+ }
+CACHED_OP_LIST(CACHED)
+#undef CACHED
+
+
+const Operator* JSOperatorBuilder::CallFunction(size_t arity,
+ CallFunctionFlags flags) {
+ CallFunctionParameters parameters(arity, flags);
+ return new (zone()) Operator1<CallFunctionParameters>( // --
+ IrOpcode::kJSCallFunction, Operator::kNoProperties, // opcode
+ "JSCallFunction", // name
+ parameters.arity(), 1, 1, 1, 1, 0, // inputs/outputs
+ parameters); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::CallRuntime(Runtime::FunctionId id,
+ size_t arity) {
+ CallRuntimeParameters parameters(id, arity);
+ const Runtime::Function* f = Runtime::FunctionForId(parameters.id());
+ DCHECK(f->nargs == -1 || f->nargs == static_cast<int>(parameters.arity()));
+ return new (zone()) Operator1<CallRuntimeParameters>( // --
+ IrOpcode::kJSCallRuntime, Operator::kNoProperties, // opcode
+ "JSCallRuntime", // name
+ parameters.arity(), 1, 1, f->result_size, 1, 0, // inputs/outputs
+ parameters); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::CallConstruct(int arguments) {
+ return new (zone()) Operator1<int>( // --
+ IrOpcode::kJSCallConstruct, Operator::kNoProperties, // opcode
+ "JSCallConstruct", // name
+ arguments, 1, 1, 1, 1, 0, // counts
+ arguments); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::LoadNamed(const Unique<Name>& name,
+ const VectorSlotPair& feedback,
+ ContextualMode contextual_mode) {
+ LoadNamedParameters parameters(name, feedback, contextual_mode);
+ return new (zone()) Operator1<LoadNamedParameters>( // --
+ IrOpcode::kJSLoadNamed, Operator::kNoProperties, // opcode
+ "JSLoadNamed", // name
+ 1, 1, 1, 1, 1, 0, // counts
+ parameters); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::LoadProperty(
+ const VectorSlotPair& feedback) {
+ LoadPropertyParameters parameters(feedback);
+ return new (zone()) Operator1<LoadPropertyParameters>( // --
+ IrOpcode::kJSLoadProperty, Operator::kNoProperties, // opcode
+ "JSLoadProperty", // name
+ 2, 1, 1, 1, 1, 0, // counts
+ parameters); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::StoreProperty(StrictMode strict_mode) {
+ return new (zone()) Operator1<StrictMode>( // --
+ IrOpcode::kJSStoreProperty, Operator::kNoProperties, // opcode
+ "JSStoreProperty", // name
+ 3, 1, 1, 0, 1, 0, // counts
+ strict_mode); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::StoreNamed(StrictMode strict_mode,
+ const Unique<Name>& name) {
+ StoreNamedParameters parameters(strict_mode, name);
+ return new (zone()) Operator1<StoreNamedParameters>( // --
+ IrOpcode::kJSStoreNamed, Operator::kNoProperties, // opcode
+ "JSStoreNamed", // name
+ 2, 1, 1, 0, 1, 0, // counts
+ parameters); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::DeleteProperty(StrictMode strict_mode) {
+ return new (zone()) Operator1<StrictMode>( // --
+ IrOpcode::kJSDeleteProperty, Operator::kNoProperties, // opcode
+ "JSDeleteProperty", // name
+ 2, 1, 1, 1, 1, 0, // counts
+ strict_mode); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::LoadContext(size_t depth, size_t index,
+ bool immutable) {
+ ContextAccess access(depth, index, immutable);
+ return new (zone()) Operator1<ContextAccess>( // --
+ IrOpcode::kJSLoadContext, Operator::kNoWrite, // opcode
+ "JSLoadContext", // name
+ 1, 1, 0, 1, 1, 0, // counts
+ access); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::StoreContext(size_t depth, size_t index) {
+ ContextAccess access(depth, index, false);
+ return new (zone()) Operator1<ContextAccess>( // --
+ IrOpcode::kJSStoreContext, Operator::kNoRead, // opcode
+ "JSStoreContext", // name
+ 2, 1, 1, 0, 1, 0, // counts
+ access); // parameter
+}
+
+
+const Operator* JSOperatorBuilder::CreateCatchContext(
+ const Unique<String>& name) {
+ return new (zone()) Operator1<Unique<String>>( // --
+ IrOpcode::kJSCreateCatchContext, Operator::kNoProperties, // opcode
+ "JSCreateCatchContext", // name
+ 1, 1, 1, 1, 1, 0, // counts
+ name); // parameter
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#ifndef V8_COMPILER_JS_OPERATOR_H_
#define V8_COMPILER_JS_OPERATOR_H_
-#include "src/compiler/linkage.h"
-#include "src/compiler/opcodes.h"
-#include "src/compiler/operator.h"
+#include "src/runtime/runtime.h"
#include "src/unique.h"
-#include "src/zone.h"
namespace v8 {
namespace internal {
namespace compiler {
+// Forward declarations.
+class Operator;
+struct JSOperatorGlobalCache;
+
+
+// Defines the arity and the call flags for a JavaScript function call. This is
+// used as a parameter by JSCallFunction operators.
+class CallFunctionParameters FINAL {
+ public:
+ CallFunctionParameters(size_t arity, CallFunctionFlags flags)
+ : arity_(arity), flags_(flags) {}
+
+ size_t arity() const { return arity_; }
+ CallFunctionFlags flags() const { return flags_; }
+
+ private:
+ const size_t arity_;
+ const CallFunctionFlags flags_;
+};
+
+bool operator==(CallFunctionParameters const&, CallFunctionParameters const&);
+bool operator!=(CallFunctionParameters const&, CallFunctionParameters const&);
+
+size_t hash_value(CallFunctionParameters const&);
+
+std::ostream& operator<<(std::ostream&, CallFunctionParameters const&);
+
+const CallFunctionParameters& CallFunctionParametersOf(const Operator* op);
+
+
+// Defines the arity and the ID for a runtime function call. This is used as a
+// parameter by JSCallRuntime operators.
+class CallRuntimeParameters FINAL {
+ public:
+ CallRuntimeParameters(Runtime::FunctionId id, size_t arity)
+ : id_(id), arity_(arity) {}
+
+ Runtime::FunctionId id() const { return id_; }
+ size_t arity() const { return arity_; }
+
+ private:
+ const Runtime::FunctionId id_;
+ const size_t arity_;
+};
+
+bool operator==(CallRuntimeParameters const&, CallRuntimeParameters const&);
+bool operator!=(CallRuntimeParameters const&, CallRuntimeParameters const&);
+
+size_t hash_value(CallRuntimeParameters const&);
+
+std::ostream& operator<<(std::ostream&, CallRuntimeParameters const&);
+
+const CallRuntimeParameters& CallRuntimeParametersOf(const Operator* op);
+
+
// Defines the location of a context slot relative to a specific scope. This is
// used as a parameter by JSLoadContext and JSStoreContext operators and allows
// accessing a context-allocated variable without keeping track of the scope.
-class ContextAccess {
+class ContextAccess FINAL {
public:
- ContextAccess(int depth, int index, bool immutable)
- : immutable_(immutable), depth_(depth), index_(index) {
- DCHECK(0 <= depth && depth <= kMaxUInt16);
- DCHECK(0 <= index && static_cast<uint32_t>(index) <= kMaxUInt32);
- }
- int depth() const { return depth_; }
- int index() const { return index_; }
+ ContextAccess(size_t depth, size_t index, bool immutable);
+
+ size_t depth() const { return depth_; }
+ size_t index() const { return index_; }
bool immutable() const { return immutable_; }
private:
const uint32_t index_;
};
+bool operator==(ContextAccess const&, ContextAccess const&);
+bool operator!=(ContextAccess const&, ContextAccess const&);
+
+size_t hash_value(ContextAccess const&);
+
+std::ostream& operator<<(std::ostream&, ContextAccess const&);
+
+ContextAccess const& ContextAccessOf(Operator const*);
+
+
+class VectorSlotPair {
+ public:
+ VectorSlotPair(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
+ : vector_(vector), slot_(slot) {}
+
+ Handle<TypeFeedbackVector> vector() const { return vector_; }
+ FeedbackVectorICSlot slot() const { return slot_; }
+
+ int index() const { return vector_->GetIndex(slot_); }
+
+ private:
+ const Handle<TypeFeedbackVector> vector_;
+ const FeedbackVectorICSlot slot_;
+};
+
+
+bool operator==(VectorSlotPair const& lhs, VectorSlotPair const& rhs);
+
+
// Defines the property being loaded from an object by a named load. This is
// used as a parameter by JSLoadNamed operators.
-struct LoadNamedParameters {
- Unique<Name> name;
- ContextualMode contextual_mode;
+class LoadNamedParameters FINAL {
+ public:
+ LoadNamedParameters(const Unique<Name>& name, const VectorSlotPair& feedback,
+ ContextualMode contextual_mode)
+ : name_(name), contextual_mode_(contextual_mode), feedback_(feedback) {}
+
+ const Unique<Name>& name() const { return name_; }
+ ContextualMode contextual_mode() const { return contextual_mode_; }
+
+ const VectorSlotPair& feedback() const { return feedback_; }
+
+ private:
+ const Unique<Name> name_;
+ const ContextualMode contextual_mode_;
+ const VectorSlotPair feedback_;
};
-// Defines the arity and the call flags for a JavaScript function call. This is
-// used as a parameter by JSCall operators.
-struct CallParameters {
- int arity;
- CallFunctionFlags flags;
+bool operator==(LoadNamedParameters const&, LoadNamedParameters const&);
+bool operator!=(LoadNamedParameters const&, LoadNamedParameters const&);
+
+size_t hash_value(LoadNamedParameters const&);
+
+std::ostream& operator<<(std::ostream&, LoadNamedParameters const&);
+
+const LoadNamedParameters& LoadNamedParametersOf(const Operator* op);
+
+
+// Defines the property being loaded from an object. This is
+// used as a parameter by JSLoadProperty operators.
+class LoadPropertyParameters FINAL {
+ public:
+ explicit LoadPropertyParameters(const VectorSlotPair& feedback)
+ : feedback_(feedback) {}
+
+ const VectorSlotPair& feedback() const { return feedback_; }
+
+ private:
+ const VectorSlotPair feedback_;
};
+bool operator==(LoadPropertyParameters const&, LoadPropertyParameters const&);
+bool operator!=(LoadPropertyParameters const&, LoadPropertyParameters const&);
+
+size_t hash_value(LoadPropertyParameters const&);
+
+std::ostream& operator<<(std::ostream&, LoadPropertyParameters const&);
+
+const LoadPropertyParameters& LoadPropertyParametersOf(const Operator* op);
+
+
// Defines the property being stored to an object by a named store. This is
// used as a parameter by JSStoreNamed operators.
-struct StoreNamedParameters {
- StrictMode strict_mode;
- Unique<Name> name;
+class StoreNamedParameters FINAL {
+ public:
+ StoreNamedParameters(StrictMode strict_mode, const Unique<Name>& name)
+ : strict_mode_(strict_mode), name_(name) {}
+
+ StrictMode strict_mode() const { return strict_mode_; }
+ const Unique<Name>& name() const { return name_; }
+
+ private:
+ const StrictMode strict_mode_;
+ const Unique<Name> name_;
};
+bool operator==(StoreNamedParameters const&, StoreNamedParameters const&);
+bool operator!=(StoreNamedParameters const&, StoreNamedParameters const&);
+
+size_t hash_value(StoreNamedParameters const&);
+
+std::ostream& operator<<(std::ostream&, StoreNamedParameters const&);
+
+const StoreNamedParameters& StoreNamedParametersOf(const Operator* op);
+
+
// Interface for building JavaScript-level operators, e.g. directly from the
// AST. Most operators have no parameters, thus can be globally shared for all
// graphs.
-class JSOperatorBuilder {
+class JSOperatorBuilder FINAL : public ZoneObject {
public:
- explicit JSOperatorBuilder(Zone* zone) : zone_(zone) {}
-
-#define SIMPLE(name, properties, inputs, outputs) \
- return new (zone_) \
- SimpleOperator(IrOpcode::k##name, properties, inputs, outputs, #name);
-
-#define NOPROPS(name, inputs, outputs) \
- SIMPLE(name, Operator::kNoProperties, inputs, outputs)
-
-#define OP1(name, ptype, pname, properties, inputs, outputs) \
- return new (zone_) Operator1<ptype>(IrOpcode::k##name, properties, inputs, \
- outputs, #name, pname)
-
-#define BINOP(name) NOPROPS(name, 2, 1)
-#define UNOP(name) NOPROPS(name, 1, 1)
-
-#define PURE_BINOP(name) SIMPLE(name, Operator::kPure, 2, 1)
-
- const Operator* Equal() { BINOP(JSEqual); }
- const Operator* NotEqual() { BINOP(JSNotEqual); }
- const Operator* StrictEqual() { PURE_BINOP(JSStrictEqual); }
- const Operator* StrictNotEqual() { PURE_BINOP(JSStrictNotEqual); }
- const Operator* LessThan() { BINOP(JSLessThan); }
- const Operator* GreaterThan() { BINOP(JSGreaterThan); }
- const Operator* LessThanOrEqual() { BINOP(JSLessThanOrEqual); }
- const Operator* GreaterThanOrEqual() { BINOP(JSGreaterThanOrEqual); }
- const Operator* BitwiseOr() { BINOP(JSBitwiseOr); }
- const Operator* BitwiseXor() { BINOP(JSBitwiseXor); }
- const Operator* BitwiseAnd() { BINOP(JSBitwiseAnd); }
- const Operator* ShiftLeft() { BINOP(JSShiftLeft); }
- const Operator* ShiftRight() { BINOP(JSShiftRight); }
- const Operator* ShiftRightLogical() { BINOP(JSShiftRightLogical); }
- const Operator* Add() { BINOP(JSAdd); }
- const Operator* Subtract() { BINOP(JSSubtract); }
- const Operator* Multiply() { BINOP(JSMultiply); }
- const Operator* Divide() { BINOP(JSDivide); }
- const Operator* Modulus() { BINOP(JSModulus); }
-
- const Operator* UnaryNot() { UNOP(JSUnaryNot); }
- const Operator* ToBoolean() { UNOP(JSToBoolean); }
- const Operator* ToNumber() { UNOP(JSToNumber); }
- const Operator* ToString() { UNOP(JSToString); }
- const Operator* ToName() { UNOP(JSToName); }
- const Operator* ToObject() { UNOP(JSToObject); }
- const Operator* Yield() { UNOP(JSYield); }
-
- const Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); }
-
- const Operator* Call(int arguments, CallFunctionFlags flags) {
- CallParameters parameters = {arguments, flags};
- OP1(JSCallFunction, CallParameters, parameters, Operator::kNoProperties,
- arguments, 1);
- }
-
- const Operator* CallNew(int arguments) {
- return new (zone_)
- Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
- arguments, 1, "JSCallConstruct", arguments);
- }
-
- const Operator* LoadProperty() { BINOP(JSLoadProperty); }
- const Operator* LoadNamed(Unique<Name> name,
- ContextualMode contextual_mode = NOT_CONTEXTUAL) {
- LoadNamedParameters parameters = {name, contextual_mode};
- OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
- 1, 1);
- }
-
- const Operator* StoreProperty(StrictMode strict_mode) {
- OP1(JSStoreProperty, StrictMode, strict_mode, Operator::kNoProperties, 3,
- 0);
- }
-
- const Operator* StoreNamed(StrictMode strict_mode, Unique<Name> name) {
- StoreNamedParameters parameters = {strict_mode, name};
- OP1(JSStoreNamed, StoreNamedParameters, parameters, Operator::kNoProperties,
- 2, 0);
- }
-
- const Operator* DeleteProperty(StrictMode strict_mode) {
- OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
- 1);
- }
-
- const Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
-
- const Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
- ContextAccess access(depth, index, immutable);
- OP1(JSLoadContext, ContextAccess, access,
- Operator::kEliminatable | Operator::kNoWrite, 1, 1);
- }
- const Operator* StoreContext(uint16_t depth, uint32_t index) {
- ContextAccess access(depth, index, false);
- OP1(JSStoreContext, ContextAccess, access, Operator::kNoProperties, 2, 0);
- }
-
- const Operator* TypeOf() { SIMPLE(JSTypeOf, Operator::kPure, 1, 1); }
- const Operator* InstanceOf() { NOPROPS(JSInstanceOf, 2, 1); }
- const Operator* Debugger() { NOPROPS(JSDebugger, 0, 0); }
+ explicit JSOperatorBuilder(Zone* zone);
+
+ const Operator* Equal();
+ const Operator* NotEqual();
+ const Operator* StrictEqual();
+ const Operator* StrictNotEqual();
+ const Operator* LessThan();
+ const Operator* GreaterThan();
+ const Operator* LessThanOrEqual();
+ const Operator* GreaterThanOrEqual();
+ const Operator* BitwiseOr();
+ const Operator* BitwiseXor();
+ const Operator* BitwiseAnd();
+ const Operator* ShiftLeft();
+ const Operator* ShiftRight();
+ const Operator* ShiftRightLogical();
+ const Operator* Add();
+ const Operator* Subtract();
+ const Operator* Multiply();
+ const Operator* Divide();
+ const Operator* Modulus();
+
+ const Operator* UnaryNot();
+ const Operator* ToBoolean();
+ const Operator* ToNumber();
+ const Operator* ToString();
+ const Operator* ToName();
+ const Operator* ToObject();
+ const Operator* Yield();
+
+ const Operator* Create();
+
+ const Operator* CallFunction(size_t arity, CallFunctionFlags flags);
+ const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
+
+ const Operator* CallConstruct(int arguments);
+
+ const Operator* LoadProperty(const VectorSlotPair& feedback);
+ const Operator* LoadNamed(const Unique<Name>& name,
+ const VectorSlotPair& feedback,
+ ContextualMode contextual_mode = NOT_CONTEXTUAL);
+
+ const Operator* StoreProperty(StrictMode strict_mode);
+ const Operator* StoreNamed(StrictMode strict_mode, const Unique<Name>& name);
+
+ const Operator* DeleteProperty(StrictMode strict_mode);
+
+ const Operator* HasProperty();
+
+ const Operator* LoadContext(size_t depth, size_t index, bool immutable);
+ const Operator* StoreContext(size_t depth, size_t index);
+
+ const Operator* TypeOf();
+ const Operator* InstanceOf();
+ const Operator* Debugger();
// TODO(titzer): nail down the static parts of each of these context flavors.
- const Operator* CreateFunctionContext() {
- NOPROPS(JSCreateFunctionContext, 1, 1);
- }
- const Operator* CreateCatchContext(Unique<String> name) {
- OP1(JSCreateCatchContext, Unique<String>, name, Operator::kNoProperties, 1,
- 1);
- }
- const Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
- const Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
- const Operator* CreateModuleContext() {
- NOPROPS(JSCreateModuleContext, 2, 1);
- }
- const Operator* CreateGlobalContext() {
- NOPROPS(JSCreateGlobalContext, 2, 1);
- }
-
- const Operator* Runtime(Runtime::FunctionId function, int arguments) {
- const Runtime::Function* f = Runtime::FunctionForId(function);
- DCHECK(f->nargs == -1 || f->nargs == arguments);
- OP1(JSCallRuntime, Runtime::FunctionId, function, Operator::kNoProperties,
- arguments, f->result_size);
- }
-
-#undef SIMPLE
-#undef NOPROPS
-#undef OP1
-#undef BINOP
-#undef UNOP
+ const Operator* CreateFunctionContext();
+ const Operator* CreateCatchContext(const Unique<String>& name);
+ const Operator* CreateWithContext();
+ const Operator* CreateBlockContext();
+ const Operator* CreateModuleContext();
+ const Operator* CreateGlobalContext();
private:
- Zone* zone_;
-};
+ Zone* zone() const { return zone_; }
-// Specialization for static parameters of type {ContextAccess}.
-template <>
-struct StaticParameterTraits<ContextAccess> {
- static OStream& PrintTo(OStream& os, ContextAccess val) { // NOLINT
- return os << val.depth() << "," << val.index()
- << (val.immutable() ? ",imm" : "");
- }
- static int HashCode(ContextAccess val) {
- return (val.depth() << 16) | (val.index() & 0xffff);
- }
- static bool Equals(ContextAccess a, ContextAccess b) {
- return a.immutable() == b.immutable() && a.depth() == b.depth() &&
- a.index() == b.index();
- }
-};
+ const JSOperatorGlobalCache& cache_;
+ Zone* const zone_;
-// Specialization for static parameters of type {Runtime::FunctionId}.
-template <>
-struct StaticParameterTraits<Runtime::FunctionId> {
- static OStream& PrintTo(OStream& os, Runtime::FunctionId val) { // NOLINT
- const Runtime::Function* f = Runtime::FunctionForId(val);
- return os << (f->name ? f->name : "?Runtime?");
- }
- static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
- static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
- return a == b;
- }
+ DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
};
} // namespace compiler
}
+JSTypedLowering::JSTypedLowering(JSGraph* jsgraph)
+ : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {
+ Factory* factory = zone()->isolate()->factory();
+ Handle<Object> zero = factory->NewNumber(0.0);
+ Handle<Object> one = factory->NewNumber(1.0);
+ zero_range_ = Type::Range(zero, zero, zone());
+ one_range_ = Type::Range(one, one, zone());
+}
+
+
JSTypedLowering::~JSTypedLowering() {}
// Remove all effect and control inputs and outputs to this node and change
// to the pure operator {op}, possibly inserting a boolean inversion.
Reduction ChangeToPureOperator(const Operator* op, bool invert = false) {
- DCHECK_EQ(0, OperatorProperties::GetEffectInputCount(op));
+ DCHECK_EQ(0, op->EffectInputCount());
DCHECK_EQ(false, OperatorProperties::HasContextInput(op));
- DCHECK_EQ(0, OperatorProperties::GetControlInputCount(op));
- DCHECK_EQ(2, OperatorProperties::GetValueInputCount(op));
+ DCHECK_EQ(0, op->ControlInputCount());
+ DCHECK_EQ(2, op->ValueInputCount());
// Remove the effects from the node, if any, and update its effect usages.
- if (OperatorProperties::GetEffectInputCount(node_->op()) > 0) {
+ if (node_->op()->EffectInputCount() > 0) {
RelaxEffects(node_);
}
// Remove the inputs corresponding to context, effect, and control.
return r.ChangeToPureOperator(simplified()->NumberAdd());
}
Type* maybe_string = Type::Union(Type::String(), Type::Receiver(), zone());
- if (r.NeitherInputCanBe(maybe_string)) {
+ if (r.BothInputsAre(Type::Primitive()) && r.NeitherInputCanBe(maybe_string)) {
// JSAdd(x:-string, y:-string) => NumberAdd(ToNumber(x), ToNumber(y))
r.ConvertInputsToNumber();
return r.ChangeToPureOperator(simplified()->NumberAdd());
}
#if 0
+ // TODO(turbofan): General ToNumber disabled for now because:
+ // a) The inserted ToNumber operation screws up observability of valueOf.
+ // b) Deoptimization at ToNumber doesn't have corresponding bailout id.
+ Type* maybe_string = Type::Union(Type::String(), Type::Receiver(), zone());
+ if (r.NeitherInputCanBe(maybe_string)) {
+ ...
+ }
+#endif
+#if 0
// TODO(turbofan): Lowering of StringAdd is disabled for now because:
// a) The inserted ToString operation screws up valueOf vs. toString order.
// b) Deoptimization at ToString doesn't have corresponding bailout id.
}
+Reduction JSTypedLowering::ReduceJSBitwiseOr(Node* node) {
+ JSBinopReduction r(this, node);
+ if (r.BothInputsAre(Type::Primitive()) || r.OneInputIs(zero_range_)) {
+ // TODO(jarin): Propagate frame state input from non-primitive input node to
+ // JSToNumber node.
+ // TODO(titzer): some Smi bitwise operations don't really require going
+ // all the way to int32, which can save tagging/untagging for some
+ // operations
+ // on some platforms.
+ // TODO(turbofan): make this heuristic configurable for code size.
+ r.ConvertInputsToInt32(true, true);
+ return r.ChangeToPureOperator(machine()->Word32Or());
+ }
+ return NoChange();
+}
+
+
+Reduction JSTypedLowering::ReduceJSMultiply(Node* node) {
+ JSBinopReduction r(this, node);
+ if (r.BothInputsAre(Type::Primitive()) || r.OneInputIs(one_range_)) {
+ // TODO(jarin): Propagate frame state input from non-primitive input node to
+ // JSToNumber node.
+ r.ConvertInputsToNumber();
+ return r.ChangeToPureOperator(simplified()->NumberMultiply());
+ }
+ // TODO(turbofan): relax/remove the effects of this operator in other cases.
+ return NoChange();
+}
+
+
Reduction JSTypedLowering::ReduceNumberBinop(Node* node,
const Operator* numberOp) {
JSBinopReduction r(this, node);
+ if (r.BothInputsAre(Type::Primitive())) {
+ r.ConvertInputsToNumber();
+ return r.ChangeToPureOperator(numberOp);
+ }
+#if 0
+ // TODO(turbofan): General ToNumber disabled for now because:
+ // a) The inserted ToNumber operation screws up observability of valueOf.
+ // b) Deoptimization at ToNumber doesn't have corresponding bailout id.
if (r.OneInputIs(Type::Primitive())) {
// If at least one input is a primitive, then insert appropriate conversions
// to number and reduce this operator to the given numeric one.
r.ConvertInputsToNumber();
return r.ChangeToPureOperator(numberOp);
}
+#endif
// TODO(turbofan): relax/remove the effects of this operator in other cases.
return NoChange();
}
bool right_signed,
const Operator* intOp) {
JSBinopReduction r(this, node);
- // TODO(titzer): some Smi bitwise operations don't really require going
- // all the way to int32, which can save tagging/untagging for some operations
- // on some platforms.
- // TODO(turbofan): make this heuristic configurable for code size.
- r.ConvertInputsToInt32(left_signed, right_signed);
- return r.ChangeToPureOperator(intOp);
+ if (r.BothInputsAre(Type::Primitive())) {
+ // TODO(titzer): some Smi bitwise operations don't really require going
+ // all the way to int32, which can save tagging/untagging for some
+ // operations
+ // on some platforms.
+ // TODO(turbofan): make this heuristic configurable for code size.
+ r.ConvertInputsToInt32(left_signed, right_signed);
+ return r.ChangeToPureOperator(intOp);
+ }
+ return NoChange();
}
Reduction JSTypedLowering::ReduceI32Shift(Node* node, bool left_signed,
const Operator* shift_op) {
JSBinopReduction r(this, node);
- r.ConvertInputsForShift(left_signed);
- return r.ChangeToPureOperator(shift_op);
+ if (r.BothInputsAre(Type::Primitive())) {
+ r.ConvertInputsForShift(left_signed);
+ return r.ChangeToPureOperator(shift_op);
+ }
+ return NoChange();
}
}
return r.ChangeToPureOperator(stringOp);
}
+#if 0
+ // TODO(turbofan): General ToNumber disabled for now because:
+ // a) The inserted ToNumber operation screws up observability of valueOf.
+ // b) Deoptimization at ToNumber doesn't have corresponding bailout id.
Type* maybe_string = Type::Union(Type::String(), Type::Receiver(), zone());
if (r.OneInputCannotBe(maybe_string)) {
// If one input cannot be a string, then emit a number comparison.
+ ...
+ }
+#endif
+ Type* maybe_string = Type::Union(Type::String(), Type::Receiver(), zone());
+ if (r.BothInputsAre(Type::Primitive()) && r.OneInputCannotBe(maybe_string)) {
const Operator* less_than;
const Operator* less_than_or_equal;
if (r.BothInputsAre(Type::Unsigned32())) {
: jsgraph()->TrueConstant());
}
}
- if (!r.left_type()->Maybe(r.right_type())) {
- // Type intersection is empty; === is always false unless both
- // inputs could be strings (one internalized and one not).
- if (r.OneInputCannotBe(Type::String())) {
- return ReplaceEagerly(node, invert ? jsgraph()->TrueConstant()
- : jsgraph()->FalseConstant());
- }
- }
if (r.OneInputIs(Type::Undefined())) {
return r.ChangeToPureOperator(
simplified()->ReferenceEqual(Type::Undefined()), invert);
Node* inv = graph()->NewNode(simplified()->BooleanNot(), cmp);
return ReplaceWith(inv);
}
- // TODO(turbofan): js-typed-lowering of ToBoolean(string)
+ if (input_type->Is(Type::String())) {
+ // JSToBoolean(x:string) => BooleanNot(NumberEqual(x.length, #0))
+ FieldAccess access = AccessBuilder::ForStringLength();
+ Node* length = graph()->NewNode(simplified()->LoadField(access), input,
+ graph()->start(), graph()->start());
+ Node* cmp = graph()->NewNode(simplified()->NumberEqual(), length,
+ jsgraph()->ZeroConstant());
+ Node* inv = graph()->NewNode(simplified()->BooleanNot(), cmp);
+ return ReplaceWith(inv);
+ }
+ // TODO(turbofan): We need some kinda of PrimitiveToBoolean simplified
+ // operator, then we can do the pushing in the SimplifiedOperatorReducer
+ // and do not need to protect against stack overflow (because of backedges
+ // in phis) below.
+ if (input->opcode() == IrOpcode::kPhi &&
+ input_type->Is(
+ Type::Union(Type::Boolean(), Type::OrderedNumber(), zone()))) {
+ // JSToBoolean(phi(x1,...,xn):ordered-number|boolean)
+ // => phi(JSToBoolean(x1),...,JSToBoolean(xn))
+ int input_count = input->InputCount() - 1;
+ Node** inputs = zone()->NewArray<Node*>(input_count + 1);
+ for (int i = 0; i < input_count; ++i) {
+ Node* value = input->InputAt(i);
+ Type* value_type = NodeProperties::GetBounds(value).upper;
+ // Recursively try to reduce the value first.
+ Reduction result = (value_type->Is(Type::Boolean()) ||
+ value_type->Is(Type::OrderedNumber()))
+ ? ReduceJSToBooleanInput(value)
+ : NoChange();
+ if (result.Changed()) {
+ inputs[i] = result.replacement();
+ } else {
+ inputs[i] = graph()->NewNode(javascript()->ToBoolean(), value,
+ jsgraph()->ZeroConstant(),
+ graph()->start(), graph()->start());
+ }
+ }
+ inputs[input_count] = input->InputAt(input_count);
+ Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, input_count),
+ input_count + 1, inputs);
+ return ReplaceWith(phi);
+ }
return NoChange();
}
Type* key_type = NodeProperties::GetBounds(key).upper;
Type* base_type = NodeProperties::GetBounds(base).upper;
// TODO(mstarzinger): This lowering is not correct if:
- // a) The typed array turns external (i.e. MaterializeArrayBuffer)
- // b) The typed array or it's buffer is neutered.
- // c) The index is out of bounds.
+ // a) The typed array or it's buffer is neutered.
if (base_type->IsConstant() && key_type->Is(Type::Integral32()) &&
base_type->AsConstant()->Value()->IsJSTypedArray()) {
// JSLoadProperty(typed-array, int32)
- JSTypedArray* array = JSTypedArray::cast(*base_type->AsConstant()->Value());
- ElementsKind elements_kind = array->map()->elements_kind();
- ExternalArrayType type = array->type();
- uint32_t length;
- CHECK(array->length()->ToUint32(&length));
- ElementAccess element_access;
- Node* elements = graph()->NewNode(
- simplified()->LoadField(AccessBuilder::ForJSObjectElements()), base,
- NodeProperties::GetEffectInput(node));
- if (IsExternalArrayElementsKind(elements_kind)) {
- elements = graph()->NewNode(
- simplified()->LoadField(AccessBuilder::ForExternalArrayPointer()),
- elements, NodeProperties::GetEffectInput(node));
- element_access = AccessBuilder::ForTypedArrayElement(type, true);
- } else {
- DCHECK(IsFixedTypedArrayElementsKind(elements_kind));
- element_access = AccessBuilder::ForTypedArrayElement(type, false);
+ Handle<JSTypedArray> array =
+ Handle<JSTypedArray>::cast(base_type->AsConstant()->Value());
+ if (IsExternalArrayElementsKind(array->map()->elements_kind())) {
+ ExternalArrayType type = array->type();
+ double byte_length = array->byte_length()->Number();
+ if (byte_length <= kMaxInt) {
+ Handle<ExternalArray> elements =
+ Handle<ExternalArray>::cast(handle(array->elements()));
+ Node* pointer = jsgraph()->IntPtrConstant(
+ bit_cast<intptr_t>(elements->external_pointer()));
+ Node* length = jsgraph()->Constant(array->length()->Number());
+ Node* effect = NodeProperties::GetEffectInput(node);
+ Node* load = graph()->NewNode(
+ simplified()->LoadElement(
+ AccessBuilder::ForTypedArrayElement(type, true)),
+ pointer, key, length, effect);
+ return ReplaceEagerly(node, load);
+ }
}
- Node* value =
- graph()->NewNode(simplified()->LoadElement(element_access), elements,
- key, jsgraph()->Uint32Constant(length),
- NodeProperties::GetEffectInput(node));
- return ReplaceEagerly(node, value);
}
return NoChange();
}
Type* key_type = NodeProperties::GetBounds(key).upper;
Type* base_type = NodeProperties::GetBounds(base).upper;
// TODO(mstarzinger): This lowering is not correct if:
- // a) The typed array turns external (i.e. MaterializeArrayBuffer)
- // b) The typed array or its buffer is neutered.
+ // a) The typed array or its buffer is neutered.
if (key_type->Is(Type::Integral32()) && base_type->IsConstant() &&
base_type->AsConstant()->Value()->IsJSTypedArray()) {
// JSStoreProperty(typed-array, int32, value)
- JSTypedArray* array = JSTypedArray::cast(*base_type->AsConstant()->Value());
- ElementsKind elements_kind = array->map()->elements_kind();
- ExternalArrayType type = array->type();
- uint32_t length;
- CHECK(array->length()->ToUint32(&length));
- ElementAccess element_access;
- Node* elements = graph()->NewNode(
- simplified()->LoadField(AccessBuilder::ForJSObjectElements()), base,
- NodeProperties::GetEffectInput(node));
- if (IsExternalArrayElementsKind(elements_kind)) {
- elements = graph()->NewNode(
- simplified()->LoadField(AccessBuilder::ForExternalArrayPointer()),
- elements, NodeProperties::GetEffectInput(node));
- element_access = AccessBuilder::ForTypedArrayElement(type, true);
- } else {
- DCHECK(IsFixedTypedArrayElementsKind(elements_kind));
- element_access = AccessBuilder::ForTypedArrayElement(type, false);
+ Handle<JSTypedArray> array =
+ Handle<JSTypedArray>::cast(base_type->AsConstant()->Value());
+ if (IsExternalArrayElementsKind(array->map()->elements_kind())) {
+ ExternalArrayType type = array->type();
+ double byte_length = array->byte_length()->Number();
+ if (byte_length <= kMaxInt) {
+ Handle<ExternalArray> elements =
+ Handle<ExternalArray>::cast(handle(array->elements()));
+ Node* pointer = jsgraph()->IntPtrConstant(
+ bit_cast<intptr_t>(elements->external_pointer()));
+ Node* length = jsgraph()->Constant(array->length()->Number());
+ Node* effect = NodeProperties::GetEffectInput(node);
+ Node* control = NodeProperties::GetControlInput(node);
+ Node* store = graph()->NewNode(
+ simplified()->StoreElement(
+ AccessBuilder::ForTypedArrayElement(type, true)),
+ pointer, key, length, value, effect, control);
+ return ReplaceEagerly(node, store);
+ }
}
-
- Node* check = graph()->NewNode(machine()->Uint32LessThan(), key,
- jsgraph()->Uint32Constant(length));
- Node* branch = graph()->NewNode(common()->Branch(), check,
- NodeProperties::GetControlInput(node));
-
- Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
-
- Node* store =
- graph()->NewNode(simplified()->StoreElement(element_access), elements,
- key, jsgraph()->Uint32Constant(length), value,
- NodeProperties::GetEffectInput(node), if_true);
-
- Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
-
- Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(common()->EffectPhi(2), store,
- NodeProperties::GetEffectInput(node), merge);
-
- return ReplaceWith(phi);
}
return NoChange();
}
Reduction JSTypedLowering::Reduce(Node* node) {
+ // Check if the output type is a singleton. In that case we already know the
+ // result value and can simply replace the node unless there are effects.
+ if (NodeProperties::IsTyped(node) &&
+ NodeProperties::GetBounds(node).upper->IsConstant() &&
+ !IrOpcode::IsLeafOpcode(node->opcode()) &&
+ node->op()->EffectOutputCount() == 0) {
+ return ReplaceEagerly(node, jsgraph()->Constant(
+ NodeProperties::GetBounds(node).upper->AsConstant()->Value()));
+ // TODO(neis): Extend this to Range(x,x), NaN, MinusZero, ...?
+ }
switch (node->opcode()) {
case IrOpcode::kJSEqual:
return ReduceJSEqual(node, false);
case IrOpcode::kJSGreaterThanOrEqual:
return ReduceJSComparison(node);
case IrOpcode::kJSBitwiseOr:
- return ReduceI32Binop(node, true, true, machine()->Word32Or());
+ return ReduceJSBitwiseOr(node);
case IrOpcode::kJSBitwiseXor:
return ReduceI32Binop(node, true, true, machine()->Word32Xor());
case IrOpcode::kJSBitwiseAnd:
case IrOpcode::kJSSubtract:
return ReduceNumberBinop(node, simplified()->NumberSubtract());
case IrOpcode::kJSMultiply:
- return ReduceNumberBinop(node, simplified()->NumberMultiply());
+ return ReduceJSMultiply(node);
case IrOpcode::kJSDivide:
return ReduceNumberBinop(node, simplified()->NumberDivide());
case IrOpcode::kJSModulus:
// Lowers JS-level operators to simplified operators based on types.
class JSTypedLowering FINAL : public Reducer {
public:
- explicit JSTypedLowering(JSGraph* jsgraph)
- : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {}
+ explicit JSTypedLowering(JSGraph* jsgraph);
virtual ~JSTypedLowering();
virtual Reduction Reduce(Node* node) OVERRIDE;
Reduction ReplaceEagerly(Node* old, Node* node);
Reduction ReplaceWith(Node* node) { return Reducer::Replace(node); }
Reduction ReduceJSAdd(Node* node);
+ Reduction ReduceJSBitwiseOr(Node* node);
+ Reduction ReduceJSMultiply(Node* node);
Reduction ReduceJSComparison(Node* node);
Reduction ReduceJSLoadProperty(Node* node);
Reduction ReduceJSStoreProperty(Node* node);
JSGraph* jsgraph_;
SimplifiedOperatorBuilder simplified_;
+ Type* zero_range_;
+ Type* one_range_;
};
} // namespace compiler
#ifndef V8_COMPILER_LINKAGE_IMPL_H_
#define V8_COMPILER_LINKAGE_IMPL_H_
+#include "src/code-stubs.h"
+
namespace v8 {
namespace internal {
namespace compiler {
}
// TODO(turbofan): cache call descriptors for JSFunction calls.
- static CallDescriptor* GetJSCallDescriptor(Zone* zone,
- int js_parameter_count) {
+ static CallDescriptor* GetJSCallDescriptor(Zone* zone, int js_parameter_count,
+ CallDescriptor::Flags flags) {
const size_t return_count = 1;
const size_t context_count = 1;
const size_t parameter_count = js_parameter_count + context_count;
// The target for JS function calls is the JSFunction object.
MachineType target_type = kMachAnyTagged;
LinkageLocation target_loc = regloc(LinkageTraits::JSCallFunctionReg());
- return new (zone) CallDescriptor(CallDescriptor::kCallJSFunction, // kind
- target_type, // target MachineType
- target_loc, // target location
- types.Build(), // machine_sig
- locations.Build(), // location_sig
- js_parameter_count, // js_parameter_count
- Operator::kNoProperties, // properties
- kNoCalleeSaved, // callee-saved
- CallDescriptor::kNeedsFrameState, // flags
- "js-call");
+ return new (zone) CallDescriptor( // --
+ CallDescriptor::kCallJSFunction, // kind
+ target_type, // target MachineType
+ target_loc, // target location
+ types.Build(), // machine_sig
+ locations.Build(), // location_sig
+ js_parameter_count, // js_parameter_count
+ Operator::kNoProperties, // properties
+ kNoCalleeSaved, // callee-saved
+ flags, // flags
+ "js-call");
}
// The target for runtime calls is a code object.
MachineType target_type = kMachAnyTagged;
LinkageLocation target_loc = LinkageLocation::AnyRegister();
- return new (zone) CallDescriptor(CallDescriptor::kCallCodeObject, // kind
- target_type, // target MachineType
- target_loc, // target location
- types.Build(), // machine_sig
- locations.Build(), // location_sig
- js_parameter_count, // js_parameter_count
- properties, // properties
- kNoCalleeSaved, // callee-saved
- flags, // flags
- function->name); // debug name
+ return new (zone) CallDescriptor( // --
+ CallDescriptor::kCallCodeObject, // kind
+ target_type, // target MachineType
+ target_loc, // target location
+ types.Build(), // machine_sig
+ locations.Build(), // location_sig
+ js_parameter_count, // js_parameter_count
+ properties, // properties
+ kNoCalleeSaved, // callee-saved
+ flags, // flags
+ function->name); // debug name
}
// TODO(turbofan): cache call descriptors for code stub calls.
static CallDescriptor* GetStubCallDescriptor(
- Zone* zone, CallInterfaceDescriptor descriptor, int stack_parameter_count,
- CallDescriptor::Flags flags) {
+ Zone* zone, const CallInterfaceDescriptor& descriptor,
+ int stack_parameter_count, CallDescriptor::Flags flags) {
const int register_parameter_count =
descriptor.GetEnvironmentParameterCount();
const int js_parameter_count =
// The target for stub calls is a code object.
MachineType target_type = kMachAnyTagged;
LinkageLocation target_loc = LinkageLocation::AnyRegister();
- return new (zone) CallDescriptor(CallDescriptor::kCallCodeObject, // kind
- target_type, // target MachineType
- target_loc, // target location
- types.Build(), // machine_sig
- locations.Build(), // location_sig
- js_parameter_count, // js_parameter_count
- Operator::kNoProperties, // properties
- kNoCalleeSaved, // callee-saved registers
- flags, // flags
- descriptor.DebugName(zone->isolate()));
+ return new (zone) CallDescriptor( // --
+ CallDescriptor::kCallCodeObject, // kind
+ target_type, // target MachineType
+ target_loc, // target location
+ types.Build(), // machine_sig
+ locations.Build(), // location_sig
+ js_parameter_count, // js_parameter_count
+ Operator::kNoProperties, // properties
+ kNoCalleeSaved, // callee-saved registers
+ flags, // flags
+ descriptor.DebugName(zone->isolate()));
}
static CallDescriptor* GetSimplifiedCDescriptor(Zone* zone,
// The target for C calls is always an address (i.e. machine pointer).
MachineType target_type = kMachPtr;
LinkageLocation target_loc = LinkageLocation::AnyRegister();
- return new (zone) CallDescriptor(CallDescriptor::kCallAddress, // kind
- target_type, // target MachineType
- target_loc, // target location
- msig, // machine_sig
- locations.Build(), // location_sig
- 0, // js_parameter_count
- Operator::kNoProperties, // properties
- LinkageTraits::CCalleeSaveRegisters(),
- CallDescriptor::kNoFlags, "c-call");
+ return new (zone) CallDescriptor( // --
+ CallDescriptor::kCallAddress, // kind
+ target_type, // target MachineType
+ target_loc, // target location
+ msig, // machine_sig
+ locations.Build(), // location_sig
+ 0, // js_parameter_count
+ Operator::kNoProperties, // properties
+ LinkageTraits::CCalleeSaveRegisters(), CallDescriptor::kNoFlags,
+ "c-call");
}
static LinkageLocation regloc(Register reg) {
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/linkage.h"
-
#include "src/code-stubs.h"
#include "src/compiler.h"
+#include "src/compiler/linkage.h"
#include "src/compiler/node.h"
#include "src/compiler/pipeline.h"
#include "src/scopes.h"
namespace compiler {
-OStream& operator<<(OStream& os, const CallDescriptor::Kind& k) {
+std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k) {
switch (k) {
case CallDescriptor::kCallCodeObject:
os << "Code";
}
-OStream& operator<<(OStream& os, const CallDescriptor& d) {
+std::ostream& operator<<(std::ostream& os, const CallDescriptor& d) {
// TODO(svenpanne) Output properties etc. and be less cryptic.
return os << d.kind() << ":" << d.debug_name() << ":r" << d.ReturnCount()
<< "j" << d.JSParameterCount() << "i" << d.InputCount() << "f"
}
-Linkage::Linkage(CompilationInfo* info) : info_(info) {
+CallDescriptor* Linkage::ComputeIncoming(Zone* zone, CompilationInfo* info) {
if (info->function() != NULL) {
// If we already have the function literal, use the number of parameters
// plus the receiver.
- incoming_ = GetJSCallDescriptor(1 + info->function()->parameter_count());
- } else if (!info->closure().is_null()) {
+ return GetJSCallDescriptor(1 + info->function()->parameter_count(), zone,
+ CallDescriptor::kNoFlags);
+ }
+ if (!info->closure().is_null()) {
// If we are compiling a JS function, use a JS call descriptor,
// plus the receiver.
SharedFunctionInfo* shared = info->closure()->shared();
- incoming_ = GetJSCallDescriptor(1 + shared->formal_parameter_count());
- } else if (info->code_stub() != NULL) {
+ return GetJSCallDescriptor(1 + shared->formal_parameter_count(), zone,
+ CallDescriptor::kNoFlags);
+ }
+ if (info->code_stub() != NULL) {
// Use the code stub interface descriptor.
CallInterfaceDescriptor descriptor =
info->code_stub()->GetCallInterfaceDescriptor();
- incoming_ = GetStubCallDescriptor(descriptor);
- } else {
- incoming_ = NULL; // TODO(titzer): ?
+ return GetStubCallDescriptor(descriptor, 0, CallDescriptor::kNoFlags, zone);
}
+ return NULL; // TODO(titzer): ?
}
-FrameOffset Linkage::GetFrameOffset(int spill_slot, Frame* frame, int extra) {
+FrameOffset Linkage::GetFrameOffset(int spill_slot, Frame* frame,
+ int extra) const {
if (frame->GetSpillSlotCount() > 0 || incoming_->IsJSFunctionCall() ||
incoming_->kind() == CallDescriptor::kCallAddress) {
int offset;
}
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count) {
- return GetJSCallDescriptor(parameter_count, this->info_->zone());
+CallDescriptor* Linkage::GetJSCallDescriptor(
+ int parameter_count, CallDescriptor::Flags flags) const {
+ return GetJSCallDescriptor(parameter_count, zone_, flags);
}
CallDescriptor* Linkage::GetRuntimeCallDescriptor(
Runtime::FunctionId function, int parameter_count,
- Operator::Properties properties) {
- return GetRuntimeCallDescriptor(function, parameter_count, properties,
- this->info_->zone());
+ Operator::Properties properties) const {
+ return GetRuntimeCallDescriptor(function, parameter_count, properties, zone_);
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
- CallDescriptor::Flags flags) {
- return GetStubCallDescriptor(descriptor, stack_parameter_count, flags,
- this->info_->zone());
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
+ CallDescriptor::Flags flags) const {
+ return GetStubCallDescriptor(descriptor, stack_parameter_count, flags, zone_);
}
// TODO(jarin) At the moment, we only add frame state for
// few chosen runtime functions.
switch (function) {
+ case Runtime::kApply:
+ case Runtime::kArrayBufferNeuter:
+ case Runtime::kArrayConcat:
+ case Runtime::kBasicJSONStringify:
+ case Runtime::kCheckExecutionState:
+ case Runtime::kCollectStackTrace:
+ case Runtime::kCompileLazy:
+ case Runtime::kCompileOptimized:
+ case Runtime::kCompileString:
+ case Runtime::kCreateObjectLiteral:
case Runtime::kDebugBreak:
+ case Runtime::kDataViewSetInt8:
+ case Runtime::kDataViewSetUint8:
+ case Runtime::kDataViewSetInt16:
+ case Runtime::kDataViewSetUint16:
+ case Runtime::kDataViewSetInt32:
+ case Runtime::kDataViewSetUint32:
+ case Runtime::kDataViewSetFloat32:
+ case Runtime::kDataViewSetFloat64:
+ case Runtime::kDataViewGetInt8:
+ case Runtime::kDataViewGetUint8:
+ case Runtime::kDataViewGetInt16:
+ case Runtime::kDataViewGetUint16:
+ case Runtime::kDataViewGetInt32:
+ case Runtime::kDataViewGetUint32:
+ case Runtime::kDataViewGetFloat32:
+ case Runtime::kDataViewGetFloat64:
+ case Runtime::kDebugEvaluate:
+ case Runtime::kDebugEvaluateGlobal:
case Runtime::kDebugGetLoadedScripts:
+ case Runtime::kDebugGetPropertyDetails:
+ case Runtime::kDebugPromiseEvent:
+ case Runtime::kDefineAccessorPropertyUnchecked:
+ case Runtime::kDefineDataPropertyUnchecked:
+ case Runtime::kDeleteProperty:
case Runtime::kDeoptimizeFunction:
+ case Runtime::kFunctionBindArguments:
+ case Runtime::kGetDefaultReceiver:
+ case Runtime::kGetFrameCount:
+ case Runtime::kGetOwnProperty:
+ case Runtime::kGetOwnPropertyNames:
+ case Runtime::kGetPropertyNamesFast:
+ case Runtime::kGetPrototype:
+ case Runtime::kInlineArguments:
case Runtime::kInlineCallFunction:
+ case Runtime::kInlineDateField:
+ case Runtime::kInlineRegExpExec:
+ case Runtime::kInternalSetPrototype:
+ case Runtime::kInterrupt:
+ case Runtime::kIsPropertyEnumerable:
+ case Runtime::kIsSloppyModeFunction:
+ case Runtime::kLiveEditGatherCompileInfo:
+ case Runtime::kLoadLookupSlot:
+ case Runtime::kLoadLookupSlotNoReferenceError:
+ case Runtime::kMaterializeRegExpLiteral:
+ case Runtime::kNewObject:
+ case Runtime::kNewObjectFromBound:
+ case Runtime::kNewObjectWithAllocationSite:
+ case Runtime::kObjectFreeze:
+ case Runtime::kOwnKeys:
+ case Runtime::kParseJson:
case Runtime::kPrepareStep:
+ case Runtime::kPreventExtensions:
+ case Runtime::kPromiseRejectEvent:
+ case Runtime::kPromiseRevokeReject:
+ case Runtime::kRegExpCompile:
+ case Runtime::kRegExpExecMultiple:
+ case Runtime::kResolvePossiblyDirectEval:
+ case Runtime::kSetPrototype:
case Runtime::kSetScriptBreakPoint:
+ case Runtime::kSparseJoinWithSeparator:
case Runtime::kStackGuard:
- case Runtime::kCheckExecutionState:
- case Runtime::kDebugEvaluate:
- case Runtime::kCollectStackTrace:
+ case Runtime::kStoreKeyedToSuper_Sloppy:
+ case Runtime::kStoreKeyedToSuper_Strict:
+ case Runtime::kStoreToSuper_Sloppy:
+ case Runtime::kStoreToSuper_Strict:
+ case Runtime::kStoreLookupSlot:
+ case Runtime::kStringBuilderConcat:
+ case Runtime::kStringBuilderJoin:
+ case Runtime::kStringMatch:
+ case Runtime::kStringReplaceGlobalRegExpWithString:
+ case Runtime::kThrowNonMethodError:
+ case Runtime::kThrowNotDateError:
+ case Runtime::kThrowReferenceError:
+ case Runtime::kThrowUnsupportedSuperError:
+ case Runtime::kThrow:
+ case Runtime::kTypedArraySetFastCases:
+ case Runtime::kTypedArrayInitializeFromArrayLike:
+#ifdef V8_I18N_SUPPORT
+ case Runtime::kGetImplFromInitializedIntlObject:
+#endif
return true;
default:
return false;
// Provide unimplemented methods on unsupported architectures, to at least link.
//==============================================================================
#if !V8_TURBOFAN_BACKEND
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone) {
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
UNIMPLEMENTED();
return NULL;
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone) {
UNIMPLEMENTED();
return NULL;
#define V8_COMPILER_LINKAGE_H_
#include "src/base/flags.h"
-#include "src/code-stubs.h"
#include "src/compiler/frame.h"
#include "src/compiler/machine-type.h"
-#include "src/compiler/node.h"
#include "src/compiler/operator.h"
#include "src/zone.h"
namespace v8 {
namespace internal {
+
+class CallInterfaceDescriptor;
+
namespace compiler {
// Describes the location for a parameter or a return value to a call.
private:
friend class Linkage;
- Kind kind_;
- MachineType target_type_;
- LinkageLocation target_loc_;
- MachineSignature* machine_sig_;
- LocationSignature* location_sig_;
- size_t js_param_count_;
- Operator::Properties properties_;
- RegList callee_saved_registers_;
- Flags flags_;
- const char* debug_name_;
+ const Kind kind_;
+ const MachineType target_type_;
+ const LinkageLocation target_loc_;
+ const MachineSignature* const machine_sig_;
+ const LocationSignature* const location_sig_;
+ const size_t js_param_count_;
+ const Operator::Properties properties_;
+ const RegList callee_saved_registers_;
+ const Flags flags_;
+ const char* const debug_name_;
+
+ DISALLOW_COPY_AND_ASSIGN(CallDescriptor);
};
DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)
-OStream& operator<<(OStream& os, const CallDescriptor& d);
-OStream& operator<<(OStream& os, const CallDescriptor::Kind& k);
+std::ostream& operator<<(std::ostream& os, const CallDescriptor& d);
+std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k);
// Defines the linkage for a compilation, including the calling conventions
// for incoming parameters and return value(s) as well as the outgoing calling
// Call[Runtime] CEntryStub, arg 1, arg 2, arg 3, [...], fun, #arg, context
class Linkage : public ZoneObject {
public:
- explicit Linkage(CompilationInfo* info);
- explicit Linkage(CompilationInfo* info, CallDescriptor* incoming)
- : info_(info), incoming_(incoming) {}
+ Linkage(Zone* zone, CompilationInfo* info)
+ : zone_(zone), incoming_(ComputeIncoming(zone, info)) {}
+ Linkage(Zone* zone, CallDescriptor* incoming)
+ : zone_(zone), incoming_(incoming) {}
+
+ static CallDescriptor* ComputeIncoming(Zone* zone, CompilationInfo* info);
// The call descriptor for this compilation unit describes the locations
// of incoming parameters and the outgoing return value(s).
- CallDescriptor* GetIncomingDescriptor() { return incoming_; }
- CallDescriptor* GetJSCallDescriptor(int parameter_count);
- static CallDescriptor* GetJSCallDescriptor(int parameter_count, Zone* zone);
- CallDescriptor* GetRuntimeCallDescriptor(Runtime::FunctionId function,
- int parameter_count,
- Operator::Properties properties);
+ CallDescriptor* GetIncomingDescriptor() const { return incoming_; }
+ CallDescriptor* GetJSCallDescriptor(int parameter_count,
+ CallDescriptor::Flags flags) const;
+ static CallDescriptor* GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags);
+ CallDescriptor* GetRuntimeCallDescriptor(
+ Runtime::FunctionId function, int parameter_count,
+ Operator::Properties properties) const;
static CallDescriptor* GetRuntimeCallDescriptor(
Runtime::FunctionId function, int parameter_count,
Operator::Properties properties, Zone* zone);
CallDescriptor* GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count = 0,
- CallDescriptor::Flags flags = CallDescriptor::kNoFlags);
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count = 0,
+ CallDescriptor::Flags flags = CallDescriptor::kNoFlags) const;
static CallDescriptor* GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone);
// Creates a call descriptor for simplified C calls that is appropriate
MachineSignature* sig);
// Get the location of an (incoming) parameter to this function.
- LinkageLocation GetParameterLocation(int index) {
+ LinkageLocation GetParameterLocation(int index) const {
return incoming_->GetInputLocation(index + 1); // + 1 to skip target.
}
// Get the machine type of an (incoming) parameter to this function.
- MachineType GetParameterType(int index) {
+ MachineType GetParameterType(int index) const {
return incoming_->GetInputType(index + 1); // + 1 to skip target.
}
// Get the location where this function should place its return value.
- LinkageLocation GetReturnLocation() {
+ LinkageLocation GetReturnLocation() const {
return incoming_->GetReturnLocation(0);
}
// Get the machine type of this function's return value.
- MachineType GetReturnType() { return incoming_->GetReturnType(0); }
+ MachineType GetReturnType() const { return incoming_->GetReturnType(0); }
// Get the frame offset for a given spill slot. The location depends on the
// calling convention and the specific frame layout, and may thus be
// architecture-specific. Negative spill slots indicate arguments on the
// caller's frame. The {extra} parameter indicates an additional offset from
// the frame offset, e.g. to index into part of a double slot.
- FrameOffset GetFrameOffset(int spill_slot, Frame* frame, int extra = 0);
-
- CompilationInfo* info() const { return info_; }
+ FrameOffset GetFrameOffset(int spill_slot, Frame* frame, int extra = 0) const;
static bool NeedsFrameState(Runtime::FunctionId function);
private:
- CompilationInfo* info_;
- CallDescriptor* incoming_;
+ Zone* const zone_;
+ CallDescriptor* const incoming_;
+
+ DISALLOW_COPY_AND_ASSIGN(Linkage);
};
} // namespace compiler
+++ /dev/null
-// 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/base/bits.h"
-#include "src/compiler/graph-unittest.h"
-#include "src/compiler/js-graph.h"
-#include "src/compiler/machine-operator-reducer.h"
-#include "src/compiler/typer.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class MachineOperatorReducerTest : public GraphTest {
- public:
- explicit MachineOperatorReducerTest(int num_parameters = 2)
- : GraphTest(num_parameters) {}
-
- protected:
- Reduction Reduce(Node* node) {
- Typer typer(zone());
- JSOperatorBuilder javascript(zone());
- JSGraph jsgraph(graph(), common(), &javascript, &typer, &machine_);
- MachineOperatorReducer reducer(&jsgraph);
- return reducer.Reduce(node);
- }
-
- MachineOperatorBuilder* machine() { return &machine_; }
-
- private:
- MachineOperatorBuilder machine_;
-};
-
-
-template <typename T>
-class MachineOperatorReducerTestWithParam
- : public MachineOperatorReducerTest,
- public ::testing::WithParamInterface<T> {
- public:
- explicit MachineOperatorReducerTestWithParam(int num_parameters = 2)
- : MachineOperatorReducerTest(num_parameters) {}
- virtual ~MachineOperatorReducerTestWithParam() {}
-};
-
-
-namespace {
-
-static const float kFloat32Values[] = {
- -std::numeric_limits<float>::infinity(), -2.70497e+38f, -1.4698e+37f,
- -1.22813e+35f, -1.20555e+35f, -1.34584e+34f,
- -1.0079e+32f, -6.49364e+26f, -3.06077e+25f,
- -1.46821e+25f, -1.17658e+23f, -1.9617e+22f,
- -2.7357e+20f, -1.48708e+13f, -1.89633e+12f,
- -4.66622e+11f, -2.22581e+11f, -1.45381e+10f,
- -1.3956e+09f, -1.32951e+09f, -1.30721e+09f,
- -1.19756e+09f, -9.26822e+08f, -6.35647e+08f,
- -4.00037e+08f, -1.81227e+08f, -5.09256e+07f,
- -964300.0f, -192446.0f, -28455.0f,
- -27194.0f, -26401.0f, -20575.0f,
- -17069.0f, -9167.0f, -960.178f,
- -113.0f, -62.0f, -15.0f,
- -7.0f, -0.0256635f, -4.60374e-07f,
- -3.63759e-10f, -4.30175e-14f, -5.27385e-15f,
- -1.48084e-15f, -1.05755e-19f, -3.2995e-21f,
- -1.67354e-23f, -1.11885e-23f, -1.78506e-30f,
- -5.07594e-31f, -3.65799e-31f, -1.43718e-34f,
- -1.27126e-38f, -0.0f, 0.0f,
- 1.17549e-38f, 1.56657e-37f, 4.08512e-29f,
- 3.31357e-28f, 6.25073e-22f, 4.1723e-13f,
- 1.44343e-09f, 5.27004e-08f, 9.48298e-08f,
- 5.57888e-07f, 4.89988e-05f, 0.244326f,
- 12.4895f, 19.0f, 47.0f,
- 106.0f, 538.324f, 564.536f,
- 819.124f, 7048.0f, 12611.0f,
- 19878.0f, 20309.0f, 797056.0f,
- 1.77219e+09f, 1.51116e+11f, 4.18193e+13f,
- 3.59167e+16f, 3.38211e+19f, 2.67488e+20f,
- 1.78831e+21f, 9.20914e+21f, 8.35654e+23f,
- 1.4495e+24f, 5.94015e+25f, 4.43608e+30f,
- 2.44502e+33f, 2.61152e+33f, 1.38178e+37f,
- 1.71306e+37f, 3.31899e+38f, 3.40282e+38f,
- std::numeric_limits<float>::infinity()};
-
-
-static const double kFloat64Values[] = {
- -V8_INFINITY, -4.23878e+275, -5.82632e+265, -6.60355e+220, -6.26172e+212,
- -2.56222e+211, -4.82408e+201, -1.84106e+157, -1.63662e+127, -1.55772e+100,
- -1.67813e+72, -2.3382e+55, -3.179e+30, -1.441e+09, -1.0647e+09,
- -7.99361e+08, -5.77375e+08, -2.20984e+08, -32757, -13171,
- -9970, -3984, -107, -105, -92,
- -77, -61, -0.000208163, -1.86685e-06, -1.17296e-10,
- -9.26358e-11, -5.08004e-60, -1.74753e-65, -1.06561e-71, -5.67879e-79,
- -5.78459e-130, -2.90989e-171, -7.15489e-243, -3.76242e-252, -1.05639e-263,
- -4.40497e-267, -2.19666e-273, -4.9998e-276, -5.59821e-278, -2.03855e-282,
- -5.99335e-283, -7.17554e-284, -3.11744e-309, -0.0, 0.0,
- 2.22507e-308, 1.30127e-270, 7.62898e-260, 4.00313e-249, 3.16829e-233,
- 1.85244e-228, 2.03544e-129, 1.35126e-110, 1.01182e-106, 5.26333e-94,
- 1.35292e-90, 2.85394e-83, 1.78323e-77, 5.4967e-57, 1.03207e-25,
- 4.57401e-25, 1.58738e-05, 2, 125, 2310,
- 9636, 14802, 17168, 28945, 29305,
- 4.81336e+07, 1.41207e+08, 4.65962e+08, 1.40499e+09, 2.12648e+09,
- 8.80006e+30, 1.4446e+45, 1.12164e+54, 2.48188e+89, 6.71121e+102,
- 3.074e+112, 4.9699e+152, 5.58383e+166, 4.30654e+172, 7.08824e+185,
- 9.6586e+214, 2.028e+223, 6.63277e+243, 1.56192e+261, 1.23202e+269,
- 5.72883e+289, 8.5798e+290, 1.40256e+294, 1.79769e+308, V8_INFINITY};
-
-
-static const int32_t kInt32Values[] = {
- -2147483647 - 1, -1914954528, -1698749618, -1578693386, -1577976073,
- -1573998034, -1529085059, -1499540537, -1299205097, -1090814845,
- -938186388, -806828902, -750927650, -520676892, -513661538,
- -453036354, -433622833, -282638793, -28375, -27788,
- -22770, -18806, -14173, -11956, -11200,
- -10212, -8160, -3751, -2758, -1522,
- -121, -120, -118, -117, -106,
- -84, -80, -74, -59, -52,
- -48, -39, -35, -17, -11,
- -10, -9, -7, -5, 0,
- 9, 12, 17, 23, 29,
- 31, 33, 35, 40, 47,
- 55, 56, 62, 64, 67,
- 68, 69, 74, 79, 84,
- 89, 90, 97, 104, 118,
- 124, 126, 127, 7278, 17787,
- 24136, 24202, 25570, 26680, 30242,
- 32399, 420886487, 642166225, 821912648, 822577803,
- 851385718, 1212241078, 1411419304, 1589626102, 1596437184,
- 1876245816, 1954730266, 2008792749, 2045320228, 2147483647};
-
-
-static const int64_t kInt64Values[] = {
- V8_INT64_C(-9223372036854775807) - 1, V8_INT64_C(-8974392461363618006),
- V8_INT64_C(-8874367046689588135), V8_INT64_C(-8269197512118230839),
- V8_INT64_C(-8146091527100606733), V8_INT64_C(-7550917981466150848),
- V8_INT64_C(-7216590251577894337), V8_INT64_C(-6464086891160048440),
- V8_INT64_C(-6365616494908257190), V8_INT64_C(-6305630541365849726),
- V8_INT64_C(-5982222642272245453), V8_INT64_C(-5510103099058504169),
- V8_INT64_C(-5496838675802432701), V8_INT64_C(-4047626578868642657),
- V8_INT64_C(-4033755046900164544), V8_INT64_C(-3554299241457877041),
- V8_INT64_C(-2482258764588614470), V8_INT64_C(-1688515425526875335),
- V8_INT64_C(-924784137176548532), V8_INT64_C(-725316567157391307),
- V8_INT64_C(-439022654781092241), V8_INT64_C(-105545757668917080),
- V8_INT64_C(-2088319373), V8_INT64_C(-2073699916),
- V8_INT64_C(-1844949911), V8_INT64_C(-1831090548),
- V8_INT64_C(-1756711933), V8_INT64_C(-1559409497),
- V8_INT64_C(-1281179700), V8_INT64_C(-1211513985),
- V8_INT64_C(-1182371520), V8_INT64_C(-785934753),
- V8_INT64_C(-767480697), V8_INT64_C(-705745662),
- V8_INT64_C(-514362436), V8_INT64_C(-459916580),
- V8_INT64_C(-312328082), V8_INT64_C(-302949707),
- V8_INT64_C(-285499304), V8_INT64_C(-125701262),
- V8_INT64_C(-95139843), V8_INT64_C(-32768),
- V8_INT64_C(-27542), V8_INT64_C(-23600),
- V8_INT64_C(-18582), V8_INT64_C(-17770),
- V8_INT64_C(-9086), V8_INT64_C(-9010),
- V8_INT64_C(-8244), V8_INT64_C(-2890),
- V8_INT64_C(-103), V8_INT64_C(-34),
- V8_INT64_C(-27), V8_INT64_C(-25),
- V8_INT64_C(-9), V8_INT64_C(-7),
- V8_INT64_C(0), V8_INT64_C(2),
- V8_INT64_C(38), V8_INT64_C(58),
- V8_INT64_C(65), V8_INT64_C(93),
- V8_INT64_C(111), V8_INT64_C(1003),
- V8_INT64_C(1267), V8_INT64_C(12797),
- V8_INT64_C(23122), V8_INT64_C(28200),
- V8_INT64_C(30888), V8_INT64_C(42648848),
- V8_INT64_C(116836693), V8_INT64_C(263003643),
- V8_INT64_C(571039860), V8_INT64_C(1079398689),
- V8_INT64_C(1145196402), V8_INT64_C(1184846321),
- V8_INT64_C(1758281648), V8_INT64_C(1859991374),
- V8_INT64_C(1960251588), V8_INT64_C(2042443199),
- V8_INT64_C(296220586027987448), V8_INT64_C(1015494173071134726),
- V8_INT64_C(1151237951914455318), V8_INT64_C(1331941174616854174),
- V8_INT64_C(2022020418667972654), V8_INT64_C(2450251424374977035),
- V8_INT64_C(3668393562685561486), V8_INT64_C(4858229301215502171),
- V8_INT64_C(4919426235170669383), V8_INT64_C(5034286595330341762),
- V8_INT64_C(5055797915536941182), V8_INT64_C(6072389716149252074),
- V8_INT64_C(6185309910199801210), V8_INT64_C(6297328311011094138),
- V8_INT64_C(6932372858072165827), V8_INT64_C(8483640924987737210),
- V8_INT64_C(8663764179455849203), V8_INT64_C(8877197042645298254),
- V8_INT64_C(8901543506779157333), V8_INT64_C(9223372036854775807)};
-
-
-static const uint32_t kUint32Values[] = {
- 0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
- 0x273a798e, 0x187937a3, 0xece3af83, 0x5495a16b, 0x0b668ecc, 0x11223344,
- 0x0000009e, 0x00000043, 0x0000af73, 0x0000116b, 0x00658ecc, 0x002b3b4c,
- 0x88776655, 0x70000000, 0x07200000, 0x7fffffff, 0x56123761, 0x7fffff00,
- 0x761c4761, 0x80000000, 0x88888888, 0xa0000000, 0xdddddddd, 0xe0000000,
- 0xeeeeeeee, 0xfffffffd, 0xf0000000, 0x007fffff, 0x003fffff, 0x001fffff,
- 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff,
- 0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff};
-
-} // namespace
-
-
-// -----------------------------------------------------------------------------
-// Unary operators
-
-
-namespace {
-
-struct UnaryOperator {
- const Operator* (MachineOperatorBuilder::*constructor)();
- const char* constructor_name;
-};
-
-
-std::ostream& operator<<(std::ostream& os, const UnaryOperator& unop) {
- return os << unop.constructor_name;
-}
-
-
-static const UnaryOperator kUnaryOperators[] = {
- {&MachineOperatorBuilder::ChangeInt32ToFloat64, "ChangeInt32ToFloat64"},
- {&MachineOperatorBuilder::ChangeUint32ToFloat64, "ChangeUint32ToFloat64"},
- {&MachineOperatorBuilder::ChangeFloat64ToInt32, "ChangeFloat64ToInt32"},
- {&MachineOperatorBuilder::ChangeFloat64ToUint32, "ChangeFloat64ToUint32"},
- {&MachineOperatorBuilder::ChangeInt32ToInt64, "ChangeInt32ToInt64"},
- {&MachineOperatorBuilder::ChangeUint32ToUint64, "ChangeUint32ToUint64"},
- {&MachineOperatorBuilder::TruncateFloat64ToInt32, "TruncateFloat64ToInt32"},
- {&MachineOperatorBuilder::TruncateInt64ToInt32, "TruncateInt64ToInt32"}};
-
-} // namespace
-
-
-typedef MachineOperatorReducerTestWithParam<UnaryOperator>
- MachineUnaryOperatorReducerTest;
-
-
-TEST_P(MachineUnaryOperatorReducerTest, Parameter) {
- const UnaryOperator unop = GetParam();
- Reduction reduction =
- Reduce(graph()->NewNode((machine()->*unop.constructor)(), Parameter(0)));
- EXPECT_FALSE(reduction.Changed());
-}
-
-
-INSTANTIATE_TEST_CASE_P(MachineOperatorReducerTest,
- MachineUnaryOperatorReducerTest,
- ::testing::ValuesIn(kUnaryOperators));
-
-
-// -----------------------------------------------------------------------------
-// ChangeFloat64ToFloat32
-
-
-TEST_F(MachineOperatorReducerTest, ChangeFloat64ToFloat32WithConstant) {
- TRACED_FOREACH(float, x, kFloat32Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->ChangeFloat32ToFloat64(), Float32Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsFloat64Constant(x));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeFloat64ToInt32
-
-
-TEST_F(MachineOperatorReducerTest,
- ChangeFloat64ToInt32WithChangeInt32ToFloat64) {
- Node* value = Parameter(0);
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->ChangeFloat64ToInt32(),
- graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_EQ(value, reduction.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, ChangeFloat64ToInt32WithConstant) {
- TRACED_FOREACH(int32_t, x, kInt32Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->ChangeFloat64ToInt32(), Float64Constant(FastI2D(x))));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(x));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeFloat64ToUint32
-
-
-TEST_F(MachineOperatorReducerTest,
- ChangeFloat64ToUint32WithChangeUint32ToFloat64) {
- Node* value = Parameter(0);
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->ChangeFloat64ToUint32(),
- graph()->NewNode(machine()->ChangeUint32ToFloat64(), value)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_EQ(value, reduction.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, ChangeFloat64ToUint32WithConstant) {
- TRACED_FOREACH(uint32_t, x, kUint32Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->ChangeFloat64ToUint32(), Float64Constant(FastUI2D(x))));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(bit_cast<int32_t>(x)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeInt32ToFloat64
-
-
-TEST_F(MachineOperatorReducerTest, ChangeInt32ToFloat64WithConstant) {
- TRACED_FOREACH(int32_t, x, kInt32Values) {
- Reduction reduction = Reduce(
- graph()->NewNode(machine()->ChangeInt32ToFloat64(), Int32Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastI2D(x)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeInt32ToInt64
-
-
-TEST_F(MachineOperatorReducerTest, ChangeInt32ToInt64WithConstant) {
- TRACED_FOREACH(int32_t, x, kInt32Values) {
- Reduction reduction = Reduce(
- graph()->NewNode(machine()->ChangeInt32ToInt64(), Int32Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt64Constant(x));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeUint32ToFloat64
-
-
-TEST_F(MachineOperatorReducerTest, ChangeUint32ToFloat64WithConstant) {
- TRACED_FOREACH(uint32_t, x, kUint32Values) {
- Reduction reduction =
- Reduce(graph()->NewNode(machine()->ChangeUint32ToFloat64(),
- Int32Constant(bit_cast<int32_t>(x))));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastUI2D(x)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// ChangeUint32ToUint64
-
-
-TEST_F(MachineOperatorReducerTest, ChangeUint32ToUint64WithConstant) {
- TRACED_FOREACH(uint32_t, x, kUint32Values) {
- Reduction reduction =
- Reduce(graph()->NewNode(machine()->ChangeUint32ToUint64(),
- Int32Constant(bit_cast<int32_t>(x))));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsInt64Constant(bit_cast<int64_t>(static_cast<uint64_t>(x))));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// TruncateFloat64ToFloat32
-
-
-TEST_F(MachineOperatorReducerTest,
- TruncateFloat64ToFloat32WithChangeFloat32ToFloat64) {
- Node* value = Parameter(0);
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->TruncateFloat64ToFloat32(),
- graph()->NewNode(machine()->ChangeFloat32ToFloat64(), value)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_EQ(value, reduction.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, TruncateFloat64ToFloat32WithConstant) {
- TRACED_FOREACH(double, x, kFloat64Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->TruncateFloat64ToFloat32(), Float64Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsFloat32Constant(DoubleToFloat32(x)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// TruncateFloat64ToInt32
-
-
-TEST_F(MachineOperatorReducerTest,
- TruncateFloat64ToInt32WithChangeInt32ToFloat64) {
- Node* value = Parameter(0);
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->TruncateFloat64ToInt32(),
- graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_EQ(value, reduction.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, TruncateFloat64ToInt32WithConstant) {
- TRACED_FOREACH(double, x, kFloat64Values) {
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->TruncateFloat64ToInt32(), Float64Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(x)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// TruncateInt64ToInt32
-
-
-TEST_F(MachineOperatorReducerTest, TruncateInt64ToInt32WithChangeInt32ToInt64) {
- Node* value = Parameter(0);
- Reduction reduction = Reduce(graph()->NewNode(
- machine()->TruncateInt64ToInt32(),
- graph()->NewNode(machine()->ChangeInt32ToInt64(), value)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_EQ(value, reduction.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, TruncateInt64ToInt32WithConstant) {
- TRACED_FOREACH(int64_t, x, kInt64Values) {
- Reduction reduction = Reduce(
- graph()->NewNode(machine()->TruncateInt64ToInt32(), Int64Constant(x)));
- ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsInt32Constant(bit_cast<int32_t>(
- static_cast<uint32_t>(bit_cast<uint64_t>(x)))));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Word32Ror
-
-
-TEST_F(MachineOperatorReducerTest, ReduceToWord32RorWithParameters) {
- Node* value = Parameter(0);
- Node* shift = Parameter(1);
- Node* shl = graph()->NewNode(machine()->Word32Shl(), value, shift);
- Node* shr = graph()->NewNode(
- machine()->Word32Shr(), value,
- graph()->NewNode(machine()->Int32Sub(), Int32Constant(32), shift));
-
- // (x << y) | (x >> (32 - y)) => x ror y
- Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
- Reduction reduction1 = Reduce(node1);
- EXPECT_TRUE(reduction1.Changed());
- EXPECT_EQ(reduction1.replacement(), node1);
- EXPECT_THAT(reduction1.replacement(), IsWord32Ror(value, shift));
-
- // (x >> (32 - y)) | (x << y) => x ror y
- Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
- Reduction reduction2 = Reduce(node2);
- EXPECT_TRUE(reduction2.Changed());
- EXPECT_EQ(reduction2.replacement(), node2);
- EXPECT_THAT(reduction2.replacement(), IsWord32Ror(value, shift));
-}
-
-
-TEST_F(MachineOperatorReducerTest, ReduceToWord32RorWithConstant) {
- Node* value = Parameter(0);
- TRACED_FORRANGE(int32_t, k, 0, 31) {
- Node* shl =
- graph()->NewNode(machine()->Word32Shl(), value, Int32Constant(k));
- Node* shr =
- graph()->NewNode(machine()->Word32Shr(), value, Int32Constant(32 - k));
-
- // (x << K) | (x >> ((32 - K) - y)) => x ror K
- Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
- Reduction reduction1 = Reduce(node1);
- EXPECT_TRUE(reduction1.Changed());
- EXPECT_EQ(reduction1.replacement(), node1);
- EXPECT_THAT(reduction1.replacement(),
- IsWord32Ror(value, IsInt32Constant(k)));
-
- // (x >> (32 - K)) | (x << K) => x ror K
- Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
- Reduction reduction2 = Reduce(node2);
- EXPECT_TRUE(reduction2.Changed());
- EXPECT_EQ(reduction2.replacement(), node2);
- EXPECT_THAT(reduction2.replacement(),
- IsWord32Ror(value, IsInt32Constant(k)));
- }
-}
-
-
-TEST_F(MachineOperatorReducerTest, Word32RorWithZeroShift) {
- Node* value = Parameter(0);
- Node* node =
- graph()->NewNode(machine()->Word32Ror(), value, Int32Constant(0));
- Reduction reduction = Reduce(node);
- EXPECT_TRUE(reduction.Changed());
- EXPECT_EQ(reduction.replacement(), value);
-}
-
-
-TEST_F(MachineOperatorReducerTest, Word32RorWithConstants) {
- TRACED_FOREACH(int32_t, x, kUint32Values) {
- TRACED_FORRANGE(int32_t, y, 0, 31) {
- Node* node = graph()->NewNode(machine()->Word32Ror(), Int32Constant(x),
- Int32Constant(y));
- Reduction reduction = Reduce(node);
- EXPECT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsInt32Constant(base::bits::RotateRight32(x, y)));
- }
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Word32Shl
-
-
-TEST_F(MachineOperatorReducerTest, Word32ShlWithZeroShift) {
- Node* p0 = Parameter(0);
- Node* node = graph()->NewNode(machine()->Word32Shl(), p0, Int32Constant(0));
- Reduction r = Reduce(node);
- ASSERT_TRUE(r.Changed());
- EXPECT_EQ(p0, r.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, Word32ShlWithWord32Sar) {
- Node* p0 = Parameter(0);
- TRACED_FORRANGE(int32_t, x, 1, 31) {
- Node* node = graph()->NewNode(
- machine()->Word32Shl(),
- graph()->NewNode(machine()->Word32Sar(), p0, Int32Constant(x)),
- Int32Constant(x));
- Reduction r = Reduce(node);
- ASSERT_TRUE(r.Changed());
- int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
- EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
- }
-}
-
-
-TEST_F(MachineOperatorReducerTest, Word32ShlWithWord32Shr) {
- Node* p0 = Parameter(0);
- TRACED_FORRANGE(int32_t, x, 1, 31) {
- Node* node = graph()->NewNode(
- machine()->Word32Shl(),
- graph()->NewNode(machine()->Word32Shr(), p0, Int32Constant(x)),
- Int32Constant(x));
- Reduction r = Reduce(node);
- ASSERT_TRUE(r.Changed());
- int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
- EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Int32AddWithOverflow
-
-
-TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithZero) {
- Node* p0 = Parameter(0);
- {
- Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
- Int32Constant(0), p0);
-
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Constant(0));
-
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_EQ(p0, r.replacement());
- }
- {
- Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), p0,
- Int32Constant(0));
-
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Constant(0));
-
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_EQ(p0, r.replacement());
- }
-}
-
-
-TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithConstant) {
- 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));
-
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(),
- IsInt32Constant(base::bits::SignedAddOverflow32(x, y, &z)));
-
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Constant(z));
- }
- }
-}
-
-
-// -----------------------------------------------------------------------------
-// Int32SubWithOverflow
-
-
-TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithZero) {
- Node* p0 = Parameter(0);
- Node* add =
- graph()->NewNode(machine()->Int32SubWithOverflow(), p0, Int32Constant(0));
-
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Constant(0));
-
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_EQ(p0, r.replacement());
-}
-
-
-TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithConstant) {
- 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));
-
- Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(),
- IsInt32Constant(base::bits::SignedSubOverflow32(x, y, &z)));
-
- r = Reduce(graph()->NewNode(common()->Projection(0), add));
- ASSERT_TRUE(r.Changed());
- EXPECT_THAT(r.replacement(), IsInt32Constant(z));
- }
- }
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
#include "src/compiler/machine-operator-reducer.h"
#include "src/base/bits.h"
+#include "src/base/division-by-constant.h"
+#include "src/codegen.h"
+#include "src/compiler/diamond.h"
#include "src/compiler/generic-node-inl.h"
#include "src/compiler/graph.h"
#include "src/compiler/js-graph.h"
}
+Node* MachineOperatorReducer::Word32And(Node* lhs, uint32_t rhs) {
+ return graph()->NewNode(machine()->Word32And(), lhs, Uint32Constant(rhs));
+}
+
+
+Node* MachineOperatorReducer::Word32Sar(Node* lhs, uint32_t rhs) {
+ if (rhs == 0) return lhs;
+ return graph()->NewNode(machine()->Word32Sar(), lhs, Uint32Constant(rhs));
+}
+
+
+Node* MachineOperatorReducer::Word32Shr(Node* lhs, uint32_t rhs) {
+ if (rhs == 0) return lhs;
+ return graph()->NewNode(machine()->Word32Shr(), lhs, Uint32Constant(rhs));
+}
+
+
+Node* MachineOperatorReducer::Word32Equal(Node* lhs, Node* rhs) {
+ return graph()->NewNode(machine()->Word32Equal(), lhs, rhs);
+}
+
+
+Node* MachineOperatorReducer::Int32Add(Node* lhs, Node* rhs) {
+ return graph()->NewNode(machine()->Int32Add(), lhs, rhs);
+}
+
+
+Node* MachineOperatorReducer::Int32Sub(Node* lhs, Node* rhs) {
+ return graph()->NewNode(machine()->Int32Sub(), lhs, rhs);
+}
+
+
+Node* MachineOperatorReducer::Int32Mul(Node* lhs, Node* rhs) {
+ return graph()->NewNode(machine()->Int32Mul(), lhs, rhs);
+}
+
+
+Node* MachineOperatorReducer::Int32Div(Node* dividend, int32_t divisor) {
+ DCHECK_NE(0, divisor);
+ DCHECK_NE(std::numeric_limits<int32_t>::min(), divisor);
+ base::MagicNumbersForDivision<uint32_t> const mag =
+ base::SignedDivisionByConstant(bit_cast<uint32_t>(divisor));
+ Node* quotient = graph()->NewNode(machine()->Int32MulHigh(), dividend,
+ Uint32Constant(mag.multiplier));
+ if (divisor > 0 && bit_cast<int32_t>(mag.multiplier) < 0) {
+ quotient = Int32Add(quotient, dividend);
+ } else if (divisor < 0 && bit_cast<int32_t>(mag.multiplier) > 0) {
+ quotient = Int32Sub(quotient, dividend);
+ }
+ return Int32Add(Word32Sar(quotient, mag.shift), Word32Shr(dividend, 31));
+}
+
+
+Node* MachineOperatorReducer::Uint32Div(Node* dividend, uint32_t divisor) {
+ DCHECK_LT(0, divisor);
+ base::MagicNumbersForDivision<uint32_t> const mag =
+ base::UnsignedDivisionByConstant(bit_cast<uint32_t>(divisor));
+ Node* quotient = graph()->NewNode(machine()->Uint32MulHigh(), dividend,
+ Uint32Constant(mag.multiplier));
+ if (mag.add) {
+ DCHECK_LE(1, mag.shift);
+ quotient = Word32Shr(
+ Int32Add(Word32Shr(Int32Sub(dividend, quotient), 1), quotient),
+ mag.shift - 1);
+ } else {
+ quotient = Word32Shr(quotient, mag.shift);
+ }
+ return quotient;
+}
+
+
// Perform constant folding and strength reduction on machine operators.
Reduction MachineOperatorReducer::Reduce(Node* node) {
switch (node->opcode()) {
return ReplaceInt32(m.left().Value() & m.right().Value());
}
if (m.LeftEqualsRight()) return Replace(m.left().node()); // x & x => x
+ if (m.left().IsWord32And() && m.right().HasValue()) {
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().HasValue()) { // (x & K) & K => x & K
+ node->ReplaceInput(0, mleft.left().node());
+ node->ReplaceInput(
+ 1, Int32Constant(m.right().Value() & mleft.right().Value()));
+ return Changed(node);
+ }
+ }
break;
}
case IrOpcode::kWord32Or: {
return ReplaceInt32(m.left().Value() ^ m.right().Value());
}
if (m.LeftEqualsRight()) return ReplaceInt32(0); // x ^ x => 0
+ if (m.left().IsWord32Xor() && m.right().Is(-1)) {
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().Is(-1)) { // (x ^ -1) ^ -1 => x
+ return Replace(mleft.left().node());
+ }
+ }
break;
}
case IrOpcode::kWord32Shl: {
if (m.LeftEqualsRight()) return ReplaceBool(true); // x == x => true
break;
}
+ case IrOpcode::kWord64Equal: {
+ Int64BinopMatcher m(node);
+ if (m.IsFoldable()) { // K == K => K
+ return ReplaceBool(m.left().Value() == m.right().Value());
+ }
+ if (m.left().IsInt64Sub() && m.right().Is(0)) { // x - y == 0 => x == y
+ Int64BinopMatcher msub(m.left().node());
+ node->ReplaceInput(0, msub.left().node());
+ node->ReplaceInput(1, msub.right().node());
+ return Changed(node);
+ }
+ // TODO(turbofan): fold HeapConstant, ExternalReference, pointer compares
+ if (m.LeftEqualsRight()) return ReplaceBool(true); // x == x => true
+ break;
+ }
case IrOpcode::kInt32Add: {
Int32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node()); // x + 0 => x
}
break;
}
- case IrOpcode::kInt32Div: {
- Int32BinopMatcher m(node);
- if (m.right().Is(1)) return Replace(m.left().node()); // x / 1 => x
- // TODO(turbofan): if (m.left().Is(0))
- // TODO(turbofan): if (m.right().IsPowerOf2())
- // TODO(turbofan): if (m.right().Is(0))
- // TODO(turbofan): if (m.LeftEqualsRight())
- if (m.IsFoldable() && !m.right().Is(0)) { // K / K => K
- if (m.right().Is(-1)) return ReplaceInt32(-m.left().Value());
- return ReplaceInt32(m.left().Value() / m.right().Value());
- }
- if (m.right().Is(-1)) { // x / -1 => 0 - x
- node->set_op(machine()->Int32Sub());
- node->ReplaceInput(0, Int32Constant(0));
- node->ReplaceInput(1, m.left().node());
- return Changed(node);
- }
- break;
- }
- case IrOpcode::kInt32UDiv: {
- Uint32BinopMatcher m(node);
- if (m.right().Is(1)) return Replace(m.left().node()); // x / 1 => x
- // TODO(turbofan): if (m.left().Is(0))
- // TODO(turbofan): if (m.right().Is(0))
- // TODO(turbofan): if (m.LeftEqualsRight())
- if (m.IsFoldable() && !m.right().Is(0)) { // K / K => K
- return ReplaceInt32(m.left().Value() / m.right().Value());
- }
- if (m.right().IsPowerOf2()) { // x / 2^n => x >> n
- node->set_op(machine()->Word32Shr());
- node->ReplaceInput(1, Int32Constant(WhichPowerOf2(m.right().Value())));
- return Changed(node);
- }
- break;
- }
- case IrOpcode::kInt32Mod: {
- Int32BinopMatcher m(node);
- if (m.right().Is(1)) return ReplaceInt32(0); // x % 1 => 0
- if (m.right().Is(-1)) return ReplaceInt32(0); // x % -1 => 0
- // TODO(turbofan): if (m.left().Is(0))
- // TODO(turbofan): if (m.right().IsPowerOf2())
- // TODO(turbofan): if (m.right().Is(0))
- // TODO(turbofan): if (m.LeftEqualsRight())
- if (m.IsFoldable() && !m.right().Is(0)) { // K % K => K
- return ReplaceInt32(m.left().Value() % m.right().Value());
- }
- break;
- }
- case IrOpcode::kInt32UMod: {
- Uint32BinopMatcher m(node);
- if (m.right().Is(1)) return ReplaceInt32(0); // x % 1 => 0
- // TODO(turbofan): if (m.left().Is(0))
- // TODO(turbofan): if (m.right().Is(0))
- // TODO(turbofan): if (m.LeftEqualsRight())
- if (m.IsFoldable() && !m.right().Is(0)) { // K % K => K
- return ReplaceInt32(m.left().Value() % m.right().Value());
- }
- if (m.right().IsPowerOf2()) { // x % 2^n => x & 2^n-1
- node->set_op(machine()->Word32And());
- node->ReplaceInput(1, Int32Constant(m.right().Value() - 1));
- return Changed(node);
- }
- break;
- }
+ case IrOpcode::kInt32Div:
+ return ReduceInt32Div(node);
+ case IrOpcode::kUint32Div:
+ return ReduceUint32Div(node);
+ case IrOpcode::kInt32Mod:
+ return ReduceInt32Mod(node);
+ case IrOpcode::kUint32Mod:
+ return ReduceUint32Mod(node);
case IrOpcode::kInt32LessThan: {
Int32BinopMatcher m(node);
if (m.IsFoldable()) { // K < K => K
return ReplaceBool(m.left().Value() < m.right().Value());
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
+ if (m.left().IsWord32Sar() && m.right().HasValue()) {
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().HasValue()) {
+ // (x >> K) < C => x < (C << K)
+ // when C < (M >> K)
+ const uint32_t c = m.right().Value();
+ const uint32_t k = mleft.right().Value() & 0x1f;
+ if (c < static_cast<uint32_t>(kMaxInt >> k)) {
+ node->ReplaceInput(0, mleft.left().node());
+ node->ReplaceInput(1, Uint32Constant(c << k));
+ return Changed(node);
+ }
+ // TODO(turbofan): else the comparison is always true.
+ }
+ }
break;
}
case IrOpcode::kUint32LessThanOrEqual: {
}
case IrOpcode::kFloat64Mul: {
Float64BinopMatcher m(node);
+ if (m.right().Is(-1)) { // x * -1.0 => -0.0 - x
+ node->set_op(machine()->Float64Sub());
+ node->ReplaceInput(0, Float64Constant(-0.0));
+ node->ReplaceInput(1, m.left().node());
+ return Changed(node);
+ }
if (m.right().Is(1)) return Replace(m.left().node()); // x * 1.0 => x
if (m.right().IsNaN()) { // x * NaN => NaN
return Replace(m.right().node());
if (m.HasValue()) return ReplaceInt64(static_cast<uint64_t>(m.Value()));
break;
}
- case IrOpcode::kTruncateFloat64ToInt32: {
- Float64Matcher m(node->InputAt(0));
- if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
- if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
- break;
- }
+ case IrOpcode::kTruncateFloat64ToInt32:
+ return ReduceTruncateFloat64ToInt32(node);
case IrOpcode::kTruncateInt64ToInt32: {
Int64Matcher m(node->InputAt(0));
if (m.HasValue()) return ReplaceInt32(static_cast<int32_t>(m.Value()));
if (m.IsChangeFloat32ToFloat64()) return Replace(m.node()->InputAt(0));
break;
}
+ case IrOpcode::kStore:
+ return ReduceStore(node);
+ default:
+ break;
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceInt32Div(Node* node) {
+ Int32BinopMatcher m(node);
+ if (m.left().Is(0)) return Replace(m.left().node()); // 0 / x => 0
+ if (m.right().Is(0)) return Replace(m.right().node()); // x / 0 => 0
+ if (m.right().Is(1)) return Replace(m.left().node()); // x / 1 => x
+ if (m.IsFoldable()) { // K / K => K
+ return ReplaceInt32(
+ base::bits::SignedDiv32(m.left().Value(), m.right().Value()));
+ }
+ if (m.LeftEqualsRight()) { // x / x => x != 0
+ Node* const zero = Int32Constant(0);
+ return Replace(Word32Equal(Word32Equal(m.left().node(), zero), zero));
+ }
+ if (m.right().Is(-1)) { // x / -1 => 0 - x
+ node->set_op(machine()->Int32Sub());
+ node->ReplaceInput(0, Int32Constant(0));
+ node->ReplaceInput(1, m.left().node());
+ node->TrimInputCount(2);
+ return Changed(node);
+ }
+ if (m.right().HasValue()) {
+ int32_t const divisor = m.right().Value();
+ Node* const dividend = m.left().node();
+ Node* quotient = dividend;
+ if (base::bits::IsPowerOfTwo32(Abs(divisor))) {
+ uint32_t const shift = WhichPowerOf2Abs(divisor);
+ DCHECK_NE(0, shift);
+ if (shift > 1) {
+ quotient = Word32Sar(quotient, 31);
+ }
+ quotient = Int32Add(Word32Shr(quotient, 32u - shift), dividend);
+ quotient = Word32Sar(quotient, shift);
+ } else {
+ quotient = Int32Div(quotient, Abs(divisor));
+ }
+ if (divisor < 0) {
+ node->set_op(machine()->Int32Sub());
+ node->ReplaceInput(0, Int32Constant(0));
+ node->ReplaceInput(1, quotient);
+ node->TrimInputCount(2);
+ return Changed(node);
+ }
+ return Replace(quotient);
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceUint32Div(Node* node) {
+ Uint32BinopMatcher m(node);
+ if (m.left().Is(0)) return Replace(m.left().node()); // 0 / x => 0
+ if (m.right().Is(0)) return Replace(m.right().node()); // x / 0 => 0
+ if (m.right().Is(1)) return Replace(m.left().node()); // x / 1 => x
+ if (m.IsFoldable()) { // K / K => K
+ return ReplaceUint32(
+ base::bits::UnsignedDiv32(m.left().Value(), m.right().Value()));
+ }
+ if (m.LeftEqualsRight()) { // x / x => x != 0
+ Node* const zero = Int32Constant(0);
+ return Replace(Word32Equal(Word32Equal(m.left().node(), zero), zero));
+ }
+ if (m.right().HasValue()) {
+ Node* const dividend = m.left().node();
+ uint32_t const divisor = m.right().Value();
+ if (base::bits::IsPowerOfTwo32(divisor)) { // x / 2^n => x >> n
+ node->set_op(machine()->Word32Shr());
+ node->ReplaceInput(1, Uint32Constant(WhichPowerOf2(m.right().Value())));
+ node->TrimInputCount(2);
+ return Changed(node);
+ } else {
+ return Replace(Uint32Div(dividend, divisor));
+ }
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceInt32Mod(Node* node) {
+ Int32BinopMatcher m(node);
+ if (m.left().Is(0)) return Replace(m.left().node()); // 0 % x => 0
+ if (m.right().Is(0)) return Replace(m.right().node()); // x % 0 => 0
+ if (m.right().Is(1)) return ReplaceInt32(0); // x % 1 => 0
+ if (m.right().Is(-1)) return ReplaceInt32(0); // x % -1 => 0
+ if (m.LeftEqualsRight()) return ReplaceInt32(0); // x % x => 0
+ if (m.IsFoldable()) { // K % K => K
+ return ReplaceInt32(
+ base::bits::SignedMod32(m.left().Value(), m.right().Value()));
+ }
+ if (m.right().HasValue()) {
+ Node* const dividend = m.left().node();
+ int32_t const divisor = Abs(m.right().Value());
+ if (base::bits::IsPowerOfTwo32(divisor)) {
+ uint32_t const mask = divisor - 1;
+ Node* const zero = Int32Constant(0);
+ node->set_op(common()->Select(kMachInt32, BranchHint::kFalse));
+ node->ReplaceInput(
+ 0, graph()->NewNode(machine()->Int32LessThan(), dividend, zero));
+ node->ReplaceInput(
+ 1, Int32Sub(zero, Word32And(Int32Sub(zero, dividend), mask)));
+ node->ReplaceInput(2, Word32And(dividend, mask));
+ } else {
+ Node* quotient = Int32Div(dividend, divisor);
+ node->set_op(machine()->Int32Sub());
+ DCHECK_EQ(dividend, node->InputAt(0));
+ node->ReplaceInput(1, Int32Mul(quotient, Int32Constant(divisor)));
+ node->TrimInputCount(2);
+ }
+ return Changed(node);
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceUint32Mod(Node* node) {
+ Uint32BinopMatcher m(node);
+ if (m.left().Is(0)) return Replace(m.left().node()); // 0 % x => 0
+ if (m.right().Is(0)) return Replace(m.right().node()); // x % 0 => 0
+ if (m.right().Is(1)) return ReplaceUint32(0); // x % 1 => 0
+ if (m.LeftEqualsRight()) return ReplaceInt32(0); // x % x => 0
+ if (m.IsFoldable()) { // K % K => K
+ return ReplaceUint32(
+ base::bits::UnsignedMod32(m.left().Value(), m.right().Value()));
+ }
+ if (m.right().HasValue()) {
+ Node* const dividend = m.left().node();
+ uint32_t const divisor = m.right().Value();
+ if (base::bits::IsPowerOfTwo32(divisor)) { // x % 2^n => x & 2^n-1
+ node->set_op(machine()->Word32And());
+ node->ReplaceInput(1, Uint32Constant(m.right().Value() - 1));
+ } else {
+ Node* quotient = Uint32Div(dividend, divisor);
+ node->set_op(machine()->Int32Sub());
+ DCHECK_EQ(dividend, node->InputAt(0));
+ node->ReplaceInput(1, Int32Mul(quotient, Uint32Constant(divisor)));
+ }
+ node->TrimInputCount(2);
+ return Changed(node);
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceTruncateFloat64ToInt32(Node* node) {
+ Float64Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
+ if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
+ if (m.IsPhi()) {
+ Node* const phi = m.node();
+ DCHECK_EQ(kRepFloat64, RepresentationOf(OpParameter<MachineType>(phi)));
+ if (phi->OwnedBy(node)) {
+ // TruncateFloat64ToInt32(Phi[Float64](x1,...,xn))
+ // => Phi[Int32](TruncateFloat64ToInt32(x1),
+ // ...,
+ // TruncateFloat64ToInt32(xn))
+ const int value_input_count = phi->InputCount() - 1;
+ for (int i = 0; i < value_input_count; ++i) {
+ Node* input = graph()->NewNode(machine()->TruncateFloat64ToInt32(),
+ phi->InputAt(i));
+ // TODO(bmeurer): Reschedule input for reduction once we have Revisit()
+ // instead of recursing into ReduceTruncateFloat64ToInt32() here.
+ Reduction reduction = ReduceTruncateFloat64ToInt32(input);
+ if (reduction.Changed()) input = reduction.replacement();
+ phi->ReplaceInput(i, input);
+ }
+ phi->set_op(common()->Phi(kMachInt32, value_input_count));
+ return Replace(phi);
+ }
+ }
+ return NoChange();
+}
+
+
+Reduction MachineOperatorReducer::ReduceStore(Node* node) {
+ MachineType const rep =
+ RepresentationOf(StoreRepresentationOf(node->op()).machine_type());
+ Node* const value = node->InputAt(2);
+ switch (value->opcode()) {
+ case IrOpcode::kWord32And: {
+ Uint32BinopMatcher m(value);
+ if (m.right().HasValue() &&
+ ((rep == kRepWord8 && (m.right().Value() & 0xff) == 0xff) ||
+ (rep == kRepWord16 && (m.right().Value() & 0xffff) == 0xffff))) {
+ node->ReplaceInput(2, m.left().node());
+ return Changed(node);
+ }
+ break;
+ }
+ case IrOpcode::kWord32Sar: {
+ Int32BinopMatcher m(value);
+ if (m.left().IsWord32Shl() &&
+ ((rep == kRepWord8 && m.right().IsInRange(1, 24)) ||
+ (rep == kRepWord16 && m.right().IsInRange(1, 16)))) {
+ Int32BinopMatcher mleft(m.left().node());
+ if (mleft.right().Is(m.right().Value())) {
+ node->ReplaceInput(2, mleft.left().node());
+ return Changed(node);
+ }
+ }
+ break;
+ }
default:
break;
}
Node* Uint32Constant(uint32_t value) {
return Int32Constant(bit_cast<uint32_t>(value));
}
+ Node* Word32And(Node* lhs, uint32_t rhs);
+ Node* Word32Sar(Node* lhs, uint32_t rhs);
+ Node* Word32Shr(Node* lhs, uint32_t rhs);
+ Node* Word32Equal(Node* lhs, Node* rhs);
+ Node* Int32Add(Node* lhs, Node* rhs);
+ Node* Int32Sub(Node* lhs, Node* rhs);
+ Node* Int32Mul(Node* lhs, Node* rhs);
+ Node* Int32Div(Node* dividend, int32_t divisor);
+ Node* Uint32Div(Node* dividend, uint32_t divisor);
Reduction ReplaceBool(bool value) { return ReplaceInt32(value ? 1 : 0); }
Reduction ReplaceFloat32(volatile float value) {
Reduction ReplaceInt32(int32_t value) {
return Replace(Int32Constant(value));
}
+ Reduction ReplaceUint32(uint32_t value) {
+ return Replace(Uint32Constant(value));
+ }
Reduction ReplaceInt64(int64_t value) {
return Replace(Int64Constant(value));
}
+ Reduction ReduceInt32Div(Node* node);
+ Reduction ReduceUint32Div(Node* node);
+ Reduction ReduceInt32Mod(Node* node);
+ Reduction ReduceUint32Mod(Node* node);
+ Reduction ReduceTruncateFloat64ToInt32(Node* node);
+ Reduction ReduceStore(Node* node);
Reduction ReduceProjection(size_t index, Node* node);
Graph* graph() const;
namespace internal {
namespace compiler {
-OStream& operator<<(OStream& os, const WriteBarrierKind& write_barrier_kind) {
- switch (write_barrier_kind) {
+std::ostream& operator<<(std::ostream& os, WriteBarrierKind kind) {
+ switch (kind) {
case kNoWriteBarrier:
return os << "NoWriteBarrier";
case kFullWriteBarrier:
}
-OStream& operator<<(OStream& os, const StoreRepresentation& rep) {
- return os << "(" << rep.machine_type() << " : " << rep.write_barrier_kind()
- << ")";
+bool operator==(StoreRepresentation lhs, StoreRepresentation rhs) {
+ return lhs.machine_type() == rhs.machine_type() &&
+ lhs.write_barrier_kind() == rhs.write_barrier_kind();
}
-template <>
-struct StaticParameterTraits<StoreRepresentation> {
- static OStream& PrintTo(OStream& os, const StoreRepresentation& rep) {
- return os << rep;
- }
- static int HashCode(const StoreRepresentation& rep) {
- return rep.machine_type() + rep.write_barrier_kind();
- }
- static bool Equals(const StoreRepresentation& rep1,
- const StoreRepresentation& rep2) {
- return rep1 == rep2;
- }
-};
+bool operator!=(StoreRepresentation lhs, StoreRepresentation rhs) {
+ return !(lhs == rhs);
+}
-template <>
-struct StaticParameterTraits<LoadRepresentation> {
- static OStream& PrintTo(OStream& os, LoadRepresentation type) { // NOLINT
- return os << type;
- }
- static int HashCode(LoadRepresentation type) { return type; }
- static bool Equals(LoadRepresentation lhs, LoadRepresentation rhs) {
- return lhs == rhs;
- }
-};
+size_t hash_value(StoreRepresentation rep) {
+ return base::hash_combine(rep.machine_type(), rep.write_barrier_kind());
+}
+
+
+std::ostream& operator<<(std::ostream& os, StoreRepresentation rep) {
+ return os << "(" << rep.machine_type() << " : " << rep.write_barrier_kind()
+ << ")";
+}
+
+
+StoreRepresentation const& StoreRepresentationOf(Operator const* op) {
+ DCHECK_EQ(IrOpcode::kStore, op->opcode());
+ return OpParameter<StoreRepresentation>(op);
+}
#define PURE_OP_LIST(V) \
- V(Word32And, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word32Or, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word32Xor, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word32Shl, Operator::kNoProperties, 2, 1) \
- V(Word32Shr, Operator::kNoProperties, 2, 1) \
- V(Word32Sar, Operator::kNoProperties, 2, 1) \
- V(Word32Ror, Operator::kNoProperties, 2, 1) \
- V(Word32Equal, Operator::kCommutative, 2, 1) \
- V(Word64And, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word64Or, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word64Xor, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Word64Shl, Operator::kNoProperties, 2, 1) \
- V(Word64Shr, Operator::kNoProperties, 2, 1) \
- V(Word64Sar, Operator::kNoProperties, 2, 1) \
- V(Word64Ror, Operator::kNoProperties, 2, 1) \
- V(Word64Equal, Operator::kCommutative, 2, 1) \
- V(Int32Add, Operator::kAssociative | Operator::kCommutative, 2, 1) \
+ V(Word32And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word32Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word32Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word32Shl, Operator::kNoProperties, 2, 0, 1) \
+ V(Word32Shr, Operator::kNoProperties, 2, 0, 1) \
+ V(Word32Sar, Operator::kNoProperties, 2, 0, 1) \
+ V(Word32Ror, Operator::kNoProperties, 2, 0, 1) \
+ V(Word32Equal, Operator::kCommutative, 2, 0, 1) \
+ V(Word64And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word64Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word64Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Word64Shl, Operator::kNoProperties, 2, 0, 1) \
+ V(Word64Shr, Operator::kNoProperties, 2, 0, 1) \
+ V(Word64Sar, Operator::kNoProperties, 2, 0, 1) \
+ V(Word64Ror, Operator::kNoProperties, 2, 0, 1) \
+ V(Word64Equal, Operator::kCommutative, 2, 0, 1) \
+ V(Int32Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
V(Int32AddWithOverflow, Operator::kAssociative | Operator::kCommutative, 2, \
- 2) \
- V(Int32Sub, Operator::kNoProperties, 2, 1) \
- V(Int32SubWithOverflow, Operator::kNoProperties, 2, 2) \
- V(Int32Mul, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Int32Div, Operator::kNoProperties, 2, 1) \
- V(Int32UDiv, Operator::kNoProperties, 2, 1) \
- V(Int32Mod, Operator::kNoProperties, 2, 1) \
- V(Int32UMod, Operator::kNoProperties, 2, 1) \
- V(Int32LessThan, Operator::kNoProperties, 2, 1) \
- V(Int32LessThanOrEqual, Operator::kNoProperties, 2, 1) \
- V(Uint32LessThan, Operator::kNoProperties, 2, 1) \
- V(Uint32LessThanOrEqual, Operator::kNoProperties, 2, 1) \
- V(Int64Add, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Int64Sub, Operator::kNoProperties, 2, 1) \
- V(Int64Mul, Operator::kAssociative | Operator::kCommutative, 2, 1) \
- V(Int64Div, Operator::kNoProperties, 2, 1) \
- V(Int64UDiv, Operator::kNoProperties, 2, 1) \
- V(Int64Mod, Operator::kNoProperties, 2, 1) \
- V(Int64UMod, Operator::kNoProperties, 2, 1) \
- V(Int64LessThan, Operator::kNoProperties, 2, 1) \
- V(Int64LessThanOrEqual, Operator::kNoProperties, 2, 1) \
- V(ChangeFloat32ToFloat64, Operator::kNoProperties, 1, 1) \
- V(ChangeFloat64ToInt32, Operator::kNoProperties, 1, 1) \
- V(ChangeFloat64ToUint32, Operator::kNoProperties, 1, 1) \
- V(ChangeInt32ToFloat64, Operator::kNoProperties, 1, 1) \
- V(ChangeInt32ToInt64, Operator::kNoProperties, 1, 1) \
- V(ChangeUint32ToFloat64, Operator::kNoProperties, 1, 1) \
- V(ChangeUint32ToUint64, Operator::kNoProperties, 1, 1) \
- V(TruncateFloat64ToFloat32, Operator::kNoProperties, 1, 1) \
- V(TruncateFloat64ToInt32, Operator::kNoProperties, 1, 1) \
- V(TruncateInt64ToInt32, Operator::kNoProperties, 1, 1) \
- V(Float64Add, Operator::kCommutative, 2, 1) \
- V(Float64Sub, Operator::kNoProperties, 2, 1) \
- V(Float64Mul, Operator::kCommutative, 2, 1) \
- V(Float64Div, Operator::kNoProperties, 2, 1) \
- V(Float64Mod, Operator::kNoProperties, 2, 1) \
- V(Float64Sqrt, Operator::kNoProperties, 1, 1) \
- V(Float64Equal, Operator::kCommutative, 2, 1) \
- V(Float64LessThan, Operator::kNoProperties, 2, 1) \
- V(Float64LessThanOrEqual, Operator::kNoProperties, 2, 1)
+ 0, 2) \
+ V(Int32Sub, Operator::kNoProperties, 2, 0, 1) \
+ V(Int32SubWithOverflow, Operator::kNoProperties, 2, 0, 2) \
+ V(Int32Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Int32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Int32Div, Operator::kNoProperties, 2, 1, 1) \
+ V(Int32Mod, Operator::kNoProperties, 2, 1, 1) \
+ V(Int32LessThan, Operator::kNoProperties, 2, 0, 1) \
+ V(Int32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint32Div, Operator::kNoProperties, 2, 1, 1) \
+ V(Uint32LessThan, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint32Mod, Operator::kNoProperties, 2, 1, 1) \
+ V(Uint32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Int64Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Int64Sub, Operator::kNoProperties, 2, 0, 1) \
+ V(Int64Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
+ V(Int64Div, Operator::kNoProperties, 2, 0, 1) \
+ V(Int64Mod, Operator::kNoProperties, 2, 0, 1) \
+ V(Int64LessThan, Operator::kNoProperties, 2, 0, 1) \
+ V(Int64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint64Div, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint64LessThan, Operator::kNoProperties, 2, 0, 1) \
+ V(Uint64Mod, Operator::kNoProperties, 2, 0, 1) \
+ V(ChangeFloat32ToFloat64, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeFloat64ToInt32, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeFloat64ToUint32, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeInt32ToFloat64, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeInt32ToInt64, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeUint32ToFloat64, Operator::kNoProperties, 1, 0, 1) \
+ V(ChangeUint32ToUint64, Operator::kNoProperties, 1, 0, 1) \
+ V(TruncateFloat64ToFloat32, Operator::kNoProperties, 1, 0, 1) \
+ V(TruncateFloat64ToInt32, Operator::kNoProperties, 1, 0, 1) \
+ V(TruncateInt64ToInt32, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64Add, Operator::kCommutative, 2, 0, 1) \
+ V(Float64Sub, Operator::kNoProperties, 2, 0, 1) \
+ V(Float64Mul, Operator::kCommutative, 2, 0, 1) \
+ V(Float64Div, Operator::kNoProperties, 2, 0, 1) \
+ V(Float64Mod, Operator::kNoProperties, 2, 0, 1) \
+ V(Float64Sqrt, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64Ceil, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64Floor, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64RoundTruncate, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64RoundTiesAway, Operator::kNoProperties, 1, 0, 1) \
+ V(Float64Equal, Operator::kCommutative, 2, 0, 1) \
+ V(Float64LessThan, Operator::kNoProperties, 2, 0, 1) \
+ V(Float64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
+ V(LoadStackPointer, Operator::kNoProperties, 0, 0, 1)
#define MACHINE_TYPE_LIST(V) \
V(RepTagged)
-struct MachineOperatorBuilderImpl {
-#define PURE(Name, properties, input_count, output_count) \
- struct Name##Operator FINAL : public SimpleOperator { \
- Name##Operator() \
- : SimpleOperator(IrOpcode::k##Name, Operator::kPure | properties, \
- input_count, output_count, #Name) {} \
- }; \
+struct MachineOperatorGlobalCache {
+#define PURE(Name, properties, value_input_count, control_input_count, \
+ output_count) \
+ struct Name##Operator FINAL : public Operator { \
+ Name##Operator() \
+ : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
+ value_input_count, 0, control_input_count, output_count, 0, \
+ 0) {} \
+ }; \
Name##Operator k##Name;
PURE_OP_LIST(PURE)
#undef PURE
-#define LOAD(Type) \
- struct Load##Type##Operator FINAL : public Operator1<LoadRepresentation> { \
- Load##Type##Operator() \
- : Operator1<LoadRepresentation>( \
- IrOpcode::kLoad, Operator::kNoThrow | Operator::kNoWrite, 2, 1, \
- "Load", k##Type) {} \
- }; \
+#define LOAD(Type) \
+ struct Load##Type##Operator FINAL : public Operator1<LoadRepresentation> { \
+ Load##Type##Operator() \
+ : Operator1<LoadRepresentation>( \
+ IrOpcode::kLoad, Operator::kNoThrow | Operator::kNoWrite, \
+ "Load", 2, 1, 1, 1, 1, 0, k##Type) {} \
+ }; \
Load##Type##Operator k##Load##Type;
MACHINE_TYPE_LIST(LOAD)
#undef LOAD
-#define STORE(Type) \
- struct Store##Type##Operator : public Operator1<StoreRepresentation> { \
- explicit Store##Type##Operator(WriteBarrierKind write_barrier_kind) \
- : Operator1<StoreRepresentation>( \
- IrOpcode::kStore, Operator::kNoRead | Operator::kNoThrow, 3, 0, \
- "Store", StoreRepresentation(k##Type, write_barrier_kind)) {} \
- }; \
- struct Store##Type##NoWriteBarrier##Operator FINAL \
- : public Store##Type##Operator { \
- Store##Type##NoWriteBarrier##Operator() \
- : Store##Type##Operator(kNoWriteBarrier) {} \
- }; \
- struct Store##Type##FullWriteBarrier##Operator FINAL \
- : public Store##Type##Operator { \
- Store##Type##FullWriteBarrier##Operator() \
- : Store##Type##Operator(kFullWriteBarrier) {} \
- }; \
- Store##Type##NoWriteBarrier##Operator k##Store##Type##NoWriteBarrier; \
+#define STORE(Type) \
+ struct Store##Type##Operator : public Operator1<StoreRepresentation> { \
+ explicit Store##Type##Operator(WriteBarrierKind write_barrier_kind) \
+ : Operator1<StoreRepresentation>( \
+ IrOpcode::kStore, Operator::kNoRead | Operator::kNoThrow, \
+ "Store", 3, 1, 1, 0, 1, 0, \
+ StoreRepresentation(k##Type, write_barrier_kind)) {} \
+ }; \
+ struct Store##Type##NoWriteBarrier##Operator FINAL \
+ : public Store##Type##Operator { \
+ Store##Type##NoWriteBarrier##Operator() \
+ : Store##Type##Operator(kNoWriteBarrier) {} \
+ }; \
+ struct Store##Type##FullWriteBarrier##Operator FINAL \
+ : public Store##Type##Operator { \
+ Store##Type##FullWriteBarrier##Operator() \
+ : Store##Type##Operator(kFullWriteBarrier) {} \
+ }; \
+ Store##Type##NoWriteBarrier##Operator k##Store##Type##NoWriteBarrier; \
Store##Type##FullWriteBarrier##Operator k##Store##Type##FullWriteBarrier;
MACHINE_TYPE_LIST(STORE)
#undef STORE
};
-static base::LazyInstance<MachineOperatorBuilderImpl>::type kImpl =
+static base::LazyInstance<MachineOperatorGlobalCache>::type kCache =
LAZY_INSTANCE_INITIALIZER;
-MachineOperatorBuilder::MachineOperatorBuilder(MachineType word)
- : impl_(kImpl.Get()), word_(word) {
+MachineOperatorBuilder::MachineOperatorBuilder(MachineType word, Flags flags)
+ : cache_(kCache.Get()), word_(word), flags_(flags) {
DCHECK(word == kRepWord32 || word == kRepWord64);
}
-#define PURE(Name, properties, input_count, output_count) \
- const Operator* MachineOperatorBuilder::Name() { return &impl_.k##Name; }
+#define PURE(Name, properties, value_input_count, control_input_count, \
+ output_count) \
+ const Operator* MachineOperatorBuilder::Name() { return &cache_.k##Name; }
PURE_OP_LIST(PURE)
#undef PURE
switch (rep) {
#define LOAD(Type) \
case k##Type: \
- return &impl_.k##Load##Type;
+ return &cache_.k##Load##Type;
MACHINE_TYPE_LIST(LOAD)
#undef LOAD
const Operator* MachineOperatorBuilder::Store(StoreRepresentation rep) {
switch (rep.machine_type()) {
-#define STORE(Type) \
- case k##Type: \
- switch (rep.write_barrier_kind()) { \
- case kNoWriteBarrier: \
- return &impl_.k##Store##Type##NoWriteBarrier; \
- case kFullWriteBarrier: \
- return &impl_.k##Store##Type##FullWriteBarrier; \
- } \
+#define STORE(Type) \
+ case k##Type: \
+ switch (rep.write_barrier_kind()) { \
+ case kNoWriteBarrier: \
+ return &cache_.k##Store##Type##NoWriteBarrier; \
+ case kFullWriteBarrier: \
+ return &cache_.k##Store##Type##FullWriteBarrier; \
+ } \
break;
MACHINE_TYPE_LIST(STORE)
#undef STORE
UNREACHABLE();
return NULL;
}
-
} // namespace compiler
} // namespace internal
} // namespace v8
#ifndef V8_COMPILER_MACHINE_OPERATOR_H_
#define V8_COMPILER_MACHINE_OPERATOR_H_
+#include "src/base/flags.h"
#include "src/compiler/machine-type.h"
namespace v8 {
namespace compiler {
// Forward declarations.
-struct MachineOperatorBuilderImpl;
+struct MachineOperatorGlobalCache;
class Operator;
// Supported write barrier modes.
enum WriteBarrierKind { kNoWriteBarrier, kFullWriteBarrier };
-OStream& operator<<(OStream& os, const WriteBarrierKind& write_barrier_kind);
+std::ostream& operator<<(std::ostream& os, WriteBarrierKind);
+// A Load needs a MachineType.
typedef MachineType LoadRepresentation;
-// A Store needs a MachineType and a WriteBarrierKind
-// in order to emit the correct write barrier.
+// A Store needs a MachineType and a WriteBarrierKind in order to emit the
+// correct write barrier.
class StoreRepresentation FINAL {
public:
StoreRepresentation(MachineType machine_type,
WriteBarrierKind write_barrier_kind_;
};
-inline bool operator==(const StoreRepresentation& rep1,
- const StoreRepresentation& rep2) {
- return rep1.machine_type() == rep2.machine_type() &&
- rep1.write_barrier_kind() == rep2.write_barrier_kind();
-}
+bool operator==(StoreRepresentation, StoreRepresentation);
+bool operator!=(StoreRepresentation, StoreRepresentation);
-inline bool operator!=(const StoreRepresentation& rep1,
- const StoreRepresentation& rep2) {
- return !(rep1 == rep2);
-}
+size_t hash_value(StoreRepresentation);
-OStream& operator<<(OStream& os, const StoreRepresentation& rep);
+std::ostream& operator<<(std::ostream&, StoreRepresentation);
+
+StoreRepresentation const& StoreRepresentationOf(Operator const*);
// Interface for building machine-level operators. These operators are
// machine-level but machine-independent and thus define a language suitable
// for generating code to run on architectures such as ia32, x64, arm, etc.
-class MachineOperatorBuilder FINAL {
+class MachineOperatorBuilder FINAL : public ZoneObject {
public:
- explicit MachineOperatorBuilder(MachineType word = kMachPtr);
+ // Flags that specify which operations are available. This is useful
+ // for operations that are unsupported by some back-ends.
+ enum Flag {
+ kNoFlags = 0u,
+ kFloat64Floor = 1u << 0,
+ kFloat64Ceil = 1u << 1,
+ kFloat64RoundTruncate = 1u << 2,
+ kFloat64RoundTiesAway = 1u << 3,
+ kInt32DivIsSafe = 1u << 4,
+ kInt32ModIsSafe = 1u << 5,
+ kUint32DivIsSafe = 1u << 6,
+ kUint32ModIsSafe = 1u << 7
+ };
+ typedef base::Flags<Flag, unsigned> Flags;
+
+ explicit MachineOperatorBuilder(MachineType word = kMachPtr,
+ Flags supportedOperators = kNoFlags);
const Operator* Word32And();
const Operator* Word32Or();
const Operator* Int32Sub();
const Operator* Int32SubWithOverflow();
const Operator* Int32Mul();
+ const Operator* Int32MulHigh();
const Operator* Int32Div();
- const Operator* Int32UDiv();
const Operator* Int32Mod();
- const Operator* Int32UMod();
const Operator* Int32LessThan();
const Operator* Int32LessThanOrEqual();
+ const Operator* Uint32Div();
const Operator* Uint32LessThan();
const Operator* Uint32LessThanOrEqual();
+ const Operator* Uint32Mod();
+ const Operator* Uint32MulHigh();
+ bool Int32DivIsSafe() const { return flags_ & kInt32DivIsSafe; }
+ bool Int32ModIsSafe() const { return flags_ & kInt32ModIsSafe; }
+ bool Uint32DivIsSafe() const { return flags_ & kUint32DivIsSafe; }
+ bool Uint32ModIsSafe() const { return flags_ & kUint32ModIsSafe; }
const Operator* Int64Add();
const Operator* Int64Sub();
const Operator* Int64Mul();
const Operator* Int64Div();
- const Operator* Int64UDiv();
const Operator* Int64Mod();
- const Operator* Int64UMod();
const Operator* Int64LessThan();
const Operator* Int64LessThanOrEqual();
+ const Operator* Uint64Div();
+ const Operator* Uint64LessThan();
+ const Operator* Uint64Mod();
// These operators change the representation of numbers while preserving the
// value of the number. Narrowing operators assume the input is representable
const Operator* Float64LessThan();
const Operator* Float64LessThanOrEqual();
+ // Floating point rounding.
+ const Operator* Float64Floor();
+ const Operator* Float64Ceil();
+ const Operator* Float64RoundTruncate();
+ const Operator* Float64RoundTiesAway();
+ bool HasFloat64Floor() { return flags_ & kFloat64Floor; }
+ bool HasFloat64Ceil() { return flags_ & kFloat64Ceil; }
+ bool HasFloat64RoundTruncate() { return flags_ & kFloat64RoundTruncate; }
+ bool HasFloat64RoundTiesAway() { return flags_ & kFloat64RoundTiesAway; }
+
// load [base + index]
const Operator* Load(LoadRepresentation rep);
// store [base + index], value
const Operator* Store(StoreRepresentation rep);
+ // Access to the machine stack.
+ const Operator* LoadStackPointer();
+
// Target machine word-size assumed by this builder.
bool Is32() const { return word() == kRepWord32; }
bool Is64() const { return word() == kRepWord64; }
V(Int, Sub) \
V(Int, Mul) \
V(Int, Div) \
- V(Int, UDiv) \
V(Int, Mod) \
- V(Int, UMod) \
V(Int, LessThan) \
- V(Int, LessThanOrEqual)
+ V(Int, LessThanOrEqual) \
+ V(Uint, Div) \
+ V(Uint, LessThan) \
+ V(Uint, Mod)
#define PSEUDO_OP(Prefix, Suffix) \
const Operator* Prefix##Suffix() { \
return Is32() ? Prefix##32##Suffix() : Prefix##64##Suffix(); \
#undef PSEUDO_OP_LIST
private:
- const MachineOperatorBuilderImpl& impl_;
+ const MachineOperatorGlobalCache& cache_;
const MachineType word_;
+ const Flags flags_;
+ DISALLOW_COPY_AND_ASSIGN(MachineOperatorBuilder);
};
+
+DEFINE_OPERATORS_FOR_FLAGS(MachineOperatorBuilder::Flags)
} // namespace compiler
} // namespace internal
} // namespace v8
}
-OStream& operator<<(OStream& os, const MachineType& type) {
+std::ostream& operator<<(std::ostream& os, const MachineType& type) {
bool before = false;
PRINT(kRepBit);
PRINT(kRepWord8);
#ifndef V8_COMPILER_MACHINE_TYPE_H_
#define V8_COMPILER_MACHINE_TYPE_H_
+#include <iosfwd>
+
#include "src/base/bits.h"
#include "src/globals.h"
#include "src/zone.h"
namespace v8 {
namespace internal {
-
-class OStream;
-
namespace compiler {
// Machine-level types and representations.
// Machine types.
kMachNone = 0,
+ kMachBool = kRepBit | kTypeBool,
kMachFloat32 = kRepFloat32 | kTypeNumber,
kMachFloat64 = kRepFloat64 | kTypeNumber,
kMachInt8 = kRepWord8 | kTypeInt32,
kMachUint32 = kRepWord32 | kTypeUint32,
kMachInt64 = kRepWord64 | kTypeInt64,
kMachUint64 = kRepWord64 | kTypeUint64,
+ kMachIntPtr = (kPointerSize == 4) ? kMachInt32 : kMachInt64,
+ kMachUintPtr = (kPointerSize == 4) ? kMachUint32 : kMachUint64,
kMachPtr = (kPointerSize == 4) ? kRepWord32 : kRepWord64,
kMachAnyTagged = kRepTagged | kTypeAny
};
-OStream& operator<<(OStream& os, const MachineType& type);
+std::ostream& operator<<(std::ostream& os, const MachineType& type);
typedef uint16_t MachineTypeUnion;
return static_cast<MachineType>(result);
}
-// Gets the element size in bytes of the machine type.
-inline int ElementSizeOf(MachineType machine_type) {
+// Gets the log2 of the element size in bytes of the machine type.
+inline int ElementSizeLog2Of(MachineType machine_type) {
switch (RepresentationOf(machine_type)) {
case kRepBit:
case kRepWord8:
- return 1;
+ return 0;
case kRepWord16:
- return 2;
+ return 1;
case kRepWord32:
case kRepFloat32:
- return 4;
+ return 2;
case kRepWord64:
case kRepFloat64:
- return 8;
+ return 3;
case kRepTagged:
- return kPointerSize;
+ return kPointerSizeLog2;
default:
- UNREACHABLE();
- return kPointerSize;
+ break;
}
+ UNREACHABLE();
+ return -1;
+}
+
+// Gets the element size in bytes of the machine type.
+inline int ElementSizeOf(MachineType machine_type) {
+ const int shift = ElementSizeLog2Of(machine_type);
+ DCHECK_NE(-1, shift);
+ return 1 << shift;
}
// Describes the inputs and outputs of a function or call.
--- /dev/null
+paul.lind@imgtec.com
+gergely.kis@imgtec.com
+akos.palfi@imgtec.com
+balazs.kilvady@imgtec.com
+dusan.milosavljevic@imgtec.com
--- /dev/null
+// 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/code-generator.h"
+#include "src/compiler/code-generator-impl.h"
+#include "src/compiler/gap-resolver.h"
+#include "src/compiler/node-matchers.h"
+#include "src/compiler/node-properties-inl.h"
+#include "src/mips/macro-assembler-mips.h"
+#include "src/scopes.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+#define __ masm()->
+
+
+// TODO(plind): Possibly avoid using these lithium names.
+#define kScratchReg kLithiumScratchReg
+#define kCompareReg kLithiumScratchReg2
+#define kScratchDoubleReg kLithiumScratchDouble
+
+
+// TODO(plind): consider renaming these macros.
+#define TRACE_MSG(msg) \
+ PrintF("code_gen: \'%s\' in function %s at line %d\n", msg, __FUNCTION__, \
+ __LINE__)
+
+#define TRACE_UNIMPL() \
+ PrintF("UNIMPLEMENTED code_generator_mips: %s at line %d\n", __FUNCTION__, \
+ __LINE__)
+
+
+// Adds Mips-specific methods to convert InstructionOperands.
+class MipsOperandConverter FINAL : public InstructionOperandConverter {
+ public:
+ MipsOperandConverter(CodeGenerator* gen, Instruction* instr)
+ : InstructionOperandConverter(gen, instr) {}
+
+ FloatRegister OutputSingleRegister(int index = 0) {
+ return ToSingleRegister(instr_->OutputAt(index));
+ }
+
+ FloatRegister InputSingleRegister(int index) {
+ return ToSingleRegister(instr_->InputAt(index));
+ }
+
+ FloatRegister ToSingleRegister(InstructionOperand* op) {
+ // Single (Float) and Double register namespace is same on MIPS,
+ // both are typedefs of FPURegister.
+ return ToDoubleRegister(op);
+ }
+
+ Operand InputImmediate(int index) {
+ Constant constant = ToConstant(instr_->InputAt(index));
+ switch (constant.type()) {
+ case Constant::kInt32:
+ return Operand(constant.ToInt32());
+ case Constant::kFloat32:
+ return Operand(
+ isolate()->factory()->NewNumber(constant.ToFloat32(), TENURED));
+ case Constant::kFloat64:
+ return Operand(
+ isolate()->factory()->NewNumber(constant.ToFloat64(), TENURED));
+ case Constant::kInt64:
+ case Constant::kExternalReference:
+ case Constant::kHeapObject:
+ // TODO(plind): Maybe we should handle ExtRef & HeapObj here?
+ // maybe not done on arm due to const pool ??
+ break;
+ }
+ UNREACHABLE();
+ return Operand(zero_reg);
+ }
+
+ Operand InputOperand(int index) {
+ InstructionOperand* op = instr_->InputAt(index);
+ if (op->IsRegister()) {
+ return Operand(ToRegister(op));
+ }
+ return InputImmediate(index);
+ }
+
+ MemOperand MemoryOperand(int* first_index) {
+ const int index = *first_index;
+ switch (AddressingModeField::decode(instr_->opcode())) {
+ case kMode_None:
+ break;
+ case kMode_MRI:
+ *first_index += 2;
+ return MemOperand(InputRegister(index + 0), InputInt32(index + 1));
+ case kMode_MRR:
+ // TODO(plind): r6 address mode, to be implemented ...
+ UNREACHABLE();
+ }
+ UNREACHABLE();
+ return MemOperand(no_reg);
+ }
+
+ MemOperand MemoryOperand() {
+ int index = 0;
+ return MemoryOperand(&index);
+ }
+
+ MemOperand ToMemOperand(InstructionOperand* op) const {
+ DCHECK(op != NULL);
+ DCHECK(!op->IsRegister());
+ DCHECK(!op->IsDoubleRegister());
+ DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
+ // The linkage computes where all spill slots are located.
+ FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), 0);
+ return MemOperand(offset.from_stack_pointer() ? sp : fp, offset.offset());
+ }
+};
+
+
+static inline bool HasRegisterInput(Instruction* instr, int index) {
+ return instr->InputAt(index)->IsRegister();
+}
+
+
+// Assembles an instruction after register allocation, producing machine code.
+void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
+ MipsOperandConverter i(this, instr);
+ InstructionCode opcode = instr->opcode();
+
+ switch (ArchOpcodeField::decode(opcode)) {
+ case kArchCallCodeObject: {
+ EnsureSpaceForLazyDeopt();
+ if (instr->InputAt(0)->IsImmediate()) {
+ __ Call(Handle<Code>::cast(i.InputHeapObject(0)),
+ RelocInfo::CODE_TARGET);
+ } else {
+ __ addiu(at, i.InputRegister(0), Code::kHeaderSize - kHeapObjectTag);
+ __ Call(at);
+ }
+ AddSafepointAndDeopt(instr);
+ break;
+ }
+ case kArchCallJSFunction: {
+ EnsureSpaceForLazyDeopt();
+ Register func = i.InputRegister(0);
+ if (FLAG_debug_code) {
+ // Check the function's context matches the context argument.
+ __ lw(kScratchReg, FieldMemOperand(func, JSFunction::kContextOffset));
+ __ Assert(eq, kWrongFunctionContext, cp, Operand(kScratchReg));
+ }
+
+ __ lw(at, FieldMemOperand(func, JSFunction::kCodeEntryOffset));
+ __ Call(at);
+ AddSafepointAndDeopt(instr);
+ break;
+ }
+ case kArchJmp:
+ __ Branch(GetLabel(i.InputRpo(0)));
+ break;
+ case kArchNop:
+ // don't emit code for nops.
+ break;
+ case kArchRet:
+ AssembleReturn();
+ break;
+ case kArchStackPointer:
+ __ mov(i.OutputRegister(), sp);
+ break;
+ case kArchTruncateDoubleToI:
+ __ TruncateDoubleToI(i.OutputRegister(), i.InputDoubleRegister(0));
+ break;
+ case kMipsAdd:
+ __ Addu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsAddOvf:
+ __ AdduAndCheckForOverflow(i.OutputRegister(), i.InputRegister(0),
+ i.InputOperand(1), kCompareReg, kScratchReg);
+ break;
+ case kMipsSub:
+ __ Subu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsSubOvf:
+ __ SubuAndCheckForOverflow(i.OutputRegister(), i.InputRegister(0),
+ i.InputOperand(1), kCompareReg, kScratchReg);
+ break;
+ case kMipsMul:
+ __ Mul(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsMulHigh:
+ __ Mulh(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsMulHighU:
+ __ Mulhu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsDiv:
+ __ Div(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsDivU:
+ __ Divu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsMod:
+ __ Mod(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsModU:
+ __ Modu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsAnd:
+ __ And(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsOr:
+ __ Or(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsXor:
+ __ Xor(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsShl:
+ if (instr->InputAt(1)->IsRegister()) {
+ __ sllv(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
+ } else {
+ int32_t imm = i.InputOperand(1).immediate();
+ __ sll(i.OutputRegister(), i.InputRegister(0), imm);
+ }
+ break;
+ case kMipsShr:
+ if (instr->InputAt(1)->IsRegister()) {
+ __ srlv(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
+ } else {
+ int32_t imm = i.InputOperand(1).immediate();
+ __ srl(i.OutputRegister(), i.InputRegister(0), imm);
+ }
+ break;
+ case kMipsSar:
+ if (instr->InputAt(1)->IsRegister()) {
+ __ srav(i.OutputRegister(), i.InputRegister(0), i.InputRegister(1));
+ } else {
+ int32_t imm = i.InputOperand(1).immediate();
+ __ sra(i.OutputRegister(), i.InputRegister(0), imm);
+ }
+ break;
+ case kMipsRor:
+ __ Ror(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
+ break;
+ case kMipsTst:
+ // Pseudo-instruction used for tst/branch. No opcode emitted here.
+ break;
+ case kMipsCmp:
+ // Pseudo-instruction used for cmp/branch. No opcode emitted here.
+ break;
+ case kMipsMov:
+ // TODO(plind): Should we combine mov/li like this, or use separate instr?
+ // - Also see x64 ASSEMBLE_BINOP & RegisterOrOperandType
+ if (HasRegisterInput(instr, 0)) {
+ __ mov(i.OutputRegister(), i.InputRegister(0));
+ } else {
+ __ li(i.OutputRegister(), i.InputOperand(0));
+ }
+ break;
+
+ case kMipsCmpD:
+ // Psuedo-instruction used for FP cmp/branch. No opcode emitted here.
+ break;
+ case kMipsAddD:
+ // TODO(plind): add special case: combine mult & add.
+ __ add_d(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+ break;
+ case kMipsSubD:
+ __ sub_d(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+ break;
+ case kMipsMulD:
+ // TODO(plind): add special case: right op is -1.0, see arm port.
+ __ mul_d(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+ break;
+ case kMipsDivD:
+ __ div_d(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+ break;
+ case kMipsModD: {
+ // TODO(bmeurer): We should really get rid of this special instruction,
+ // and generate a CallAddress instruction instead.
+ FrameScope scope(masm(), StackFrame::MANUAL);
+ __ PrepareCallCFunction(0, 2, kScratchReg);
+ __ MovToFloatParameters(i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+ __ CallCFunction(ExternalReference::mod_two_doubles_operation(isolate()),
+ 0, 2);
+ // Move the result in the double result register.
+ __ MovFromFloatResult(i.OutputDoubleRegister());
+ break;
+ }
+ case kMipsSqrtD: {
+ __ sqrt_d(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ break;
+ }
+ case kMipsCvtSD: {
+ __ cvt_s_d(i.OutputSingleRegister(), i.InputDoubleRegister(0));
+ break;
+ }
+ case kMipsCvtDS: {
+ __ cvt_d_s(i.OutputDoubleRegister(), i.InputSingleRegister(0));
+ break;
+ }
+ case kMipsCvtDW: {
+ FPURegister scratch = kScratchDoubleReg;
+ __ mtc1(i.InputRegister(0), scratch);
+ __ cvt_d_w(i.OutputDoubleRegister(), scratch);
+ break;
+ }
+ case kMipsCvtDUw: {
+ FPURegister scratch = kScratchDoubleReg;
+ __ Cvt_d_uw(i.OutputDoubleRegister(), i.InputRegister(0), scratch);
+ break;
+ }
+ case kMipsTruncWD: {
+ FPURegister scratch = kScratchDoubleReg;
+ // Other arches use round to zero here, so we follow.
+ __ trunc_w_d(scratch, i.InputDoubleRegister(0));
+ __ mfc1(i.OutputRegister(), scratch);
+ break;
+ }
+ case kMipsTruncUwD: {
+ FPURegister scratch = kScratchDoubleReg;
+ // TODO(plind): Fix wrong param order of Trunc_uw_d() macro-asm function.
+ __ Trunc_uw_d(i.InputDoubleRegister(0), i.OutputRegister(), scratch);
+ break;
+ }
+ // ... more basic instructions ...
+
+ case kMipsLbu:
+ __ lbu(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kMipsLb:
+ __ lb(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kMipsSb:
+ __ sb(i.InputRegister(2), i.MemoryOperand());
+ break;
+ case kMipsLhu:
+ __ lhu(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kMipsLh:
+ __ lh(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kMipsSh:
+ __ sh(i.InputRegister(2), i.MemoryOperand());
+ break;
+ case kMipsLw:
+ __ lw(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kMipsSw:
+ __ sw(i.InputRegister(2), i.MemoryOperand());
+ break;
+ case kMipsLwc1: {
+ __ lwc1(i.OutputSingleRegister(), i.MemoryOperand());
+ break;
+ }
+ case kMipsSwc1: {
+ int index = 0;
+ MemOperand operand = i.MemoryOperand(&index);
+ __ swc1(i.InputSingleRegister(index), operand);
+ break;
+ }
+ case kMipsLdc1:
+ __ ldc1(i.OutputDoubleRegister(), i.MemoryOperand());
+ break;
+ case kMipsSdc1:
+ __ sdc1(i.InputDoubleRegister(2), i.MemoryOperand());
+ break;
+ case kMipsPush:
+ __ Push(i.InputRegister(0));
+ break;
+ case kMipsStoreWriteBarrier:
+ Register object = i.InputRegister(0);
+ Register index = i.InputRegister(1);
+ Register value = i.InputRegister(2);
+ __ addu(index, object, index);
+ __ sw(value, MemOperand(index));
+ SaveFPRegsMode mode =
+ frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
+ RAStatus ra_status = kRAHasNotBeenSaved;
+ __ RecordWrite(object, index, value, ra_status, mode);
+ break;
+ }
+}
+
+
+#define UNSUPPORTED_COND(opcode, condition) \
+ OFStream out(stdout); \
+ out << "Unsupported " << #opcode << " condition: \"" << condition << "\""; \
+ UNIMPLEMENTED();
+
+// Assembles branches after an instruction.
+void CodeGenerator::AssembleArchBranch(Instruction* instr,
+ FlagsCondition condition) {
+ MipsOperandConverter i(this, instr);
+ Label done;
+
+ // Emit a branch. The true and false targets are always the last two inputs
+ // to the instruction.
+ BasicBlock::RpoNumber tblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
+ BasicBlock::RpoNumber fblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
+ bool fallthru = IsNextInAssemblyOrder(fblock);
+ Label* tlabel = GetLabel(tblock);
+ Label* flabel = fallthru ? &done : GetLabel(fblock);
+ Condition cc = kNoCondition;
+
+ // MIPS does not have condition code flags, so compare and branch are
+ // implemented differently than on the other arch's. The compare operations
+ // emit mips psuedo-instructions, which are handled here by branch
+ // instructions that do the actual comparison. Essential that the input
+ // registers to compare psuedo-op are not modified before this branch op, as
+ // they are tested here.
+ // TODO(plind): Add CHECK() to ensure that test/cmp and this branch were
+ // not separated by other instructions.
+
+ if (instr->arch_opcode() == kMipsTst) {
+ switch (condition) {
+ case kNotEqual:
+ cc = ne;
+ break;
+ case kEqual:
+ cc = eq;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsTst, condition);
+ break;
+ }
+ __ And(at, i.InputRegister(0), i.InputOperand(1));
+ __ Branch(tlabel, cc, at, Operand(zero_reg));
+
+ } else if (instr->arch_opcode() == kMipsAddOvf ||
+ instr->arch_opcode() == kMipsSubOvf) {
+ // kMipsAddOvf, SubOvf emit negative result to 'kCompareReg' on overflow.
+ switch (condition) {
+ case kOverflow:
+ cc = lt;
+ break;
+ case kNotOverflow:
+ cc = ge;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsAddOvf, condition);
+ break;
+ }
+ __ Branch(tlabel, cc, kCompareReg, Operand(zero_reg));
+
+ } else if (instr->arch_opcode() == kMipsCmp) {
+ switch (condition) {
+ case kEqual:
+ cc = eq;
+ break;
+ case kNotEqual:
+ cc = ne;
+ break;
+ case kSignedLessThan:
+ cc = lt;
+ break;
+ case kSignedGreaterThanOrEqual:
+ cc = ge;
+ break;
+ case kSignedLessThanOrEqual:
+ cc = le;
+ break;
+ case kSignedGreaterThan:
+ cc = gt;
+ break;
+ case kUnsignedLessThan:
+ cc = lo;
+ break;
+ case kUnsignedGreaterThanOrEqual:
+ cc = hs;
+ break;
+ case kUnsignedLessThanOrEqual:
+ cc = ls;
+ break;
+ case kUnsignedGreaterThan:
+ cc = hi;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsCmp, condition);
+ break;
+ }
+ __ Branch(tlabel, cc, i.InputRegister(0), i.InputOperand(1));
+
+ if (!fallthru) __ Branch(flabel); // no fallthru to flabel.
+ __ bind(&done);
+
+ } else if (instr->arch_opcode() == kMipsCmpD) {
+ // TODO(dusmil) optimize unordered checks to use less instructions
+ // even if we have to unfold BranchF macro.
+ Label* nan = flabel;
+ switch (condition) {
+ case kUnorderedEqual:
+ cc = eq;
+ break;
+ case kUnorderedNotEqual:
+ cc = ne;
+ nan = tlabel;
+ break;
+ case kUnorderedLessThan:
+ cc = lt;
+ break;
+ case kUnorderedGreaterThanOrEqual:
+ cc = ge;
+ nan = tlabel;
+ break;
+ case kUnorderedLessThanOrEqual:
+ cc = le;
+ break;
+ case kUnorderedGreaterThan:
+ cc = gt;
+ nan = tlabel;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsCmpD, condition);
+ break;
+ }
+ __ BranchF(tlabel, nan, cc, i.InputDoubleRegister(0),
+ i.InputDoubleRegister(1));
+
+ if (!fallthru) __ Branch(flabel); // no fallthru to flabel.
+ __ bind(&done);
+
+ } else {
+ PrintF("AssembleArchBranch Unimplemented arch_opcode: %d\n",
+ instr->arch_opcode());
+ UNIMPLEMENTED();
+ }
+}
+
+
+// Assembles boolean materializations after an instruction.
+void CodeGenerator::AssembleArchBoolean(Instruction* instr,
+ FlagsCondition condition) {
+ MipsOperandConverter i(this, instr);
+ Label done;
+
+ // Materialize a full 32-bit 1 or 0 value. The result register is always the
+ // last output of the instruction.
+ Label false_value;
+ DCHECK_NE(0, instr->OutputCount());
+ Register result = i.OutputRegister(instr->OutputCount() - 1);
+ Condition cc = kNoCondition;
+
+ // MIPS does not have condition code flags, so compare and branch are
+ // implemented differently than on the other arch's. The compare operations
+ // emit mips psuedo-instructions, which are checked and handled here.
+
+ // For materializations, we use delay slot to set the result true, and
+ // in the false case, where we fall thru the branch, we reset the result
+ // false.
+
+ // TODO(plind): Add CHECK() to ensure that test/cmp and this branch were
+ // not separated by other instructions.
+ if (instr->arch_opcode() == kMipsTst) {
+ switch (condition) {
+ case kNotEqual:
+ cc = ne;
+ break;
+ case kEqual:
+ cc = eq;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsTst, condition);
+ break;
+ }
+ __ And(at, i.InputRegister(0), i.InputOperand(1));
+ __ Branch(USE_DELAY_SLOT, &done, cc, at, Operand(zero_reg));
+ __ li(result, Operand(1)); // In delay slot.
+
+ } else if (instr->arch_opcode() == kMipsAddOvf ||
+ instr->arch_opcode() == kMipsSubOvf) {
+ // kMipsAddOvf, SubOvf emits negative result to 'kCompareReg' on overflow.
+ switch (condition) {
+ case kOverflow:
+ cc = lt;
+ break;
+ case kNotOverflow:
+ cc = ge;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsAddOvf, condition);
+ break;
+ }
+ __ Branch(USE_DELAY_SLOT, &done, cc, kCompareReg, Operand(zero_reg));
+ __ li(result, Operand(1)); // In delay slot.
+
+
+ } else if (instr->arch_opcode() == kMipsCmp) {
+ Register left = i.InputRegister(0);
+ Operand right = i.InputOperand(1);
+ switch (condition) {
+ case kEqual:
+ cc = eq;
+ break;
+ case kNotEqual:
+ cc = ne;
+ break;
+ case kSignedLessThan:
+ cc = lt;
+ break;
+ case kSignedGreaterThanOrEqual:
+ cc = ge;
+ break;
+ case kSignedLessThanOrEqual:
+ cc = le;
+ break;
+ case kSignedGreaterThan:
+ cc = gt;
+ break;
+ case kUnsignedLessThan:
+ cc = lo;
+ break;
+ case kUnsignedGreaterThanOrEqual:
+ cc = hs;
+ break;
+ case kUnsignedLessThanOrEqual:
+ cc = ls;
+ break;
+ case kUnsignedGreaterThan:
+ cc = hi;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsCmp, condition);
+ break;
+ }
+ __ Branch(USE_DELAY_SLOT, &done, cc, left, right);
+ __ li(result, Operand(1)); // In delay slot.
+
+ } else if (instr->arch_opcode() == kMipsCmpD) {
+ FPURegister left = i.InputDoubleRegister(0);
+ FPURegister right = i.InputDoubleRegister(1);
+ // TODO(plind): Provide NaN-testing macro-asm function without need for
+ // BranchF.
+ FPURegister dummy1 = f0;
+ FPURegister dummy2 = f2;
+ switch (condition) {
+ case kUnorderedEqual:
+ // TODO(plind): improve the NaN testing throughout this function.
+ __ BranchF(NULL, &false_value, kNoCondition, dummy1, dummy2);
+ cc = eq;
+ break;
+ case kUnorderedNotEqual:
+ __ BranchF(USE_DELAY_SLOT, NULL, &done, kNoCondition, dummy1, dummy2);
+ __ li(result, Operand(1)); // In delay slot - returns 1 on NaN.
+ cc = ne;
+ break;
+ case kUnorderedLessThan:
+ __ BranchF(NULL, &false_value, kNoCondition, dummy1, dummy2);
+ cc = lt;
+ break;
+ case kUnorderedGreaterThanOrEqual:
+ __ BranchF(USE_DELAY_SLOT, NULL, &done, kNoCondition, dummy1, dummy2);
+ __ li(result, Operand(1)); // In delay slot - returns 1 on NaN.
+ cc = ge;
+ break;
+ case kUnorderedLessThanOrEqual:
+ __ BranchF(NULL, &false_value, kNoCondition, dummy1, dummy2);
+ cc = le;
+ break;
+ case kUnorderedGreaterThan:
+ __ BranchF(USE_DELAY_SLOT, NULL, &done, kNoCondition, dummy1, dummy2);
+ __ li(result, Operand(1)); // In delay slot - returns 1 on NaN.
+ cc = gt;
+ break;
+ default:
+ UNSUPPORTED_COND(kMipsCmp, condition);
+ break;
+ }
+ __ BranchF(USE_DELAY_SLOT, &done, NULL, cc, left, right);
+ __ li(result, Operand(1)); // In delay slot - branch taken returns 1.
+ // Fall-thru (branch not taken) returns 0.
+
+ } else {
+ PrintF("AssembleArchBranch Unimplemented arch_opcode is : %d\n",
+ instr->arch_opcode());
+ TRACE_UNIMPL();
+ UNIMPLEMENTED();
+ }
+ // Fallthru case is the false materialization.
+ __ bind(&false_value);
+ __ li(result, Operand(0));
+ __ bind(&done);
+}
+
+
+void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
+ Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
+ isolate(), deoptimization_id, Deoptimizer::LAZY);
+ __ Call(deopt_entry, RelocInfo::RUNTIME_ENTRY);
+}
+
+
+void CodeGenerator::AssemblePrologue() {
+ CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
+ if (descriptor->kind() == CallDescriptor::kCallAddress) {
+ __ Push(ra, fp);
+ __ mov(fp, sp);
+ const RegList saves = descriptor->CalleeSavedRegisters();
+ if (saves != 0) { // Save callee-saved registers.
+ // TODO(plind): make callee save size const, possibly DCHECK it.
+ int register_save_area_size = 0;
+ for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
+ if (!((1 << i) & saves)) continue;
+ register_save_area_size += kPointerSize;
+ }
+ frame()->SetRegisterSaveAreaSize(register_save_area_size);
+ __ MultiPush(saves);
+ }
+ } else if (descriptor->IsJSFunctionCall()) {
+ CompilationInfo* info = this->info();
+ __ Prologue(info->IsCodePreAgingActive());
+ frame()->SetRegisterSaveAreaSize(
+ StandardFrameConstants::kFixedFrameSizeFromFp);
+
+ // Sloppy mode functions and builtins need to replace the receiver with the
+ // global proxy when called as functions (without an explicit receiver
+ // object).
+ // TODO(mstarzinger/verwaest): Should this be moved back into the CallIC?
+ if (info->strict_mode() == SLOPPY && !info->is_native()) {
+ Label ok;
+ // +2 for return address and saved frame pointer.
+ int receiver_slot = info->scope()->num_parameters() + 2;
+ __ lw(a2, MemOperand(fp, receiver_slot * kPointerSize));
+ __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
+ __ Branch(&ok, ne, a2, Operand(at));
+
+ __ lw(a2, GlobalObjectOperand());
+ __ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalProxyOffset));
+ __ sw(a2, MemOperand(fp, receiver_slot * kPointerSize));
+ __ bind(&ok);
+ }
+ } else {
+ __ StubPrologue();
+ frame()->SetRegisterSaveAreaSize(
+ StandardFrameConstants::kFixedFrameSizeFromFp);
+ }
+ int stack_slots = frame()->GetSpillSlotCount();
+ if (stack_slots > 0) {
+ __ Subu(sp, sp, Operand(stack_slots * kPointerSize));
+ }
+}
+
+
+void CodeGenerator::AssembleReturn() {
+ CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
+ if (descriptor->kind() == CallDescriptor::kCallAddress) {
+ if (frame()->GetRegisterSaveAreaSize() > 0) {
+ // Remove this frame's spill slots first.
+ int stack_slots = frame()->GetSpillSlotCount();
+ if (stack_slots > 0) {
+ __ Addu(sp, sp, Operand(stack_slots * kPointerSize));
+ }
+ // Restore registers.
+ const RegList saves = descriptor->CalleeSavedRegisters();
+ if (saves != 0) {
+ __ MultiPop(saves);
+ }
+ }
+ __ mov(sp, fp);
+ __ Pop(ra, fp);
+ __ Ret();
+ } else {
+ __ mov(sp, fp);
+ __ Pop(ra, fp);
+ int pop_count = descriptor->IsJSFunctionCall()
+ ? static_cast<int>(descriptor->JSParameterCount())
+ : 0;
+ __ DropAndRet(pop_count);
+ }
+}
+
+
+void CodeGenerator::AssembleMove(InstructionOperand* source,
+ InstructionOperand* destination) {
+ MipsOperandConverter g(this, NULL);
+ // Dispatch on the source and destination operand kinds. Not all
+ // combinations are possible.
+ if (source->IsRegister()) {
+ DCHECK(destination->IsRegister() || destination->IsStackSlot());
+ Register src = g.ToRegister(source);
+ if (destination->IsRegister()) {
+ __ mov(g.ToRegister(destination), src);
+ } else {
+ __ sw(src, g.ToMemOperand(destination));
+ }
+ } else if (source->IsStackSlot()) {
+ DCHECK(destination->IsRegister() || destination->IsStackSlot());
+ MemOperand src = g.ToMemOperand(source);
+ if (destination->IsRegister()) {
+ __ lw(g.ToRegister(destination), src);
+ } else {
+ Register temp = kScratchReg;
+ __ lw(temp, src);
+ __ sw(temp, g.ToMemOperand(destination));
+ }
+ } else if (source->IsConstant()) {
+ Constant src = g.ToConstant(source);
+ if (destination->IsRegister() || destination->IsStackSlot()) {
+ Register dst =
+ destination->IsRegister() ? g.ToRegister(destination) : kScratchReg;
+ switch (src.type()) {
+ case Constant::kInt32:
+ __ li(dst, Operand(src.ToInt32()));
+ break;
+ case Constant::kFloat32:
+ __ li(dst, isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
+ break;
+ case Constant::kInt64:
+ UNREACHABLE();
+ break;
+ case Constant::kFloat64:
+ __ li(dst, isolate()->factory()->NewNumber(src.ToFloat64(), TENURED));
+ break;
+ case Constant::kExternalReference:
+ __ li(dst, Operand(src.ToExternalReference()));
+ break;
+ case Constant::kHeapObject:
+ __ li(dst, src.ToHeapObject());
+ break;
+ }
+ if (destination->IsStackSlot()) __ sw(dst, g.ToMemOperand(destination));
+ } else if (src.type() == Constant::kFloat32) {
+ FPURegister dst = destination->IsDoubleRegister()
+ ? g.ToDoubleRegister(destination)
+ : kScratchDoubleReg.low();
+ // TODO(turbofan): Can we do better here?
+ __ li(at, Operand(bit_cast<int32_t>(src.ToFloat32())));
+ __ mtc1(at, dst);
+ if (destination->IsDoubleStackSlot()) {
+ __ swc1(dst, g.ToMemOperand(destination));
+ }
+ } else {
+ DCHECK_EQ(Constant::kFloat64, src.type());
+ DoubleRegister dst = destination->IsDoubleRegister()
+ ? g.ToDoubleRegister(destination)
+ : kScratchDoubleReg;
+ __ Move(dst, src.ToFloat64());
+ if (destination->IsDoubleStackSlot()) {
+ __ sdc1(dst, g.ToMemOperand(destination));
+ }
+ }
+ } else if (source->IsDoubleRegister()) {
+ FPURegister src = g.ToDoubleRegister(source);
+ if (destination->IsDoubleRegister()) {
+ FPURegister dst = g.ToDoubleRegister(destination);
+ __ Move(dst, src);
+ } else {
+ DCHECK(destination->IsDoubleStackSlot());
+ __ sdc1(src, g.ToMemOperand(destination));
+ }
+ } else if (source->IsDoubleStackSlot()) {
+ DCHECK(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
+ MemOperand src = g.ToMemOperand(source);
+ if (destination->IsDoubleRegister()) {
+ __ ldc1(g.ToDoubleRegister(destination), src);
+ } else {
+ FPURegister temp = kScratchDoubleReg;
+ __ ldc1(temp, src);
+ __ sdc1(temp, g.ToMemOperand(destination));
+ }
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+void CodeGenerator::AssembleSwap(InstructionOperand* source,
+ InstructionOperand* destination) {
+ MipsOperandConverter g(this, NULL);
+ // Dispatch on the source and destination operand kinds. Not all
+ // combinations are possible.
+ if (source->IsRegister()) {
+ // Register-register.
+ Register temp = kScratchReg;
+ Register src = g.ToRegister(source);
+ if (destination->IsRegister()) {
+ Register dst = g.ToRegister(destination);
+ __ Move(temp, src);
+ __ Move(src, dst);
+ __ Move(dst, temp);
+ } else {
+ DCHECK(destination->IsStackSlot());
+ MemOperand dst = g.ToMemOperand(destination);
+ __ mov(temp, src);
+ __ lw(src, dst);
+ __ sw(temp, dst);
+ }
+ } else if (source->IsStackSlot()) {
+ DCHECK(destination->IsStackSlot());
+ Register temp_0 = kScratchReg;
+ Register temp_1 = kCompareReg;
+ MemOperand src = g.ToMemOperand(source);
+ MemOperand dst = g.ToMemOperand(destination);
+ __ lw(temp_0, src);
+ __ lw(temp_1, dst);
+ __ sw(temp_0, dst);
+ __ sw(temp_1, src);
+ } else if (source->IsDoubleRegister()) {
+ FPURegister temp = kScratchDoubleReg;
+ FPURegister src = g.ToDoubleRegister(source);
+ if (destination->IsDoubleRegister()) {
+ FPURegister dst = g.ToDoubleRegister(destination);
+ __ Move(temp, src);
+ __ Move(src, dst);
+ __ Move(dst, temp);
+ } else {
+ DCHECK(destination->IsDoubleStackSlot());
+ MemOperand dst = g.ToMemOperand(destination);
+ __ Move(temp, src);
+ __ ldc1(src, dst);
+ __ sdc1(temp, dst);
+ }
+ } else if (source->IsDoubleStackSlot()) {
+ DCHECK(destination->IsDoubleStackSlot());
+ Register temp_0 = kScratchReg;
+ FPURegister temp_1 = kScratchDoubleReg;
+ MemOperand src0 = g.ToMemOperand(source);
+ MemOperand src1(src0.rm(), src0.offset() + kPointerSize);
+ MemOperand dst0 = g.ToMemOperand(destination);
+ MemOperand dst1(dst0.rm(), dst0.offset() + kPointerSize);
+ __ ldc1(temp_1, dst0); // Save destination in temp_1.
+ __ lw(temp_0, src0); // Then use temp_0 to copy source to destination.
+ __ sw(temp_0, dst0);
+ __ lw(temp_0, src1);
+ __ sw(temp_0, dst1);
+ __ sdc1(temp_1, src0);
+ } else {
+ // No other combinations are possible.
+ UNREACHABLE();
+ }
+}
+
+
+void CodeGenerator::AddNopForSmiCodeInlining() {
+ // Unused on 32-bit ARM. Still exists on 64-bit arm.
+ // TODO(plind): Unclear when this is called now. Understand, fix if needed.
+ __ nop(); // Maybe PROPERTY_ACCESS_INLINED?
+}
+
+
+void CodeGenerator::EnsureSpaceForLazyDeopt() {
+ int space_needed = Deoptimizer::patch_size();
+ if (!info()->IsStub()) {
+ // Ensure that we have enough space after the previous lazy-bailout
+ // instruction for patching the code here.
+ int current_pc = masm()->pc_offset();
+ if (current_pc < last_lazy_deopt_pc_ + space_needed) {
+ // Block tramoline pool emission for duration of padding.
+ v8::internal::Assembler::BlockTrampolinePoolScope block_trampoline_pool(
+ masm());
+ int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
+ DCHECK_EQ(0, padding_size % v8::internal::Assembler::kInstrSize);
+ while (padding_size > 0) {
+ __ nop();
+ padding_size -= v8::internal::Assembler::kInstrSize;
+ }
+ }
+ }
+ MarkLazyDeoptSite();
+}
+
+#undef __
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_MIPS_INSTRUCTION_CODES_MIPS_H_
+#define V8_COMPILER_MIPS_INSTRUCTION_CODES_MIPS_H_
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// MIPS-specific opcodes that specify which assembly sequence to emit.
+// Most opcodes specify a single instruction.
+#define TARGET_ARCH_OPCODE_LIST(V) \
+ V(MipsAdd) \
+ V(MipsAddOvf) \
+ V(MipsSub) \
+ V(MipsSubOvf) \
+ V(MipsMul) \
+ V(MipsMulHigh) \
+ V(MipsMulHighU) \
+ V(MipsDiv) \
+ V(MipsDivU) \
+ V(MipsMod) \
+ V(MipsModU) \
+ V(MipsAnd) \
+ V(MipsOr) \
+ V(MipsXor) \
+ V(MipsShl) \
+ V(MipsShr) \
+ V(MipsSar) \
+ V(MipsRor) \
+ V(MipsMov) \
+ V(MipsTst) \
+ V(MipsCmp) \
+ V(MipsCmpD) \
+ V(MipsAddD) \
+ V(MipsSubD) \
+ V(MipsMulD) \
+ V(MipsDivD) \
+ V(MipsModD) \
+ V(MipsSqrtD) \
+ V(MipsCvtSD) \
+ V(MipsCvtDS) \
+ V(MipsTruncWD) \
+ V(MipsTruncUwD) \
+ V(MipsCvtDW) \
+ V(MipsCvtDUw) \
+ V(MipsLb) \
+ V(MipsLbu) \
+ V(MipsSb) \
+ V(MipsLh) \
+ V(MipsLhu) \
+ V(MipsSh) \
+ V(MipsLw) \
+ V(MipsSw) \
+ V(MipsLwc1) \
+ V(MipsSwc1) \
+ V(MipsLdc1) \
+ V(MipsSdc1) \
+ V(MipsPush) \
+ V(MipsStoreWriteBarrier)
+
+
+// Addressing modes represent the "shape" of inputs to an instruction.
+// Many instructions support multiple addressing modes. Addressing modes
+// are encoded into the InstructionCode of the instruction and tell the
+// code generator after register allocation which assembler method to call.
+//
+// We use the following local notation for addressing modes:
+//
+// R = register
+// O = register or stack slot
+// D = double register
+// I = immediate (handle, external, int32)
+// MRI = [register + immediate]
+// MRR = [register + register]
+// TODO(plind): Add the new r6 address modes.
+#define TARGET_ADDRESSING_MODE_LIST(V) \
+ V(MRI) /* [%r0 + K] */ \
+ V(MRR) /* [%r0 + %r1] */
+
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_MIPS_INSTRUCTION_CODES_MIPS_H_
--- /dev/null
+// 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/base/bits.h"
+#include "src/compiler/instruction-selector-impl.h"
+#include "src/compiler/node-matchers.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+#define TRACE_UNIMPL() \
+ PrintF("UNIMPLEMENTED instr_sel: %s at line %d\n", __FUNCTION__, __LINE__)
+
+#define TRACE() PrintF("instr_sel: %s at line %d\n", __FUNCTION__, __LINE__)
+
+
+// Adds Mips-specific methods for generating InstructionOperands.
+class MipsOperandGenerator FINAL : public OperandGenerator {
+ public:
+ explicit MipsOperandGenerator(InstructionSelector* selector)
+ : OperandGenerator(selector) {}
+
+ InstructionOperand* UseOperand(Node* node, InstructionCode opcode) {
+ if (CanBeImmediate(node, opcode)) {
+ return UseImmediate(node);
+ }
+ return UseRegister(node);
+ }
+
+ bool CanBeImmediate(Node* node, InstructionCode opcode) {
+ Int32Matcher m(node);
+ if (!m.HasValue()) return false;
+ int32_t value = m.Value();
+ switch (ArchOpcodeField::decode(opcode)) {
+ case kMipsShl:
+ case kMipsSar:
+ case kMipsShr:
+ return is_uint5(value);
+ case kMipsXor:
+ return is_uint16(value);
+ case kMipsLdc1:
+ case kMipsSdc1:
+ return is_int16(value + kIntSize);
+ default:
+ return is_int16(value);
+ }
+ }
+
+ private:
+ bool ImmediateFitsAddrMode1Instruction(int32_t imm) const {
+ TRACE_UNIMPL();
+ return false;
+ }
+};
+
+
+static void VisitRRR(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ MipsOperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+}
+
+
+static void VisitRRO(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ MipsOperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)),
+ g.UseOperand(node->InputAt(1), opcode));
+}
+
+
+static void VisitBinop(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont) {
+ MipsOperandGenerator g(selector);
+ Int32BinopMatcher m(node);
+ InstructionOperand* inputs[4];
+ size_t input_count = 0;
+ InstructionOperand* outputs[2];
+ size_t output_count = 0;
+
+ inputs[input_count++] = g.UseRegister(m.left().node());
+ inputs[input_count++] = g.UseOperand(m.right().node(), opcode);
+
+ if (cont->IsBranch()) {
+ inputs[input_count++] = g.Label(cont->true_block());
+ inputs[input_count++] = g.Label(cont->false_block());
+ }
+
+ outputs[output_count++] = g.DefineAsRegister(node);
+ if (cont->IsSet()) {
+ outputs[output_count++] = g.DefineAsRegister(cont->result());
+ }
+
+ DCHECK_NE(0, input_count);
+ DCHECK_NE(0, output_count);
+ DCHECK_GE(arraysize(inputs), input_count);
+ DCHECK_GE(arraysize(outputs), output_count);
+
+ Instruction* instr = selector->Emit(cont->Encode(opcode), output_count,
+ outputs, input_count, inputs);
+ if (cont->IsBranch()) instr->MarkAsControl();
+}
+
+
+static void VisitBinop(InstructionSelector* selector, Node* node,
+ InstructionCode opcode) {
+ FlagsContinuation cont;
+ VisitBinop(selector, node, opcode, &cont);
+}
+
+
+void InstructionSelector::VisitLoad(Node* node) {
+ MachineType rep = RepresentationOf(OpParameter<LoadRepresentation>(node));
+ MachineType typ = TypeOf(OpParameter<LoadRepresentation>(node));
+ MipsOperandGenerator g(this);
+ Node* base = node->InputAt(0);
+ Node* index = node->InputAt(1);
+
+ ArchOpcode opcode;
+ switch (rep) {
+ case kRepFloat32:
+ opcode = kMipsLwc1;
+ break;
+ case kRepFloat64:
+ opcode = kMipsLdc1;
+ break;
+ case kRepBit: // Fall through.
+ case kRepWord8:
+ opcode = typ == kTypeUint32 ? kMipsLbu : kMipsLb;
+ break;
+ case kRepWord16:
+ opcode = typ == kTypeUint32 ? kMipsLhu : kMipsLh;
+ break;
+ case kRepTagged: // Fall through.
+ case kRepWord32:
+ opcode = kMipsLw;
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+
+ if (g.CanBeImmediate(index, opcode)) {
+ Emit(opcode | AddressingModeField::encode(kMode_MRI),
+ g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
+ } else {
+ InstructionOperand* addr_reg = g.TempRegister();
+ Emit(kMipsAdd | AddressingModeField::encode(kMode_None), addr_reg,
+ g.UseRegister(index), g.UseRegister(base));
+ // Emit desired load opcode, using temp addr_reg.
+ Emit(opcode | AddressingModeField::encode(kMode_MRI),
+ g.DefineAsRegister(node), addr_reg, g.TempImmediate(0));
+ }
+}
+
+
+void InstructionSelector::VisitStore(Node* node) {
+ MipsOperandGenerator g(this);
+ Node* base = node->InputAt(0);
+ Node* index = node->InputAt(1);
+ Node* value = node->InputAt(2);
+
+ StoreRepresentation store_rep = OpParameter<StoreRepresentation>(node);
+ MachineType rep = RepresentationOf(store_rep.machine_type());
+ if (store_rep.write_barrier_kind() == kFullWriteBarrier) {
+ DCHECK(rep == kRepTagged);
+ // TODO(dcarney): refactor RecordWrite function to take temp registers
+ // and pass them here instead of using fixed regs
+ // TODO(dcarney): handle immediate indices.
+ InstructionOperand* temps[] = {g.TempRegister(t1), g.TempRegister(t2)};
+ Emit(kMipsStoreWriteBarrier, NULL, g.UseFixed(base, t0),
+ g.UseFixed(index, t1), g.UseFixed(value, t2), arraysize(temps), temps);
+ return;
+ }
+ DCHECK_EQ(kNoWriteBarrier, store_rep.write_barrier_kind());
+
+ ArchOpcode opcode;
+ switch (rep) {
+ case kRepFloat32:
+ opcode = kMipsSwc1;
+ break;
+ case kRepFloat64:
+ opcode = kMipsSdc1;
+ break;
+ case kRepBit: // Fall through.
+ case kRepWord8:
+ opcode = kMipsSb;
+ break;
+ case kRepWord16:
+ opcode = kMipsSh;
+ break;
+ case kRepTagged: // Fall through.
+ case kRepWord32:
+ opcode = kMipsSw;
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+
+ if (g.CanBeImmediate(index, opcode)) {
+ Emit(opcode | AddressingModeField::encode(kMode_MRI), NULL,
+ g.UseRegister(base), g.UseImmediate(index), g.UseRegister(value));
+ } else {
+ InstructionOperand* addr_reg = g.TempRegister();
+ Emit(kMipsAdd | AddressingModeField::encode(kMode_None), addr_reg,
+ g.UseRegister(index), g.UseRegister(base));
+ // Emit desired store opcode, using temp addr_reg.
+ Emit(opcode | AddressingModeField::encode(kMode_MRI), NULL, addr_reg,
+ g.TempImmediate(0), g.UseRegister(value));
+ }
+}
+
+
+void InstructionSelector::VisitWord32And(Node* node) {
+ VisitBinop(this, node, kMipsAnd);
+}
+
+
+void InstructionSelector::VisitWord32Or(Node* node) {
+ VisitBinop(this, node, kMipsOr);
+}
+
+
+void InstructionSelector::VisitWord32Xor(Node* node) {
+ VisitBinop(this, node, kMipsXor);
+}
+
+
+void InstructionSelector::VisitWord32Shl(Node* node) {
+ VisitRRO(this, kMipsShl, node);
+}
+
+
+void InstructionSelector::VisitWord32Shr(Node* node) {
+ VisitRRO(this, kMipsShr, node);
+}
+
+
+void InstructionSelector::VisitWord32Sar(Node* node) {
+ VisitRRO(this, kMipsSar, node);
+}
+
+
+void InstructionSelector::VisitWord32Ror(Node* node) {
+ VisitRRO(this, kMipsRor, node);
+}
+
+
+void InstructionSelector::VisitInt32Add(Node* node) {
+ MipsOperandGenerator g(this);
+
+ // TODO(plind): Consider multiply & add optimization from arm port.
+ VisitBinop(this, node, kMipsAdd);
+}
+
+
+void InstructionSelector::VisitInt32Sub(Node* node) {
+ VisitBinop(this, node, kMipsSub);
+}
+
+
+void InstructionSelector::VisitInt32Mul(Node* node) {
+ MipsOperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ if (m.right().HasValue() && m.right().Value() > 0) {
+ int32_t value = m.right().Value();
+ if (base::bits::IsPowerOfTwo32(value)) {
+ Emit(kMipsShl | AddressingModeField::encode(kMode_None),
+ g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.TempImmediate(WhichPowerOf2(value)));
+ return;
+ }
+ if (base::bits::IsPowerOfTwo32(value - 1)) {
+ InstructionOperand* temp = g.TempRegister();
+ Emit(kMipsShl | AddressingModeField::encode(kMode_None), temp,
+ g.UseRegister(m.left().node()),
+ g.TempImmediate(WhichPowerOf2(value - 1)));
+ Emit(kMipsAdd | AddressingModeField::encode(kMode_None),
+ g.DefineAsRegister(node), g.UseRegister(m.left().node()), temp);
+ return;
+ }
+ if (base::bits::IsPowerOfTwo32(value + 1)) {
+ InstructionOperand* temp = g.TempRegister();
+ Emit(kMipsShl | AddressingModeField::encode(kMode_None), temp,
+ g.UseRegister(m.left().node()),
+ g.TempImmediate(WhichPowerOf2(value + 1)));
+ Emit(kMipsSub | AddressingModeField::encode(kMode_None),
+ g.DefineAsRegister(node), temp, g.UseRegister(m.left().node()));
+ return;
+ }
+ }
+ Emit(kMipsMul, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()));
+}
+
+
+void InstructionSelector::VisitInt32MulHigh(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsMulHigh, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+}
+
+
+void InstructionSelector::VisitUint32MulHigh(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsMulHighU, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)),
+ g.UseRegister(node->InputAt(1)));
+}
+
+
+void InstructionSelector::VisitInt32Div(Node* node) {
+ MipsOperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ Emit(kMipsDiv, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()));
+}
+
+
+void InstructionSelector::VisitUint32Div(Node* node) {
+ MipsOperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ Emit(kMipsDivU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()));
+}
+
+
+void InstructionSelector::VisitInt32Mod(Node* node) {
+ MipsOperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ Emit(kMipsMod, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()));
+}
+
+
+void InstructionSelector::VisitUint32Mod(Node* node) {
+ MipsOperandGenerator g(this);
+ Int32BinopMatcher m(node);
+ Emit(kMipsModU, g.DefineAsRegister(node), g.UseRegister(m.left().node()),
+ g.UseRegister(m.right().node()));
+}
+
+
+void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsCvtDS, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsCvtDW, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsCvtDUw, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsTruncWD, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsTruncUwD, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsCvtSD, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitFloat64Add(Node* node) {
+ VisitRRR(this, kMipsAddD, node);
+}
+
+
+void InstructionSelector::VisitFloat64Sub(Node* node) {
+ VisitRRR(this, kMipsSubD, node);
+}
+
+
+void InstructionSelector::VisitFloat64Mul(Node* node) {
+ VisitRRR(this, kMipsMulD, node);
+}
+
+
+void InstructionSelector::VisitFloat64Div(Node* node) {
+ VisitRRR(this, kMipsDivD, node);
+}
+
+
+void InstructionSelector::VisitFloat64Mod(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsModD, g.DefineAsFixed(node, f0), g.UseFixed(node->InputAt(0), f12),
+ g.UseFixed(node->InputAt(1), f14))->MarkAsCall();
+}
+
+
+void InstructionSelector::VisitFloat64Sqrt(Node* node) {
+ MipsOperandGenerator g(this);
+ Emit(kMipsSqrtD, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+}
+
+
+void InstructionSelector::VisitFloat64Floor(Node* node) { UNREACHABLE(); }
+
+
+void InstructionSelector::VisitFloat64Ceil(Node* node) { UNREACHABLE(); }
+
+
+void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
+ UNREACHABLE();
+}
+
+
+void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
+ UNREACHABLE();
+}
+
+
+void InstructionSelector::VisitCall(Node* node) {
+ MipsOperandGenerator g(this);
+ CallDescriptor* descriptor = OpParameter<CallDescriptor*>(node);
+
+ FrameStateDescriptor* frame_state_descriptor = NULL;
+ if (descriptor->NeedsFrameState()) {
+ frame_state_descriptor =
+ GetFrameStateDescriptor(node->InputAt(descriptor->InputCount()));
+ }
+
+ CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
+
+ // Compute InstructionOperands for inputs and outputs.
+ InitializeCallBuffer(node, &buffer, true, false);
+
+ // TODO(dcarney): might be possible to use claim/poke instead
+ // Push any stack arguments.
+ for (NodeVectorRIter input = buffer.pushed_nodes.rbegin();
+ input != buffer.pushed_nodes.rend(); input++) {
+ // TODO(plind): inefficient for MIPS, use MultiPush here.
+ // - Also need to align the stack. See arm64.
+ // - Maybe combine with arg slot stuff in DirectCEntry stub.
+ Emit(kMipsPush, NULL, g.UseRegister(*input));
+ }
+
+ // Select the appropriate opcode based on the call type.
+ InstructionCode opcode;
+ switch (descriptor->kind()) {
+ case CallDescriptor::kCallCodeObject: {
+ opcode = kArchCallCodeObject;
+ break;
+ }
+ case CallDescriptor::kCallJSFunction:
+ opcode = kArchCallJSFunction;
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+ opcode |= MiscField::encode(descriptor->flags());
+
+ // Emit the call instruction.
+ InstructionOperand** first_output =
+ buffer.outputs.size() > 0 ? &buffer.outputs.front() : NULL;
+ Instruction* call_instr =
+ Emit(opcode, buffer.outputs.size(), first_output,
+ buffer.instruction_args.size(), &buffer.instruction_args.front());
+ call_instr->MarkAsCall();
+}
+
+
+namespace {
+
+// Shared routine for multiple compare operations.
+static void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
+ InstructionOperand* left, InstructionOperand* right,
+ FlagsContinuation* cont) {
+ MipsOperandGenerator g(selector);
+ opcode = cont->Encode(opcode);
+ if (cont->IsBranch()) {
+ selector->Emit(opcode, NULL, left, right, g.Label(cont->true_block()),
+ g.Label(cont->false_block()))->MarkAsControl();
+ } else {
+ DCHECK(cont->IsSet());
+ // TODO(plind): Revisit and test this path.
+ selector->Emit(opcode, g.DefineAsRegister(cont->result()), left, right);
+ }
+}
+
+
+// Shared routine for multiple float compare operations.
+void VisitFloat64Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ MipsOperandGenerator g(selector);
+ Node* left = node->InputAt(0);
+ Node* right = node->InputAt(1);
+ VisitCompare(selector, kMipsCmpD, g.UseRegister(left), g.UseRegister(right),
+ cont);
+}
+
+
+// Shared routine for multiple word compare operations.
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont,
+ bool commutative) {
+ MipsOperandGenerator g(selector);
+ Node* left = node->InputAt(0);
+ Node* right = node->InputAt(1);
+
+ // Match immediates on left or right side of comparison.
+ if (g.CanBeImmediate(right, opcode)) {
+ VisitCompare(selector, opcode, g.UseRegister(left), g.UseImmediate(right),
+ cont);
+ } else if (g.CanBeImmediate(left, opcode)) {
+ if (!commutative) cont->Commute();
+ VisitCompare(selector, opcode, g.UseRegister(right), g.UseImmediate(left),
+ cont);
+ } else {
+ VisitCompare(selector, opcode, g.UseRegister(left), g.UseRegister(right),
+ cont);
+ }
+}
+
+
+void VisitWordCompare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitWordCompare(selector, node, kMipsCmp, cont, false);
+}
+
+} // namespace
+
+
+// Shared routine for word comparisons against zero.
+void VisitWordCompareZero(InstructionSelector* selector, Node* user,
+ Node* value, FlagsContinuation* cont) {
+ while (selector->CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord32Equal: {
+ // Combine with comparisons against 0 by simply inverting the
+ // continuation.
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont->Negate();
+ continue;
+ }
+ cont->OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(selector, value, cont);
+ }
+ case IrOpcode::kInt32LessThan:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kInt32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kUint32LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
+ return VisitWordCompare(selector, value, cont);
+ case IrOpcode::kFloat64Equal:
+ cont->OverwriteAndNegateIfEqual(kUnorderedEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThan:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThan);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kFloat64LessThanOrEqual:
+ cont->OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
+ return VisitFloat64Compare(selector, value, cont);
+ case IrOpcode::kProjection:
+ // Check if this is the overflow output projection of an
+ // <Operation>WithOverflow node.
+ if (OpParameter<size_t>(value) == 1u) {
+ // We cannot combine the <Operation>WithOverflow with this branch
+ // unless the 0th projection (the use of the actual value of the
+ // <Operation> is either NULL, which means there's no use of the
+ // actual value, or was already defined, which means it is scheduled
+ // *AFTER* this branch).
+ Node* const node = value->InputAt(0);
+ Node* const result = node->FindProjection(0);
+ if (!result || selector->IsDefined(result)) {
+ switch (node->opcode()) {
+ case IrOpcode::kInt32AddWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kMipsAddOvf, cont);
+ case IrOpcode::kInt32SubWithOverflow:
+ cont->OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(selector, node, kMipsSubOvf, cont);
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(selector, value, kMipsTst, cont, true);
+ default:
+ break;
+ }
+ break;
+ }
+
+ // Continuation could not be combined with a compare, emit compare against 0.
+ MipsOperandGenerator g(selector);
+ InstructionCode const opcode = cont->Encode(kMipsCmp);
+ InstructionOperand* const value_operand = g.UseRegister(value);
+ if (cont->IsBranch()) {
+ selector->Emit(opcode, nullptr, value_operand, g.TempImmediate(0),
+ g.Label(cont->true_block()),
+ g.Label(cont->false_block()))->MarkAsControl();
+ } else {
+ selector->Emit(opcode, g.DefineAsRegister(cont->result()), value_operand,
+ g.TempImmediate(0));
+ }
+}
+
+
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
+ FlagsContinuation cont(kNotEqual, tbranch, fbranch);
+ // If we can fall through to the true block, invert the branch.
+ if (IsNextInAssemblyOrder(tbranch)) {
+ cont.Negate();
+ cont.SwapBlocks();
+ }
+ VisitWordCompareZero(this, branch, branch->InputAt(0), &cont);
+}
+
+
+void InstructionSelector::VisitWord32Equal(Node* const node) {
+ FlagsContinuation cont(kEqual, node);
+ Int32BinopMatcher m(node);
+ if (m.right().Is(0)) {
+ return VisitWordCompareZero(this, m.node(), m.left().node(), &cont);
+ }
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kMipsAddOvf, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop(this, node, kMipsAddOvf, &cont);
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kMipsSubOvf, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop(this, node, kMipsSubOvf, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64Equal(Node* node) {
+ FlagsContinuation cont(kUnorderedEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThan(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThan, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ return MachineOperatorBuilder::kNoFlags;
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/v8.h"
+
+#include "src/assembler.h"
+#include "src/code-stubs.h"
+#include "src/compiler/linkage.h"
+#include "src/compiler/linkage-impl.h"
+#include "src/zone.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+struct MipsLinkageHelperTraits {
+ static Register ReturnValueReg() { return v0; }
+ static Register ReturnValue2Reg() { return v1; }
+ static Register JSCallFunctionReg() { return a1; }
+ static Register ContextReg() { return cp; }
+ static Register RuntimeCallFunctionReg() { return a1; }
+ static Register RuntimeCallArgCountReg() { return a0; }
+ static RegList CCalleeSaveRegisters() {
+ return s0.bit() | s1.bit() | s2.bit() | s3.bit() | s4.bit() | s5.bit() |
+ s6.bit() | s7.bit();
+ }
+ static Register CRegisterParameter(int i) {
+ static Register register_parameters[] = {a0, a1, a2, a3};
+ return register_parameters[i];
+ }
+ static int CRegisterParametersLength() { return 4; }
+};
+
+
+typedef LinkageHelper<MipsLinkageHelperTraits> LH;
+
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
+ return LH::GetJSCallDescriptor(zone, parameter_count, flags);
+}
+
+
+CallDescriptor* Linkage::GetRuntimeCallDescriptor(
+ Runtime::FunctionId function, int parameter_count,
+ Operator::Properties properties, Zone* zone) {
+ return LH::GetRuntimeCallDescriptor(zone, function, parameter_count,
+ properties);
+}
+
+
+CallDescriptor* Linkage::GetStubCallDescriptor(
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
+ CallDescriptor::Flags flags, Zone* zone) {
+ return LH::GetStubCallDescriptor(zone, descriptor, stack_parameter_count,
+ flags);
+}
+
+
+CallDescriptor* Linkage::GetSimplifiedCDescriptor(Zone* zone,
+ MachineSignature* sig) {
+ return LH::GetSimplifiedCDescriptor(zone, sig);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
template <class T>
-T NodeAuxData<T>::Get(Node* node) {
+T NodeAuxData<T>::Get(Node* node) const {
int id = node->id();
if (id >= static_cast<int>(aux_data_.size())) {
return T();
inline explicit NodeAuxData(Zone* zone);
inline void Set(Node* node, const T& data);
- inline T Get(Node* node);
+ inline T Get(Node* node) const;
private:
ZoneVector<T> aux_data_;
#include "src/compiler/node-cache.h"
+#include <cstring>
+
+#include "src/zone.h"
+#include "src/zone-containers.h"
+
namespace v8 {
namespace internal {
namespace compiler {
-#define INITIAL_SIZE 16
-#define LINEAR_PROBE 5
-
-template <typename Key>
-int32_t NodeCacheHash(Key key) {
- UNIMPLEMENTED();
- return 0;
-}
-
-template <>
-inline int32_t NodeCacheHash(int32_t key) {
- return ComputeIntegerHash(key, 0);
-}
-
-
-template <>
-inline int32_t NodeCacheHash(int64_t key) {
- return ComputeLongHash(key);
-}
-
-
-template <>
-inline int32_t NodeCacheHash(double key) {
- return ComputeLongHash(bit_cast<int64_t>(key));
-}
-
-
-template <>
-inline int32_t NodeCacheHash(void* key) {
- return ComputePointerHash(key);
-}
+template <typename Key, typename Hash, typename Pred>
+struct NodeCache<Key, Hash, Pred>::Entry {
+ Key key_;
+ Node* value_;
+};
-template <typename Key>
-bool NodeCache<Key>::Resize(Zone* zone) {
+template <typename Key, typename Hash, typename Pred>
+bool NodeCache<Key, Hash, Pred>::Resize(Zone* zone) {
if (size_ >= max_) return false; // Don't grow past the maximum size.
// Allocate a new block of entries 4x the size.
Entry* old_entries = entries_;
- int old_size = size_ + LINEAR_PROBE;
- size_ = size_ * 4;
- int num_entries = size_ + LINEAR_PROBE;
- entries_ = zone->NewArray<Entry>(num_entries);
+ size_t old_size = size_ + kLinearProbe;
+ size_ *= 4;
+ size_t num_entries = size_ + kLinearProbe;
+ entries_ = zone->NewArray<Entry>(static_cast<int>(num_entries));
memset(entries_, 0, sizeof(Entry) * num_entries);
// Insert the old entries into the new block.
- for (int i = 0; i < old_size; i++) {
+ for (size_t i = 0; i < old_size; ++i) {
Entry* old = &old_entries[i];
- if (old->value_ != NULL) {
- int hash = NodeCacheHash(old->key_);
- int start = hash & (size_ - 1);
- int end = start + LINEAR_PROBE;
- for (int j = start; j < end; j++) {
+ if (old->value_) {
+ size_t hash = hash_(old->key_);
+ size_t start = hash & (size_ - 1);
+ size_t end = start + kLinearProbe;
+ for (size_t j = start; j < end; ++j) {
Entry* entry = &entries_[j];
- if (entry->value_ == NULL) {
+ if (!entry->value_) {
entry->key_ = old->key_;
entry->value_ = old->value_;
break;
}
-template <typename Key>
-Node** NodeCache<Key>::Find(Zone* zone, Key key) {
- int32_t hash = NodeCacheHash(key);
- if (entries_ == NULL) {
+template <typename Key, typename Hash, typename Pred>
+Node** NodeCache<Key, Hash, Pred>::Find(Zone* zone, Key key) {
+ size_t hash = hash_(key);
+ if (!entries_) {
// Allocate the initial entries and insert the first entry.
- int num_entries = INITIAL_SIZE + LINEAR_PROBE;
- entries_ = zone->NewArray<Entry>(num_entries);
- size_ = INITIAL_SIZE;
+ size_t num_entries = kInitialSize + kLinearProbe;
+ entries_ = zone->NewArray<Entry>(static_cast<int>(num_entries));
+ size_ = kInitialSize;
memset(entries_, 0, sizeof(Entry) * num_entries);
- Entry* entry = &entries_[hash & (INITIAL_SIZE - 1)];
+ Entry* entry = &entries_[hash & (kInitialSize - 1)];
entry->key_ = key;
return &entry->value_;
}
- while (true) {
+ for (;;) {
// Search up to N entries after (linear probing).
- int start = hash & (size_ - 1);
- int end = start + LINEAR_PROBE;
- for (int i = start; i < end; i++) {
+ size_t start = hash & (size_ - 1);
+ size_t end = start + kLinearProbe;
+ for (size_t i = start; i < end; i++) {
Entry* entry = &entries_[i];
- if (entry->key_ == key) return &entry->value_;
- if (entry->value_ == NULL) {
+ if (pred_(entry->key_, key)) return &entry->value_;
+ if (!entry->value_) {
entry->key_ = key;
return &entry->value_;
}
// If resized to maximum and still didn't find space, overwrite an entry.
Entry* entry = &entries_[hash & (size_ - 1)];
entry->key_ = key;
- entry->value_ = NULL;
+ entry->value_ = nullptr;
return &entry->value_;
}
+template <typename Key, typename Hash, typename Pred>
+void NodeCache<Key, Hash, Pred>::GetCachedNodes(NodeVector* nodes) {
+ if (entries_) {
+ for (size_t i = 0; i < size_ + kLinearProbe; i++) {
+ if (entries_[i].value_ != NULL) nodes->push_back(entries_[i].value_);
+ }
+ }
+}
+
template class NodeCache<int64_t>;
template class NodeCache<int32_t>;
template class NodeCache<void*>;
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#ifndef V8_COMPILER_NODE_CACHE_H_
#define V8_COMPILER_NODE_CACHE_H_
-#include "src/v8.h"
-
+#include "src/base/functional.h"
+#include "src/base/macros.h"
#include "src/compiler/node.h"
namespace v8 {
// A cache for nodes based on a key. Useful for implementing canonicalization of
// nodes such as constants, parameters, etc.
-template <typename Key>
-class NodeCache {
+template <typename Key, typename Hash = base::hash<Key>,
+ typename Pred = std::equal_to<Key> >
+class NodeCache FINAL {
public:
- explicit NodeCache(int max = 256) : entries_(NULL), size_(0), max_(max) {}
+ explicit NodeCache(size_t max = 256)
+ : entries_(nullptr), size_(0), max_(max) {}
// Search for node associated with {key} and return a pointer to a memory
// location in this cache that stores an entry for the key. If the location
// too full or encounters too many hash collisions.
Node** Find(Zone* zone, Key key);
+ void GetCachedNodes(NodeVector* nodes);
+
private:
- struct Entry {
- Key key_;
- Node* value_;
- };
+ enum { kInitialSize = 16u, kLinearProbe = 5u };
+
+ struct Entry;
Entry* entries_; // lazily-allocated hash entries.
- int32_t size_;
- int32_t max_;
+ size_t size_;
+ size_t max_;
+ Hash hash_;
+ Pred pred_;
bool Resize(Zone* zone);
};
typedef NodeCache<int64_t> Int64NodeCache;
typedef NodeCache<int32_t> Int32NodeCache;
typedef NodeCache<void*> PtrNodeCache;
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_NODE_CACHE_H_
#include "src/compiler/node.h"
#include "src/compiler/operator.h"
+#include "src/unique.h"
namespace v8 {
namespace internal {
typedef IntMatcher<uint32_t, IrOpcode::kInt32Constant> Uint32Matcher;
typedef IntMatcher<int64_t, IrOpcode::kInt64Constant> Int64Matcher;
typedef IntMatcher<uint64_t, IrOpcode::kInt64Constant> Uint64Matcher;
+#if V8_HOST_ARCH_32_BIT
+typedef Int32Matcher IntPtrMatcher;
+typedef Uint32Matcher UintPtrMatcher;
+#else
+typedef Int64Matcher IntPtrMatcher;
+typedef Uint64Matcher UintPtrMatcher;
+#endif
// A pattern matcher for floating point constants.
typedef BinopMatcher<Uint32Matcher, Uint32Matcher> Uint32BinopMatcher;
typedef BinopMatcher<Int64Matcher, Int64Matcher> Int64BinopMatcher;
typedef BinopMatcher<Uint64Matcher, Uint64Matcher> Uint64BinopMatcher;
+typedef BinopMatcher<IntPtrMatcher, IntPtrMatcher> IntPtrBinopMatcher;
+typedef BinopMatcher<UintPtrMatcher, UintPtrMatcher> UintPtrBinopMatcher;
typedef BinopMatcher<Float64Matcher, Float64Matcher> Float64BinopMatcher;
-
-
-// Fairly intel-specify node matcher used for matching scale factors in
-// addressing modes.
-// Matches nodes of form [x * N] for N in {1,2,4,8}
-class ScaleFactorMatcher : public NodeMatcher {
- public:
- explicit ScaleFactorMatcher(Node* node)
- : NodeMatcher(node), left_(NULL), power_(0) {
- Match();
- }
-
- bool Matches() { return left_ != NULL; }
- int Power() {
- DCHECK(Matches());
- return power_;
- }
- Node* Left() {
- DCHECK(Matches());
- return left_;
- }
-
- private:
- void Match() {
- if (opcode() != IrOpcode::kInt32Mul) return;
- Int32BinopMatcher m(node());
- if (!m.right().HasValue()) return;
- int32_t value = m.right().Value();
- switch (value) {
- case 8:
- power_++; // Fall through.
- case 4:
- power_++; // Fall through.
- case 2:
- power_++; // Fall through.
- case 1:
- break;
- default:
- return;
- }
- left_ = m.left().node();
- }
-
- Node* left_;
- int power_;
-};
-
-
-// Fairly intel-specify node matcher used for matching index and displacement
-// operands in addressing modes.
-// Matches nodes of form:
-// [x * N]
-// [x * N + K]
-// [x + K]
-// [x] -- fallback case
-// for N in {1,2,4,8} and K int32_t
-class IndexAndDisplacementMatcher : public NodeMatcher {
- public:
- explicit IndexAndDisplacementMatcher(Node* node)
- : NodeMatcher(node), index_node_(node), displacement_(0), power_(0) {
- Match();
- }
-
- Node* index_node() { return index_node_; }
- int displacement() { return displacement_; }
- int power() { return power_; }
-
- private:
- void Match() {
- if (opcode() == IrOpcode::kInt32Add) {
- // Assume reduction has put constant on the right.
- Int32BinopMatcher m(node());
- if (m.right().HasValue()) {
- displacement_ = m.right().Value();
- index_node_ = m.left().node();
- }
- }
- // Test scale factor.
- ScaleFactorMatcher scale_matcher(index_node_);
- if (scale_matcher.Matches()) {
- index_node_ = scale_matcher.Left();
- power_ = scale_matcher.Power();
- }
- }
-
- Node* index_node_;
- int displacement_;
- int power_;
-};
-
+typedef BinopMatcher<NumberMatcher, NumberMatcher> NumberBinopMatcher;
} // namespace compiler
} // namespace internal
inline int NodeProperties::PastValueIndex(Node* node) {
- return FirstValueIndex(node) +
- OperatorProperties::GetValueInputCount(node->op());
+ return FirstValueIndex(node) + node->op()->ValueInputCount();
}
inline int NodeProperties::PastContextIndex(Node* node) {
}
inline int NodeProperties::PastEffectIndex(Node* node) {
- return FirstEffectIndex(node) +
- OperatorProperties::GetEffectInputCount(node->op());
+ return FirstEffectIndex(node) + node->op()->EffectInputCount();
}
inline int NodeProperties::PastControlIndex(Node* node) {
- return FirstControlIndex(node) +
- OperatorProperties::GetControlInputCount(node->op());
+ return FirstControlIndex(node) + node->op()->ControlInputCount();
}
// Input accessors.
inline Node* NodeProperties::GetValueInput(Node* node, int index) {
- DCHECK(0 <= index &&
- index < OperatorProperties::GetValueInputCount(node->op()));
+ DCHECK(0 <= index && index < node->op()->ValueInputCount());
return node->InputAt(FirstValueIndex(node) + index);
}
}
inline Node* NodeProperties::GetEffectInput(Node* node, int index) {
- DCHECK(0 <= index &&
- index < OperatorProperties::GetEffectInputCount(node->op()));
+ DCHECK(0 <= index && index < node->op()->EffectInputCount());
return node->InputAt(FirstEffectIndex(node) + index);
}
inline Node* NodeProperties::GetControlInput(Node* node, int index) {
- DCHECK(0 <= index &&
- index < OperatorProperties::GetControlInputCount(node->op()));
+ DCHECK(0 <= index && index < node->op()->ControlInputCount());
return node->InputAt(FirstControlIndex(node) + index);
}
inline bool NodeProperties::IsValueEdge(Node::Edge edge) {
Node* node = edge.from();
return IsInputRange(edge, FirstValueIndex(node),
- OperatorProperties::GetValueInputCount(node->op()));
+ node->op()->ValueInputCount());
}
inline bool NodeProperties::IsContextEdge(Node::Edge edge) {
inline bool NodeProperties::IsEffectEdge(Node::Edge edge) {
Node* node = edge.from();
return IsInputRange(edge, FirstEffectIndex(node),
- OperatorProperties::GetEffectInputCount(node->op()));
+ node->op()->EffectInputCount());
}
inline bool NodeProperties::IsControlEdge(Node::Edge edge) {
Node* node = edge.from();
return IsInputRange(edge, FirstControlIndex(node),
- OperatorProperties::GetControlInputCount(node->op()));
+ node->op()->ControlInputCount());
}
inline void NodeProperties::ReplaceEffectInput(Node* node, Node* effect,
int index) {
- DCHECK(index < OperatorProperties::GetEffectInputCount(node->op()));
+ DCHECK(index < node->op()->EffectInputCount());
return node->ReplaceInput(FirstEffectIndex(node) + index, effect);
}
}
inline void NodeProperties::RemoveNonValueInputs(Node* node) {
- node->TrimInputCount(OperatorProperties::GetValueInputCount(node->op()));
+ node->TrimInputCount(node->op()->ValueInputCount());
}
// {effect}. If {effect == NULL}, then use the effect input to {node}.
inline void NodeProperties::ReplaceWithValue(Node* node, Node* value,
Node* effect) {
- DCHECK(!OperatorProperties::HasControlOutput(node->op()));
- if (effect == NULL && OperatorProperties::HasEffectInput(node->op())) {
+ DCHECK(node->op()->ControlOutputCount() == 0);
+ if (effect == NULL && node->op()->EffectInputCount() > 0) {
effect = NodeProperties::GetEffectInput(node);
}
// -----------------------------------------------------------------------------
// Type Bounds.
-inline Bounds NodeProperties::GetBounds(Node* node) { return node->bounds(); }
+inline bool NodeProperties::IsTyped(Node* node) {
+ Bounds bounds = node->bounds();
+ DCHECK((bounds.lower == NULL) == (bounds.upper == NULL));
+ return bounds.upper != NULL;
+}
+
+inline Bounds NodeProperties::GetBounds(Node* node) {
+ DCHECK(IsTyped(node));
+ return node->bounds();
+}
inline void NodeProperties::SetBounds(Node* node, Bounds b) {
+ DCHECK(b.lower != NULL && b.upper != NULL);
node->set_bounds(b);
}
+inline bool NodeProperties::AllValueInputsAreTyped(Node* node) {
+ int input_count = node->op()->ValueInputCount();
+ for (int i = 0; i < input_count; ++i) {
+ if (!IsTyped(GetValueInput(node, i))) return false;
+ }
+ return true;
+}
+
}
}
static inline void ReplaceWithValue(Node* node, Node* value,
Node* effect = NULL);
+ static inline bool IsTyped(Node* node);
static inline Bounds GetBounds(Node* node);
static inline void SetBounds(Node* node, Bounds bounds);
+ static inline bool AllValueInputsAreTyped(Node* node);
static inline int FirstValueIndex(Node* node);
static inline int FirstContextIndex(Node* node);
}
-OStream& operator<<(OStream& os, const Operator& op) { return op.PrintTo(os); }
-
-
-OStream& operator<<(OStream& os, const Node& n) {
+std::ostream& operator<<(std::ostream& os, const Node& n) {
os << n.id() << ": " << *n.op();
- if (n.op()->InputCount() != 0) {
+ if (n.InputCount() > 0) {
os << "(";
- for (int i = 0; i < n.op()->InputCount(); ++i) {
+ for (int i = 0; i < n.InputCount(); ++i) {
if (i != 0) os << ", ";
os << n.InputAt(i)->id();
}
return static_cast<IrOpcode::Value>(op_->opcode());
}
- Bounds bounds() { return bounds_; }
-
protected:
const Operator* op_;
Bounds bounds_;
- explicit NodeData(Zone* zone) : bounds_(Bounds(Type::None(zone))) {}
+ explicit NodeData(Zone* zone) {}
friend class NodeProperties;
+ Bounds bounds() { return bounds_; }
void set_bounds(Bounds b) { bounds_ = b; }
};
// out-of-line indexed by the Node's id.
class Node FINAL : public GenericNode<NodeData, Node> {
public:
- Node(GenericGraphBase* graph, int input_count)
- : GenericNode<NodeData, Node>(graph, input_count) {}
+ Node(GenericGraphBase* graph, int input_count, int reserve_input_count)
+ : GenericNode<NodeData, Node>(graph, input_count, reserve_input_count) {}
void Initialize(const Operator* op) { set_op(op); }
Node* FindProjection(size_t projection_index);
};
-OStream& operator<<(OStream& os, const Node& n);
+std::ostream& operator<<(std::ostream& os, const Node& n);
typedef GenericGraphVisit::NullNodeVisitor<NodeData, Node> NullNodeVisitor;
// Opcodes for control operators.
#define INNER_CONTROL_OP_LIST(V) \
- V(Dead) \
- V(Loop) \
- V(Branch) \
- V(IfTrue) \
- V(IfFalse) \
- V(Merge) \
- V(Return) \
+ V(Dead) \
+ V(Loop) \
+ V(Branch) \
+ V(IfTrue) \
+ V(IfFalse) \
+ V(Merge) \
+ V(Return) \
+ V(Terminate) \
V(Throw)
#define CONTROL_OP_LIST(V) \
V(HeapConstant)
#define INNER_OP_LIST(V) \
+ V(Select) \
V(Phi) \
V(EffectPhi) \
- V(ControlEffect) \
V(ValueEffect) \
V(Finish) \
V(FrameState) \
V(LoadField) \
V(LoadElement) \
V(StoreField) \
- V(StoreElement)
+ V(StoreElement) \
+ V(ObjectIsSmi) \
+ V(ObjectIsNonNegativeSmi)
// Opcodes for Machine-level operators.
#define MACHINE_OP_LIST(V) \
V(Int32Sub) \
V(Int32SubWithOverflow) \
V(Int32Mul) \
+ V(Int32MulHigh) \
V(Int32Div) \
- V(Int32UDiv) \
V(Int32Mod) \
- V(Int32UMod) \
V(Int32LessThan) \
V(Int32LessThanOrEqual) \
+ V(Uint32Div) \
V(Uint32LessThan) \
V(Uint32LessThanOrEqual) \
+ V(Uint32Mod) \
+ V(Uint32MulHigh) \
V(Int64Add) \
V(Int64Sub) \
V(Int64Mul) \
V(Int64Div) \
- V(Int64UDiv) \
V(Int64Mod) \
- V(Int64UMod) \
V(Int64LessThan) \
V(Int64LessThanOrEqual) \
+ V(Uint64Div) \
+ V(Uint64LessThan) \
+ V(Uint64Mod) \
V(ChangeFloat32ToFloat64) \
V(ChangeFloat64ToInt32) \
V(ChangeFloat64ToUint32) \
V(Float64Sqrt) \
V(Float64Equal) \
V(Float64LessThan) \
- V(Float64LessThanOrEqual)
+ V(Float64LessThanOrEqual) \
+ V(Float64Floor) \
+ V(Float64Ceil) \
+ V(Float64RoundTruncate) \
+ V(Float64RoundTiesAway) \
+ V(LoadStackPointer)
#define VALUE_OP_LIST(V) \
COMMON_OP_LIST(V) \
// Returns the mnemonic name of an opcode.
static const char* Mnemonic(Value val) {
+ // TODO(turbofan): make this a table lookup.
switch (val) {
#define RETURN_NAME(x) \
case k##x: \
static bool IsJsOpcode(Value val) {
switch (val) {
+// TODO(turbofan): make this a range check.
#define RETURN_NAME(x) \
case k##x: \
return true;
static bool IsControlOpcode(Value val) {
switch (val) {
+// TODO(turbofan): make this a range check.
#define RETURN_NAME(x) \
case k##x: \
return true;
}
}
+ static bool IsLeafOpcode(Value val) {
+ switch (val) {
+// TODO(turbofan): make this a table lookup.
+#define RETURN_NAME(x) \
+ case k##x: \
+ return true;
+ LEAF_OP_LIST(RETURN_NAME)
+#undef RETURN_NAME
+ default:
+ return false;
+ }
+ }
+
static bool IsCommonOpcode(Value val) {
switch (val) {
+// TODO(turbofan): make this a table lookup or a range check.
#define RETURN_NAME(x) \
case k##x: \
return true;
#include "src/compiler/common-operator.h"
#include "src/compiler/js-operator.h"
+#include "src/compiler/linkage.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator-properties.h"
namespace internal {
namespace compiler {
-inline bool OperatorProperties::HasValueInput(const Operator* op) {
- return OperatorProperties::GetValueInputCount(op) > 0;
-}
-
inline bool OperatorProperties::HasContextInput(const Operator* op) {
IrOpcode::Value opcode = static_cast<IrOpcode::Value>(op->opcode());
return IrOpcode::IsJsOpcode(opcode);
}
-inline bool OperatorProperties::HasEffectInput(const Operator* op) {
- return OperatorProperties::GetEffectInputCount(op) > 0;
-}
-
-inline bool OperatorProperties::HasControlInput(const Operator* op) {
- return OperatorProperties::GetControlInputCount(op) > 0;
-}
-
inline bool OperatorProperties::HasFrameStateInput(const Operator* op) {
if (!FLAG_turbo_deoptimization) {
return false;
case IrOpcode::kFrameState:
return true;
case IrOpcode::kJSCallRuntime: {
- Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(op);
- return Linkage::NeedsFrameState(function);
+ const CallRuntimeParameters& p = CallRuntimeParametersOf(op);
+ return Linkage::NeedsFrameState(p.id());
}
// Strict equality cannot lazily deoptimize.
// Compare operations
case IrOpcode::kJSEqual:
- case IrOpcode::kJSNotEqual:
- case IrOpcode::kJSLessThan:
case IrOpcode::kJSGreaterThan:
- case IrOpcode::kJSLessThanOrEqual:
case IrOpcode::kJSGreaterThanOrEqual:
+ case IrOpcode::kJSHasProperty:
+ case IrOpcode::kJSInstanceOf:
+ case IrOpcode::kJSLessThan:
+ case IrOpcode::kJSLessThanOrEqual:
+ case IrOpcode::kJSNotEqual:
// Binary operations
+ case IrOpcode::kJSAdd:
+ case IrOpcode::kJSBitwiseAnd:
case IrOpcode::kJSBitwiseOr:
case IrOpcode::kJSBitwiseXor:
- case IrOpcode::kJSBitwiseAnd:
+ case IrOpcode::kJSDivide:
+ case IrOpcode::kJSLoadNamed:
+ case IrOpcode::kJSLoadProperty:
+ case IrOpcode::kJSModulus:
+ case IrOpcode::kJSMultiply:
case IrOpcode::kJSShiftLeft:
case IrOpcode::kJSShiftRight:
case IrOpcode::kJSShiftRightLogical:
- case IrOpcode::kJSAdd:
- case IrOpcode::kJSSubtract:
- case IrOpcode::kJSMultiply:
- case IrOpcode::kJSDivide:
- case IrOpcode::kJSModulus:
- case IrOpcode::kJSLoadProperty:
- case IrOpcode::kJSStoreProperty:
- case IrOpcode::kJSLoadNamed:
case IrOpcode::kJSStoreNamed:
+ case IrOpcode::kJSStoreProperty:
+ case IrOpcode::kJSSubtract:
+
+ // Conversions
+ case IrOpcode::kJSToObject:
+
+ // Other
+ case IrOpcode::kJSDeleteProperty:
return true;
default:
}
}
-inline int OperatorProperties::GetValueInputCount(const Operator* op) {
- return op->InputCount();
-}
-
inline int OperatorProperties::GetContextInputCount(const Operator* op) {
return OperatorProperties::HasContextInput(op) ? 1 : 0;
}
return OperatorProperties::HasFrameStateInput(op) ? 1 : 0;
}
-inline int OperatorProperties::GetEffectInputCount(const Operator* op) {
- if (op->opcode() == IrOpcode::kEffectPhi ||
- op->opcode() == IrOpcode::kFinish) {
- return OpParameter<int>(op);
- }
- if (op->HasProperty(Operator::kNoRead) && op->HasProperty(Operator::kNoWrite))
- return 0; // no effects.
- return 1;
-}
-
-inline int OperatorProperties::GetControlInputCount(const Operator* op) {
- switch (op->opcode()) {
- case IrOpcode::kPhi:
- case IrOpcode::kEffectPhi:
- case IrOpcode::kControlEffect:
- return 1;
-#define OPCODE_CASE(x) case IrOpcode::k##x:
- CONTROL_OP_LIST(OPCODE_CASE)
-#undef OPCODE_CASE
- // Control operators are Operator1<int>.
- return OpParameter<int>(op);
- default:
- // Operators that have write effects must have a control
- // dependency. Effect dependencies only ensure the correct order of
- // write/read operations without consideration of control flow. Without an
- // explicit control dependency writes can be float in the schedule too
- // early along a path that shouldn't generate a side-effect.
- return op->HasProperty(Operator::kNoWrite) ? 0 : 1;
- }
- return 0;
-}
-
inline int OperatorProperties::GetTotalInputCount(const Operator* op) {
- return GetValueInputCount(op) + GetContextInputCount(op) +
- GetFrameStateInputCount(op) + GetEffectInputCount(op) +
- GetControlInputCount(op);
+ return op->ValueInputCount() + GetContextInputCount(op) +
+ GetFrameStateInputCount(op) + op->EffectInputCount() +
+ op->ControlInputCount();
}
// -----------------------------------------------------------------------------
// Output properties.
-inline bool OperatorProperties::HasValueOutput(const Operator* op) {
- return GetValueOutputCount(op) > 0;
-}
-
-inline bool OperatorProperties::HasEffectOutput(const Operator* op) {
- return op->opcode() == IrOpcode::kStart ||
- op->opcode() == IrOpcode::kControlEffect ||
- op->opcode() == IrOpcode::kValueEffect ||
- (op->opcode() != IrOpcode::kFinish && GetEffectInputCount(op) > 0);
-}
-
-inline bool OperatorProperties::HasControlOutput(const Operator* op) {
- IrOpcode::Value opcode = static_cast<IrOpcode::Value>(op->opcode());
- return (opcode != IrOpcode::kEnd && IrOpcode::IsControlOpcode(opcode));
-}
-
-
-inline int OperatorProperties::GetValueOutputCount(const Operator* op) {
- return op->OutputCount();
-}
-
-inline int OperatorProperties::GetEffectOutputCount(const Operator* op) {
- return HasEffectOutput(op) ? 1 : 0;
-}
-
-inline int OperatorProperties::GetControlOutputCount(const Operator* node) {
- return node->opcode() == IrOpcode::kBranch ? 2 : HasControlOutput(node) ? 1
- : 0;
-}
-
-
inline bool OperatorProperties::IsBasicBlockBegin(const Operator* op) {
uint8_t opcode = op->opcode();
return opcode == IrOpcode::kStart || opcode == IrOpcode::kEnd ||
class OperatorProperties {
public:
- static inline bool HasValueInput(const Operator* op);
static inline bool HasContextInput(const Operator* op);
- static inline bool HasEffectInput(const Operator* op);
- static inline bool HasControlInput(const Operator* op);
static inline bool HasFrameStateInput(const Operator* op);
- static inline int GetValueInputCount(const Operator* op);
static inline int GetContextInputCount(const Operator* op);
- static inline int GetEffectInputCount(const Operator* op);
- static inline int GetControlInputCount(const Operator* op);
static inline int GetFrameStateInputCount(const Operator* op);
static inline int GetTotalInputCount(const Operator* op);
- static inline bool HasValueOutput(const Operator* op);
- static inline bool HasEffectOutput(const Operator* op);
- static inline bool HasControlOutput(const Operator* op);
-
- static inline int GetValueOutputCount(const Operator* op);
- static inline int GetEffectOutputCount(const Operator* op);
- static inline int GetControlOutputCount(const Operator* op);
-
static inline bool IsBasicBlockBegin(const Operator* op);
};
#include "src/compiler/operator.h"
+#include <limits>
+
namespace v8 {
namespace internal {
namespace compiler {
-Operator::~Operator() {}
+
+template <typename N>
+static inline N CheckRange(size_t val) {
+ CHECK(val <= std::numeric_limits<N>::max());
+ return static_cast<N>(val);
+}
+
+
+Operator::Operator(Opcode opcode, Properties properties, const char* mnemonic,
+ size_t value_in, size_t effect_in, size_t control_in,
+ size_t value_out, size_t effect_out, size_t control_out)
+ : opcode_(opcode),
+ properties_(properties),
+ mnemonic_(mnemonic),
+ value_in_(CheckRange<uint32_t>(value_in)),
+ effect_in_(CheckRange<uint16_t>(effect_in)),
+ control_in_(CheckRange<uint16_t>(control_in)),
+ value_out_(CheckRange<uint16_t>(value_out)),
+ effect_out_(CheckRange<uint8_t>(effect_out)),
+ control_out_(CheckRange<uint8_t>(control_out)) {}
-SimpleOperator::SimpleOperator(Opcode opcode, Properties properties,
- int input_count, int output_count,
- const char* mnemonic)
- : Operator(opcode, properties, mnemonic),
- input_count_(input_count),
- output_count_(output_count) {}
+std::ostream& operator<<(std::ostream& os, const Operator& op) {
+ op.PrintTo(os);
+ return os;
+}
-SimpleOperator::~SimpleOperator() {}
+void Operator::PrintTo(std::ostream& os) const { os << mnemonic(); }
} // namespace compiler
} // namespace internal
#ifndef V8_COMPILER_OPERATOR_H_
#define V8_COMPILER_OPERATOR_H_
+#include <ostream> // NOLINT(readability/streams)
+
#include "src/base/flags.h"
-#include "src/ostreams.h"
-#include "src/unique.h"
+#include "src/base/functional.h"
+#include "src/zone.h"
namespace v8 {
namespace internal {
};
typedef base::Flags<Property, uint8_t> Properties;
- Operator(Opcode opcode, Properties properties, const char* mnemonic)
- : opcode_(opcode), properties_(properties), mnemonic_(mnemonic) {}
- virtual ~Operator();
+ // Constructor.
+ Operator(Opcode opcode, Properties properties, const char* mnemonic,
+ size_t value_in, size_t effect_in, size_t control_in,
+ size_t value_out, size_t effect_out, size_t control_out);
+
+ virtual ~Operator() {}
// A small integer unique to all instances of a particular kind of operator,
// useful for quick matching for specific kinds of operators. For fast access
// Check if this operator equals another operator. Equivalent operators can
// be merged, and nodes with equivalent operators and equivalent inputs
// can be merged.
- virtual bool Equals(const Operator* other) const = 0;
+ virtual bool Equals(const Operator* that) const {
+ return this->opcode() == that->opcode();
+ }
// Compute a hashcode to speed up equivalence-set checking.
// Equal operators should always have equal hashcodes, and unequal operators
// should have unequal hashcodes with high probability.
- virtual int HashCode() const = 0;
+ virtual size_t HashCode() const { return base::hash<Opcode>()(opcode()); }
// Check whether this operator has the given property.
bool HasProperty(Property property) const {
}
// Number of data inputs to the operator, for verifying graph structure.
- virtual int InputCount() const = 0;
+ // TODO(titzer): convert callers to ValueInputCount();
+ int InputCount() const { return ValueInputCount(); }
// Number of data outputs from the operator, for verifying graph structure.
- virtual int OutputCount() const = 0;
+ // TODO(titzer): convert callers to ValueOutputCount();
+ int OutputCount() const { return ValueOutputCount(); }
Properties properties() const { return properties_; }
+ // TODO(titzer): convert return values here to size_t.
+ int ValueInputCount() const { return value_in_; }
+ int EffectInputCount() const { return effect_in_; }
+ int ControlInputCount() const { return control_in_; }
+
+ int ValueOutputCount() const { return value_out_; }
+ int EffectOutputCount() const { return effect_out_; }
+ int ControlOutputCount() const { return control_out_; }
+
+ static inline size_t ZeroIfPure(Properties properties) {
+ return (properties & kPure) == kPure ? 0 : 1;
+ }
+
// TODO(titzer): API for input and output types, for typechecking graph.
protected:
// Print the full operator into the given stream, including any
// static parameters. Useful for debugging and visualizing the IR.
- virtual OStream& PrintTo(OStream& os) const = 0; // NOLINT
- friend OStream& operator<<(OStream& os, const Operator& op);
+ virtual void PrintTo(std::ostream& os) const;
+ friend std::ostream& operator<<(std::ostream& os, const Operator& op);
private:
Opcode opcode_;
Properties properties_;
const char* mnemonic_;
+ uint32_t value_in_;
+ uint16_t effect_in_;
+ uint16_t control_in_;
+ uint16_t value_out_;
+ uint8_t effect_out_;
+ uint8_t control_out_;
DISALLOW_COPY_AND_ASSIGN(Operator);
};
DEFINE_OPERATORS_FOR_FLAGS(Operator::Properties)
-OStream& operator<<(OStream& os, const Operator& op);
-
-// An implementation of Operator that has no static parameters. Such operators
-// have just a name, an opcode, and a fixed number of inputs and outputs.
-// They can represented by singletons and shared globally.
-class SimpleOperator : public Operator {
- public:
- SimpleOperator(Opcode opcode, Properties properties, int input_count,
- int output_count, const char* mnemonic);
- ~SimpleOperator();
-
- virtual bool Equals(const Operator* that) const FINAL {
- return opcode() == that->opcode();
- }
- virtual int HashCode() const FINAL { return opcode(); }
- virtual int InputCount() const FINAL { return input_count_; }
- virtual int OutputCount() const FINAL { return output_count_; }
-
- private:
- virtual OStream& PrintTo(OStream& os) const FINAL { // NOLINT
- return os << mnemonic();
- }
-
- int input_count_;
- int output_count_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleOperator);
-};
-
-// Template specialization implements a kind of type class for dealing with the
-// static parameters of Operator1 automatically.
-template <typename T>
-struct StaticParameterTraits {
- static OStream& PrintTo(OStream& os, T val) { // NOLINT
- return os << "??";
- }
- static int HashCode(T a) { return 0; }
- static bool Equals(T a, T b) {
- return false; // Not every T has a ==. By default, be conservative.
- }
-};
-
-// Specialization for static parameters of type {int}.
-template <>
-struct StaticParameterTraits<int> {
- static OStream& PrintTo(OStream& os, int val) { // NOLINT
- return os << val;
- }
- static int HashCode(int a) { return a; }
- static bool Equals(int a, int b) { return a == b; }
-};
-
-// Specialization for static parameters of type {double}.
-template <>
-struct StaticParameterTraits<double> {
- static OStream& PrintTo(OStream& os, double val) { // NOLINT
- return os << val;
- }
- static int HashCode(double a) {
- return static_cast<int>(bit_cast<int64_t>(a));
- }
- static bool Equals(double a, double b) {
- return bit_cast<int64_t>(a) == bit_cast<int64_t>(b);
- }
-};
-
-// Specialization for static parameters of type {Unique<Object>}.
-template <>
-struct StaticParameterTraits<Unique<Object> > {
- static OStream& PrintTo(OStream& os, Unique<Object> val) { // NOLINT
- return os << Brief(*val.handle());
- }
- static int HashCode(Unique<Object> a) {
- return static_cast<int>(a.Hashcode());
- }
- static bool Equals(Unique<Object> a, Unique<Object> b) { return a == b; }
-};
-
-// Specialization for static parameters of type {Unique<Name>}.
-template <>
-struct StaticParameterTraits<Unique<Name> > {
- static OStream& PrintTo(OStream& os, Unique<Name> val) { // NOLINT
- return os << Brief(*val.handle());
- }
- static int HashCode(Unique<Name> a) { return static_cast<int>(a.Hashcode()); }
- static bool Equals(Unique<Name> a, Unique<Name> b) { return a == b; }
-};
+std::ostream& operator<<(std::ostream& os, const Operator& op);
-#if DEBUG
-// Specialization for static parameters of type {Handle<Object>} to prevent any
-// direct usage of Handles in constants.
-template <>
-struct StaticParameterTraits<Handle<Object> > {
- static OStream& PrintTo(OStream& os, Handle<Object> val) { // NOLINT
- UNREACHABLE(); // Should use Unique<Object> instead
- return os;
- }
- static int HashCode(Handle<Object> a) {
- UNREACHABLE(); // Should use Unique<Object> instead
- return 0;
- }
- static bool Equals(Handle<Object> a, Handle<Object> b) {
- UNREACHABLE(); // Should use Unique<Object> instead
- return false;
- }
-};
-#endif
// A templatized implementation of Operator that has one static parameter of
-// type {T}. If a specialization of StaticParameterTraits<{T}> exists, then
-// operators of this kind can automatically be hashed, compared, and printed.
-template <typename T>
+// type {T}.
+template <typename T, typename Pred = std::equal_to<T>,
+ typename Hash = base::hash<T>>
class Operator1 : public Operator {
public:
- Operator1(Opcode opcode, Properties properties, int input_count,
- int output_count, const char* mnemonic, T parameter)
- : Operator(opcode, properties, mnemonic),
- input_count_(input_count),
- output_count_(output_count),
- parameter_(parameter) {}
-
- const T& parameter() const { return parameter_; }
-
- virtual bool Equals(const Operator* other) const OVERRIDE {
+ Operator1(Opcode opcode, Properties properties, const char* mnemonic,
+ size_t value_in, size_t effect_in, size_t control_in,
+ size_t value_out, size_t effect_out, size_t control_out,
+ T parameter, Pred const& pred = Pred(), Hash const& hash = Hash())
+ : Operator(opcode, properties, mnemonic, value_in, effect_in, control_in,
+ value_out, effect_out, control_out),
+ parameter_(parameter),
+ pred_(pred),
+ hash_(hash) {}
+
+ T const& parameter() const { return parameter_; }
+
+ virtual bool Equals(const Operator* other) const FINAL {
if (opcode() != other->opcode()) return false;
const Operator1<T>* that = static_cast<const Operator1<T>*>(other);
- return StaticParameterTraits<T>::Equals(this->parameter_, that->parameter_);
+ return this->pred_(this->parameter(), that->parameter());
}
- virtual int HashCode() const OVERRIDE {
- return opcode() + 33 * StaticParameterTraits<T>::HashCode(this->parameter_);
+ virtual size_t HashCode() const FINAL {
+ return base::hash_combine(this->opcode(), this->hash_(this->parameter()));
}
- virtual int InputCount() const OVERRIDE { return input_count_; }
- virtual int OutputCount() const OVERRIDE { return output_count_; }
- virtual OStream& PrintParameter(OStream& os) const { // NOLINT
- return StaticParameterTraits<T>::PrintTo(os << "[", parameter_) << "]";
+ virtual void PrintParameter(std::ostream& os) const {
+ os << "[" << this->parameter() << "]";
}
protected:
- virtual OStream& PrintTo(OStream& os) const FINAL { // NOLINT
- return PrintParameter(os << mnemonic());
+ virtual void PrintTo(std::ostream& os) const FINAL {
+ os << mnemonic();
+ PrintParameter(os);
}
private:
- int input_count_;
- int output_count_;
- T parameter_;
+ T const parameter_;
+ Pred const pred_;
+ Hash const hash_;
};
// Helper to extract parameters from Operator1<*> operator.
template <typename T>
-static inline const T& OpParameter(const Operator* op) {
- return reinterpret_cast<const Operator1<T>*>(op)->parameter();
+inline T const& OpParameter(const Operator* op) {
+ return static_cast<const Operator1<T>*>(op)->parameter();
}
} // namespace compiler
#ifndef V8_COMPILER_PHI_REDUCER_H_
#define V8_COMPILER_PHI_REDUCER_H_
+#include "src/compiler/generic-node-inl.h"
#include "src/compiler/graph-reducer.h"
namespace v8 {
--- /dev/null
+// 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.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+void PipelineStatistics::CommonStats::Begin(
+ PipelineStatistics* pipeline_stats) {
+ DCHECK(scope_.is_empty());
+ scope_.Reset(new ZonePool::StatsScope(pipeline_stats->zone_pool_));
+ timer_.Start();
+ outer_zone_initial_size_ = pipeline_stats->OuterZoneSize();
+ allocated_bytes_at_start_ =
+ outer_zone_initial_size_ -
+ pipeline_stats->total_stats_.outer_zone_initial_size_ +
+ pipeline_stats->zone_pool_->GetCurrentAllocatedBytes();
+}
+
+
+void PipelineStatistics::CommonStats::End(
+ PipelineStatistics* pipeline_stats,
+ CompilationStatistics::BasicStats* diff) {
+ DCHECK(!scope_.is_empty());
+ diff->function_name_ = pipeline_stats->function_name_;
+ diff->delta_ = timer_.Elapsed();
+ size_t outer_zone_diff =
+ pipeline_stats->OuterZoneSize() - outer_zone_initial_size_;
+ diff->max_allocated_bytes_ = outer_zone_diff + scope_->GetMaxAllocatedBytes();
+ diff->absolute_max_allocated_bytes_ =
+ diff->max_allocated_bytes_ + allocated_bytes_at_start_;
+ diff->total_allocated_bytes_ =
+ outer_zone_diff + scope_->GetTotalAllocatedBytes();
+ scope_.Reset(NULL);
+ timer_.Stop();
+}
+
+
+PipelineStatistics::PipelineStatistics(CompilationInfo* info,
+ ZonePool* zone_pool)
+ : isolate_(info->zone()->isolate()),
+ outer_zone_(info->zone()),
+ zone_pool_(zone_pool),
+ compilation_stats_(isolate_->GetTurboStatistics()),
+ source_size_(0),
+ phase_kind_name_(NULL),
+ phase_name_(NULL) {
+ if (!info->shared_info().is_null()) {
+ source_size_ = static_cast<size_t>(info->shared_info()->SourceSize());
+ SmartArrayPointer<char> name =
+ info->shared_info()->DebugName()->ToCString();
+ function_name_ = name.get();
+ }
+ total_stats_.Begin(this);
+}
+
+
+PipelineStatistics::~PipelineStatistics() {
+ if (InPhaseKind()) EndPhaseKind();
+ CompilationStatistics::BasicStats diff;
+ total_stats_.End(this, &diff);
+ compilation_stats_->RecordTotalStats(source_size_, diff);
+}
+
+
+void PipelineStatistics::BeginPhaseKind(const char* phase_kind_name) {
+ DCHECK(!InPhase());
+ if (InPhaseKind()) EndPhaseKind();
+ phase_kind_name_ = phase_kind_name;
+ phase_kind_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhaseKind() {
+ DCHECK(!InPhase());
+ CompilationStatistics::BasicStats diff;
+ phase_kind_stats_.End(this, &diff);
+ compilation_stats_->RecordPhaseKindStats(phase_kind_name_, diff);
+}
+
+
+void PipelineStatistics::BeginPhase(const char* name) {
+ DCHECK(InPhaseKind());
+ phase_name_ = name;
+ phase_stats_.Begin(this);
+}
+
+
+void PipelineStatistics::EndPhase() {
+ DCHECK(InPhaseKind());
+ CompilationStatistics::BasicStats diff;
+ phase_stats_.End(this, &diff);
+ compilation_stats_->RecordPhaseStats(phase_kind_name_, phase_name_, diff);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_PIPELINE_STATISTICS_H_
+#define V8_COMPILER_PIPELINE_STATISTICS_H_
+
+#include <string>
+
+#include "src/compilation-statistics.h"
+#include "src/compiler/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class PhaseScope;
+
+class PipelineStatistics : public Malloced {
+ public:
+ PipelineStatistics(CompilationInfo* info, ZonePool* zone_pool);
+ ~PipelineStatistics();
+
+ void BeginPhaseKind(const char* phase_kind_name);
+
+ private:
+ size_t OuterZoneSize() {
+ return static_cast<size_t>(outer_zone_->allocation_size());
+ }
+
+ class CommonStats {
+ public:
+ CommonStats() : outer_zone_initial_size_(0) {}
+
+ void Begin(PipelineStatistics* pipeline_stats);
+ void End(PipelineStatistics* pipeline_stats,
+ CompilationStatistics::BasicStats* diff);
+
+ SmartPointer<ZonePool::StatsScope> scope_;
+ base::ElapsedTimer timer_;
+ size_t outer_zone_initial_size_;
+ size_t allocated_bytes_at_start_;
+ };
+
+ bool InPhaseKind() { return !phase_kind_stats_.scope_.is_empty(); }
+ void EndPhaseKind();
+
+ friend class PhaseScope;
+ bool InPhase() { return !phase_stats_.scope_.is_empty(); }
+ void BeginPhase(const char* name);
+ void EndPhase();
+
+ Isolate* isolate_;
+ Zone* outer_zone_;
+ ZonePool* zone_pool_;
+ CompilationStatistics* compilation_stats_;
+ std::string function_name_;
+
+ // Stats for the entire compilation.
+ CommonStats total_stats_;
+ size_t source_size_;
+
+ // Stats for phase kind.
+ const char* phase_kind_name_;
+ CommonStats phase_kind_stats_;
+
+ // Stats for phase.
+ const char* phase_name_;
+ CommonStats phase_stats_;
+
+ DISALLOW_COPY_AND_ASSIGN(PipelineStatistics);
+};
+
+
+class PhaseScope {
+ public:
+ PhaseScope(PipelineStatistics* pipeline_stats, const char* name)
+ : pipeline_stats_(pipeline_stats) {
+ if (pipeline_stats_ != NULL) pipeline_stats_->BeginPhase(name);
+ }
+ ~PhaseScope() {
+ if (pipeline_stats_ != NULL) pipeline_stats_->EndPhase();
+ }
+
+ private:
+ PipelineStatistics* const pipeline_stats_;
+
+ DISALLOW_COPY_AND_ASSIGN(PhaseScope);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif
#include "src/compiler/pipeline.h"
+#include <fstream> // NOLINT(readability/streams)
+#include <sstream>
+
#include "src/base/platform/elapsed-timer.h"
#include "src/compiler/ast-graph-builder.h"
#include "src/compiler/basic-block-instrumentor.h"
#include "src/compiler/change-lowering.h"
#include "src/compiler/code-generator.h"
+#include "src/compiler/control-reducer.h"
#include "src/compiler/graph-replay.h"
#include "src/compiler/graph-visualizer.h"
#include "src/compiler/instruction.h"
#include "src/compiler/js-inlining.h"
#include "src/compiler/js-typed-lowering.h"
#include "src/compiler/machine-operator-reducer.h"
-#include "src/compiler/phi-reducer.h"
+#include "src/compiler/pipeline-statistics.h"
#include "src/compiler/register-allocator.h"
#include "src/compiler/schedule.h"
#include "src/compiler/scheduler.h"
+#include "src/compiler/select-lowering.h"
#include "src/compiler/simplified-lowering.h"
#include "src/compiler/simplified-operator-reducer.h"
#include "src/compiler/typer.h"
#include "src/compiler/value-numbering-reducer.h"
#include "src/compiler/verifier.h"
-#include "src/hydrogen.h"
+#include "src/compiler/zone-pool.h"
#include "src/ostreams.h"
#include "src/utils.h"
namespace internal {
namespace compiler {
-class PhaseStats {
+class PipelineData {
public:
- enum PhaseKind { CREATE_GRAPH, OPTIMIZATION, CODEGEN };
-
- PhaseStats(CompilationInfo* info, PhaseKind kind, const char* name)
- : info_(info),
- kind_(kind),
- name_(name),
- size_(info->zone()->allocation_size()) {
- if (FLAG_turbo_stats) {
- timer_.Start();
- }
+ explicit PipelineData(CompilationInfo* info, ZonePool* zone_pool,
+ PipelineStatistics* pipeline_statistics)
+ : isolate_(info->zone()->isolate()),
+ outer_zone_(info->zone()),
+ zone_pool_(zone_pool),
+ pipeline_statistics_(pipeline_statistics),
+ graph_zone_scope_(zone_pool_),
+ graph_zone_(graph_zone_scope_.zone()),
+ graph_(new (graph_zone()) Graph(graph_zone())),
+ source_positions_(new SourcePositionTable(graph())),
+ machine_(new (graph_zone()) MachineOperatorBuilder(
+ kMachPtr, InstructionSelector::SupportedMachineOperatorFlags())),
+ common_(new (graph_zone()) CommonOperatorBuilder(graph_zone())),
+ javascript_(new (graph_zone()) JSOperatorBuilder(graph_zone())),
+ jsgraph_(new (graph_zone())
+ JSGraph(graph(), common(), javascript(), machine())),
+ typer_(new Typer(graph(), info->context())),
+ schedule_(NULL),
+ instruction_zone_scope_(zone_pool_),
+ instruction_zone_(instruction_zone_scope_.zone()) {}
+
+ // For machine graph testing only.
+ PipelineData(Graph* graph, Schedule* schedule, ZonePool* zone_pool)
+ : isolate_(graph->zone()->isolate()),
+ outer_zone_(NULL),
+ zone_pool_(zone_pool),
+ pipeline_statistics_(NULL),
+ graph_zone_scope_(zone_pool_),
+ graph_zone_(NULL),
+ graph_(graph),
+ source_positions_(new SourcePositionTable(graph)),
+ machine_(NULL),
+ common_(NULL),
+ javascript_(NULL),
+ jsgraph_(NULL),
+ typer_(NULL),
+ schedule_(schedule),
+ instruction_zone_scope_(zone_pool_),
+ instruction_zone_(instruction_zone_scope_.zone()) {}
+
+ ~PipelineData() {
+ DeleteInstructionZone();
+ DeleteGraphZone();
}
- ~PhaseStats() {
- if (FLAG_turbo_stats) {
- base::TimeDelta delta = timer_.Elapsed();
- size_t bytes = info_->zone()->allocation_size() - size_;
- HStatistics* stats = info_->isolate()->GetTStatistics();
- stats->SaveTiming(name_, delta, static_cast<int>(bytes));
-
- switch (kind_) {
- case CREATE_GRAPH:
- stats->IncrementCreateGraph(delta);
- break;
- case OPTIMIZATION:
- stats->IncrementOptimizeGraph(delta);
- break;
- case CODEGEN:
- stats->IncrementGenerateCode(delta);
- break;
- }
- }
+ Isolate* isolate() const { return isolate_; }
+ ZonePool* zone_pool() const { return zone_pool_; }
+ PipelineStatistics* pipeline_statistics() { return pipeline_statistics_; }
+
+ Zone* graph_zone() const { return graph_zone_; }
+ Graph* graph() const { return graph_; }
+ SourcePositionTable* source_positions() const {
+ return source_positions_.get();
+ }
+ MachineOperatorBuilder* machine() const { return machine_; }
+ CommonOperatorBuilder* common() const { return common_; }
+ JSOperatorBuilder* javascript() const { return javascript_; }
+ JSGraph* jsgraph() const { return jsgraph_; }
+ Typer* typer() const { return typer_.get(); }
+ Schedule* schedule() const { return schedule_; }
+ void set_schedule(Schedule* schedule) {
+ DCHECK_EQ(NULL, schedule_);
+ schedule_ = schedule;
+ }
+
+ Zone* instruction_zone() const { return instruction_zone_; }
+
+ void DeleteGraphZone() {
+ // Destroy objects with destructors first.
+ source_positions_.Reset(NULL);
+ typer_.Reset(NULL);
+ if (graph_zone_ == NULL) return;
+ // Destroy zone and clear pointers.
+ graph_zone_scope_.Destroy();
+ graph_zone_ = NULL;
+ graph_ = NULL;
+ machine_ = NULL;
+ common_ = NULL;
+ javascript_ = NULL;
+ jsgraph_ = NULL;
+ schedule_ = NULL;
+ }
+
+ void DeleteInstructionZone() {
+ if (instruction_zone_ == NULL) return;
+ instruction_zone_scope_.Destroy();
+ instruction_zone_ = NULL;
}
private:
- CompilationInfo* info_;
- PhaseKind kind_;
- const char* name_;
- size_t size_;
- base::ElapsedTimer timer_;
+ Isolate* isolate_;
+ Zone* outer_zone_;
+ ZonePool* zone_pool_;
+ PipelineStatistics* pipeline_statistics_;
+
+ ZonePool::Scope graph_zone_scope_;
+ Zone* graph_zone_;
+ // All objects in the following group of fields are allocated in graph_zone_.
+ // They are all set to NULL when the graph_zone_ is destroyed.
+ Graph* graph_;
+ // TODO(dcarney): make this into a ZoneObject.
+ SmartPointer<SourcePositionTable> source_positions_;
+ MachineOperatorBuilder* machine_;
+ CommonOperatorBuilder* common_;
+ JSOperatorBuilder* javascript_;
+ JSGraph* jsgraph_;
+ // TODO(dcarney): make this into a ZoneObject.
+ SmartPointer<Typer> typer_;
+ Schedule* schedule_;
+
+ // All objects in the following group of fields are allocated in
+ // instruction_zone_. They are all set to NULL when the instruction_zone_ is
+ // destroyed.
+ ZonePool::Scope instruction_zone_scope_;
+ Zone* instruction_zone_;
+
+ DISALLOW_COPY_AND_ASSIGN(PipelineData);
};
}
-void Pipeline::VerifyAndPrintGraph(Graph* graph, const char* phase) {
+struct TurboCfgFile : public std::ofstream {
+ explicit TurboCfgFile(Isolate* isolate)
+ : std::ofstream(isolate->GetTurboCfgFileName().c_str(),
+ std::ios_base::app) {}
+};
+
+
+void Pipeline::VerifyAndPrintGraph(
+ Graph* graph, const char* phase, bool untyped) {
if (FLAG_trace_turbo) {
char buffer[256];
Vector<char> filename(buffer, sizeof(buffer));
+ SmartArrayPointer<char> functionname;
if (!info_->shared_info().is_null()) {
- SmartArrayPointer<char> functionname =
- info_->shared_info()->DebugName()->ToCString();
+ functionname = info_->shared_info()->DebugName()->ToCString();
if (strlen(functionname.get()) > 0) {
SNPrintF(filename, "turbo-%s-%s", functionname.get(), phase);
} else {
os << "-- " << phase << " graph printed to file " << filename.start()
<< "\n";
}
- if (VerifyGraphs()) Verifier::Run(graph);
+ if (VerifyGraphs()) {
+ Verifier::Run(graph,
+ FLAG_turbo_types && !untyped ? Verifier::TYPED : Verifier::UNTYPED);
+ }
}
class AstGraphBuilderWithPositions : public AstGraphBuilder {
public:
- explicit AstGraphBuilderWithPositions(CompilationInfo* info, JSGraph* jsgraph,
+ explicit AstGraphBuilderWithPositions(Zone* local_zone, CompilationInfo* info,
+ JSGraph* jsgraph,
SourcePositionTable* source_positions)
- : AstGraphBuilder(info, jsgraph), source_positions_(source_positions) {}
+ : AstGraphBuilder(local_zone, info, jsgraph),
+ source_positions_(source_positions) {}
bool CreateGraph() {
SourcePositionTable::Scope pos(source_positions_,
}
#define DEF_VISIT(type) \
- virtual void Visit##type(type* node) OVERRIDE { \
+ virtual void Visit##type(type* node) OVERRIDE { \
SourcePositionTable::Scope pos(source_positions_, \
SourcePosition(node->position())); \
AstGraphBuilder::Visit##type(node); \
}
+static SmartArrayPointer<char> GetDebugName(CompilationInfo* info) {
+ SmartArrayPointer<char> name;
+ if (info->IsStub()) {
+ if (info->code_stub() != NULL) {
+ CodeStub::Major major_key = info->code_stub()->MajorKey();
+ const char* major_name = CodeStub::MajorName(major_key, false);
+ size_t len = strlen(major_name);
+ name.Reset(new char[len]);
+ memcpy(name.get(), major_name, len);
+ }
+ } else {
+ AllowHandleDereference allow_deref;
+ name = info->function()->debug_name()->ToCString();
+ }
+ return name;
+}
+
+
Handle<Code> Pipeline::GenerateCode() {
+ // This list must be kept in sync with DONT_TURBOFAN_NODE in ast.cc.
if (info()->function()->dont_optimize_reason() == kTryCatchStatement ||
info()->function()->dont_optimize_reason() == kTryFinallyStatement ||
// TODO(turbofan): Make ES6 for-of work and remove this bailout.
info()->function()->dont_optimize_reason() == kForOfStatement ||
// TODO(turbofan): Make super work and remove this bailout.
info()->function()->dont_optimize_reason() == kSuperReference ||
+ // TODO(turbofan): Make class literals work and remove this bailout.
+ info()->function()->dont_optimize_reason() == kClassLiteral ||
// TODO(turbofan): Make OSR work and remove this bailout.
info()->is_osr()) {
return Handle<Code>::null();
}
- if (FLAG_turbo_stats) isolate()->GetTStatistics()->Initialize(info_);
+ ZonePool zone_pool(isolate());
+
+ SmartPointer<PipelineStatistics> pipeline_statistics;
+ if (FLAG_turbo_stats) {
+ pipeline_statistics.Reset(new PipelineStatistics(info(), &zone_pool));
+ pipeline_statistics->BeginPhaseKind("graph creation");
+ }
if (FLAG_trace_turbo) {
OFStream os(stdout);
os << "---------------------------------------------------\n"
- << "Begin compiling method "
- << info()->function()->debug_name()->ToCString().get()
- << " using Turbofan" << endl;
- }
-
- // Build the graph.
- Graph graph(zone());
- SourcePositionTable source_positions(&graph);
- source_positions.AddDecorator();
- // TODO(turbofan): there is no need to type anything during initial graph
- // construction. This is currently only needed for the node cache, which the
- // typer could sweep over later.
- Typer typer(zone());
- MachineOperatorBuilder machine;
- CommonOperatorBuilder common(zone());
- JSOperatorBuilder javascript(zone());
- JSGraph jsgraph(&graph, &common, &javascript, &typer, &machine);
+ << "Begin compiling method " << GetDebugName(info()).get()
+ << " using Turbofan" << std::endl;
+ TurboCfgFile tcf(isolate());
+ tcf << AsC1VCompilation(info());
+ }
+
+ // Initialize the graph and builders.
+ PipelineData data(info(), &zone_pool, pipeline_statistics.get());
+
+ data.source_positions()->AddDecorator();
+
Node* context_node;
{
- PhaseStats graph_builder_stats(info(), PhaseStats::CREATE_GRAPH,
- "graph builder");
- AstGraphBuilderWithPositions graph_builder(info(), &jsgraph,
- &source_positions);
- graph_builder.CreateGraph();
+ PhaseScope phase_scope(pipeline_statistics.get(), "graph builder");
+ ZonePool::Scope zone_scope(data.zone_pool());
+ AstGraphBuilderWithPositions graph_builder(
+ zone_scope.zone(), info(), data.jsgraph(), data.source_positions());
+ if (!graph_builder.CreateGraph()) return Handle<Code>::null();
context_node = graph_builder.GetFunctionContext();
}
+
+ VerifyAndPrintGraph(data.graph(), "Initial untyped", true);
+
{
- PhaseStats phi_reducer_stats(info(), PhaseStats::CREATE_GRAPH,
- "phi reduction");
- PhiReducer phi_reducer;
- GraphReducer graph_reducer(&graph);
- graph_reducer.AddReducer(&phi_reducer);
- graph_reducer.ReduceGraph();
- // TODO(mstarzinger): Running reducer once ought to be enough for everyone.
- graph_reducer.ReduceGraph();
- graph_reducer.ReduceGraph();
- }
+ PhaseScope phase_scope(pipeline_statistics.get(),
+ "early control reduction");
+ SourcePositionTable::Scope pos(data.source_positions(),
+ SourcePosition::Unknown());
+ ZonePool::Scope zone_scope(data.zone_pool());
+ ControlReducer::ReduceGraph(zone_scope.zone(), data.jsgraph(),
+ data.common());
- VerifyAndPrintGraph(&graph, "Initial untyped");
+ VerifyAndPrintGraph(data.graph(), "Early Control reduced", true);
+ }
if (info()->is_context_specializing()) {
- SourcePositionTable::Scope pos(&source_positions,
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
// Specialize the code to the context as aggressively as possible.
- JSContextSpecializer spec(info(), &jsgraph, context_node);
+ JSContextSpecializer spec(info(), data.jsgraph(), context_node);
spec.SpecializeToContext();
- VerifyAndPrintGraph(&graph, "Context specialized");
+ VerifyAndPrintGraph(data.graph(), "Context specialized", true);
}
if (info()->is_inlining_enabled()) {
- SourcePositionTable::Scope pos(&source_positions,
+ PhaseScope phase_scope(pipeline_statistics.get(), "inlining");
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
- JSInliner inliner(info(), &jsgraph);
+ ZonePool::Scope zone_scope(data.zone_pool());
+ JSInliner inliner(zone_scope.zone(), info(), data.jsgraph());
inliner.Inline();
- VerifyAndPrintGraph(&graph, "Inlined");
+ VerifyAndPrintGraph(data.graph(), "Inlined", true);
}
// Print a replay of the initial graph.
if (FLAG_print_turbo_replay) {
- GraphReplayPrinter::PrintReplay(&graph);
+ GraphReplayPrinter::PrintReplay(data.graph());
}
// Bailout here in case target architecture is not supported.
if (info()->is_typing_enabled()) {
{
// Type the graph.
- PhaseStats typer_stats(info(), PhaseStats::CREATE_GRAPH, "typer");
- typer.Run(&graph, info()->context());
- VerifyAndPrintGraph(&graph, "Typed");
+ PhaseScope phase_scope(pipeline_statistics.get(), "typer");
+ data.typer()->Run();
+ VerifyAndPrintGraph(data.graph(), "Typed");
}
- // All new nodes must be typed.
- typer.DecorateGraph(&graph);
+ }
+
+ if (!pipeline_statistics.is_empty()) {
+ pipeline_statistics->BeginPhaseKind("lowering");
+ }
+
+ if (info()->is_typing_enabled()) {
{
// Lower JSOperators where we can determine types.
- PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
- "typed lowering");
- SourcePositionTable::Scope pos(&source_positions,
+ PhaseScope phase_scope(pipeline_statistics.get(), "typed lowering");
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
- JSTypedLowering lowering(&jsgraph);
- GraphReducer graph_reducer(&graph);
+ ValueNumberingReducer vn_reducer(data.graph_zone());
+ JSTypedLowering lowering(data.jsgraph());
+ SimplifiedOperatorReducer simple_reducer(data.jsgraph());
+ GraphReducer graph_reducer(data.graph());
+ graph_reducer.AddReducer(&vn_reducer);
graph_reducer.AddReducer(&lowering);
+ graph_reducer.AddReducer(&simple_reducer);
graph_reducer.ReduceGraph();
- VerifyAndPrintGraph(&graph, "Lowered typed");
+ VerifyAndPrintGraph(data.graph(), "Lowered typed");
}
{
// Lower simplified operators and insert changes.
- PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
- "simplified lowering");
- SourcePositionTable::Scope pos(&source_positions,
+ PhaseScope phase_scope(pipeline_statistics.get(), "simplified lowering");
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
- SimplifiedLowering lowering(&jsgraph);
+ SimplifiedLowering lowering(data.jsgraph());
lowering.LowerAllNodes();
+ ValueNumberingReducer vn_reducer(data.graph_zone());
+ SimplifiedOperatorReducer simple_reducer(data.jsgraph());
+ GraphReducer graph_reducer(data.graph());
+ graph_reducer.AddReducer(&vn_reducer);
+ graph_reducer.AddReducer(&simple_reducer);
+ graph_reducer.ReduceGraph();
- VerifyAndPrintGraph(&graph, "Lowered simplified");
+ VerifyAndPrintGraph(data.graph(), "Lowered simplified");
}
{
// Lower changes that have been inserted before.
- PhaseStats lowering_stats(info(), PhaseStats::OPTIMIZATION,
- "change lowering");
- SourcePositionTable::Scope pos(&source_positions,
+ PhaseScope phase_scope(pipeline_statistics.get(), "change lowering");
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
- Linkage linkage(info());
- // TODO(turbofan): Value numbering disabled for now.
- // ValueNumberingReducer vn_reducer(zone());
- SimplifiedOperatorReducer simple_reducer(&jsgraph);
- ChangeLowering lowering(&jsgraph, &linkage);
- MachineOperatorReducer mach_reducer(&jsgraph);
- GraphReducer graph_reducer(&graph);
+ Linkage linkage(data.graph_zone(), info());
+ ValueNumberingReducer vn_reducer(data.graph_zone());
+ SimplifiedOperatorReducer simple_reducer(data.jsgraph());
+ ChangeLowering lowering(data.jsgraph(), &linkage);
+ MachineOperatorReducer mach_reducer(data.jsgraph());
+ GraphReducer graph_reducer(data.graph());
// TODO(titzer): Figure out if we should run all reducers at once here.
- // graph_reducer.AddReducer(&vn_reducer);
+ graph_reducer.AddReducer(&vn_reducer);
graph_reducer.AddReducer(&simple_reducer);
graph_reducer.AddReducer(&lowering);
graph_reducer.AddReducer(&mach_reducer);
graph_reducer.ReduceGraph();
- VerifyAndPrintGraph(&graph, "Lowered changes");
+ // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
+ VerifyAndPrintGraph(data.graph(), "Lowered changes", true);
+ }
+
+ {
+ PhaseScope phase_scope(pipeline_statistics.get(),
+ "late control reduction");
+ SourcePositionTable::Scope pos(data.source_positions(),
+ SourcePosition::Unknown());
+ ZonePool::Scope zone_scope(data.zone_pool());
+ ControlReducer::ReduceGraph(zone_scope.zone(), data.jsgraph(),
+ data.common());
+
+ VerifyAndPrintGraph(data.graph(), "Late Control reduced");
}
}
{
// Lower any remaining generic JSOperators.
- PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
- "generic lowering");
- SourcePositionTable::Scope pos(&source_positions,
+ PhaseScope phase_scope(pipeline_statistics.get(), "generic lowering");
+ SourcePositionTable::Scope pos(data.source_positions(),
SourcePosition::Unknown());
- JSGenericLowering lowering(info(), &jsgraph);
- GraphReducer graph_reducer(&graph);
- graph_reducer.AddReducer(&lowering);
+ JSGenericLowering generic(info(), data.jsgraph());
+ SelectLowering select(data.jsgraph()->graph(), data.jsgraph()->common());
+ GraphReducer graph_reducer(data.graph());
+ graph_reducer.AddReducer(&generic);
+ graph_reducer.AddReducer(&select);
graph_reducer.ReduceGraph();
- VerifyAndPrintGraph(&graph, "Lowered generic");
+ // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
+ VerifyAndPrintGraph(data.graph(), "Lowered generic", true);
+ }
+
+ if (!pipeline_statistics.is_empty()) {
+ pipeline_statistics->BeginPhaseKind("block building");
}
- source_positions.RemoveDecorator();
+ data.source_positions()->RemoveDecorator();
+
+ // Compute a schedule.
+ ComputeSchedule(&data);
Handle<Code> code = Handle<Code>::null();
{
- // Compute a schedule.
- Schedule* schedule = ComputeSchedule(&graph);
// Generate optimized code.
- PhaseStats codegen_stats(info(), PhaseStats::CODEGEN, "codegen");
- Linkage linkage(info());
- code = GenerateCode(&linkage, &graph, schedule, &source_positions);
+ Linkage linkage(data.instruction_zone(), info());
+ code = GenerateCode(&linkage, &data);
info()->SetCode(code);
}
if (FLAG_trace_turbo) {
OFStream os(stdout);
os << "--------------------------------------------------\n"
- << "Finished compiling method "
- << info()->function()->debug_name()->ToCString().get()
- << " using Turbofan" << endl;
+ << "Finished compiling method " << GetDebugName(info()).get()
+ << " using Turbofan" << std::endl;
}
return code;
}
-Schedule* Pipeline::ComputeSchedule(Graph* graph) {
- PhaseStats schedule_stats(info(), PhaseStats::CODEGEN, "scheduling");
- Schedule* schedule = Scheduler::ComputeSchedule(graph);
+void Pipeline::ComputeSchedule(PipelineData* data) {
+ PhaseScope phase_scope(data->pipeline_statistics(), "scheduling");
+ Schedule* schedule =
+ Scheduler::ComputeSchedule(data->zone_pool(), data->graph());
TraceSchedule(schedule);
if (VerifyGraphs()) ScheduleVerifier::Run(schedule);
- return schedule;
+ data->set_schedule(schedule);
}
Handle<Code> Pipeline::GenerateCodeForMachineGraph(Linkage* linkage,
Graph* graph,
Schedule* schedule) {
+ ZonePool zone_pool(isolate());
CHECK(SupportedBackend());
+ PipelineData data(graph, schedule, &zone_pool);
if (schedule == NULL) {
- VerifyAndPrintGraph(graph, "Machine");
- schedule = ComputeSchedule(graph);
+ // TODO(rossberg): Should this really be untyped?
+ VerifyAndPrintGraph(graph, "Machine", true);
+ ComputeSchedule(&data);
+ } else {
+ TraceSchedule(schedule);
}
- TraceSchedule(schedule);
- SourcePositionTable source_positions(graph);
- Handle<Code> code = GenerateCode(linkage, graph, schedule, &source_positions);
+ Handle<Code> code = GenerateCode(linkage, &data);
#if ENABLE_DISASSEMBLER
if (!code.is_null() && FLAG_print_opt_code) {
CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
}
-Handle<Code> Pipeline::GenerateCode(Linkage* linkage, Graph* graph,
- Schedule* schedule,
- SourcePositionTable* source_positions) {
- DCHECK_NOT_NULL(graph);
+Handle<Code> Pipeline::GenerateCode(Linkage* linkage, PipelineData* data) {
DCHECK_NOT_NULL(linkage);
- DCHECK_NOT_NULL(schedule);
+ DCHECK_NOT_NULL(data->graph());
+ DCHECK_NOT_NULL(data->schedule());
CHECK(SupportedBackend());
BasicBlockProfiler::Data* profiler_data = NULL;
if (FLAG_turbo_profiling) {
- profiler_data = BasicBlockInstrumentor::Instrument(info_, graph, schedule);
+ profiler_data = BasicBlockInstrumentor::Instrument(info(), data->graph(),
+ data->schedule());
}
- InstructionSequence sequence(linkage, graph, schedule);
+ InstructionBlocks* instruction_blocks =
+ InstructionSequence::InstructionBlocksFor(data->instruction_zone(),
+ data->schedule());
+ InstructionSequence sequence(data->instruction_zone(), instruction_blocks);
// Select and schedule instructions covering the scheduled graph.
{
- InstructionSelector selector(&sequence, source_positions);
+ PhaseScope phase_scope(data->pipeline_statistics(), "select instructions");
+ ZonePool::Scope zone_scope(data->zone_pool());
+ InstructionSelector selector(zone_scope.zone(), data->graph(), linkage,
+ &sequence, data->schedule(),
+ data->source_positions());
selector.SelectInstructions();
}
if (FLAG_trace_turbo) {
OFStream os(stdout);
+ PrintableInstructionSequence printable = {
+ RegisterConfiguration::ArchDefault(), &sequence};
os << "----- Instruction sequence before register allocation -----\n"
- << sequence;
+ << printable;
+ TurboCfgFile tcf(isolate());
+ tcf << AsC1V("CodeGen", data->schedule(), data->source_positions(),
+ &sequence);
+ }
+
+ data->DeleteGraphZone();
+
+ if (data->pipeline_statistics() != NULL) {
+ data->pipeline_statistics()->BeginPhaseKind("register allocation");
}
// Allocate registers.
+ Frame frame;
{
- int node_count = graph->NodeCount();
+ int node_count = sequence.VirtualRegisterCount();
if (node_count > UnallocatedOperand::kMaxVirtualRegisters) {
- linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersForValues);
+ info()->AbortOptimization(kNotEnoughVirtualRegistersForValues);
return Handle<Code>::null();
}
- RegisterAllocator allocator(&sequence);
- if (!allocator.Allocate()) {
- linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
+ ZonePool::Scope zone_scope(data->zone_pool());
+
+ SmartArrayPointer<char> debug_name;
+#ifdef DEBUG
+ debug_name = GetDebugName(info());
+#endif
+
+
+ RegisterAllocator allocator(RegisterConfiguration::ArchDefault(),
+ zone_scope.zone(), &frame, &sequence,
+ debug_name.get());
+ if (!allocator.Allocate(data->pipeline_statistics())) {
+ info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
return Handle<Code>::null();
}
+ if (FLAG_trace_turbo) {
+ TurboCfgFile tcf(isolate());
+ tcf << AsC1VAllocator("CodeGen", &allocator);
+ }
}
if (FLAG_trace_turbo) {
OFStream os(stdout);
+ PrintableInstructionSequence printable = {
+ RegisterConfiguration::ArchDefault(), &sequence};
os << "----- Instruction sequence after register allocation -----\n"
- << sequence;
+ << printable;
+ }
+
+ if (data->pipeline_statistics() != NULL) {
+ data->pipeline_statistics()->BeginPhaseKind("code generation");
}
// Generate native sequence.
- CodeGenerator generator(&sequence);
- Handle<Code> code = generator.GenerateCode();
+ Handle<Code> code;
+ {
+ PhaseScope phase_scope(data->pipeline_statistics(), "generate code");
+ CodeGenerator generator(&frame, linkage, &sequence, info());
+ code = generator.GenerateCode();
+ }
if (profiler_data != NULL) {
#if ENABLE_DISASSEMBLER
- OStringStream os;
+ std::ostringstream os;
code->Disassemble(NULL, os);
profiler_data->SetCode(&os);
#endif
// Clients of this interface shouldn't depend on lots of compiler internals.
class Graph;
-class Schedule;
-class SourcePositionTable;
class Linkage;
+class PipelineData;
+class Schedule;
class Pipeline {
public:
CompilationInfo* info() const { return info_; }
Isolate* isolate() { return info_->isolate(); }
- Zone* zone() { return info_->zone(); }
- Schedule* ComputeSchedule(Graph* graph);
- void VerifyAndPrintGraph(Graph* graph, const char* phase);
- Handle<Code> GenerateCode(Linkage* linkage, Graph* graph, Schedule* schedule,
- SourcePositionTable* source_positions);
+ void ComputeSchedule(PipelineData* data);
+ void VerifyAndPrintGraph(Graph* graph, const char* phase,
+ bool untyped = false);
+ Handle<Code> GenerateCode(Linkage* linkage, PipelineData* data);
};
}
}
RawMachineAssembler::RawMachineAssembler(Graph* graph,
MachineSignature* machine_sig,
- MachineType word)
+ MachineType word,
+ MachineOperatorBuilder::Flags flags)
: GraphBuilder(graph),
schedule_(new (zone()) Schedule(zone())),
- machine_(word),
+ machine_(word, flags),
common_(zone()),
machine_sig_(machine_sig),
call_descriptor_(
Schedule* RawMachineAssembler::Export() {
// Compute the correct codegen order.
DCHECK(schedule_->rpo_order()->empty());
- Scheduler::ComputeSpecialRPO(schedule_);
+ ZonePool zone_pool(isolate());
+ Scheduler::ComputeSpecialRPO(&zone_pool, schedule_);
// Invalidate MachineAssembler.
Schedule* schedule = schedule_;
schedule_ = NULL;
Node* RawMachineAssembler::CallJS0(Node* function, Node* receiver,
Node* context, Node* frame_state) {
- CallDescriptor* descriptor = Linkage::GetJSCallDescriptor(1, zone());
+ CallDescriptor* descriptor =
+ Linkage::GetJSCallDescriptor(1, zone(), CallDescriptor::kNeedsFrameState);
Node* call = graph()->NewNode(common()->Call(descriptor), function, receiver,
context, frame_state);
schedule()->AddNode(CurrentBlock(), call);
Node* RawMachineAssembler::MakeNode(const Operator* op, int input_count,
- Node** inputs) {
+ Node** inputs, bool incomplete) {
DCHECK(ScheduleValid());
DCHECK(current_block_ != NULL);
- Node* node = graph()->NewNode(op, input_count, inputs);
+ Node* node = graph()->NewNode(op, input_count, inputs, incomplete);
BasicBlock* block = op->opcode() == IrOpcode::kParameter ? schedule()->start()
: CurrentBlock();
schedule()->AddNode(block, node);
};
RawMachineAssembler(Graph* graph, MachineSignature* machine_sig,
- MachineType word = kMachPtr);
+ MachineType word = kMachPtr,
+ MachineOperatorBuilder::Flags flags =
+ MachineOperatorBuilder::Flag::kNoFlags);
virtual ~RawMachineAssembler() {}
Isolate* isolate() const { return zone()->isolate(); }
MachineSignature* machine_sig() const { return machine_sig_; }
Node* UndefinedConstant() {
- Unique<Object> unique = Unique<Object>::CreateImmovable(
+ Unique<HeapObject> unique = Unique<HeapObject>::CreateImmovable(
isolate()->factory()->undefined_value());
return NewNode(common()->HeapConstant(unique));
}
Node* Float64Constant(double value) {
return NewNode(common()->Float64Constant(value));
}
- Node* HeapConstant(Handle<Object> object) {
- Unique<Object> val = Unique<Object>::CreateUninitialized(object);
+ Node* HeapConstant(Handle<HeapObject> object) {
+ Unique<HeapObject> val = Unique<HeapObject>::CreateUninitialized(object);
return NewNode(common()->HeapConstant(val));
}
return Load(rep, base, Int32Constant(0));
}
Node* Load(MachineType rep, Node* base, Node* index) {
- return NewNode(machine()->Load(rep), base, index);
+ return NewNode(machine()->Load(rep), base, index, graph()->start(),
+ graph()->start());
}
void Store(MachineType rep, Node* base, Node* value) {
Store(rep, base, Int32Constant(0), value);
}
void Store(MachineType rep, Node* base, Node* index, Node* value) {
NewNode(machine()->Store(StoreRepresentation(rep, kNoWriteBarrier)), base,
- index, value);
+ index, value, graph()->start(), graph()->start());
}
// Arithmetic Operations.
Node* WordAnd(Node* a, Node* b) {
Node* Int32Mul(Node* a, Node* b) {
return NewNode(machine()->Int32Mul(), a, b);
}
- Node* Int32Div(Node* a, Node* b) {
- return NewNode(machine()->Int32Div(), a, b);
+ Node* Int32MulHigh(Node* a, Node* b) {
+ return NewNode(machine()->Int32MulHigh(), a, b);
}
- Node* Int32UDiv(Node* a, Node* b) {
- return NewNode(machine()->Int32UDiv(), a, b);
+ Node* Int32Div(Node* a, Node* b) {
+ return NewNode(machine()->Int32Div(), a, b, graph()->start());
}
Node* Int32Mod(Node* a, Node* b) {
- return NewNode(machine()->Int32Mod(), a, b);
- }
- Node* Int32UMod(Node* a, Node* b) {
- return NewNode(machine()->Int32UMod(), a, b);
+ return NewNode(machine()->Int32Mod(), a, b, graph()->start());
}
Node* Int32LessThan(Node* a, Node* b) {
return NewNode(machine()->Int32LessThan(), a, b);
Node* Int32LessThanOrEqual(Node* a, Node* b) {
return NewNode(machine()->Int32LessThanOrEqual(), a, b);
}
+ Node* Uint32Div(Node* a, Node* b) {
+ return NewNode(machine()->Uint32Div(), a, b, graph()->start());
+ }
Node* Uint32LessThan(Node* a, Node* b) {
return NewNode(machine()->Uint32LessThan(), a, b);
}
Node* Uint32LessThanOrEqual(Node* a, Node* b) {
return NewNode(machine()->Uint32LessThanOrEqual(), a, b);
}
+ Node* Uint32Mod(Node* a, Node* b) {
+ return NewNode(machine()->Uint32Mod(), a, b, graph()->start());
+ }
+ Node* Uint32MulHigh(Node* a, Node* b) {
+ return NewNode(machine()->Uint32MulHigh(), a, b);
+ }
Node* Int32GreaterThan(Node* a, Node* b) { return Int32LessThan(b, a); }
Node* Int32GreaterThanOrEqual(Node* a, Node* b) {
return Int32LessThanOrEqual(b, a);
Node* Int64Div(Node* a, Node* b) {
return NewNode(machine()->Int64Div(), a, b);
}
- Node* Int64UDiv(Node* a, Node* b) {
- return NewNode(machine()->Int64UDiv(), a, b);
- }
Node* Int64Mod(Node* a, Node* b) {
return NewNode(machine()->Int64Mod(), a, b);
}
- Node* Int64UMod(Node* a, Node* b) {
- return NewNode(machine()->Int64UMod(), a, b);
- }
Node* Int64Neg(Node* a) { return Int64Sub(Int64Constant(0), a); }
Node* Int64LessThan(Node* a, Node* b) {
return NewNode(machine()->Int64LessThan(), a, b);
Node* Int64GreaterThanOrEqual(Node* a, Node* b) {
return Int64LessThanOrEqual(b, a);
}
+ Node* Uint64Div(Node* a, Node* b) {
+ return NewNode(machine()->Uint64Div(), a, b);
+ }
+ Node* Uint64Mod(Node* a, Node* b) {
+ return NewNode(machine()->Uint64Mod(), a, b);
+ }
// TODO(turbofan): What is this used for?
Node* ConvertIntPtrToInt32(Node* a) {
Node* TruncateInt64ToInt32(Node* a) {
return NewNode(machine()->TruncateInt64ToInt32(), a);
}
+ Node* Float64Floor(Node* a) { return NewNode(machine()->Float64Floor(), a); }
+ Node* Float64Ceil(Node* a) { return NewNode(machine()->Float64Ceil(), a); }
+ Node* Float64RoundTruncate(Node* a) {
+ return NewNode(machine()->Float64RoundTruncate(), a);
+ }
+ Node* Float64RoundTiesAway(Node* a) {
+ return NewNode(machine()->Float64RoundTiesAway(), a);
+ }
// Parameters.
Node* Parameter(size_t index);
Schedule* Export();
protected:
- virtual Node* MakeNode(const Operator* op, int input_count,
- Node** inputs) FINAL;
+ virtual Node* MakeNode(const Operator* op, int input_count, Node** inputs,
+ bool incomplete) FINAL;
bool ScheduleValid() { return schedule_ != NULL; }
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/register-allocator.h"
-
#include "src/compiler/linkage.h"
-#include "src/hydrogen.h"
+#include "src/compiler/pipeline-statistics.h"
+#include "src/compiler/register-allocator.h"
#include "src/string-stream.h"
namespace v8 {
}
+static void TraceAlloc(const char* msg, ...) {
+ if (FLAG_trace_alloc) {
+ va_list arguments;
+ va_start(arguments, msg);
+ base::OS::VPrint(msg, arguments);
+ va_end(arguments);
+ }
+}
+
+
UsePosition::UsePosition(LifetimePosition pos, InstructionOperand* operand,
InstructionOperand* hint)
: operand_(operand),
}
-InstructionOperand* LiveRange::CreateAssignedOperand(Zone* zone) {
+InstructionOperand* LiveRange::CreateAssignedOperand(Zone* zone) const {
InstructionOperand* op = NULL;
if (HasRegisterAssigned()) {
DCHECK(!IsSpilled());
void LiveRange::ShortenTo(LifetimePosition start) {
- RegisterAllocator::TraceAlloc("Shorten live range %d to [%d\n", id_,
- start.Value());
+ TraceAlloc("Shorten live range %d to [%d\n", id_, start.Value());
DCHECK(first_interval_ != NULL);
DCHECK(first_interval_->start().Value() <= start.Value());
DCHECK(start.Value() < first_interval_->end().Value());
void LiveRange::EnsureInterval(LifetimePosition start, LifetimePosition end,
Zone* zone) {
- RegisterAllocator::TraceAlloc("Ensure live range %d in interval [%d %d[\n",
- id_, start.Value(), end.Value());
+ TraceAlloc("Ensure live range %d in interval [%d %d[\n", id_, start.Value(),
+ end.Value());
LifetimePosition new_end = end;
while (first_interval_ != NULL &&
first_interval_->start().Value() <= end.Value()) {
void LiveRange::AddUseInterval(LifetimePosition start, LifetimePosition end,
Zone* zone) {
- RegisterAllocator::TraceAlloc("Add to live range %d interval [%d %d[\n", id_,
- start.Value(), end.Value());
+ TraceAlloc("Add to live range %d interval [%d %d[\n", id_, start.Value(),
+ end.Value());
if (first_interval_ == NULL) {
UseInterval* interval = new (zone) UseInterval(start, end);
first_interval_ = interval;
void LiveRange::AddUsePosition(LifetimePosition pos,
InstructionOperand* operand,
InstructionOperand* hint, Zone* zone) {
- RegisterAllocator::TraceAlloc("Add to live range %d use position %d\n", id_,
- pos.Value());
+ TraceAlloc("Add to live range %d use position %d\n", id_, pos.Value());
UsePosition* use_pos = new (zone) UsePosition(pos, operand, hint);
UsePosition* prev_hint = NULL;
UsePosition* prev = NULL;
}
-RegisterAllocator::RegisterAllocator(InstructionSequence* code)
- : zone_(code->isolate()),
+RegisterAllocator::RegisterAllocator(const RegisterConfiguration* config,
+ Zone* zone, Frame* frame,
+ InstructionSequence* code,
+ const char* debug_name)
+ : local_zone_(zone),
+ frame_(frame),
code_(code),
- live_in_sets_(code->BasicBlockCount(), zone()),
- live_ranges_(code->VirtualRegisterCount() * 2, zone()),
- fixed_live_ranges_(NULL),
- fixed_double_live_ranges_(NULL),
- unhandled_live_ranges_(code->VirtualRegisterCount() * 2, zone()),
- active_live_ranges_(8, zone()),
- inactive_live_ranges_(8, zone()),
- reusable_slots_(8, zone()),
+ debug_name_(debug_name),
+ config_(config),
+ live_in_sets_(code->InstructionBlockCount(), local_zone()),
+ live_ranges_(code->VirtualRegisterCount() * 2, local_zone()),
+ fixed_live_ranges_(this->config()->num_general_registers(), NULL,
+ local_zone()),
+ fixed_double_live_ranges_(this->config()->num_double_registers(), NULL,
+ local_zone()),
+ unhandled_live_ranges_(code->VirtualRegisterCount() * 2, local_zone()),
+ active_live_ranges_(8, local_zone()),
+ inactive_live_ranges_(8, local_zone()),
+ reusable_slots_(8, local_zone()),
mode_(UNALLOCATED_REGISTERS),
num_registers_(-1),
- allocation_ok_(true) {}
+ allocation_ok_(true) {
+ DCHECK(this->config()->num_general_registers() <=
+ RegisterConfiguration::kMaxGeneralRegisters);
+ DCHECK(this->config()->num_double_registers() <=
+ RegisterConfiguration::kMaxDoubleRegisters);
+ // TryAllocateFreeReg and AllocateBlockedReg assume this
+ // when allocating local arrays.
+ DCHECK(this->config()->num_double_registers() >=
+ this->config()->num_general_registers());
+}
void RegisterAllocator::InitializeLivenessAnalysis() {
// Initialize the live_in sets for each block to NULL.
- int block_count = code()->BasicBlockCount();
- live_in_sets_.Initialize(block_count, zone());
- live_in_sets_.AddBlock(NULL, block_count, zone());
+ int block_count = code()->InstructionBlockCount();
+ live_in_sets_.Initialize(block_count, local_zone());
+ live_in_sets_.AddBlock(NULL, block_count, local_zone());
}
-BitVector* RegisterAllocator::ComputeLiveOut(BasicBlock* block) {
+BitVector* RegisterAllocator::ComputeLiveOut(const InstructionBlock* block) {
// Compute live out for the given block, except not including backward
// successor edges.
- BitVector* live_out =
- new (zone()) BitVector(code()->VirtualRegisterCount(), zone());
+ BitVector* live_out = new (local_zone())
+ BitVector(code()->VirtualRegisterCount(), local_zone());
// Process all successor blocks.
- BasicBlock::Successors successors = block->successors();
- for (BasicBlock::Successors::iterator i = successors.begin();
- i != successors.end(); ++i) {
+ for (auto succ : block->successors()) {
// Add values live on entry to the successor. Note the successor's
// live_in will not be computed yet for backwards edges.
- BasicBlock* successor = *i;
- BitVector* live_in = live_in_sets_[successor->rpo_number_];
+ BitVector* live_in = live_in_sets_[static_cast<int>(succ.ToSize())];
if (live_in != NULL) live_out->Union(*live_in);
// All phi input operands corresponding to this successor edge are live
// out from this block.
- int index = successor->PredecessorIndexOf(block);
- DCHECK(index >= 0);
- DCHECK(index < static_cast<int>(successor->PredecessorCount()));
- for (BasicBlock::const_iterator j = successor->begin();
- j != successor->end(); ++j) {
- Node* phi = *j;
- if (phi->opcode() != IrOpcode::kPhi) continue;
- Node* input = phi->InputAt(index);
- live_out->Add(input->id());
+ const InstructionBlock* successor = code()->InstructionBlockAt(succ);
+ size_t index = successor->PredecessorIndexOf(block->rpo_number());
+ DCHECK(index < successor->PredecessorCount());
+ for (auto phi : successor->phis()) {
+ live_out->Add(phi->operands()[index]);
}
}
-
return live_out;
}
-void RegisterAllocator::AddInitialIntervals(BasicBlock* block,
+void RegisterAllocator::AddInitialIntervals(const InstructionBlock* block,
BitVector* live_out) {
// Add an interval that includes the entire block to the live range for
// each live_out value.
while (!iterator.Done()) {
int operand_index = iterator.Current();
LiveRange* range = LiveRangeFor(operand_index);
- range->AddUseInterval(start, end, zone());
+ range->AddUseInterval(start, end, local_zone());
iterator.Advance();
}
}
int RegisterAllocator::FixedDoubleLiveRangeID(int index) {
- return -index - 1 - Register::kMaxNumAllocatableRegisters;
+ return -index - 1 - config()->num_general_registers();
}
LiveRange* RegisterAllocator::FixedLiveRangeFor(int index) {
- DCHECK(index < Register::kMaxNumAllocatableRegisters);
+ DCHECK(index < config()->num_general_registers());
LiveRange* result = fixed_live_ranges_[index];
if (result == NULL) {
// TODO(titzer): add a utility method to allocate a new LiveRange:
// The LiveRange object itself can go in this zone, but the
// InstructionOperand needs
// to go in the code zone, since it may survive register allocation.
- result = new (zone()) LiveRange(FixedLiveRangeID(index), code_zone());
+ result = new (local_zone()) LiveRange(FixedLiveRangeID(index), code_zone());
DCHECK(result->IsFixed());
result->kind_ = GENERAL_REGISTERS;
SetLiveRangeAssignedRegister(result, index);
LiveRange* RegisterAllocator::FixedDoubleLiveRangeFor(int index) {
- DCHECK(index < DoubleRegister::NumAllocatableAliasedRegisters());
+ DCHECK(index < config()->num_aliased_double_registers());
LiveRange* result = fixed_double_live_ranges_[index];
if (result == NULL) {
- result = new (zone()) LiveRange(FixedDoubleLiveRangeID(index), code_zone());
+ result = new (local_zone())
+ LiveRange(FixedDoubleLiveRangeID(index), code_zone());
DCHECK(result->IsFixed());
result->kind_ = DOUBLE_REGISTERS;
SetLiveRangeAssignedRegister(result, index);
LiveRange* RegisterAllocator::LiveRangeFor(int index) {
if (index >= live_ranges_.length()) {
- live_ranges_.AddBlock(NULL, index - live_ranges_.length() + 1, zone());
+ live_ranges_.AddBlock(NULL, index - live_ranges_.length() + 1,
+ local_zone());
}
LiveRange* result = live_ranges_[index];
if (result == NULL) {
- result = new (zone()) LiveRange(index, code_zone());
+ result = new (local_zone()) LiveRange(index, code_zone());
live_ranges_[index] = result;
}
return result;
}
-GapInstruction* RegisterAllocator::GetLastGap(BasicBlock* block) {
+GapInstruction* RegisterAllocator::GetLastGap(const InstructionBlock* block) {
int last_instruction = block->last_instruction_index();
return code()->GapAt(last_instruction - 1);
}
if (range->IsEmpty() || range->Start().Value() > position.Value()) {
// Can happen if there is a definition without use.
- range->AddUseInterval(position, position.NextInstruction(), zone());
- range->AddUsePosition(position.NextInstruction(), NULL, NULL, zone());
+ range->AddUseInterval(position, position.NextInstruction(), local_zone());
+ range->AddUsePosition(position.NextInstruction(), NULL, NULL, local_zone());
} else {
range->ShortenTo(position);
}
if (operand->IsUnallocated()) {
UnallocatedOperand* unalloc_operand = UnallocatedOperand::cast(operand);
- range->AddUsePosition(position, unalloc_operand, hint, zone());
+ range->AddUsePosition(position, unalloc_operand, hint, local_zone());
}
}
if (range == NULL) return;
if (operand->IsUnallocated()) {
UnallocatedOperand* unalloc_operand = UnallocatedOperand::cast(operand);
- range->AddUsePosition(position, unalloc_operand, hint, zone());
+ range->AddUsePosition(position, unalloc_operand, hint, local_zone());
}
- range->AddUseInterval(block_start, position, zone());
+ range->AddUseInterval(block_start, position, local_zone());
}
}
-void RegisterAllocator::MeetRegisterConstraints(BasicBlock* block) {
+void RegisterAllocator::MeetRegisterConstraints(const InstructionBlock* block) {
int start = block->first_instruction_index();
int end = block->last_instruction_index();
DCHECK_NE(-1, start);
void RegisterAllocator::MeetRegisterConstraintsForLastInstructionInBlock(
- BasicBlock* block) {
+ const InstructionBlock* block) {
int end = block->last_instruction_index();
Instruction* last_instruction = InstructionAt(end);
for (size_t i = 0; i < last_instruction->OutputCount(); i++) {
assigned = true;
}
- BasicBlock::Successors successors = block->successors();
- for (BasicBlock::Successors::iterator succ = successors.begin();
- succ != successors.end(); ++succ) {
- DCHECK((*succ)->PredecessorCount() == 1);
- int gap_index = (*succ)->first_instruction_index() + 1;
+ for (auto succ : block->successors()) {
+ const InstructionBlock* successor = code()->InstructionBlockAt(succ);
+ DCHECK(successor->PredecessorCount() == 1);
+ int gap_index = successor->first_instruction_index() + 1;
DCHECK(code()->IsGapAt(gap_index));
// Create an unconstrained operand for the same virtual register
}
if (!assigned) {
- BasicBlock::Successors successors = block->successors();
- for (BasicBlock::Successors::iterator succ = successors.begin();
- succ != successors.end(); ++succ) {
- DCHECK((*succ)->PredecessorCount() == 1);
- int gap_index = (*succ)->first_instruction_index() + 1;
+ for (auto succ : block->successors()) {
+ const InstructionBlock* successor = code()->InstructionBlockAt(succ);
+ DCHECK(successor->PredecessorCount() == 1);
+ int gap_index = successor->first_instruction_index() + 1;
range->SetSpillStartIndex(gap_index);
// This move to spill operand is not a real use. Liveness analysis
}
-void RegisterAllocator::ProcessInstructions(BasicBlock* block,
+void RegisterAllocator::ProcessInstructions(const InstructionBlock* block,
BitVector* live) {
int block_start = block->first_instruction_index();
}
if (instr->ClobbersRegisters()) {
- for (int i = 0; i < Register::kMaxNumAllocatableRegisters; ++i) {
+ for (int i = 0; i < config()->num_general_registers(); ++i) {
if (!IsOutputRegisterOf(instr, i)) {
LiveRange* range = FixedLiveRangeFor(i);
range->AddUseInterval(curr_position, curr_position.InstructionEnd(),
- zone());
+ local_zone());
}
}
}
if (instr->ClobbersDoubleRegisters()) {
- for (int i = 0; i < DoubleRegister::NumAllocatableAliasedRegisters();
- ++i) {
+ for (int i = 0; i < config()->num_aliased_double_registers(); ++i) {
if (!IsOutputDoubleRegisterOf(instr, i)) {
LiveRange* range = FixedDoubleLiveRangeFor(i);
range->AddUseInterval(curr_position, curr_position.InstructionEnd(),
- zone());
+ local_zone());
}
}
}
}
-void RegisterAllocator::ResolvePhis(BasicBlock* block) {
- for (BasicBlock::const_iterator i = block->begin(); i != block->end(); ++i) {
- Node* phi = *i;
- if (phi->opcode() != IrOpcode::kPhi) continue;
-
+void RegisterAllocator::ResolvePhis(const InstructionBlock* block) {
+ for (auto phi : block->phis()) {
UnallocatedOperand* phi_operand =
new (code_zone()) UnallocatedOperand(UnallocatedOperand::NONE);
- phi_operand->set_virtual_register(phi->id());
-
- int j = 0;
- Node::Inputs inputs = phi->inputs();
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter, ++j) {
- Node* op = *iter;
- // TODO(mstarzinger): Use a ValueInputIterator instead.
- if (j >= block->PredecessorCount()) continue;
+ int phi_vreg = phi->virtual_register();
+ phi_operand->set_virtual_register(phi_vreg);
+
+ for (size_t i = 0; i < phi->operands().size(); ++i) {
UnallocatedOperand* operand =
new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY);
- operand->set_virtual_register(op->id());
- BasicBlock* cur_block = block->PredecessorAt(j);
+ operand->set_virtual_register(phi->operands()[i]);
+ InstructionBlock* cur_block =
+ code()->InstructionBlockAt(block->predecessors()[i]);
// The gap move must be added without any special processing as in
// the AddConstraintsGapMove.
code()->AddGapMove(cur_block->last_instruction_index() - 1, operand,
USE(branch);
}
- LiveRange* live_range = LiveRangeFor(phi->id());
- BlockStartInstruction* block_start = code()->GetBlockStart(block);
+ LiveRange* live_range = LiveRangeFor(phi_vreg);
+ BlockStartInstruction* block_start =
+ code()->GetBlockStart(block->rpo_number());
block_start->GetOrCreateParallelMove(GapInstruction::START, code_zone())
->AddMove(phi_operand, live_range->GetSpillOperand(), code_zone());
live_range->SetSpillStartIndex(block->first_instruction_index());
}
-bool RegisterAllocator::Allocate() {
+bool RegisterAllocator::Allocate(PipelineStatistics* stats) {
assigned_registers_ = new (code_zone())
- BitVector(Register::NumAllocatableRegisters(), code_zone());
+ BitVector(config()->num_general_registers(), code_zone());
assigned_double_registers_ = new (code_zone())
- BitVector(DoubleRegister::NumAllocatableAliasedRegisters(), code_zone());
- MeetRegisterConstraints();
+ BitVector(config()->num_aliased_double_registers(), code_zone());
+ {
+ PhaseScope phase_scope(stats, "meet register constraints");
+ MeetRegisterConstraints();
+ }
if (!AllocationOk()) return false;
- ResolvePhis();
- BuildLiveRanges();
- AllocateGeneralRegisters();
+ {
+ PhaseScope phase_scope(stats, "resolve phis");
+ ResolvePhis();
+ }
+ {
+ PhaseScope phase_scope(stats, "build live ranges");
+ BuildLiveRanges();
+ }
+ {
+ PhaseScope phase_scope(stats, "allocate general registers");
+ AllocateGeneralRegisters();
+ }
if (!AllocationOk()) return false;
- AllocateDoubleRegisters();
+ {
+ PhaseScope phase_scope(stats, "allocate double registers");
+ AllocateDoubleRegisters();
+ }
if (!AllocationOk()) return false;
- PopulatePointerMaps();
- ConnectRanges();
- ResolveControlFlow();
- code()->frame()->SetAllocatedRegisters(assigned_registers_);
- code()->frame()->SetAllocatedDoubleRegisters(assigned_double_registers_);
+ {
+ PhaseScope phase_scope(stats, "populate pointer maps");
+ PopulatePointerMaps();
+ }
+ {
+ PhaseScope phase_scope(stats, "connect ranges");
+ ConnectRanges();
+ }
+ {
+ PhaseScope phase_scope(stats, "resolve control flow");
+ ResolveControlFlow();
+ }
+ frame()->SetAllocatedRegisters(assigned_registers_);
+ frame()->SetAllocatedDoubleRegisters(assigned_double_registers_);
return true;
}
void RegisterAllocator::MeetRegisterConstraints() {
- RegisterAllocatorPhase phase("L_Register constraints", this);
- for (int i = 0; i < code()->BasicBlockCount(); ++i) {
- MeetRegisterConstraints(code()->BlockAt(i));
+ for (auto block : code()->instruction_blocks()) {
+ MeetRegisterConstraints(block);
if (!AllocationOk()) return;
}
}
void RegisterAllocator::ResolvePhis() {
- RegisterAllocatorPhase phase("L_Resolve phis", this);
-
// Process the blocks in reverse order.
- for (int i = code()->BasicBlockCount() - 1; i >= 0; --i) {
- ResolvePhis(code()->BlockAt(i));
- }
-}
-
-
-void RegisterAllocator::ResolveControlFlow(LiveRange* range, BasicBlock* block,
- BasicBlock* pred) {
- LifetimePosition pred_end =
- LifetimePosition::FromInstructionIndex(pred->last_instruction_index());
- LifetimePosition cur_start =
- LifetimePosition::FromInstructionIndex(block->first_instruction_index());
- LiveRange* pred_cover = NULL;
- LiveRange* cur_cover = NULL;
- LiveRange* cur_range = range;
- while (cur_range != NULL && (cur_cover == NULL || pred_cover == NULL)) {
- if (cur_range->CanCover(cur_start)) {
- DCHECK(cur_cover == NULL);
- cur_cover = cur_range;
- }
- if (cur_range->CanCover(pred_end)) {
- DCHECK(pred_cover == NULL);
- pred_cover = cur_range;
- }
- cur_range = cur_range->next();
- }
-
- if (cur_cover->IsSpilled()) return;
- DCHECK(pred_cover != NULL && cur_cover != NULL);
- if (pred_cover != cur_cover) {
- InstructionOperand* pred_op =
- pred_cover->CreateAssignedOperand(code_zone());
- InstructionOperand* cur_op = cur_cover->CreateAssignedOperand(code_zone());
- if (!pred_op->Equals(cur_op)) {
- GapInstruction* gap = NULL;
- if (block->PredecessorCount() == 1) {
- gap = code()->GapAt(block->first_instruction_index());
- } else {
- DCHECK(pred->SuccessorCount() == 1);
- gap = GetLastGap(pred);
-
- Instruction* branch = InstructionAt(pred->last_instruction_index());
- DCHECK(!branch->HasPointerMap());
- USE(branch);
- }
- gap->GetOrCreateParallelMove(GapInstruction::START, code_zone())
- ->AddMove(pred_op, cur_op, code_zone());
- }
+ for (auto i = code()->instruction_blocks().rbegin();
+ i != code()->instruction_blocks().rend(); ++i) {
+ ResolvePhis(*i);
}
}
}
-BasicBlock* RegisterAllocator::GetBlock(LifetimePosition pos) {
- return code()->GetBasicBlock(pos.InstructionIndex());
+const InstructionBlock* RegisterAllocator::GetInstructionBlock(
+ LifetimePosition pos) {
+ return code()->GetInstructionBlock(pos.InstructionIndex());
}
void RegisterAllocator::ConnectRanges() {
- RegisterAllocatorPhase phase("L_Connect ranges", this);
- for (int i = 0; i < live_ranges()->length(); ++i) {
- LiveRange* first_range = live_ranges()->at(i);
+ for (int i = 0; i < live_ranges().length(); ++i) {
+ LiveRange* first_range = live_ranges().at(i);
if (first_range == NULL || first_range->parent() != NULL) continue;
LiveRange* second_range = first_range->next();
if (first_range->End().Value() == pos.Value()) {
bool should_insert = true;
if (IsBlockBoundary(pos)) {
- should_insert = CanEagerlyResolveControlFlow(GetBlock(pos));
+ should_insert =
+ CanEagerlyResolveControlFlow(GetInstructionBlock(pos));
}
if (should_insert) {
ParallelMove* move = GetConnectingParallelMove(pos);
}
-bool RegisterAllocator::CanEagerlyResolveControlFlow(BasicBlock* block) const {
+bool RegisterAllocator::CanEagerlyResolveControlFlow(
+ const InstructionBlock* block) const {
if (block->PredecessorCount() != 1) return false;
- return block->PredecessorAt(0)->rpo_number_ == block->rpo_number_ - 1;
+ return block->predecessors()[0].IsNext(block->rpo_number());
}
+namespace {
+
+class LiveRangeBound {
+ public:
+ explicit LiveRangeBound(const LiveRange* range)
+ : range_(range), start_(range->Start()), end_(range->End()) {
+ DCHECK(!range->IsEmpty());
+ }
+
+ bool CanCover(LifetimePosition position) {
+ return start_.Value() <= position.Value() &&
+ position.Value() < end_.Value();
+ }
+
+ const LiveRange* const range_;
+ const LifetimePosition start_;
+ const LifetimePosition end_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(LiveRangeBound);
+};
+
+
+struct FindResult {
+ const LiveRange* cur_cover_;
+ const LiveRange* pred_cover_;
+};
+
+
+class LiveRangeBoundArray {
+ public:
+ LiveRangeBoundArray() : length_(0), start_(nullptr) {}
+
+ bool ShouldInitialize() { return start_ == NULL; }
+
+ void Initialize(Zone* zone, const LiveRange* const range) {
+ size_t length = 0;
+ for (const LiveRange* i = range; i != NULL; i = i->next()) length++;
+ start_ = zone->NewArray<LiveRangeBound>(static_cast<int>(length));
+ length_ = length;
+ LiveRangeBound* curr = start_;
+ for (const LiveRange* i = range; i != NULL; i = i->next(), ++curr) {
+ new (curr) LiveRangeBound(i);
+ }
+ }
+
+ LiveRangeBound* Find(const LifetimePosition position) const {
+ size_t left_index = 0;
+ size_t right_index = length_;
+ while (true) {
+ size_t current_index = left_index + (right_index - left_index) / 2;
+ DCHECK(right_index > current_index);
+ LiveRangeBound* bound = &start_[current_index];
+ if (bound->start_.Value() <= position.Value()) {
+ if (position.Value() < bound->end_.Value()) return bound;
+ DCHECK(left_index < current_index);
+ left_index = current_index;
+ } else {
+ right_index = current_index;
+ }
+ }
+ }
+
+ void Find(const InstructionBlock* block, const InstructionBlock* pred,
+ FindResult* result) const {
+ const LifetimePosition pred_end =
+ LifetimePosition::FromInstructionIndex(pred->last_instruction_index());
+ LiveRangeBound* bound = Find(pred_end);
+ result->pred_cover_ = bound->range_;
+ const LifetimePosition cur_start = LifetimePosition::FromInstructionIndex(
+ block->first_instruction_index());
+ // Common case.
+ if (bound->CanCover(cur_start)) {
+ result->cur_cover_ = bound->range_;
+ return;
+ }
+ result->cur_cover_ = Find(cur_start)->range_;
+ DCHECK(result->pred_cover_ != NULL && result->cur_cover_ != NULL);
+ }
+
+ private:
+ size_t length_;
+ LiveRangeBound* start_;
+
+ DISALLOW_COPY_AND_ASSIGN(LiveRangeBoundArray);
+};
+
+
+class LiveRangeFinder {
+ public:
+ explicit LiveRangeFinder(const RegisterAllocator& allocator)
+ : allocator_(allocator),
+ bounds_length_(allocator.live_ranges().length()),
+ bounds_(allocator.local_zone()->NewArray<LiveRangeBoundArray>(
+ bounds_length_)) {
+ for (int i = 0; i < bounds_length_; ++i) {
+ new (&bounds_[i]) LiveRangeBoundArray();
+ }
+ }
+
+ LiveRangeBoundArray* ArrayFor(int operand_index) {
+ DCHECK(operand_index < bounds_length_);
+ const LiveRange* range = allocator_.live_ranges()[operand_index];
+ DCHECK(range != nullptr && !range->IsEmpty());
+ LiveRangeBoundArray* array = &bounds_[operand_index];
+ if (array->ShouldInitialize()) {
+ array->Initialize(allocator_.local_zone(), range);
+ }
+ return array;
+ }
+
+ private:
+ const RegisterAllocator& allocator_;
+ const int bounds_length_;
+ LiveRangeBoundArray* const bounds_;
+
+ DISALLOW_COPY_AND_ASSIGN(LiveRangeFinder);
+};
+
+} // namespace
+
+
void RegisterAllocator::ResolveControlFlow() {
- RegisterAllocatorPhase phase("L_Resolve control flow", this);
- for (int block_id = 1; block_id < code()->BasicBlockCount(); ++block_id) {
- BasicBlock* block = code()->BlockAt(block_id);
+ // Lazily linearize live ranges in memory for fast lookup.
+ LiveRangeFinder finder(*this);
+ for (auto block : code()->instruction_blocks()) {
if (CanEagerlyResolveControlFlow(block)) continue;
- BitVector* live = live_in_sets_[block->rpo_number_];
+ BitVector* live = live_in_sets_[block->rpo_number().ToInt()];
BitVector::Iterator iterator(live);
while (!iterator.Done()) {
- int operand_index = iterator.Current();
- BasicBlock::Predecessors predecessors = block->predecessors();
- for (BasicBlock::Predecessors::iterator i = predecessors.begin();
- i != predecessors.end(); ++i) {
- BasicBlock* cur = *i;
- LiveRange* cur_range = LiveRangeFor(operand_index);
- ResolveControlFlow(cur_range, block, cur);
+ LiveRangeBoundArray* array = finder.ArrayFor(iterator.Current());
+ for (auto pred : block->predecessors()) {
+ FindResult result;
+ const InstructionBlock* pred_block = code()->InstructionBlockAt(pred);
+ array->Find(block, pred_block, &result);
+ if (result.cur_cover_ == result.pred_cover_ ||
+ result.cur_cover_->IsSpilled())
+ continue;
+ ResolveControlFlow(block, result.cur_cover_, pred_block,
+ result.pred_cover_);
}
iterator.Advance();
}
}
+void RegisterAllocator::ResolveControlFlow(const InstructionBlock* block,
+ const LiveRange* cur_cover,
+ const InstructionBlock* pred,
+ const LiveRange* pred_cover) {
+ InstructionOperand* pred_op = pred_cover->CreateAssignedOperand(code_zone());
+ InstructionOperand* cur_op = cur_cover->CreateAssignedOperand(code_zone());
+ if (!pred_op->Equals(cur_op)) {
+ GapInstruction* gap = NULL;
+ if (block->PredecessorCount() == 1) {
+ gap = code()->GapAt(block->first_instruction_index());
+ } else {
+ DCHECK(pred->SuccessorCount() == 1);
+ gap = GetLastGap(pred);
+
+ Instruction* branch = InstructionAt(pred->last_instruction_index());
+ DCHECK(!branch->HasPointerMap());
+ USE(branch);
+ }
+ gap->GetOrCreateParallelMove(GapInstruction::START, code_zone())
+ ->AddMove(pred_op, cur_op, code_zone());
+ }
+}
+
+
void RegisterAllocator::BuildLiveRanges() {
- RegisterAllocatorPhase phase("L_Build live ranges", this);
InitializeLivenessAnalysis();
// Process the blocks in reverse order.
- for (int block_id = code()->BasicBlockCount() - 1; block_id >= 0;
+ for (int block_id = code()->InstructionBlockCount() - 1; block_id >= 0;
--block_id) {
- BasicBlock* block = code()->BlockAt(block_id);
+ const InstructionBlock* block =
+ code()->InstructionBlockAt(BasicBlock::RpoNumber::FromInt(block_id));
BitVector* live = ComputeLiveOut(block);
// Initially consider all live_out values live for the entire block. We
// will shorten these intervals if necessary.
// live values.
ProcessInstructions(block, live);
// All phi output operands are killed by this block.
- for (BasicBlock::const_iterator i = block->begin(); i != block->end();
- ++i) {
- Node* phi = *i;
- if (phi->opcode() != IrOpcode::kPhi) continue;
-
+ for (auto phi : block->phis()) {
// The live range interval already ends at the first instruction of the
// block.
- live->Remove(phi->id());
+ int phi_vreg = phi->virtual_register();
+ live->Remove(phi_vreg);
InstructionOperand* hint = NULL;
InstructionOperand* phi_operand = NULL;
- GapInstruction* gap = GetLastGap(block->PredecessorAt(0));
+ GapInstruction* gap =
+ GetLastGap(code()->InstructionBlockAt(block->predecessors()[0]));
// TODO(titzer): no need to create the parallel move if it doesn't exit.
ParallelMove* move =
for (int j = 0; j < move->move_operands()->length(); ++j) {
InstructionOperand* to = move->move_operands()->at(j).destination();
if (to->IsUnallocated() &&
- UnallocatedOperand::cast(to)->virtual_register() == phi->id()) {
+ UnallocatedOperand::cast(to)->virtual_register() == phi_vreg) {
hint = move->move_operands()->at(j).source();
phi_operand = to;
break;
BitVector::Iterator iterator(live);
LifetimePosition start = LifetimePosition::FromInstructionIndex(
block->first_instruction_index());
- int end_index =
- code()->BlockAt(block->loop_end_)->last_instruction_index();
LifetimePosition end =
- LifetimePosition::FromInstructionIndex(end_index).NextInstruction();
+ LifetimePosition::FromInstructionIndex(
+ code()->LastLoopInstructionIndex(block)).NextInstruction();
while (!iterator.Done()) {
int operand_index = iterator.Current();
LiveRange* range = LiveRangeFor(operand_index);
- range->EnsureInterval(start, end, zone());
+ range->EnsureInterval(start, end, local_zone());
iterator.Advance();
}
// Insert all values into the live in sets of all blocks in the loop.
- for (int i = block->rpo_number_ + 1; i < block->loop_end_; ++i) {
+ for (int i = block->rpo_number().ToInt() + 1;
+ i < block->loop_end().ToInt(); ++i) {
live_in_sets_[i]->Union(*live);
}
}
operand_index);
LiveRange* range = LiveRangeFor(operand_index);
PrintF(" (first use is at %d)\n", range->first_pos()->pos().Value());
- CompilationInfo* info = code()->linkage()->info();
- if (info->IsStub()) {
- if (info->code_stub() == NULL) {
- PrintF("\n");
- } else {
- CodeStub::Major major_key = info->code_stub()->MajorKey();
- PrintF(" (function: %s)\n", CodeStub::MajorName(major_key, false));
- }
+ if (debug_name() == nullptr) {
+ PrintF("\n");
} else {
- DCHECK(info->IsOptimizing());
- AllowHandleDereference allow_deref;
- PrintF(" (function: %s)\n",
- info->function()->debug_name()->ToCString().get());
+ PrintF(" (function: %s)\n", debug_name());
}
iterator.Advance();
}
for (UsePosition* pos = range->first_pos(); pos != NULL;
pos = pos->next_) {
pos->register_beneficial_ = true;
- pos->requires_reg_ = true;
+ // TODO(dcarney): should the else case assert requires_reg_ == false?
+ // Can't mark phis as needing a register.
+ if (!code()
+ ->InstructionAt(pos->pos().InstructionIndex())
+ ->IsGapMoves()) {
+ pos->requires_reg_ = true;
+ }
}
}
}
void RegisterAllocator::PopulatePointerMaps() {
- RegisterAllocatorPhase phase("L_Populate pointer maps", this);
-
DCHECK(SafePointsAreInOrder());
// Iterate over all safe point positions and record a pointer
int last_range_start = 0;
const PointerMapDeque* pointer_maps = code()->pointer_maps();
PointerMapDeque::const_iterator first_it = pointer_maps->begin();
- for (int range_idx = 0; range_idx < live_ranges()->length(); ++range_idx) {
- LiveRange* range = live_ranges()->at(range_idx);
+ for (int range_idx = 0; range_idx < live_ranges().length(); ++range_idx) {
+ LiveRange* range = live_ranges().at(range_idx);
if (range == NULL) continue;
// Iterate over the first parts of multi-part live ranges.
if (range->parent() != NULL) continue;
void RegisterAllocator::AllocateGeneralRegisters() {
- RegisterAllocatorPhase phase("L_Allocate general registers", this);
- num_registers_ = Register::NumAllocatableRegisters();
+ num_registers_ = config()->num_general_registers();
mode_ = GENERAL_REGISTERS;
AllocateRegisters();
}
void RegisterAllocator::AllocateDoubleRegisters() {
- RegisterAllocatorPhase phase("L_Allocate double registers", this);
- num_registers_ = DoubleRegister::NumAllocatableAliasedRegisters();
+ num_registers_ = config()->num_aliased_double_registers();
mode_ = DOUBLE_REGISTERS;
AllocateRegisters();
}
DCHECK(inactive_live_ranges_.is_empty());
if (mode_ == DOUBLE_REGISTERS) {
- for (int i = 0; i < DoubleRegister::NumAllocatableAliasedRegisters(); ++i) {
+ for (int i = 0; i < config()->num_aliased_double_registers(); ++i) {
LiveRange* current = fixed_double_live_ranges_.at(i);
if (current != NULL) {
AddToInactive(current);
}
} else {
DCHECK(mode_ == GENERAL_REGISTERS);
- for (int i = 0; i < fixed_live_ranges_.length(); ++i) {
- LiveRange* current = fixed_live_ranges_.at(i);
+ for (auto current : fixed_live_ranges()) {
if (current != NULL) {
AddToInactive(current);
}
const char* RegisterAllocator::RegisterName(int allocation_index) {
if (mode_ == GENERAL_REGISTERS) {
- return Register::AllocationIndexToString(allocation_index);
+ return config()->general_register_name(allocation_index);
} else {
- return DoubleRegister::AllocationIndexToString(allocation_index);
- }
-}
-
-
-void RegisterAllocator::TraceAlloc(const char* msg, ...) {
- if (FLAG_trace_alloc) {
- va_list arguments;
- va_start(arguments, msg);
- base::OS::VPrint(msg, arguments);
- va_end(arguments);
+ return config()->double_register_name(allocation_index);
}
}
void RegisterAllocator::AddToActive(LiveRange* range) {
TraceAlloc("Add live range %d to active\n", range->id());
- active_live_ranges_.Add(range, zone());
+ active_live_ranges_.Add(range, local_zone());
}
void RegisterAllocator::AddToInactive(LiveRange* range) {
TraceAlloc("Add live range %d to inactive\n", range->id());
- inactive_live_ranges_.Add(range, zone());
+ inactive_live_ranges_.Add(range, local_zone());
}
LiveRange* cur_range = unhandled_live_ranges_.at(i);
if (range->ShouldBeAllocatedBefore(cur_range)) {
TraceAlloc("Add live range %d to unhandled at %d\n", range->id(), i + 1);
- unhandled_live_ranges_.InsertAt(i + 1, range, zone());
+ unhandled_live_ranges_.InsertAt(i + 1, range, local_zone());
DCHECK(UnhandledIsSorted());
return;
}
}
TraceAlloc("Add live range %d to unhandled at start\n", range->id());
- unhandled_live_ranges_.InsertAt(0, range, zone());
+ unhandled_live_ranges_.InsertAt(0, range, local_zone());
DCHECK(UnhandledIsSorted());
}
if (range == NULL || range->IsEmpty()) return;
DCHECK(!range->HasRegisterAssigned() && !range->IsSpilled());
TraceAlloc("Add live range %d to unhandled unsorted at end\n", range->id());
- unhandled_live_ranges_.Add(range, zone());
+ unhandled_live_ranges_.Add(range, local_zone());
}
InstructionOperand* spill_operand = range->TopLevel()->GetSpillOperand();
if (spill_operand->IsConstant()) return;
if (spill_operand->index() >= 0) {
- reusable_slots_.Add(range, zone());
+ reusable_slots_.Add(range, local_zone());
}
}
void RegisterAllocator::ActiveToInactive(LiveRange* range) {
DCHECK(active_live_ranges_.Contains(range));
active_live_ranges_.RemoveElement(range);
- inactive_live_ranges_.Add(range, zone());
+ inactive_live_ranges_.Add(range, local_zone());
TraceAlloc("Moving live range %d from active to inactive\n", range->id());
}
void RegisterAllocator::InactiveToActive(LiveRange* range) {
DCHECK(inactive_live_ranges_.Contains(range));
inactive_live_ranges_.RemoveElement(range);
- active_live_ranges_.Add(range, zone());
+ active_live_ranges_.Add(range, local_zone());
TraceAlloc("Moving live range %d from inactive to active\n", range->id());
}
-// TryAllocateFreeReg and AllocateBlockedReg assume this
-// when allocating local arrays.
-STATIC_ASSERT(DoubleRegister::kMaxNumAllocatableRegisters >=
- Register::kMaxNumAllocatableRegisters);
-
-
bool RegisterAllocator::TryAllocateFreeReg(LiveRange* current) {
- LifetimePosition free_until_pos[DoubleRegister::kMaxNumAllocatableRegisters];
+ LifetimePosition free_until_pos[RegisterConfiguration::kMaxDoubleRegisters];
for (int i = 0; i < num_registers_; i++) {
free_until_pos[i] = LifetimePosition::MaxPosition();
return;
}
-
- LifetimePosition use_pos[DoubleRegister::kMaxNumAllocatableRegisters];
- LifetimePosition block_pos[DoubleRegister::kMaxNumAllocatableRegisters];
+ LifetimePosition use_pos[RegisterConfiguration::kMaxGeneralRegisters];
+ LifetimePosition block_pos[RegisterConfiguration::kMaxDoubleRegisters];
for (int i = 0; i < num_registers_; i++) {
use_pos[i] = block_pos[i] = LifetimePosition::MaxPosition();
}
+static const InstructionBlock* GetContainingLoop(
+ const InstructionSequence* sequence, const InstructionBlock* block) {
+ BasicBlock::RpoNumber index = block->loop_header();
+ if (!index.IsValid()) return NULL;
+ return sequence->InstructionBlockAt(index);
+}
+
+
LifetimePosition RegisterAllocator::FindOptimalSpillingPos(
LiveRange* range, LifetimePosition pos) {
- BasicBlock* block = GetBlock(pos.InstructionStart());
- BasicBlock* loop_header =
- block->IsLoopHeader() ? block : code()->GetContainingLoop(block);
+ const InstructionBlock* block = GetInstructionBlock(pos.InstructionStart());
+ const InstructionBlock* loop_header =
+ block->IsLoopHeader() ? block : GetContainingLoop(code(), block);
if (loop_header == NULL) return pos;
}
// Try hoisting out to an outer loop.
- loop_header = code()->GetContainingLoop(loop_header);
+ loop_header = GetContainingLoop(code(), loop_header);
}
return pos;
int vreg = GetVirtualRegister();
if (!AllocationOk()) return NULL;
LiveRange* result = LiveRangeFor(vreg);
- range->SplitAt(pos, result, zone());
+ range->SplitAt(pos, result, local_zone());
return result;
}
// We have no choice
if (start_instr == end_instr) return end;
- BasicBlock* start_block = GetBlock(start);
- BasicBlock* end_block = GetBlock(end);
+ const InstructionBlock* start_block = GetInstructionBlock(start);
+ const InstructionBlock* end_block = GetInstructionBlock(end);
if (end_block == start_block) {
// The interval is split in the same basic block. Split at the latest
return end;
}
- BasicBlock* block = end_block;
+ const InstructionBlock* block = end_block;
// Find header of outermost loop.
// TODO(titzer): fix redundancy below.
- while (code()->GetContainingLoop(block) != NULL &&
- code()->GetContainingLoop(block)->rpo_number_ >
- start_block->rpo_number_) {
- block = code()->GetContainingLoop(block);
+ while (GetContainingLoop(code(), block) != NULL &&
+ GetContainingLoop(code(), block)->rpo_number().ToInt() >
+ start_block->rpo_number().ToInt()) {
+ block = GetContainingLoop(code(), block);
}
// We did not find any suitable outer loop. Split at the latest possible
if (op == NULL) {
// Allocate a new operand referring to the spill slot.
RegisterKind kind = range->Kind();
- int index = code()->frame()->AllocateSpillSlot(kind == DOUBLE_REGISTERS);
+ int index = frame()->AllocateSpillSlot(kind == DOUBLE_REGISTERS);
if (kind == DOUBLE_REGISTERS) {
- op = DoubleStackSlotOperand::Create(index, zone());
+ op = DoubleStackSlotOperand::Create(index, local_zone());
} else {
DCHECK(kind == GENERAL_REGISTERS);
- op = StackSlotOperand::Create(index, zone());
+ op = StackSlotOperand::Create(index, local_zone());
}
}
first->SetSpillOperand(op);
void RegisterAllocator::Verify() const {
- for (int i = 0; i < live_ranges()->length(); ++i) {
- LiveRange* current = live_ranges()->at(i);
+ for (auto current : live_ranges()) {
if (current != NULL) current->Verify();
}
}
range->set_assigned_register(reg, code_zone());
}
-
-RegisterAllocatorPhase::RegisterAllocatorPhase(const char* name,
- RegisterAllocator* allocator)
- : CompilationPhase(name, allocator->code()->linkage()->info()),
- allocator_(allocator) {
- if (FLAG_turbo_stats) {
- allocator_zone_start_allocation_size_ =
- allocator->zone()->allocation_size();
- }
-}
-
-
-RegisterAllocatorPhase::~RegisterAllocatorPhase() {
- if (FLAG_turbo_stats) {
- unsigned size = allocator_->zone()->allocation_size() -
- allocator_zone_start_allocation_size_;
- isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
- }
-#ifdef DEBUG
- if (allocator_ != NULL) allocator_->Verify();
-#endif
-}
}
}
} // namespace v8::internal::compiler
#ifndef V8_REGISTER_ALLOCATOR_H_
#define V8_REGISTER_ALLOCATOR_H_
-#include "src/allocation.h"
#include "src/compiler/instruction.h"
-#include "src/compiler/node.h"
-#include "src/compiler/schedule.h"
-#include "src/macro-assembler.h"
-#include "src/zone.h"
+#include "src/zone-containers.h"
namespace v8 {
namespace internal {
-
-// Forward declarations.
-class BitVector;
-class InstructionOperand;
-class UnallocatedOperand;
-class ParallelMove;
-class PointerMap;
-
namespace compiler {
+class PipelineStatistics;
+
enum RegisterKind {
UNALLOCATED_REGISTERS,
GENERAL_REGISTERS,
// each instruction there are exactly two lifetime positions: the beginning and
// the end of the instruction. Lifetime positions for different instructions are
// disjoint.
-class LifetimePosition {
+class LifetimePosition FINAL {
public:
// Return the lifetime position that corresponds to the beginning of
// the instruction with the given index.
// Representation of the non-empty interval [start,end[.
-class UseInterval : public ZoneObject {
+class UseInterval FINAL : public ZoneObject {
public:
UseInterval(LifetimePosition start, LifetimePosition end)
: start_(start), end_(end), next_(NULL) {
LifetimePosition start_;
LifetimePosition end_;
UseInterval* next_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(UseInterval);
};
+
// Representation of a use position.
-class UsePosition : public ZoneObject {
+class UsePosition FINAL : public ZoneObject {
public:
UsePosition(LifetimePosition pos, InstructionOperand* operand,
InstructionOperand* hint);
InstructionOperand* const hint_;
LifetimePosition const pos_;
UsePosition* next_;
- bool requires_reg_;
- bool register_beneficial_;
+ bool requires_reg_ : 1;
+ bool register_beneficial_ : 1;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(UsePosition);
};
+
// Representation of SSA values' live ranges as a collection of (continuous)
// intervals over the instruction ordering.
-class LiveRange : public ZoneObject {
+class LiveRange FINAL : public ZoneObject {
public:
static const int kInvalidAssignment = 0x7fffffff;
UsePosition* first_pos() const { return first_pos_; }
LiveRange* parent() const { return parent_; }
LiveRange* TopLevel() { return (parent_ == NULL) ? this : parent_; }
+ const LiveRange* TopLevel() const {
+ return (parent_ == NULL) ? this : parent_;
+ }
LiveRange* next() const { return next_; }
bool IsChild() const { return parent() != NULL; }
int id() const { return id_; }
bool IsFixed() const { return id_ < 0; }
bool IsEmpty() const { return first_interval() == NULL; }
- InstructionOperand* CreateAssignedOperand(Zone* zone);
+ InstructionOperand* CreateAssignedOperand(Zone* zone) const;
int assigned_register() const { return assigned_register_; }
int spill_start_index() const { return spill_start_index_; }
void set_assigned_register(int reg, Zone* zone);
int spill_start_index_;
friend class RegisterAllocator; // Assigns to kind_.
+
+ DISALLOW_COPY_AND_ASSIGN(LiveRange);
};
-class RegisterAllocator BASE_EMBEDDED {
+class RegisterAllocator FINAL {
public:
- explicit RegisterAllocator(InstructionSequence* code);
-
- static void TraceAlloc(const char* msg, ...);
-
- // Checks whether the value of a given virtual register is a reference.
- // TODO(titzer): rename this to IsReference.
- bool HasTaggedValue(int virtual_register) const;
+ explicit RegisterAllocator(const RegisterConfiguration* config,
+ Zone* local_zone, Frame* frame,
+ InstructionSequence* code,
+ const char* debug_name = nullptr);
- // Returns the register kind required by the given virtual register.
- RegisterKind RequiredRegisterKind(int virtual_register) const;
-
- bool Allocate();
+ bool Allocate(PipelineStatistics* stats = NULL);
+ bool AllocationOk() { return allocation_ok_; }
+ BitVector* assigned_registers() { return assigned_registers_; }
+ BitVector* assigned_double_registers() { return assigned_double_registers_; }
- const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
- const Vector<LiveRange*>* fixed_live_ranges() const {
- return &fixed_live_ranges_;
+ const ZoneList<LiveRange*>& live_ranges() const { return live_ranges_; }
+ const ZoneVector<LiveRange*>& fixed_live_ranges() const {
+ return fixed_live_ranges_;
}
- const Vector<LiveRange*>* fixed_double_live_ranges() const {
- return &fixed_double_live_ranges_;
+ const ZoneVector<LiveRange*>& fixed_double_live_ranges() const {
+ return fixed_double_live_ranges_;
}
-
- inline InstructionSequence* code() const { return code_; }
-
+ InstructionSequence* code() const { return code_; }
// This zone is for datastructures only needed during register allocation.
- inline Zone* zone() { return &zone_; }
-
- // This zone is for InstructionOperands and moves that live beyond register
- // allocation.
- inline Zone* code_zone() { return code()->zone(); }
+ Zone* local_zone() const { return local_zone_; }
+ private:
int GetVirtualRegister() {
int vreg = code()->NextVirtualRegister();
if (vreg >= UnallocatedOperand::kMaxVirtualRegisters) {
return vreg;
}
- bool AllocationOk() { return allocation_ok_; }
+ // Checks whether the value of a given virtual register is a reference.
+ // TODO(titzer): rename this to IsReference.
+ bool HasTaggedValue(int virtual_register) const;
+
+ // Returns the register kind required by the given virtual register.
+ RegisterKind RequiredRegisterKind(int virtual_register) const;
+
+ // This zone is for InstructionOperands and moves that live beyond register
+ // allocation.
+ Zone* code_zone() const { return code()->zone(); }
#ifdef DEBUG
void Verify() const;
#endif
- BitVector* assigned_registers() { return assigned_registers_; }
- BitVector* assigned_double_registers() { return assigned_double_registers_; }
-
- private:
void MeetRegisterConstraints();
void ResolvePhis();
void BuildLiveRanges();
void ResolveControlFlow();
void PopulatePointerMaps(); // TODO(titzer): rename to PopulateReferenceMaps.
void AllocateRegisters();
- bool CanEagerlyResolveControlFlow(BasicBlock* block) const;
- inline bool SafePointsAreInOrder() const;
+ bool CanEagerlyResolveControlFlow(const InstructionBlock* block) const;
+ bool SafePointsAreInOrder() const;
// Liveness analysis support.
void InitializeLivenessAnalysis();
- BitVector* ComputeLiveOut(BasicBlock* block);
- void AddInitialIntervals(BasicBlock* block, BitVector* live_out);
+ BitVector* ComputeLiveOut(const InstructionBlock* block);
+ void AddInitialIntervals(const InstructionBlock* block, BitVector* live_out);
bool IsOutputRegisterOf(Instruction* instr, int index);
bool IsOutputDoubleRegisterOf(Instruction* instr, int index);
- void ProcessInstructions(BasicBlock* block, BitVector* live);
- void MeetRegisterConstraints(BasicBlock* block);
+ void ProcessInstructions(const InstructionBlock* block, BitVector* live);
+ void MeetRegisterConstraints(const InstructionBlock* block);
void MeetConstraintsBetween(Instruction* first, Instruction* second,
int gap_index);
- void MeetRegisterConstraintsForLastInstructionInBlock(BasicBlock* block);
- void ResolvePhis(BasicBlock* block);
+ void MeetRegisterConstraintsForLastInstructionInBlock(
+ const InstructionBlock* block);
+ void ResolvePhis(const InstructionBlock* block);
// Helper methods for building intervals.
InstructionOperand* AllocateFixed(UnallocatedOperand* operand, int pos,
bool IsBlockBoundary(LifetimePosition pos);
// Helper methods for resolving control flow.
- void ResolveControlFlow(LiveRange* range, BasicBlock* block,
- BasicBlock* pred);
+ void ResolveControlFlow(const InstructionBlock* block,
+ const LiveRange* cur_cover,
+ const InstructionBlock* pred,
+ const LiveRange* pred_cover);
- inline void SetLiveRangeAssignedRegister(LiveRange* range, int reg);
+ void SetLiveRangeAssignedRegister(LiveRange* range, int reg);
// Return parallel move that should be used to connect ranges split at the
// given position.
ParallelMove* GetConnectingParallelMove(LifetimePosition pos);
// Return the block which contains give lifetime position.
- BasicBlock* GetBlock(LifetimePosition pos);
+ const InstructionBlock* GetInstructionBlock(LifetimePosition pos);
// Helper methods for the fixed registers.
int RegisterCount() const;
static int FixedLiveRangeID(int index) { return -index - 1; }
- static int FixedDoubleLiveRangeID(int index);
+ int FixedDoubleLiveRangeID(int index);
LiveRange* FixedLiveRangeFor(int index);
LiveRange* FixedDoubleLiveRangeFor(int index);
LiveRange* LiveRangeFor(int index);
- GapInstruction* GetLastGap(BasicBlock* block);
+ GapInstruction* GetLastGap(const InstructionBlock* block);
const char* RegisterName(int allocation_index);
- inline Instruction* InstructionAt(int index) {
- return code()->InstructionAt(index);
- }
+ Instruction* InstructionAt(int index) { return code()->InstructionAt(index); }
+
+ Frame* frame() const { return frame_; }
+ const char* debug_name() const { return debug_name_; }
+ const RegisterConfiguration* config() const { return config_; }
+
+ Zone* const local_zone_;
+ Frame* const frame_;
+ InstructionSequence* const code_;
+ const char* const debug_name_;
- Zone zone_;
- InstructionSequence* code_;
+ const RegisterConfiguration* config_;
// During liveness analysis keep a mapping from block id to live_in sets
// for blocks already analyzed.
ZoneList<LiveRange*> live_ranges_;
// Lists of live ranges
- EmbeddedVector<LiveRange*, Register::kMaxNumAllocatableRegisters>
- fixed_live_ranges_;
- EmbeddedVector<LiveRange*, DoubleRegister::kMaxNumAllocatableRegisters>
- fixed_double_live_ranges_;
+ ZoneVector<LiveRange*> fixed_live_ranges_;
+ ZoneVector<LiveRange*> fixed_double_live_ranges_;
ZoneList<LiveRange*> unhandled_live_ranges_;
ZoneList<LiveRange*> active_live_ranges_;
ZoneList<LiveRange*> inactive_live_ranges_;
DISALLOW_COPY_AND_ASSIGN(RegisterAllocator);
};
-
-class RegisterAllocatorPhase : public CompilationPhase {
- public:
- RegisterAllocatorPhase(const char* name, RegisterAllocator* allocator);
- ~RegisterAllocatorPhase();
-
- private:
- RegisterAllocator* allocator_;
- unsigned allocator_zone_start_allocation_size_;
-
- DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
-};
}
}
} // namespace v8::internal::compiler
--- /dev/null
+// 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/register-configuration.h"
+#include "src/macro-assembler.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+namespace {
+
+STATIC_ASSERT(RegisterConfiguration::kMaxGeneralRegisters >=
+ Register::kNumRegisters);
+STATIC_ASSERT(RegisterConfiguration::kMaxDoubleRegisters >=
+ DoubleRegister::kMaxNumRegisters);
+
+class ArchDefaultRegisterConfiguration : public RegisterConfiguration {
+ public:
+ ArchDefaultRegisterConfiguration()
+ : RegisterConfiguration(Register::kMaxNumAllocatableRegisters,
+ DoubleRegister::kMaxNumAllocatableRegisters,
+ DoubleRegister::NumAllocatableAliasedRegisters(),
+ general_register_name_table_,
+ double_register_name_table_) {
+ DCHECK_EQ(Register::kMaxNumAllocatableRegisters,
+ Register::NumAllocatableRegisters());
+ for (int i = 0; i < Register::kMaxNumAllocatableRegisters; ++i) {
+ general_register_name_table_[i] = Register::AllocationIndexToString(i);
+ }
+ for (int i = 0; i < DoubleRegister::kMaxNumAllocatableRegisters; ++i) {
+ double_register_name_table_[i] =
+ DoubleRegister::AllocationIndexToString(i);
+ }
+ }
+
+ const char*
+ general_register_name_table_[Register::kMaxNumAllocatableRegisters];
+ const char*
+ double_register_name_table_[DoubleRegister::kMaxNumAllocatableRegisters];
+};
+
+
+static base::LazyInstance<ArchDefaultRegisterConfiguration>::type
+ kDefaultRegisterConfiguration = LAZY_INSTANCE_INITIALIZER;
+
+} // namepace
+
+
+const RegisterConfiguration* RegisterConfiguration::ArchDefault() {
+ return &kDefaultRegisterConfiguration.Get();
+}
+
+RegisterConfiguration::RegisterConfiguration(
+ int num_general_registers, int num_double_registers,
+ int num_aliased_double_registers, const char* const* general_register_names,
+ const char* const* double_register_names)
+ : num_general_registers_(num_general_registers),
+ num_double_registers_(num_double_registers),
+ num_aliased_double_registers_(num_aliased_double_registers),
+ general_register_names_(general_register_names),
+ double_register_names_(double_register_names) {}
+
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_REGISTER_CONFIGURATION_H_
+#define V8_COMPILER_REGISTER_CONFIGURATION_H_
+
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// An architecture independent representation of the sets of registers available
+// for instruction creation.
+class RegisterConfiguration {
+ public:
+ // Architecture independent maxes.
+ static const int kMaxGeneralRegisters = 32;
+ static const int kMaxDoubleRegisters = 32;
+
+ static const RegisterConfiguration* ArchDefault();
+
+ RegisterConfiguration(int num_general_registers, int num_double_registers,
+ int num_aliased_double_registers,
+ const char* const* general_register_name,
+ const char* const* double_register_name);
+
+ int num_general_registers() const { return num_general_registers_; }
+ int num_double_registers() const { return num_double_registers_; }
+ int num_aliased_double_registers() const {
+ return num_aliased_double_registers_;
+ }
+
+ const char* general_register_name(int offset) const {
+ DCHECK(offset >= 0 && offset < kMaxGeneralRegisters);
+ return general_register_names_[offset];
+ }
+ const char* double_register_name(int offset) const {
+ DCHECK(offset >= 0 && offset < kMaxDoubleRegisters);
+ return double_register_names_[offset];
+ }
+
+ private:
+ const int num_general_registers_;
+ const int num_double_registers_;
+ const int num_aliased_double_registers_;
+ const char* const* general_register_names_;
+ const char* const* double_register_names_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_REGISTER_CONFIGURATION_H_
#ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
#define V8_COMPILER_REPRESENTATION_CHANGE_H_
+#include <sstream>
+
#include "src/base/bits.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/machine-operator.h"
node = jsgraph()->graph()->NewNode(op, node);
op = machine()->TruncateFloat64ToFloat32();
} else if (output_type & kRepFloat64) {
- op = machine()->ChangeFloat32ToFloat64();
+ op = machine()->TruncateFloat64ToFloat32();
} else {
return TypeError(node, output_type, kRepFloat32);
}
}
}
+ Node* GetTruncatedWord32For(Node* node, MachineTypeUnion output_type) {
+ // Eagerly fold truncations for constants.
+ switch (node->opcode()) {
+ case IrOpcode::kInt32Constant:
+ return node; // No change necessary.
+ case IrOpcode::kFloat32Constant:
+ return jsgraph()->Int32Constant(
+ DoubleToInt32(OpParameter<float>(node)));
+ case IrOpcode::kNumberConstant:
+ case IrOpcode::kFloat64Constant:
+ return jsgraph()->Int32Constant(
+ DoubleToInt32(OpParameter<double>(node)));
+ default:
+ break;
+ }
+ // Select the correct X -> Word32 truncation operator.
+ const Operator* op = NULL;
+ if (output_type & kRepFloat64) {
+ op = machine()->TruncateFloat64ToInt32();
+ } else if (output_type & kRepFloat32) {
+ node = InsertChangeFloat32ToFloat64(node);
+ op = machine()->TruncateFloat64ToInt32();
+ } else if (output_type & kRepTagged) {
+ node = InsertChangeTaggedToFloat64(node);
+ op = machine()->TruncateFloat64ToInt32();
+ } else {
+ return TypeError(node, output_type, kRepWord32);
+ }
+ return jsgraph()->graph()->NewNode(op, node);
+ }
+
Node* GetWord32RepresentationFor(Node* node, MachineTypeUnion output_type,
bool use_unsigned) {
// Eagerly fold representation changes for constants.
case IrOpcode::kNumberMultiply:
return machine()->Int32Mul();
case IrOpcode::kNumberDivide:
- return machine()->Int32UDiv();
+ return machine()->Uint32Div();
case IrOpcode::kNumberModulus:
- return machine()->Int32UMod();
+ return machine()->Uint32Mod();
case IrOpcode::kNumberEqual:
return machine()->Word32Equal();
case IrOpcode::kNumberLessThan:
MachineTypeUnion use) {
type_error_ = true;
if (!testing_type_errors_) {
- OStringStream out_str;
+ std::ostringstream out_str;
out_str << static_cast<MachineType>(output_type);
- OStringStream use_str;
+ std::ostringstream use_str;
use_str << static_cast<MachineType>(use);
V8_Fatal(__FILE__, __LINE__,
"RepresentationChangerError: node #%d:%s of "
"%s cannot be changed to %s",
- node->id(), node->op()->mnemonic(), out_str.c_str(),
- use_str.c_str());
+ node->id(), node->op()->mnemonic(), out_str.str().c_str(),
+ use_str.str().c_str());
}
return node;
}
node);
}
+ Node* InsertChangeTaggedToFloat64(Node* node) {
+ return jsgraph()->graph()->NewNode(simplified()->ChangeTaggedToFloat64(),
+ node);
+ }
+
JSGraph* jsgraph() { return jsgraph_; }
Isolate* isolate() { return isolate_; }
SimplifiedOperatorBuilder* simplified() { return simplified_; }
namespace internal {
namespace compiler {
-OStream& operator<<(OStream& os, const BasicBlockData::Control& c) {
+BasicBlock::BasicBlock(Zone* zone, Id id)
+ : ao_number_(-1),
+ rpo_number_(-1),
+ deferred_(false),
+ dominator_depth_(-1),
+ dominator_(NULL),
+ loop_header_(NULL),
+ loop_end_(NULL),
+ loop_depth_(0),
+ control_(kNone),
+ control_input_(NULL),
+ nodes_(zone),
+ successors_(zone),
+ predecessors_(zone),
+ id_(id) {}
+
+
+bool BasicBlock::LoopContains(BasicBlock* block) const {
+ // RPO numbers must be initialized.
+ DCHECK(rpo_number_ >= 0);
+ DCHECK(block->rpo_number_ >= 0);
+ if (loop_end_ == NULL) return false; // This is not a loop.
+ return block->rpo_number_ >= rpo_number_ &&
+ block->rpo_number_ < loop_end_->rpo_number_;
+}
+
+
+void BasicBlock::AddSuccessor(BasicBlock* successor) {
+ successors_.push_back(successor);
+}
+
+
+void BasicBlock::AddPredecessor(BasicBlock* predecessor) {
+ predecessors_.push_back(predecessor);
+}
+
+
+void BasicBlock::AddNode(Node* node) { nodes_.push_back(node); }
+
+
+void BasicBlock::set_control(Control control) {
+ control_ = control;
+}
+
+
+void BasicBlock::set_control_input(Node* control_input) {
+ control_input_ = control_input;
+}
+
+
+void BasicBlock::set_dominator_depth(int32_t dominator_depth) {
+ dominator_depth_ = dominator_depth;
+}
+
+
+void BasicBlock::set_dominator(BasicBlock* dominator) {
+ dominator_ = dominator;
+}
+
+
+void BasicBlock::set_loop_depth(int32_t loop_depth) {
+ loop_depth_ = loop_depth;
+}
+
+
+void BasicBlock::set_rpo_number(int32_t rpo_number) {
+ rpo_number_ = rpo_number;
+}
+
+
+void BasicBlock::set_loop_end(BasicBlock* loop_end) { loop_end_ = loop_end; }
+
+
+void BasicBlock::set_loop_header(BasicBlock* loop_header) {
+ loop_header_ = loop_header;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const BasicBlock::Control& c) {
switch (c) {
- case BasicBlockData::kNone:
+ case BasicBlock::kNone:
return os << "none";
- case BasicBlockData::kGoto:
+ case BasicBlock::kGoto:
return os << "goto";
- case BasicBlockData::kBranch:
+ case BasicBlock::kBranch:
return os << "branch";
- case BasicBlockData::kReturn:
+ case BasicBlock::kReturn:
return os << "return";
- case BasicBlockData::kThrow:
+ case BasicBlock::kThrow:
return os << "throw";
}
UNREACHABLE();
}
-OStream& operator<<(OStream& os, const Schedule& s) {
+std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id) {
+ return os << id.ToSize();
+}
+
+
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo) {
+ return os << rpo.ToSize();
+}
+
+
+Schedule::Schedule(Zone* zone, size_t node_count_hint)
+ : zone_(zone),
+ all_blocks_(zone),
+ nodeid_to_block_(zone),
+ rpo_order_(zone),
+ start_(NewBasicBlock()),
+ end_(NewBasicBlock()) {
+ nodeid_to_block_.reserve(node_count_hint);
+}
+
+
+BasicBlock* Schedule::block(Node* node) const {
+ if (node->id() < static_cast<NodeId>(nodeid_to_block_.size())) {
+ return nodeid_to_block_[node->id()];
+ }
+ return NULL;
+}
+
+
+bool Schedule::IsScheduled(Node* node) {
+ int length = static_cast<int>(nodeid_to_block_.size());
+ if (node->id() >= length) return false;
+ return nodeid_to_block_[node->id()] != NULL;
+}
+
+
+BasicBlock* Schedule::GetBlockById(BasicBlock::Id block_id) {
+ DCHECK(block_id.ToSize() < all_blocks_.size());
+ return all_blocks_[block_id.ToSize()];
+}
+
+
+bool Schedule::SameBasicBlock(Node* a, Node* b) const {
+ BasicBlock* block = this->block(a);
+ return block != NULL && block == this->block(b);
+}
+
+
+BasicBlock* Schedule::NewBasicBlock() {
+ BasicBlock* block = new (zone_)
+ BasicBlock(zone_, BasicBlock::Id::FromSize(all_blocks_.size()));
+ all_blocks_.push_back(block);
+ return block;
+}
+
+
+void Schedule::PlanNode(BasicBlock* block, Node* node) {
+ if (FLAG_trace_turbo_scheduler) {
+ OFStream os(stdout);
+ os << "Planning #" << node->id() << ":" << node->op()->mnemonic()
+ << " for future add to B" << block->id() << "\n";
+ }
+ DCHECK(this->block(node) == NULL);
+ SetBlockForNode(block, node);
+}
+
+
+void Schedule::AddNode(BasicBlock* block, Node* node) {
+ if (FLAG_trace_turbo_scheduler) {
+ OFStream os(stdout);
+ os << "Adding #" << node->id() << ":" << node->op()->mnemonic() << " to B"
+ << block->id() << "\n";
+ }
+ DCHECK(this->block(node) == NULL || this->block(node) == block);
+ block->AddNode(node);
+ SetBlockForNode(block, node);
+}
+
+
+void Schedule::AddGoto(BasicBlock* block, BasicBlock* succ) {
+ DCHECK(block->control() == BasicBlock::kNone);
+ block->set_control(BasicBlock::kGoto);
+ AddSuccessor(block, succ);
+}
+
+
+void Schedule::AddBranch(BasicBlock* block, Node* branch, BasicBlock* tblock,
+ BasicBlock* fblock) {
+ DCHECK(block->control() == BasicBlock::kNone);
+ DCHECK(branch->opcode() == IrOpcode::kBranch);
+ block->set_control(BasicBlock::kBranch);
+ AddSuccessor(block, tblock);
+ AddSuccessor(block, fblock);
+ SetControlInput(block, branch);
+}
+
+
+void Schedule::AddReturn(BasicBlock* block, Node* input) {
+ DCHECK(block->control() == BasicBlock::kNone);
+ block->set_control(BasicBlock::kReturn);
+ SetControlInput(block, input);
+ if (block != end()) AddSuccessor(block, end());
+}
+
+
+void Schedule::AddThrow(BasicBlock* block, Node* input) {
+ DCHECK(block->control() == BasicBlock::kNone);
+ block->set_control(BasicBlock::kThrow);
+ SetControlInput(block, input);
+ if (block != end()) AddSuccessor(block, end());
+}
+
+
+void Schedule::InsertBranch(BasicBlock* block, BasicBlock* end, Node* branch,
+ BasicBlock* tblock, BasicBlock* fblock) {
+ DCHECK(block->control() != BasicBlock::kNone);
+ DCHECK(end->control() == BasicBlock::kNone);
+ end->set_control(block->control());
+ block->set_control(BasicBlock::kBranch);
+ MoveSuccessors(block, end);
+ AddSuccessor(block, tblock);
+ AddSuccessor(block, fblock);
+ if (block->control_input() != NULL) {
+ SetControlInput(end, block->control_input());
+ }
+ SetControlInput(block, branch);
+}
+
+
+void Schedule::AddSuccessor(BasicBlock* block, BasicBlock* succ) {
+ block->AddSuccessor(succ);
+ succ->AddPredecessor(block);
+}
+
+
+void Schedule::MoveSuccessors(BasicBlock* from, BasicBlock* to) {
+ for (BasicBlock::Predecessors::iterator i = from->successors_begin();
+ i != from->successors_end(); ++i) {
+ BasicBlock* succ = *i;
+ to->AddSuccessor(succ);
+ for (BasicBlock::Predecessors::iterator j = succ->predecessors_begin();
+ j != succ->predecessors_end(); ++j) {
+ if (*j == from) *j = to;
+ }
+ }
+ from->ClearSuccessors();
+}
+
+
+void Schedule::SetControlInput(BasicBlock* block, Node* node) {
+ block->set_control_input(node);
+ SetBlockForNode(block, node);
+}
+
+
+void Schedule::SetBlockForNode(BasicBlock* block, Node* node) {
+ int length = static_cast<int>(nodeid_to_block_.size());
+ if (node->id() >= length) {
+ nodeid_to_block_.resize(node->id() + 1);
+ }
+ nodeid_to_block_[node->id()] = block;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const Schedule& s) {
// TODO(svenpanne) Const-correct the RPO stuff/iterators.
BasicBlockVector* rpo = const_cast<Schedule*>(&s)->rpo_order();
for (BasicBlockVectorIter i = rpo->begin(); i != rpo->end(); ++i) {
BasicBlock* block = *i;
os << "--- BLOCK B" << block->id();
+ if (block->deferred()) os << " (deferred)";
if (block->PredecessorCount() != 0) os << " <- ";
- BasicBlock::Predecessors predecessors = block->predecessors();
bool comma = false;
- for (BasicBlock::Predecessors::iterator j = predecessors.begin();
- j != predecessors.end(); ++j) {
+ for (BasicBlock::Predecessors::iterator j = block->predecessors_begin();
+ j != block->predecessors_end(); ++j) {
if (comma) os << ", ";
comma = true;
os << "B" << (*j)->id();
++j) {
Node* node = *j;
os << " " << *node;
- if (!NodeProperties::IsControl(node)) {
+ if (NodeProperties::IsTyped(node)) {
Bounds bounds = NodeProperties::GetBounds(node);
os << " : ";
bounds.lower->PrintTo(os);
}
os << "\n";
}
- BasicBlock::Control control = block->control_;
+ BasicBlock::Control control = block->control();
if (control != BasicBlock::kNone) {
os << " ";
- if (block->control_input_ != NULL) {
- os << *block->control_input_;
+ if (block->control_input() != NULL) {
+ os << *block->control_input();
} else {
os << "Goto";
}
os << " -> ";
- BasicBlock::Successors successors = block->successors();
comma = false;
- for (BasicBlock::Successors::iterator j = successors.begin();
- j != successors.end(); ++j) {
+ for (BasicBlock::Successors::iterator j = block->successors_begin();
+ j != block->successors_end(); ++j) {
if (comma) os << ", ";
comma = true;
os << "B" << (*j)->id();
}
return os;
}
+
} // namespace compiler
} // namespace internal
} // namespace v8
#ifndef V8_COMPILER_SCHEDULE_H_
#define V8_COMPILER_SCHEDULE_H_
+#include <iosfwd>
#include <vector>
#include "src/v8.h"
-#include "src/compiler/generic-algorithm.h"
-#include "src/compiler/generic-graph.h"
-#include "src/compiler/generic-node.h"
-#include "src/compiler/generic-node-inl.h"
#include "src/compiler/node.h"
#include "src/compiler/opcodes.h"
#include "src/zone.h"
class ConstructScheduleData;
class CodeGenerator; // Because of a namespace bug in clang.
-class BasicBlockData {
+// A basic block contains an ordered list of nodes and ends with a control
+// node. Note that if a basic block has phis, then all phis must appear as the
+// first nodes in the block.
+class BasicBlock FINAL : public ZoneObject {
public:
// Possible control nodes that can end a block.
enum Control {
kThrow // Throw an exception.
};
- int32_t rpo_number_; // special RPO number of the block.
- BasicBlock* dominator_; // Immediate dominator of the block.
- BasicBlock* loop_header_; // Pointer to dominating loop header basic block,
- // NULL if none. For loop headers, this points to
- // enclosing loop header.
- int32_t loop_depth_; // loop nesting, 0 is top-level
- int32_t loop_end_; // end of the loop, if this block is a loop header.
- int32_t code_start_; // start index of arch-specific code.
- int32_t code_end_; // end index of arch-specific code.
- bool deferred_; // {true} if this block is considered the slow
- // path.
- Control control_; // Control at the end of the block.
- Node* control_input_; // Input value for control.
- NodeVector nodes_; // nodes of this block in forward order.
+ class Id {
+ public:
+ int ToInt() const { return static_cast<int>(index_); }
+ size_t ToSize() const { return index_; }
+ static Id FromSize(size_t index) { return Id(index); }
+ static Id FromInt(int index) { return Id(static_cast<size_t>(index)); }
- explicit BasicBlockData(Zone* zone)
- : rpo_number_(-1),
- dominator_(NULL),
- loop_header_(NULL),
- loop_depth_(0),
- loop_end_(-1),
- code_start_(-1),
- code_end_(-1),
- deferred_(false),
- control_(kNone),
- control_input_(NULL),
- nodes_(zone) {}
-
- inline bool IsLoopHeader() const { return loop_end_ >= 0; }
- inline bool LoopContains(BasicBlockData* block) const {
- // RPO numbers must be initialized.
- DCHECK(rpo_number_ >= 0);
- DCHECK(block->rpo_number_ >= 0);
- if (loop_end_ < 0) return false; // This is not a loop.
- return block->rpo_number_ >= rpo_number_ && block->rpo_number_ < loop_end_;
- }
- int first_instruction_index() {
- DCHECK(code_start_ >= 0);
- DCHECK(code_end_ > 0);
- DCHECK(code_end_ >= code_start_);
- return code_start_;
- }
- int last_instruction_index() {
- DCHECK(code_start_ >= 0);
- DCHECK(code_end_ > 0);
- DCHECK(code_end_ >= code_start_);
- return code_end_ - 1;
- }
-};
+ private:
+ explicit Id(size_t index) : index_(index) {}
+ size_t index_;
+ };
-OStream& operator<<(OStream& os, const BasicBlockData::Control& c);
+ static const int kInvalidRpoNumber = -1;
+ class RpoNumber FINAL {
+ public:
+ int ToInt() const {
+ DCHECK(IsValid());
+ return index_;
+ }
+ size_t ToSize() const {
+ DCHECK(IsValid());
+ return static_cast<size_t>(index_);
+ }
+ bool IsValid() const { return index_ != kInvalidRpoNumber; }
+ static RpoNumber FromInt(int index) { return RpoNumber(index); }
+ static RpoNumber Invalid() { return RpoNumber(kInvalidRpoNumber); }
-// A basic block contains an ordered list of nodes and ends with a control
-// node. Note that if a basic block has phis, then all phis must appear as the
-// first nodes in the block.
-class BasicBlock FINAL : public GenericNode<BasicBlockData, BasicBlock> {
- public:
- BasicBlock(GenericGraphBase* graph, int input_count)
- : GenericNode<BasicBlockData, BasicBlock>(graph, input_count) {}
+ bool IsNext(const RpoNumber other) const {
+ DCHECK(IsValid());
+ return other.index_ == this->index_ + 1;
+ }
- typedef Uses Successors;
- typedef Inputs Predecessors;
+ bool operator==(RpoNumber other) const {
+ return this->index_ == other.index_;
+ }
- Successors successors() { return static_cast<Successors>(uses()); }
- Predecessors predecessors() { return static_cast<Predecessors>(inputs()); }
+ private:
+ explicit RpoNumber(int32_t index) : index_(index) {}
+ int32_t index_;
+ };
- int PredecessorCount() { return InputCount(); }
- BasicBlock* PredecessorAt(int index) { return InputAt(index); }
+ BasicBlock(Zone* zone, Id id);
- int SuccessorCount() { return UseCount(); }
- BasicBlock* SuccessorAt(int index) { return UseAt(index); }
+ Id id() const { return id_; }
- int PredecessorIndexOf(BasicBlock* predecessor) {
- BasicBlock::Predecessors predecessors = this->predecessors();
- for (BasicBlock::Predecessors::iterator i = predecessors.begin();
- i != predecessors.end(); ++i) {
- if (*i == predecessor) return i.index();
- }
- return -1;
+ // Predecessors and successors.
+ typedef ZoneVector<BasicBlock*> Predecessors;
+ Predecessors::iterator predecessors_begin() { return predecessors_.begin(); }
+ Predecessors::iterator predecessors_end() { return predecessors_.end(); }
+ Predecessors::const_iterator predecessors_begin() const {
+ return predecessors_.begin();
}
-
- inline BasicBlock* loop_header() {
- return static_cast<BasicBlock*>(loop_header_);
+ Predecessors::const_iterator predecessors_end() const {
+ return predecessors_.end();
}
- inline BasicBlock* ContainingLoop() {
- if (IsLoopHeader()) return this;
- return static_cast<BasicBlock*>(loop_header_);
+ size_t PredecessorCount() const { return predecessors_.size(); }
+ BasicBlock* PredecessorAt(size_t index) { return predecessors_[index]; }
+ void ClearPredecessors() { predecessors_.clear(); }
+ void AddPredecessor(BasicBlock* predecessor);
+
+ typedef ZoneVector<BasicBlock*> Successors;
+ Successors::iterator successors_begin() { return successors_.begin(); }
+ Successors::iterator successors_end() { return successors_.end(); }
+ Successors::const_iterator successors_begin() const {
+ return successors_.begin();
}
+ Successors::const_iterator successors_end() const {
+ return successors_.end();
+ }
+ size_t SuccessorCount() const { return successors_.size(); }
+ BasicBlock* SuccessorAt(size_t index) { return successors_[index]; }
+ void ClearSuccessors() { successors_.clear(); }
+ void AddSuccessor(BasicBlock* successor);
+
+ // Nodes in the basic block.
+ Node* NodeAt(size_t index) { return nodes_[index]; }
+ size_t NodeCount() const { return nodes_.size(); }
typedef NodeVector::iterator iterator;
iterator begin() { return nodes_.begin(); }
reverse_iterator rbegin() { return nodes_.rbegin(); }
reverse_iterator rend() { return nodes_.rend(); }
+ void AddNode(Node* node);
+ template <class InputIterator>
+ void InsertNodes(iterator insertion_point, InputIterator insertion_start,
+ InputIterator insertion_end) {
+ nodes_.insert(insertion_point, insertion_start, insertion_end);
+ }
+
+ // Accessors.
+ Control control() const { return control_; }
+ void set_control(Control control);
+
+ Node* control_input() const { return control_input_; }
+ void set_control_input(Node* control_input);
+
+ bool deferred() const { return deferred_; }
+ void set_deferred(bool deferred) { deferred_ = deferred; }
+
+ int32_t dominator_depth() const { return dominator_depth_; }
+ void set_dominator_depth(int32_t dominator_depth);
+
+ BasicBlock* dominator() const { return dominator_; }
+ void set_dominator(BasicBlock* dominator);
+
+ BasicBlock* loop_header() const { return loop_header_; }
+ void set_loop_header(BasicBlock* loop_header);
+
+ BasicBlock* loop_end() const { return loop_end_; }
+ void set_loop_end(BasicBlock* loop_end);
+
+ int32_t loop_depth() const { return loop_depth_; }
+ void set_loop_depth(int32_t loop_depth);
+
+ RpoNumber GetAoNumber() const { return RpoNumber::FromInt(ao_number_); }
+ int32_t ao_number() const { return ao_number_; }
+ void set_ao_number(int32_t ao_number) { ao_number_ = ao_number; }
+
+ RpoNumber GetRpoNumber() const { return RpoNumber::FromInt(rpo_number_); }
+ int32_t rpo_number() const { return rpo_number_; }
+ void set_rpo_number(int32_t rpo_number);
+
+ // Loop membership helpers.
+ inline bool IsLoopHeader() const { return loop_end_ != NULL; }
+ bool LoopContains(BasicBlock* block) const;
+
private:
+ int32_t ao_number_; // assembly order number of the block.
+ int32_t rpo_number_; // special RPO number of the block.
+ bool deferred_; // true if the block contains deferred code.
+ int32_t dominator_depth_; // Depth within the dominator tree.
+ BasicBlock* dominator_; // Immediate dominator of the block.
+ BasicBlock* loop_header_; // Pointer to dominating loop header basic block,
+ // NULL if none. For loop headers, this points to
+ // enclosing loop header.
+ BasicBlock* loop_end_; // end of the loop, if this block is a loop header.
+ int32_t loop_depth_; // loop nesting, 0 is top-level
+
+ Control control_; // Control at the end of the block.
+ Node* control_input_; // Input value for control.
+ NodeVector nodes_; // nodes of this block in forward order.
+
+ Successors successors_;
+ Predecessors predecessors_;
+ Id id_;
+
DISALLOW_COPY_AND_ASSIGN(BasicBlock);
};
-typedef GenericGraphVisit::NullNodeVisitor<BasicBlockData, BasicBlock>
- NullBasicBlockVisitor;
+std::ostream& operator<<(std::ostream& os, const BasicBlock::Control& c);
+std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id);
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo);
typedef ZoneVector<BasicBlock*> BasicBlockVector;
typedef BasicBlockVector::iterator BasicBlockVectorIter;
// and ordering them within basic blocks. Prior to computing a schedule,
// a graph has no notion of control flow ordering other than that induced
// by the graph's dependencies. A schedule is required to generate code.
-class Schedule : public GenericGraph<BasicBlock> {
+class Schedule FINAL : public ZoneObject {
public:
- explicit Schedule(Zone* zone, size_t node_count_hint = 0)
- : GenericGraph<BasicBlock>(zone),
- zone_(zone),
- all_blocks_(zone),
- nodeid_to_block_(zone),
- rpo_order_(zone) {
- SetStart(NewBasicBlock()); // entry.
- SetEnd(NewBasicBlock()); // exit.
- nodeid_to_block_.reserve(node_count_hint);
- }
+ explicit Schedule(Zone* zone, size_t node_count_hint = 0);
// Return the block which contains {node}, if any.
- BasicBlock* block(Node* node) const {
- if (node->id() < static_cast<NodeId>(nodeid_to_block_.size())) {
- return nodeid_to_block_[node->id()];
- }
- return NULL;
- }
-
- bool IsScheduled(Node* node) {
- int length = static_cast<int>(nodeid_to_block_.size());
- if (node->id() >= length) return false;
- return nodeid_to_block_[node->id()] != NULL;
- }
-
- BasicBlock* GetBlockById(int block_id) { return all_blocks_[block_id]; }
-
- int BasicBlockCount() const { return NodeCount(); }
- int RpoBlockCount() const { return static_cast<int>(rpo_order_.size()); }
+ BasicBlock* block(Node* node) const;
- typedef ContainerPointerWrapper<BasicBlockVector> BasicBlocks;
+ bool IsScheduled(Node* node);
+ BasicBlock* GetBlockById(BasicBlock::Id block_id);
- // Return a list of all the blocks in the schedule, in arbitrary order.
- BasicBlocks all_blocks() { return BasicBlocks(&all_blocks_); }
+ size_t BasicBlockCount() const { return all_blocks_.size(); }
+ size_t RpoBlockCount() const { return rpo_order_.size(); }
// Check if nodes {a} and {b} are in the same block.
- inline bool SameBasicBlock(Node* a, Node* b) const {
- BasicBlock* block = this->block(a);
- return block != NULL && block == this->block(b);
- }
+ bool SameBasicBlock(Node* a, Node* b) const;
// BasicBlock building: create a new block.
- inline BasicBlock* NewBasicBlock() {
- BasicBlock* block =
- BasicBlock::New(this, 0, static_cast<BasicBlock**>(NULL));
- all_blocks_.push_back(block);
- return block;
- }
+ BasicBlock* NewBasicBlock();
// BasicBlock building: records that a node will later be added to a block but
// doesn't actually add the node to the block.
- inline void PlanNode(BasicBlock* block, Node* node) {
- if (FLAG_trace_turbo_scheduler) {
- PrintF("Planning #%d:%s for future add to B%d\n", node->id(),
- node->op()->mnemonic(), block->id());
- }
- DCHECK(this->block(node) == NULL);
- SetBlockForNode(block, node);
- }
+ void PlanNode(BasicBlock* block, Node* node);
// BasicBlock building: add a node to the end of the block.
- inline void AddNode(BasicBlock* block, Node* node) {
- if (FLAG_trace_turbo_scheduler) {
- PrintF("Adding #%d:%s to B%d\n", node->id(), node->op()->mnemonic(),
- block->id());
- }
- DCHECK(this->block(node) == NULL || this->block(node) == block);
- block->nodes_.push_back(node);
- SetBlockForNode(block, node);
- }
+ void AddNode(BasicBlock* block, Node* node);
// BasicBlock building: add a goto to the end of {block}.
- void AddGoto(BasicBlock* block, BasicBlock* succ) {
- DCHECK(block->control_ == BasicBlock::kNone);
- block->control_ = BasicBlock::kGoto;
- AddSuccessor(block, succ);
- }
+ void AddGoto(BasicBlock* block, BasicBlock* succ);
// BasicBlock building: add a branch at the end of {block}.
void AddBranch(BasicBlock* block, Node* branch, BasicBlock* tblock,
- BasicBlock* fblock) {
- DCHECK(block->control_ == BasicBlock::kNone);
- DCHECK(branch->opcode() == IrOpcode::kBranch);
- block->control_ = BasicBlock::kBranch;
- AddSuccessor(block, tblock);
- AddSuccessor(block, fblock);
- SetControlInput(block, branch);
- if (branch->opcode() == IrOpcode::kBranch) {
- // TODO(titzer): require a Branch node here. (sloppy tests).
- SetBlockForNode(block, branch);
- }
- }
+ BasicBlock* fblock);
// BasicBlock building: add a return at the end of {block}.
- void AddReturn(BasicBlock* block, Node* input) {
- DCHECK(block->control_ == BasicBlock::kNone);
- block->control_ = BasicBlock::kReturn;
- SetControlInput(block, input);
- if (block != end()) AddSuccessor(block, end());
- if (input->opcode() == IrOpcode::kReturn) {
- // TODO(titzer): require a Return node here. (sloppy tests).
- SetBlockForNode(block, input);
- }
- }
+ void AddReturn(BasicBlock* block, Node* input);
// BasicBlock building: add a throw at the end of {block}.
- void AddThrow(BasicBlock* block, Node* input) {
- DCHECK(block->control_ == BasicBlock::kNone);
- block->control_ = BasicBlock::kThrow;
- SetControlInput(block, input);
- if (block != end()) AddSuccessor(block, end());
- }
+ void AddThrow(BasicBlock* block, Node* input);
- friend class Scheduler;
- friend class CodeGenerator;
+ // BasicBlock mutation: insert a branch into the end of {block}.
+ void InsertBranch(BasicBlock* block, BasicBlock* end, Node* branch,
+ BasicBlock* tblock, BasicBlock* fblock);
- void AddSuccessor(BasicBlock* block, BasicBlock* succ) {
- succ->AppendInput(zone_, block);
+ // Exposed publicly for testing only.
+ void AddSuccessorForTesting(BasicBlock* block, BasicBlock* succ) {
+ return AddSuccessor(block, succ);
}
BasicBlockVector* rpo_order() { return &rpo_order_; }
+ const BasicBlockVector* rpo_order() const { return &rpo_order_; }
+
+ BasicBlock* start() { return start_; }
+ BasicBlock* end() { return end_; }
+
+ Zone* zone() const { return zone_; }
private:
+ friend class Scheduler;
+ friend class CodeGenerator;
friend class ScheduleVisualizer;
friend class BasicBlockInstrumentor;
- void SetControlInput(BasicBlock* block, Node* node) {
- block->control_input_ = node;
- SetBlockForNode(block, node);
- }
+ void AddSuccessor(BasicBlock* block, BasicBlock* succ);
+ void MoveSuccessors(BasicBlock* from, BasicBlock* to);
- void SetBlockForNode(BasicBlock* block, Node* node) {
- int length = static_cast<int>(nodeid_to_block_.size());
- if (node->id() >= length) {
- nodeid_to_block_.resize(node->id() + 1);
- }
- nodeid_to_block_[node->id()] = block;
- }
+ void SetControlInput(BasicBlock* block, Node* node);
+ void SetBlockForNode(BasicBlock* block, Node* node);
Zone* zone_;
BasicBlockVector all_blocks_; // All basic blocks in the schedule.
BasicBlockVector nodeid_to_block_; // Map from node to containing block.
BasicBlockVector rpo_order_; // Reverse-post-order block list.
+ BasicBlock* start_;
+ BasicBlock* end_;
+
+ DISALLOW_COPY_AND_ASSIGN(Schedule);
};
-OStream& operator<<(OStream& os, const Schedule& s);
-}
-}
-} // namespace v8::internal::compiler
+std::ostream& operator<<(std::ostream& os, const Schedule& s);
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_SCHEDULE_H_
#include "src/compiler/scheduler.h"
+#include "src/bit-vector.h"
#include "src/compiler/graph.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/node.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/node-properties-inl.h"
-#include "src/data-flow.h"
namespace v8 {
namespace internal {
}
+Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
+ : zone_(zone),
+ graph_(graph),
+ schedule_(schedule),
+ scheduled_nodes_(zone),
+ schedule_root_nodes_(zone),
+ schedule_queue_(zone),
+ node_data_(graph_->NodeCount(), DefaultSchedulerData(), zone) {}
+
+
+Schedule* Scheduler::ComputeSchedule(ZonePool* zone_pool, Graph* graph) {
+ ZonePool::Scope zone_scope(zone_pool);
+ Schedule* schedule = new (graph->zone())
+ Schedule(graph->zone(), static_cast<size_t>(graph->NodeCount()));
+ Scheduler scheduler(zone_scope.zone(), graph, schedule);
+
+ scheduler.BuildCFG();
+ scheduler.ComputeSpecialRPONumbering();
+ scheduler.GenerateImmediateDominatorTree();
+
+ scheduler.PrepareUses();
+ scheduler.ScheduleEarly();
+ scheduler.ScheduleLate();
+
+ scheduler.SealFinalSchedule();
+
+ return schedule;
+}
+
+
+Scheduler::SchedulerData Scheduler::DefaultSchedulerData() {
+ SchedulerData def = {schedule_->start(), 0, false, false, kUnknown};
+ return def;
+}
+
+
+Scheduler::SchedulerData* Scheduler::GetData(Node* node) {
+ DCHECK(node->id() < static_cast<int>(node_data_.size()));
+ return &node_data_[node->id()];
+}
+
+
+Scheduler::Placement Scheduler::GetPlacement(Node* node) {
+ SchedulerData* data = GetData(node);
+ if (data->placement_ == kUnknown) { // Compute placement, once, on demand.
+ switch (node->opcode()) {
+ case IrOpcode::kParameter:
+ // Parameters are always fixed to the start node.
+ data->placement_ = kFixed;
+ break;
+ case IrOpcode::kPhi:
+ case IrOpcode::kEffectPhi: {
+ // Phis and effect phis are fixed if their control inputs are, whereas
+ // otherwise they are coupled to a floating control node.
+ Placement p = GetPlacement(NodeProperties::GetControlInput(node));
+ data->placement_ = (p == kFixed ? kFixed : kCoupled);
+ break;
+ }
+#define DEFINE_FLOATING_CONTROL_CASE(V) case IrOpcode::k##V:
+ CONTROL_OP_LIST(DEFINE_FLOATING_CONTROL_CASE)
+#undef DEFINE_FLOATING_CONTROL_CASE
+ {
+ // Control nodes that were not control-reachable from end may float.
+ data->placement_ = kSchedulable;
+ if (!data->is_connected_control_) {
+ data->is_floating_control_ = true;
+ Trace("Floating control found: #%d:%s\n", node->id(),
+ node->op()->mnemonic());
+ }
+ break;
+ }
+ default:
+ data->placement_ = kSchedulable;
+ break;
+ }
+ }
+ return data->placement_;
+}
+
+
+void Scheduler::UpdatePlacement(Node* node, Placement placement) {
+ SchedulerData* data = GetData(node);
+ if (data->placement_ != kUnknown) { // Trap on mutation, not initialization.
+ switch (node->opcode()) {
+ case IrOpcode::kParameter:
+ // Parameters are fixed once and for all.
+ UNREACHABLE();
+ break;
+ case IrOpcode::kPhi:
+ case IrOpcode::kEffectPhi: {
+ // Phis and effect phis are coupled to their respective blocks.
+ DCHECK_EQ(Scheduler::kCoupled, data->placement_);
+ DCHECK_EQ(Scheduler::kFixed, placement);
+ Node* control = NodeProperties::GetControlInput(node);
+ BasicBlock* block = schedule_->block(control);
+ schedule_->AddNode(block, node);
+ break;
+ }
+#define DEFINE_FLOATING_CONTROL_CASE(V) case IrOpcode::k##V:
+ CONTROL_OP_LIST(DEFINE_FLOATING_CONTROL_CASE)
+#undef DEFINE_FLOATING_CONTROL_CASE
+ {
+ // Control nodes force coupled uses to be placed.
+ Node::Uses uses = node->uses();
+ for (Node::Uses::iterator i = uses.begin(); i != uses.end(); ++i) {
+ if (GetPlacement(*i) == Scheduler::kCoupled) {
+ DCHECK_EQ(node, NodeProperties::GetControlInput(*i));
+ UpdatePlacement(*i, placement);
+ }
+ }
+ break;
+ }
+ default:
+ DCHECK_EQ(Scheduler::kSchedulable, data->placement_);
+ DCHECK_EQ(Scheduler::kScheduled, placement);
+ break;
+ }
+ // Reduce the use count of the node's inputs to potentially make them
+ // schedulable. If all the uses of a node have been scheduled, then the node
+ // itself can be scheduled.
+ for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
+ DecrementUnscheduledUseCount(*i, i.index(), i.edge().from());
+ }
+ }
+ data->placement_ = placement;
+}
+
+
+bool Scheduler::IsCoupledControlEdge(Node* node, int index) {
+ return GetPlacement(node) == kCoupled &&
+ NodeProperties::FirstControlIndex(node) == index;
+}
+
+
+void Scheduler::IncrementUnscheduledUseCount(Node* node, int index,
+ Node* from) {
+ // Make sure that control edges from coupled nodes are not counted.
+ if (IsCoupledControlEdge(from, index)) return;
+
+ // Tracking use counts for fixed nodes is useless.
+ if (GetPlacement(node) == kFixed) return;
+
+ // Use count for coupled nodes is summed up on their control.
+ if (GetPlacement(node) == kCoupled) {
+ Node* control = NodeProperties::GetControlInput(node);
+ return IncrementUnscheduledUseCount(control, index, from);
+ }
+
+ ++(GetData(node)->unscheduled_count_);
+ if (FLAG_trace_turbo_scheduler) {
+ Trace(" Use count of #%d:%s (used by #%d:%s)++ = %d\n", node->id(),
+ node->op()->mnemonic(), from->id(), from->op()->mnemonic(),
+ GetData(node)->unscheduled_count_);
+ }
+}
+
+
+void Scheduler::DecrementUnscheduledUseCount(Node* node, int index,
+ Node* from) {
+ // Make sure that control edges from coupled nodes are not counted.
+ if (IsCoupledControlEdge(from, index)) return;
+
+ // Tracking use counts for fixed nodes is useless.
+ if (GetPlacement(node) == kFixed) return;
+
+ // Use count for coupled nodes is summed up on their control.
+ if (GetPlacement(node) == kCoupled) {
+ Node* control = NodeProperties::GetControlInput(node);
+ return DecrementUnscheduledUseCount(control, index, from);
+ }
+
+ DCHECK(GetData(node)->unscheduled_count_ > 0);
+ --(GetData(node)->unscheduled_count_);
+ if (FLAG_trace_turbo_scheduler) {
+ Trace(" Use count of #%d:%s (used by #%d:%s)-- = %d\n", node->id(),
+ node->op()->mnemonic(), from->id(), from->op()->mnemonic(),
+ GetData(node)->unscheduled_count_);
+ }
+ if (GetData(node)->unscheduled_count_ == 0) {
+ Trace(" newly eligible #%d:%s\n", node->id(), node->op()->mnemonic());
+ schedule_queue_.push(node);
+ }
+}
+
+
+BasicBlock* Scheduler::GetCommonDominator(BasicBlock* b1, BasicBlock* b2) {
+ while (b1 != b2) {
+ int32_t b1_depth = b1->dominator_depth();
+ int32_t b2_depth = b2->dominator_depth();
+ if (b1_depth < b2_depth) {
+ b2 = b2->dominator();
+ } else {
+ b1 = b1->dominator();
+ }
+ }
+ return b1;
+}
+
+
+// -----------------------------------------------------------------------------
+// Phase 1: Build control-flow graph.
+
+
// Internal class to build a control flow graph (i.e the basic blocks and edges
-// between them within a Schedule) from the node graph.
-// Visits the control edges of the graph backwards from end in order to find
-// the connected control subgraph, needed for scheduling.
+// between them within a Schedule) from the node graph. Visits control edges of
+// the graph backwards from an end node in order to find the connected control
+// subgraph, needed for scheduling.
class CFGBuilder {
public:
- Scheduler* scheduler_;
- Schedule* schedule_;
- ZoneQueue<Node*> queue_;
- NodeVector control_;
-
CFGBuilder(Zone* zone, Scheduler* scheduler)
: scheduler_(scheduler),
schedule_(scheduler->schedule_),
queue_(zone),
- control_(zone) {}
+ control_(zone),
+ component_head_(NULL),
+ component_start_(NULL),
+ component_end_(NULL) {}
// Run the control flow graph construction algorithm by walking the graph
// backwards from end through control edges, building and connecting the
// basic blocks for control nodes.
void Run() {
- Graph* graph = scheduler_->graph_;
- FixNode(schedule_->start(), graph->start());
- Queue(graph->end());
+ Queue(scheduler_->graph_->end());
while (!queue_.empty()) { // Breadth-first backwards traversal.
Node* node = queue_.front();
for (NodeVector::iterator i = control_.begin(); i != control_.end(); ++i) {
ConnectBlocks(*i); // Connect block to its predecessor/successors.
}
+ }
+
+ // Run the control flow graph construction for a minimal control-connected
+ // component ending in {node} and merge that component into an existing
+ // control flow graph at the bottom of {block}.
+ void Run(BasicBlock* block, Node* node) {
+ Queue(node);
+
+ component_start_ = block;
+ component_end_ = schedule_->block(node);
+ while (!queue_.empty()) { // Breadth-first backwards traversal.
+ Node* node = queue_.front();
+ queue_.pop();
+ bool is_dom = true;
+ int max = NodeProperties::PastControlIndex(node);
+ for (int i = NodeProperties::FirstControlIndex(node); i < max; i++) {
+ is_dom = is_dom &&
+ !scheduler_->GetData(node->InputAt(i))->is_floating_control_;
+ Queue(node->InputAt(i));
+ }
+ // TODO(mstarzinger): This is a hacky way to find component dominator.
+ if (is_dom) component_head_ = node;
+ }
+ DCHECK_NOT_NULL(component_head_);
- FixNode(schedule_->end(), graph->end());
+ for (NodeVector::iterator i = control_.begin(); i != control_.end(); ++i) {
+ scheduler_->GetData(*i)->is_floating_control_ = false;
+ ConnectBlocks(*i); // Connect block to its predecessor/successors.
+ }
}
+ private:
void FixNode(BasicBlock* block, Node* node) {
schedule_->AddNode(block, node);
- scheduler_->GetData(node)->is_connected_control_ = true;
- scheduler_->GetData(node)->placement_ = Scheduler::kFixed;
+ scheduler_->UpdatePlacement(node, Scheduler::kFixed);
}
void Queue(Node* node) {
- // Mark the connected control nodes as they queued.
+ // Mark the connected control nodes as they are queued.
Scheduler::SchedulerData* data = scheduler_->GetData(node);
if (!data->is_connected_control_) {
+ data->is_connected_control_ = true;
BuildBlocks(node);
queue_.push(node);
control_.push_back(node);
- data->is_connected_control_ = true;
}
}
+
void BuildBlocks(Node* node) {
switch (node->opcode()) {
+ case IrOpcode::kEnd:
+ FixNode(schedule_->end(), node);
+ break;
+ case IrOpcode::kStart:
+ FixNode(schedule_->start(), node);
+ break;
case IrOpcode::kLoop:
case IrOpcode::kMerge:
BuildBlockForNode(node);
break;
+ case IrOpcode::kTerminate: {
+ // Put Terminate in the loop to which it refers.
+ Node* loop = NodeProperties::GetControlInput(node);
+ BasicBlock* block = BuildBlockForNode(loop);
+ FixNode(block, node);
+ break;
+ }
case IrOpcode::kBranch:
BuildBlocksForSuccessors(node, IrOpcode::kIfTrue, IrOpcode::kIfFalse);
break;
ConnectMerge(node);
break;
case IrOpcode::kBranch:
- scheduler_->schedule_root_nodes_.push_back(node);
+ scheduler_->UpdatePlacement(node, Scheduler::kFixed);
ConnectBranch(node);
break;
case IrOpcode::kReturn:
- scheduler_->schedule_root_nodes_.push_back(node);
+ scheduler_->UpdatePlacement(node, Scheduler::kFixed);
ConnectReturn(node);
break;
default:
}
}
- void BuildBlockForNode(Node* node) {
- if (schedule_->block(node) == NULL) {
- BasicBlock* block = schedule_->NewBasicBlock();
- Trace("Create block B%d for #%d:%s\n", block->id(), node->id(),
+ BasicBlock* BuildBlockForNode(Node* node) {
+ BasicBlock* block = schedule_->block(node);
+ if (block == NULL) {
+ block = schedule_->NewBasicBlock();
+ Trace("Create block B%d for #%d:%s\n", block->id().ToInt(), node->id(),
node->op()->mnemonic());
FixNode(block, node);
}
+ return block;
}
void BuildBlocksForSuccessors(Node* node, IrOpcode::Value a,
}
void ConnectBranch(Node* branch) {
- Node* branch_block_node = NodeProperties::GetControlInput(branch);
- BasicBlock* branch_block = schedule_->block(branch_block_node);
- DCHECK(branch_block != NULL);
-
BasicBlock* successor_blocks[2];
CollectSuccessorBlocks(branch, successor_blocks, IrOpcode::kIfTrue,
IrOpcode::kIfFalse);
- TraceConnect(branch, branch_block, successor_blocks[0]);
- TraceConnect(branch, branch_block, successor_blocks[1]);
+ // Consider branch hints.
+ switch (BranchHintOf(branch->op())) {
+ case BranchHint::kNone:
+ break;
+ case BranchHint::kTrue:
+ successor_blocks[1]->set_deferred(true);
+ break;
+ case BranchHint::kFalse:
+ successor_blocks[0]->set_deferred(true);
+ break;
+ }
- schedule_->AddBranch(branch_block, branch, successor_blocks[0],
- successor_blocks[1]);
+ if (branch == component_head_) {
+ TraceConnect(branch, component_start_, successor_blocks[0]);
+ TraceConnect(branch, component_start_, successor_blocks[1]);
+ schedule_->InsertBranch(component_start_, component_end_, branch,
+ successor_blocks[0], successor_blocks[1]);
+ } else {
+ Node* branch_block_node = NodeProperties::GetControlInput(branch);
+ BasicBlock* branch_block = schedule_->block(branch_block_node);
+ DCHECK(branch_block != NULL);
+
+ TraceConnect(branch, branch_block, successor_blocks[0]);
+ TraceConnect(branch, branch_block, successor_blocks[1]);
+ schedule_->AddBranch(branch_block, branch, successor_blocks[0],
+ successor_blocks[1]);
+ }
}
void ConnectMerge(Node* merge) {
+ // Don't connect the special merge at the end to its predecessors.
+ if (IsFinalMerge(merge)) return;
+
BasicBlock* block = schedule_->block(merge);
DCHECK(block != NULL);
// For all of the merge's control inputs, add a goto at the end to the
for (InputIter j = merge->inputs().begin(); j != merge->inputs().end();
++j) {
BasicBlock* predecessor_block = schedule_->block(*j);
- if ((*j)->opcode() != IrOpcode::kReturn) {
- TraceConnect(merge, predecessor_block, block);
- schedule_->AddGoto(predecessor_block, block);
- }
+ TraceConnect(merge, predecessor_block, block);
+ schedule_->AddGoto(predecessor_block, block);
}
}
DCHECK_NE(NULL, block);
if (succ == NULL) {
Trace("Connect #%d:%s, B%d -> end\n", node->id(), node->op()->mnemonic(),
- block->id());
+ block->id().ToInt());
} else {
Trace("Connect #%d:%s, B%d -> B%d\n", node->id(), node->op()->mnemonic(),
- block->id(), succ->id());
+ block->id().ToInt(), succ->id().ToInt());
}
}
-};
-
-
-Scheduler::SchedulerData Scheduler::DefaultSchedulerData() {
- SchedulerData def = {0, 0, false, false, kUnknown};
- return def;
-}
-
-
-Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
- : zone_(zone),
- graph_(graph),
- schedule_(schedule),
- scheduled_nodes_(zone),
- schedule_root_nodes_(zone),
- node_data_(graph_->NodeCount(), DefaultSchedulerData(), zone),
- has_floating_control_(false) {}
-
-Schedule* Scheduler::ComputeSchedule(Graph* graph) {
- Schedule* schedule;
- bool had_floating_control = false;
- do {
- Zone tmp_zone(graph->zone()->isolate());
- schedule = new (graph->zone())
- Schedule(graph->zone(), static_cast<size_t>(graph->NodeCount()));
- Scheduler scheduler(&tmp_zone, graph, schedule);
-
- scheduler.BuildCFG();
-
- Scheduler::ComputeSpecialRPO(schedule);
- scheduler.GenerateImmediateDominatorTree();
-
- scheduler.PrepareUses();
- scheduler.ScheduleEarly();
- scheduler.ScheduleLate();
-
- had_floating_control = scheduler.ConnectFloatingControl();
- } while (had_floating_control);
-
- return schedule;
-}
-
-
-Scheduler::Placement Scheduler::GetPlacement(Node* node) {
- SchedulerData* data = GetData(node);
- if (data->placement_ == kUnknown) { // Compute placement, once, on demand.
- switch (node->opcode()) {
- case IrOpcode::kParameter:
- // Parameters are always fixed to the start node.
- data->placement_ = kFixed;
- break;
- case IrOpcode::kPhi:
- case IrOpcode::kEffectPhi: {
- // Phis and effect phis are fixed if their control inputs are.
- data->placement_ = GetPlacement(NodeProperties::GetControlInput(node));
- break;
- }
-#define DEFINE_FLOATING_CONTROL_CASE(V) case IrOpcode::k##V:
- CONTROL_OP_LIST(DEFINE_FLOATING_CONTROL_CASE)
-#undef DEFINE_FLOATING_CONTROL_CASE
- {
- // Control nodes that were not control-reachable from end may float.
- data->placement_ = kSchedulable;
- if (!data->is_connected_control_) {
- data->is_floating_control_ = true;
- has_floating_control_ = true;
- Trace("Floating control found: #%d:%s\n", node->id(),
- node->op()->mnemonic());
- }
- break;
- }
- default:
- data->placement_ = kSchedulable;
- break;
- }
+ bool IsFinalMerge(Node* node) {
+ return (node->opcode() == IrOpcode::kMerge &&
+ node == scheduler_->graph_->end()->InputAt(0));
}
- return data->placement_;
-}
+
+ Scheduler* scheduler_;
+ Schedule* schedule_;
+ ZoneQueue<Node*> queue_;
+ NodeVector control_;
+ Node* component_head_;
+ BasicBlock* component_start_;
+ BasicBlock* component_end_;
+};
void Scheduler::BuildCFG() {
- Trace("---------------- CREATING CFG ------------------\n");
+ Trace("--- CREATING CFG -------------------------------------------\n");
+
+ // Build a control-flow graph for the main control-connected component that
+ // is being spanned by the graph's start and end nodes.
CFGBuilder cfg_builder(zone_, this);
cfg_builder.Run();
+
// Initialize per-block data.
scheduled_nodes_.resize(schedule_->BasicBlockCount(), NodeVector(zone_));
}
-BasicBlock* Scheduler::GetCommonDominator(BasicBlock* b1, BasicBlock* b2) {
- while (b1 != b2) {
- int b1_rpo = GetRPONumber(b1);
- int b2_rpo = GetRPONumber(b2);
- DCHECK(b1_rpo != b2_rpo);
- if (b1_rpo < b2_rpo) {
- b2 = b2->dominator_;
- } else {
- b1 = b1->dominator_;
- }
+// -----------------------------------------------------------------------------
+// Phase 2: Compute special RPO and dominator tree.
+
+
+// Compute the special reverse-post-order block ordering, which is essentially
+// a RPO of the graph where loop bodies are contiguous. Properties:
+// 1. If block A is a predecessor of B, then A appears before B in the order,
+// unless B is a loop header and A is in the loop headed at B
+// (i.e. A -> B is a backedge).
+// => If block A dominates block B, then A appears before B in the order.
+// => If block A is a loop header, A appears before all blocks in the loop
+// headed at A.
+// 2. All loops are contiguous in the order (i.e. no intervening blocks that
+// do not belong to the loop.)
+// Note a simple RPO traversal satisfies (1) but not (2).
+class SpecialRPONumberer : public ZoneObject {
+ public:
+ SpecialRPONumberer(Zone* zone, Schedule* schedule)
+ : zone_(zone),
+ schedule_(schedule),
+ order_(NULL),
+ loops_(zone),
+ beyond_end_(NULL),
+ backedges_(1, zone),
+ stack_(zone),
+ previous_block_count_(0) {}
+
+ // Computes the special reverse-post-order for the main control flow graph,
+ // that is for the graph spanned between the schedule's start and end blocks.
+ void ComputeSpecialRPO() {
+ DCHECK_EQ(NULL, order_); // Main order does not exist yet.
+ // TODO(mstarzinger): Should use Schedule::end() after tests are fixed.
+ ComputeAndInsertSpecialRPO(schedule_->start(), NULL);
}
- return b1;
-}
+ // Computes the special reverse-post-order for a partial control flow graph,
+ // that is for the graph spanned between the given {entry} and {end} blocks,
+ // then updates the existing ordering with this new information.
+ void UpdateSpecialRPO(BasicBlock* entry, BasicBlock* end) {
+ DCHECK_NE(NULL, order_); // Main order to be updated is present.
+ ComputeAndInsertSpecialRPO(entry, end);
+ }
-void Scheduler::GenerateImmediateDominatorTree() {
- // Build the dominator graph. TODO(danno): consider using Lengauer & Tarjan's
- // if this becomes really slow.
- Trace("------------ IMMEDIATE BLOCK DOMINATORS -----------\n");
- for (size_t i = 0; i < schedule_->rpo_order_.size(); i++) {
- BasicBlock* current_rpo = schedule_->rpo_order_[i];
- if (current_rpo != schedule_->start()) {
- BasicBlock::Predecessors::iterator current_pred =
- current_rpo->predecessors().begin();
- BasicBlock::Predecessors::iterator end =
- current_rpo->predecessors().end();
- DCHECK(current_pred != end);
- BasicBlock* dominator = *current_pred;
- ++current_pred;
- // For multiple predecessors, walk up the rpo ordering until a common
- // dominator is found.
- int current_rpo_pos = GetRPONumber(current_rpo);
- while (current_pred != end) {
- // Don't examine backwards edges
- BasicBlock* pred = *current_pred;
- if (GetRPONumber(pred) < current_rpo_pos) {
- dominator = GetCommonDominator(dominator, *current_pred);
- }
- ++current_pred;
- }
- current_rpo->dominator_ = dominator;
- Trace("Block %d's idom is %d\n", current_rpo->id(), dominator->id());
+ // Serialize the previously computed order as an assembly order (non-deferred
+ // code first, deferred code afterwards) into the final schedule.
+ void SerializeAOIntoSchedule() {
+ int32_t number = 0;
+ for (BlockList* l = order_; l != NULL; l = l->next) {
+ if (l->block->deferred()) continue;
+ l->block->set_ao_number(number++);
+ }
+ for (BlockList* l = order_; l != NULL; l = l->next) {
+ if (!l->block->deferred()) continue;
+ l->block->set_ao_number(number++);
}
}
-}
+ // Serialize the previously computed order as a special reverse-post-order
+ // numbering for basic blocks into the final schedule.
+ void SerializeRPOIntoSchedule() {
+ int32_t number = 0;
+ for (BlockList* l = order_; l != NULL; l = l->next) {
+ l->block->set_rpo_number(number++);
+ schedule_->rpo_order()->push_back(l->block);
+ }
+ BeyondEndSentinel()->set_rpo_number(number);
+ }
-class ScheduleEarlyNodeVisitor : public NullNodeVisitor {
- public:
- explicit ScheduleEarlyNodeVisitor(Scheduler* scheduler)
- : has_changed_rpo_constraints_(true),
- scheduler_(scheduler),
- schedule_(scheduler->schedule_) {}
+ // Print and verify the special reverse-post-order.
+ void PrintAndVerifySpecialRPO() {
+#if DEBUG
+ if (FLAG_trace_turbo_scheduler) PrintRPO();
+ VerifySpecialRPO();
+#endif
+ }
- GenericGraphVisit::Control Pre(Node* node) {
- int max_rpo = 0;
- // Fixed nodes already know their schedule early position.
- if (scheduler_->GetPlacement(node) == Scheduler::kFixed) {
- BasicBlock* block = schedule_->block(node);
- DCHECK(block != NULL);
- max_rpo = block->rpo_number_;
- if (scheduler_->GetData(node)->minimum_rpo_ != max_rpo) {
- has_changed_rpo_constraints_ = true;
- }
- scheduler_->GetData(node)->minimum_rpo_ = max_rpo;
- Trace("Preschedule #%d:%s minimum_rpo = %d\n", node->id(),
- node->op()->mnemonic(), max_rpo);
+ private:
+ typedef std::pair<BasicBlock*, size_t> Backedge;
+
+ // TODO(mstarzinger): Only for Scheduler::GenerateImmediateDominatorTree.
+ friend class Scheduler;
+
+ // Numbering for BasicBlock::rpo_number for this block traversal:
+ static const int kBlockOnStack = -2;
+ static const int kBlockVisited1 = -3;
+ static const int kBlockVisited2 = -4;
+ static const int kBlockUnvisited1 = -1;
+ static const int kBlockUnvisited2 = kBlockVisited1;
+
+ struct SpecialRPOStackFrame {
+ BasicBlock* block;
+ size_t index;
+ };
+
+ struct BlockList {
+ BasicBlock* block;
+ BlockList* next;
+
+ BlockList* Add(Zone* zone, BasicBlock* b) {
+ BlockList* list = static_cast<BlockList*>(zone->New(sizeof(BlockList)));
+ list->block = b;
+ list->next = this;
+ return list;
}
- return GenericGraphVisit::CONTINUE;
- }
- GenericGraphVisit::Control Post(Node* node) {
- int max_rpo = 0;
- // Otherwise, the minimum rpo for the node is the max of all of the inputs.
- if (scheduler_->GetPlacement(node) != Scheduler::kFixed) {
- for (InputIter i = node->inputs().begin(); i != node->inputs().end();
- ++i) {
- int control_rpo = scheduler_->GetData(*i)->minimum_rpo_;
- if (control_rpo > max_rpo) {
- max_rpo = control_rpo;
- }
+ BlockList* FindForBlock(BasicBlock* b) {
+ for (BlockList* l = this; l != NULL; l = l->next) {
+ if (l->block == b) return l;
}
- if (scheduler_->GetData(node)->minimum_rpo_ != max_rpo) {
- has_changed_rpo_constraints_ = true;
+ return NULL;
+ }
+ };
+
+ struct LoopInfo {
+ BasicBlock* header;
+ ZoneList<BasicBlock*>* outgoing;
+ BitVector* members;
+ LoopInfo* prev;
+ BlockList* end;
+ BlockList* start;
+
+ void AddOutgoing(Zone* zone, BasicBlock* block) {
+ if (outgoing == NULL) {
+ outgoing = new (zone) ZoneList<BasicBlock*>(2, zone);
}
- scheduler_->GetData(node)->minimum_rpo_ = max_rpo;
- Trace("Postschedule #%d:%s minimum_rpo = %d\n", node->id(),
- node->op()->mnemonic(), max_rpo);
+ outgoing->Add(block, zone);
+ }
+ };
+
+ int Push(ZoneVector<SpecialRPOStackFrame>& stack, int depth,
+ BasicBlock* child, int unvisited) {
+ if (child->rpo_number() == unvisited) {
+ stack[depth].block = child;
+ stack[depth].index = 0;
+ child->set_rpo_number(kBlockOnStack);
+ return depth + 1;
}
- return GenericGraphVisit::CONTINUE;
+ return depth;
}
- // TODO(mstarzinger): Dirty hack to unblock others, schedule early should be
- // rewritten to use a pre-order traversal from the start instead.
- bool has_changed_rpo_constraints_;
-
- private:
- Scheduler* scheduler_;
- Schedule* schedule_;
-};
-
+ // We are hijacking the {ao_number} to enumerate loops temporarily. Note that
+ // these numbers are only valid within this class.
+ static int GetLoopNumber(BasicBlock* block) { return block->ao_number(); }
+ static void SetLoopNumber(BasicBlock* block, int loop_number) {
+ return block->set_ao_number(loop_number);
+ }
+ static bool HasLoopNumber(BasicBlock* block) {
+ return block->ao_number() >= 0;
+ }
-void Scheduler::ScheduleEarly() {
- Trace("------------------- SCHEDULE EARLY ----------------\n");
-
- int fixpoint_count = 0;
- ScheduleEarlyNodeVisitor visitor(this);
- while (visitor.has_changed_rpo_constraints_) {
- visitor.has_changed_rpo_constraints_ = false;
- graph_->VisitNodeInputsFromEnd(&visitor);
- fixpoint_count++;
+ // TODO(mstarzinger): We only need this special sentinel because some tests
+ // use the schedule's end block in actual control flow (e.g. with end having
+ // successors). Once this has been cleaned up we can use the end block here.
+ BasicBlock* BeyondEndSentinel() {
+ if (beyond_end_ == NULL) {
+ BasicBlock::Id id = BasicBlock::Id::FromInt(-1);
+ beyond_end_ = new (schedule_->zone()) BasicBlock(schedule_->zone(), id);
+ }
+ return beyond_end_;
}
- Trace("It took %d iterations to determine fixpoint\n", fixpoint_count);
-}
+ // Compute special RPO for the control flow graph between {entry} and {end},
+ // mutating any existing order so that the result is still valid.
+ void ComputeAndInsertSpecialRPO(BasicBlock* entry, BasicBlock* end) {
+ // RPO should not have been serialized for this schedule yet.
+ CHECK_EQ(kBlockUnvisited1, schedule_->start()->ao_number());
+ CHECK_EQ(kBlockUnvisited1, schedule_->start()->rpo_number());
+ CHECK_EQ(0, static_cast<int>(schedule_->rpo_order()->size()));
+
+ // Find correct insertion point within existing order.
+ BlockList* insert_before = order_->FindForBlock(entry);
+ BlockList* insert_after = insert_before ? insert_before->next : NULL;
+ BlockList* order = insert_after;
+
+ // Perform an iterative RPO traversal using an explicit stack,
+ // recording backedges that form cycles. O(|B|).
+ DCHECK_LT(previous_block_count_, schedule_->BasicBlockCount());
+ stack_.resize(schedule_->BasicBlockCount() - previous_block_count_);
+ previous_block_count_ = schedule_->BasicBlockCount();
+ int stack_depth = Push(stack_, 0, entry, kBlockUnvisited1);
+ int num_loops = 0;
+ while (stack_depth > 0) {
+ int current = stack_depth - 1;
+ SpecialRPOStackFrame* frame = &stack_[current];
+
+ if (frame->block != end &&
+ frame->index < frame->block->SuccessorCount()) {
+ // Process the next successor.
+ BasicBlock* succ = frame->block->SuccessorAt(frame->index++);
+ if (succ->rpo_number() == kBlockVisited1) continue;
+ if (succ->rpo_number() == kBlockOnStack) {
+ // The successor is on the stack, so this is a backedge (cycle).
+ backedges_.Add(Backedge(frame->block, frame->index - 1), zone_);
+ if (!HasLoopNumber(succ)) {
+ // Assign a new loop number to the header if it doesn't have one.
+ SetLoopNumber(succ, num_loops++);
+ }
+ } else {
+ // Push the successor onto the stack.
+ DCHECK(succ->rpo_number() == kBlockUnvisited1);
+ stack_depth = Push(stack_, stack_depth, succ, kBlockUnvisited1);
+ }
+ } else {
+ // Finished with all successors; pop the stack and add the block.
+ order = order->Add(zone_, frame->block);
+ frame->block->set_rpo_number(kBlockVisited1);
+ stack_depth--;
+ }
+ }
+
+ // If no loops were encountered, then the order we computed was correct.
+ if (num_loops != 0) {
+ // Otherwise, compute the loop information from the backedges in order
+ // to perform a traversal that groups loop bodies together.
+ ComputeLoopInfo(stack_, num_loops, &backedges_);
+
+ // Initialize the "loop stack". Note the entry could be a loop header.
+ LoopInfo* loop =
+ HasLoopNumber(entry) ? &loops_[GetLoopNumber(entry)] : NULL;
+ order = NULL;
+
+ // Perform an iterative post-order traversal, visiting loop bodies before
+ // edges that lead out of loops. Visits each block once, but linking loop
+ // sections together is linear in the loop size, so overall is
+ // O(|B| + max(loop_depth) * max(|loop|))
+ stack_depth = Push(stack_, 0, entry, kBlockUnvisited2);
+ while (stack_depth > 0) {
+ SpecialRPOStackFrame* frame = &stack_[stack_depth - 1];
+ BasicBlock* block = frame->block;
+ BasicBlock* succ = NULL;
+
+ if (frame->index < block->SuccessorCount()) {
+ // Process the next normal successor.
+ succ = block->SuccessorAt(frame->index++);
+ } else if (HasLoopNumber(block)) {
+ // Process additional outgoing edges from the loop header.
+ if (block->rpo_number() == kBlockOnStack) {
+ // Finish the loop body the first time the header is left on the
+ // stack.
+ DCHECK(loop != NULL && loop->header == block);
+ loop->start = order->Add(zone_, block);
+ order = loop->end;
+ block->set_rpo_number(kBlockVisited2);
+ // Pop the loop stack and continue visiting outgoing edges within
+ // the context of the outer loop, if any.
+ loop = loop->prev;
+ // We leave the loop header on the stack; the rest of this iteration
+ // and later iterations will go through its outgoing edges list.
+ }
+
+ // Use the next outgoing edge if there are any.
+ int outgoing_index =
+ static_cast<int>(frame->index - block->SuccessorCount());
+ LoopInfo* info = &loops_[GetLoopNumber(block)];
+ DCHECK(loop != info);
+ if (info->outgoing != NULL &&
+ outgoing_index < info->outgoing->length()) {
+ succ = info->outgoing->at(outgoing_index);
+ frame->index++;
+ }
+ }
+
+ if (succ != NULL) {
+ // Process the next successor.
+ if (succ->rpo_number() == kBlockOnStack) continue;
+ if (succ->rpo_number() == kBlockVisited2) continue;
+ DCHECK(succ->rpo_number() == kBlockUnvisited2);
+ if (loop != NULL && !loop->members->Contains(succ->id().ToInt())) {
+ // The successor is not in the current loop or any nested loop.
+ // Add it to the outgoing edges of this loop and visit it later.
+ loop->AddOutgoing(zone_, succ);
+ } else {
+ // Push the successor onto the stack.
+ stack_depth = Push(stack_, stack_depth, succ, kBlockUnvisited2);
+ if (HasLoopNumber(succ)) {
+ // Push the inner loop onto the loop stack.
+ DCHECK(GetLoopNumber(succ) < num_loops);
+ LoopInfo* next = &loops_[GetLoopNumber(succ)];
+ next->end = order;
+ next->prev = loop;
+ loop = next;
+ }
+ }
+ } else {
+ // Finished with all successors of the current block.
+ if (HasLoopNumber(block)) {
+ // If we are going to pop a loop header, then add its entire body.
+ LoopInfo* info = &loops_[GetLoopNumber(block)];
+ for (BlockList* l = info->start; true; l = l->next) {
+ if (l->next == info->end) {
+ l->next = order;
+ info->end = order;
+ break;
+ }
+ }
+ order = info->start;
+ } else {
+ // Pop a single node off the stack and add it to the order.
+ order = order->Add(zone_, block);
+ block->set_rpo_number(kBlockVisited2);
+ }
+ stack_depth--;
+ }
+ }
+ }
+
+ // Insert result into existing order.
+ if (insert_before == NULL) {
+ order_ = order;
+ } else {
+ // There already is a list element for the entry block in the list, hence
+ // we skip the first element of the sub-list to compensate duplication.
+ DCHECK_EQ(insert_before->block, order->block);
+ insert_before->next = order->next;
+ }
+
+ // Compute the correct loop headers and set the correct loop ends.
+ LoopInfo* current_loop = NULL;
+ BasicBlock* current_header = entry->loop_header();
+ int32_t loop_depth = entry->loop_depth();
+ if (entry->IsLoopHeader()) --loop_depth; // Entry might be a loop header.
+ for (BlockList* l = order; l != insert_after; l = l->next) {
+ BasicBlock* current = l->block;
+
+ // Reset BasicBlock::rpo_number again.
+ current->set_rpo_number(kBlockUnvisited1);
+
+ // Finish the previous loop(s) if we just exited them.
+ while (current_header != NULL && current == current_header->loop_end()) {
+ DCHECK(current_header->IsLoopHeader());
+ DCHECK(current_loop != NULL);
+ current_loop = current_loop->prev;
+ current_header = current_loop == NULL ? NULL : current_loop->header;
+ --loop_depth;
+ }
+ current->set_loop_header(current_header);
+
+ // Push a new loop onto the stack if this loop is a loop header.
+ if (HasLoopNumber(current)) {
+ ++loop_depth;
+ current_loop = &loops_[GetLoopNumber(current)];
+ BlockList* end = current_loop->end;
+ current->set_loop_end(end == NULL ? BeyondEndSentinel() : end->block);
+ current_header = current_loop->header;
+ Trace("B%d is a loop header, increment loop depth to %d\n",
+ current->id().ToInt(), loop_depth);
+ }
+
+ current->set_loop_depth(loop_depth);
+
+ if (current->loop_header() == NULL) {
+ Trace("B%d is not in a loop (depth == %d)\n", current->id().ToInt(),
+ current->loop_depth());
+ } else {
+ Trace("B%d has loop header B%d, (depth == %d)\n", current->id().ToInt(),
+ current->loop_header()->id().ToInt(), current->loop_depth());
+ }
+ }
+ }
+
+ // Computes loop membership from the backedges of the control flow graph.
+ void ComputeLoopInfo(ZoneVector<SpecialRPOStackFrame>& queue,
+ size_t num_loops, ZoneList<Backedge>* backedges) {
+ loops_.resize(num_loops, LoopInfo());
+
+ // Compute loop membership starting from backedges.
+ // O(max(loop_depth) * max(|loop|)
+ for (int i = 0; i < backedges->length(); i++) {
+ BasicBlock* member = backedges->at(i).first;
+ BasicBlock* header = member->SuccessorAt(backedges->at(i).second);
+ size_t loop_num = GetLoopNumber(header);
+ if (loops_[loop_num].header == NULL) {
+ loops_[loop_num].header = header;
+ loops_[loop_num].members = new (zone_)
+ BitVector(static_cast<int>(schedule_->BasicBlockCount()), zone_);
+ }
+
+ int queue_length = 0;
+ if (member != header) {
+ // As long as the header doesn't have a backedge to itself,
+ // Push the member onto the queue and process its predecessors.
+ if (!loops_[loop_num].members->Contains(member->id().ToInt())) {
+ loops_[loop_num].members->Add(member->id().ToInt());
+ }
+ queue[queue_length++].block = member;
+ }
+
+ // Propagate loop membership backwards. All predecessors of M up to the
+ // loop header H are members of the loop too. O(|blocks between M and H|).
+ while (queue_length > 0) {
+ BasicBlock* block = queue[--queue_length].block;
+ for (size_t i = 0; i < block->PredecessorCount(); i++) {
+ BasicBlock* pred = block->PredecessorAt(i);
+ if (pred != header) {
+ if (!loops_[loop_num].members->Contains(pred->id().ToInt())) {
+ loops_[loop_num].members->Add(pred->id().ToInt());
+ queue[queue_length++].block = pred;
+ }
+ }
+ }
+ }
+ }
+ }
+
+#if DEBUG
+ void PrintRPO() {
+ OFStream os(stdout);
+ os << "RPO with " << loops_.size() << " loops";
+ if (loops_.size() > 0) {
+ os << " (";
+ for (size_t i = 0; i < loops_.size(); i++) {
+ if (i > 0) os << " ";
+ os << "B" << loops_[i].header->id();
+ }
+ os << ")";
+ }
+ os << ":\n";
+
+ for (BlockList* l = order_; l != NULL; l = l->next) {
+ BasicBlock* block = l->block;
+ BasicBlock::Id bid = block->id();
+ // TODO(jarin,svenpanne): Add formatting here once we have support for
+ // that in streams (we want an equivalent of PrintF("%5d:", x) here).
+ os << " " << block->rpo_number() << ":";
+ for (size_t i = 0; i < loops_.size(); i++) {
+ bool range = loops_[i].header->LoopContains(block);
+ bool membership = loops_[i].header != block && range;
+ os << (membership ? " |" : " ");
+ os << (range ? "x" : " ");
+ }
+ os << " B" << bid << ": ";
+ if (block->loop_end() != NULL) {
+ os << " range: [" << block->rpo_number() << ", "
+ << block->loop_end()->rpo_number() << ")";
+ }
+ if (block->loop_header() != NULL) {
+ os << " header: B" << block->loop_header()->id();
+ }
+ if (block->loop_depth() > 0) {
+ os << " depth: " << block->loop_depth();
+ }
+ os << "\n";
+ }
+ }
+
+ void VerifySpecialRPO() {
+ BasicBlockVector* order = schedule_->rpo_order();
+ DCHECK(order->size() > 0);
+ DCHECK((*order)[0]->id().ToInt() == 0); // entry should be first.
+
+ for (size_t i = 0; i < loops_.size(); i++) {
+ LoopInfo* loop = &loops_[i];
+ BasicBlock* header = loop->header;
+ BasicBlock* end = header->loop_end();
+
+ DCHECK(header != NULL);
+ DCHECK(header->rpo_number() >= 0);
+ DCHECK(header->rpo_number() < static_cast<int>(order->size()));
+ DCHECK(end != NULL);
+ DCHECK(end->rpo_number() <= static_cast<int>(order->size()));
+ DCHECK(end->rpo_number() > header->rpo_number());
+ DCHECK(header->loop_header() != header);
+
+ // Verify the start ... end list relationship.
+ int links = 0;
+ BlockList* l = loop->start;
+ DCHECK(l != NULL && l->block == header);
+ bool end_found;
+ while (true) {
+ if (l == NULL || l == loop->end) {
+ end_found = (loop->end == l);
+ break;
+ }
+ // The list should be in same order as the final result.
+ DCHECK(l->block->rpo_number() == links + header->rpo_number());
+ links++;
+ l = l->next;
+ DCHECK(links < static_cast<int>(2 * order->size())); // cycle?
+ }
+ DCHECK(links > 0);
+ DCHECK(links == end->rpo_number() - header->rpo_number());
+ DCHECK(end_found);
+
+ // Check loop depth of the header.
+ int loop_depth = 0;
+ for (LoopInfo* outer = loop; outer != NULL; outer = outer->prev) {
+ loop_depth++;
+ }
+ DCHECK_EQ(loop_depth, header->loop_depth());
+
+ // Check the contiguousness of loops.
+ int count = 0;
+ for (int j = 0; j < static_cast<int>(order->size()); j++) {
+ BasicBlock* block = order->at(j);
+ DCHECK(block->rpo_number() == j);
+ if (j < header->rpo_number() || j >= end->rpo_number()) {
+ DCHECK(!header->LoopContains(block));
+ } else {
+ DCHECK(header->LoopContains(block));
+ DCHECK_GE(block->loop_depth(), loop_depth);
+ count++;
+ }
+ }
+ DCHECK(links == count);
+ }
+ }
+#endif // DEBUG
+
+ Zone* zone_;
+ Schedule* schedule_;
+ BlockList* order_;
+ ZoneVector<LoopInfo> loops_;
+ BasicBlock* beyond_end_;
+ ZoneList<Backedge> backedges_;
+ ZoneVector<SpecialRPOStackFrame> stack_;
+ size_t previous_block_count_;
+};
-class PrepareUsesVisitor : public NullNodeVisitor {
- public:
- explicit PrepareUsesVisitor(Scheduler* scheduler)
- : scheduler_(scheduler), schedule_(scheduler->schedule_) {}
- GenericGraphVisit::Control Pre(Node* node) {
+BasicBlockVector* Scheduler::ComputeSpecialRPO(ZonePool* zone_pool,
+ Schedule* schedule) {
+ ZonePool::Scope zone_scope(zone_pool);
+ Zone* zone = zone_scope.zone();
+
+ SpecialRPONumberer numberer(zone, schedule);
+ numberer.ComputeSpecialRPO();
+ numberer.SerializeAOIntoSchedule();
+ numberer.SerializeRPOIntoSchedule();
+ numberer.PrintAndVerifySpecialRPO();
+ return schedule->rpo_order();
+}
+
+
+void Scheduler::ComputeSpecialRPONumbering() {
+ Trace("--- COMPUTING SPECIAL RPO ----------------------------------\n");
+
+ // Compute the special reverse-post-order for basic blocks.
+ special_rpo_ = new (zone_) SpecialRPONumberer(zone_, schedule_);
+ special_rpo_->ComputeSpecialRPO();
+}
+
+
+void Scheduler::GenerateImmediateDominatorTree() {
+ Trace("--- IMMEDIATE BLOCK DOMINATORS -----------------------------\n");
+
+ // TODO(danno): Consider using Lengauer & Tarjan's if this becomes too slow.
+
+ // Build the block dominator tree.
+ schedule_->start()->set_dominator_depth(0);
+ typedef SpecialRPONumberer::BlockList BlockList;
+ for (BlockList* l = special_rpo_->order_; l != NULL; l = l->next) {
+ BasicBlock* current = l->block;
+ if (current == schedule_->start()) continue;
+ BasicBlock::Predecessors::iterator pred = current->predecessors_begin();
+ BasicBlock::Predecessors::iterator end = current->predecessors_end();
+ DCHECK(pred != end); // All blocks except start have predecessors.
+ BasicBlock* dominator = *pred;
+ // For multiple predecessors, walk up the dominator tree until a common
+ // dominator is found. Visitation order guarantees that all predecessors
+ // except for backwards edges have been visited.
+ for (++pred; pred != end; ++pred) {
+ // Don't examine backwards edges.
+ if ((*pred)->dominator_depth() < 0) continue;
+ dominator = GetCommonDominator(dominator, *pred);
+ }
+ current->set_dominator(dominator);
+ current->set_dominator_depth(dominator->dominator_depth() + 1);
+ // Propagate "deferredness" of the dominator.
+ if (dominator->deferred()) current->set_deferred(true);
+ Trace("Block B%d's idom is B%d, depth = %d\n", current->id().ToInt(),
+ dominator->id().ToInt(), current->dominator_depth());
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Phase 3: Prepare use counts for nodes.
+
+
+class PrepareUsesVisitor : public NullNodeVisitor {
+ public:
+ explicit PrepareUsesVisitor(Scheduler* scheduler)
+ : scheduler_(scheduler), schedule_(scheduler->schedule_) {}
+
+ void Pre(Node* node) {
if (scheduler_->GetPlacement(node) == Scheduler::kFixed) {
// Fixed nodes are always roots for schedule late.
scheduler_->schedule_root_nodes_.push_back(node);
if (!schedule_->IsScheduled(node)) {
// Make sure root nodes are scheduled in their respective blocks.
- Trace(" Scheduling fixed position node #%d:%s\n", node->id(),
+ Trace("Scheduling fixed position node #%d:%s\n", node->id(),
node->op()->mnemonic());
IrOpcode::Value opcode = node->opcode();
BasicBlock* block =
schedule_->AddNode(block, node);
}
}
-
- return GenericGraphVisit::CONTINUE;
}
void PostEdge(Node* from, int index, Node* to) {
// for decrementing use counts.
if (!schedule_->IsScheduled(from)) {
DCHECK_NE(Scheduler::kFixed, scheduler_->GetPlacement(from));
- ++(scheduler_->GetData(to)->unscheduled_count_);
- Trace(" Use count of #%d:%s (used by #%d:%s)++ = %d\n", to->id(),
- to->op()->mnemonic(), from->id(), from->op()->mnemonic(),
- scheduler_->GetData(to)->unscheduled_count_);
+ scheduler_->IncrementUnscheduledUseCount(to, index, from);
}
}
void Scheduler::PrepareUses() {
- Trace("------------------- PREPARE USES ------------------\n");
+ Trace("--- PREPARE USES -------------------------------------------\n");
+
// Count the uses of every node, it will be used to ensure that all of a
// node's uses are scheduled before the node itself.
PrepareUsesVisitor prepare_uses(this);
}
-class ScheduleLateNodeVisitor : public NullNodeVisitor {
+// -----------------------------------------------------------------------------
+// Phase 4: Schedule nodes early.
+
+
+class ScheduleEarlyNodeVisitor {
public:
- explicit ScheduleLateNodeVisitor(Scheduler* scheduler)
- : scheduler_(scheduler), schedule_(scheduler_->schedule_) {}
+ ScheduleEarlyNodeVisitor(Zone* zone, Scheduler* scheduler)
+ : scheduler_(scheduler), schedule_(scheduler->schedule_), queue_(zone) {}
+
+ // Run the schedule early algorithm on a set of fixed root nodes.
+ void Run(NodeVector* roots) {
+ for (NodeVectorIter i = roots->begin(); i != roots->end(); ++i) {
+ queue_.push(*i);
+ while (!queue_.empty()) {
+ VisitNode(queue_.front());
+ queue_.pop();
+ }
+ }
+ }
- GenericGraphVisit::Control Pre(Node* node) {
- // Don't schedule nodes that are already scheduled.
- if (schedule_->IsScheduled(node)) {
- return GenericGraphVisit::CONTINUE;
+ private:
+ // Visits one node from the queue and propagates its current schedule early
+ // position to all uses. This in turn might push more nodes onto the queue.
+ void VisitNode(Node* node) {
+ Scheduler::SchedulerData* data = scheduler_->GetData(node);
+
+ // Fixed nodes already know their schedule early position.
+ if (scheduler_->GetPlacement(node) == Scheduler::kFixed) {
+ DCHECK_EQ(schedule_->start(), data->minimum_block_);
+ data->minimum_block_ = schedule_->block(node);
+ Trace("Fixing #%d:%s minimum_block = B%d, dominator_depth = %d\n",
+ node->id(), node->op()->mnemonic(),
+ data->minimum_block_->id().ToInt(),
+ data->minimum_block_->dominator_depth());
}
+
+ // No need to propagate unconstrained schedule early positions.
+ if (data->minimum_block_ == schedule_->start()) return;
+
+ // Propagate schedule early position.
+ DCHECK(data->minimum_block_ != NULL);
+ Node::Uses uses = node->uses();
+ for (Node::Uses::iterator i = uses.begin(); i != uses.end(); ++i) {
+ PropagateMinimumPositionToNode(data->minimum_block_, *i);
+ }
+ }
+
+ // Propagates {block} as another minimum position into the given {node}. This
+ // has the net effect of computing the minimum dominator block of {node} that
+ // still post-dominates all inputs to {node} when the queue is processed.
+ void PropagateMinimumPositionToNode(BasicBlock* block, Node* node) {
Scheduler::SchedulerData* data = scheduler_->GetData(node);
- DCHECK_EQ(Scheduler::kSchedulable, data->placement_);
- // If all the uses of a node have been scheduled, then the node itself can
- // be scheduled.
- bool eligible = data->unscheduled_count_ == 0;
- Trace("Testing for schedule eligibility for #%d:%s = %s\n", node->id(),
- node->op()->mnemonic(), eligible ? "true" : "false");
- if (!eligible) return GenericGraphVisit::DEFER;
+ // No need to propagate to fixed node, it's guaranteed to be a root.
+ if (scheduler_->GetPlacement(node) == Scheduler::kFixed) return;
+
+ // Coupled nodes influence schedule early position of their control.
+ if (scheduler_->GetPlacement(node) == Scheduler::kCoupled) {
+ Node* control = NodeProperties::GetControlInput(node);
+ PropagateMinimumPositionToNode(block, control);
+ }
+
+ // Propagate new position if it is deeper down the dominator tree than the
+ // current. Note that all inputs need to have minimum block position inside
+ // the dominator chain of {node}'s minimum block position.
+ DCHECK(InsideSameDominatorChain(block, data->minimum_block_));
+ if (block->dominator_depth() > data->minimum_block_->dominator_depth()) {
+ data->minimum_block_ = block;
+ queue_.push(node);
+ Trace("Propagating #%d:%s minimum_block = B%d, dominator_depth = %d\n",
+ node->id(), node->op()->mnemonic(),
+ data->minimum_block_->id().ToInt(),
+ data->minimum_block_->dominator_depth());
+ }
+ }
+
+#if DEBUG
+ bool InsideSameDominatorChain(BasicBlock* b1, BasicBlock* b2) {
+ BasicBlock* dominator = scheduler_->GetCommonDominator(b1, b2);
+ return dominator == b1 || dominator == b2;
+ }
+#endif
+
+ Scheduler* scheduler_;
+ Schedule* schedule_;
+ ZoneQueue<Node*> queue_;
+};
+
+
+void Scheduler::ScheduleEarly() {
+ Trace("--- SCHEDULE EARLY -----------------------------------------\n");
+ if (FLAG_trace_turbo_scheduler) {
+ Trace("roots: ");
+ for (Node* node : schedule_root_nodes_) {
+ Trace("#%d:%s ", node->id(), node->op()->mnemonic());
+ }
+ Trace("\n");
+ }
+
+ // Compute the minimum block for each node thereby determining the earliest
+ // position each node could be placed within a valid schedule.
+ ScheduleEarlyNodeVisitor schedule_early_visitor(zone_, this);
+ schedule_early_visitor.Run(&schedule_root_nodes_);
+}
+
+
+// -----------------------------------------------------------------------------
+// Phase 5: Schedule nodes late.
+
+
+class ScheduleLateNodeVisitor {
+ public:
+ ScheduleLateNodeVisitor(Zone* zone, Scheduler* scheduler)
+ : scheduler_(scheduler), schedule_(scheduler_->schedule_) {}
+
+ // Run the schedule late algorithm on a set of fixed root nodes.
+ void Run(NodeVector* roots) {
+ for (NodeVectorIter i = roots->begin(); i != roots->end(); ++i) {
+ ProcessQueue(*i);
+ }
+ }
+
+ private:
+ void ProcessQueue(Node* root) {
+ ZoneQueue<Node*>* queue = &(scheduler_->schedule_queue_);
+ for (InputIter i = root->inputs().begin(); i != root->inputs().end(); ++i) {
+ Node* node = *i;
+
+ // Don't schedule coupled nodes on their own.
+ if (scheduler_->GetPlacement(node) == Scheduler::kCoupled) {
+ node = NodeProperties::GetControlInput(node);
+ }
+
+ // Test schedulability condition by looking at unscheduled use count.
+ if (scheduler_->GetData(node)->unscheduled_count_ != 0) continue;
+
+ queue->push(node);
+ while (!queue->empty()) {
+ VisitNode(queue->front());
+ queue->pop();
+ }
+ }
+ }
+
+ // Visits one node from the queue of schedulable nodes and determines its
+ // schedule late position. Also hoists nodes out of loops to find a more
+ // optimal scheduling position.
+ void VisitNode(Node* node) {
+ DCHECK_EQ(0, scheduler_->GetData(node)->unscheduled_count_);
+
+ // Don't schedule nodes that are already scheduled.
+ if (schedule_->IsScheduled(node)) return;
+ DCHECK_EQ(Scheduler::kSchedulable, scheduler_->GetPlacement(node));
// Determine the dominating block for all of the uses of this node. It is
// the latest block that this node can be scheduled in.
+ Trace("Scheduling #%d:%s\n", node->id(), node->op()->mnemonic());
+ BasicBlock* block = GetCommonDominatorOfUses(node);
+ DCHECK_NOT_NULL(block);
+
+ // The schedule early block dominates the schedule late block.
+ BasicBlock* min_block = scheduler_->GetData(node)->minimum_block_;
+ DCHECK_EQ(min_block, scheduler_->GetCommonDominator(block, min_block));
+ Trace("Schedule late of #%d:%s is B%d at loop depth %d, minimum = B%d\n",
+ node->id(), node->op()->mnemonic(), block->id().ToInt(),
+ block->loop_depth(), min_block->id().ToInt());
+
+ // Hoist nodes out of loops if possible. Nodes can be hoisted iteratively
+ // into enclosing loop pre-headers until they would preceed their schedule
+ // early position.
+ BasicBlock* hoist_block = GetPreHeader(block);
+ while (hoist_block != NULL &&
+ hoist_block->dominator_depth() >= min_block->dominator_depth()) {
+ Trace(" hoisting #%d:%s to block B%d\n", node->id(),
+ node->op()->mnemonic(), hoist_block->id().ToInt());
+ DCHECK_LT(hoist_block->loop_depth(), block->loop_depth());
+ block = hoist_block;
+ hoist_block = GetPreHeader(hoist_block);
+ }
+
+ // Schedule the node or a floating control structure.
+ if (NodeProperties::IsControl(node)) {
+ ScheduleFloatingControl(block, node);
+ } else {
+ ScheduleNode(block, node);
+ }
+ }
+
+ BasicBlock* GetPreHeader(BasicBlock* block) {
+ if (block->IsLoopHeader()) {
+ return block->dominator();
+ } else if (block->loop_header() != NULL) {
+ return block->loop_header()->dominator();
+ } else {
+ return NULL;
+ }
+ }
+
+ BasicBlock* GetCommonDominatorOfUses(Node* node) {
BasicBlock* block = NULL;
- for (Node::Uses::iterator i = node->uses().begin(); i != node->uses().end();
- ++i) {
+ Node::Uses uses = node->uses();
+ for (Node::Uses::iterator i = uses.begin(); i != uses.end(); ++i) {
BasicBlock* use_block = GetBlockForUse(i.edge());
block = block == NULL ? use_block : use_block == NULL
? block
: scheduler_->GetCommonDominator(
block, use_block);
}
- DCHECK(block != NULL);
-
- int min_rpo = data->minimum_rpo_;
- Trace(
- "Schedule late conservative for #%d:%s is B%d at loop depth %d, "
- "minimum_rpo = %d\n",
- node->id(), node->op()->mnemonic(), block->id(), block->loop_depth_,
- min_rpo);
- // Hoist nodes out of loops if possible. Nodes can be hoisted iteratively
- // into enclosing loop pre-headers until they would preceed their
- // ScheduleEarly position.
- BasicBlock* hoist_block = block;
- while (hoist_block != NULL && hoist_block->rpo_number_ >= min_rpo) {
- if (hoist_block->loop_depth_ < block->loop_depth_) {
- block = hoist_block;
- Trace(" hoisting #%d:%s to block %d\n", node->id(),
- node->op()->mnemonic(), block->id());
- }
- // Try to hoist to the pre-header of the loop header.
- hoist_block = hoist_block->loop_header();
- if (hoist_block != NULL) {
- BasicBlock* pre_header = hoist_block->dominator_;
- DCHECK(pre_header == NULL ||
- *hoist_block->predecessors().begin() == pre_header);
- Trace(
- " hoist to pre-header B%d of loop header B%d, depth would be %d\n",
- pre_header->id(), hoist_block->id(), pre_header->loop_depth_);
- hoist_block = pre_header;
- }
- }
-
- ScheduleNode(block, node);
-
- return GenericGraphVisit::CONTINUE;
+ return block;
}
- private:
BasicBlock* GetBlockForUse(Node::Edge edge) {
Node* use = edge.from();
IrOpcode::Value opcode = use->opcode();
if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
+ // If the use is from a coupled (i.e. floating) phi, compute the common
+ // dominator of its uses. This will not recurse more than one level.
+ if (scheduler_->GetPlacement(use) == Scheduler::kCoupled) {
+ Trace(" inspecting uses of coupled #%d:%s\n", use->id(),
+ use->op()->mnemonic());
+ DCHECK_EQ(edge.to(), NodeProperties::GetControlInput(use));
+ return GetCommonDominatorOfUses(use);
+ }
// If the use is from a fixed (i.e. non-floating) phi, use the block
// of the corresponding control input to the merge.
- int index = edge.index();
if (scheduler_->GetPlacement(use) == Scheduler::kFixed) {
- Trace(" input@%d into a fixed phi #%d:%s\n", index, use->id(),
+ Trace(" input@%d into a fixed phi #%d:%s\n", edge.index(), use->id(),
use->op()->mnemonic());
Node* merge = NodeProperties::GetControlInput(use, 0);
opcode = merge->opcode();
DCHECK(opcode == IrOpcode::kMerge || opcode == IrOpcode::kLoop);
- use = NodeProperties::GetControlInput(merge, index);
+ use = NodeProperties::GetControlInput(merge, edge.index());
}
}
BasicBlock* result = schedule_->block(use);
if (result == NULL) return NULL;
Trace(" must dominate use #%d:%s in B%d\n", use->id(),
- use->op()->mnemonic(), result->id());
+ use->op()->mnemonic(), result->id().ToInt());
return result;
}
+ void ScheduleFloatingControl(BasicBlock* block, Node* node) {
+ DCHECK(scheduler_->GetData(node)->is_floating_control_);
+ scheduler_->FuseFloatingControl(block, node);
+ }
+
void ScheduleNode(BasicBlock* block, Node* node) {
schedule_->PlanNode(block, node);
- scheduler_->scheduled_nodes_[block->id()].push_back(node);
-
- // Reduce the use count of the node's inputs to potentially make them
- // schedulable.
- for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
- Scheduler::SchedulerData* data = scheduler_->GetData(*i);
- DCHECK(data->unscheduled_count_ > 0);
- --data->unscheduled_count_;
- if (FLAG_trace_turbo_scheduler) {
- Trace(" Use count for #%d:%s (used by #%d:%s)-- = %d\n", (*i)->id(),
- (*i)->op()->mnemonic(), i.edge().from()->id(),
- i.edge().from()->op()->mnemonic(), data->unscheduled_count_);
- if (data->unscheduled_count_ == 0) {
- Trace(" newly eligible #%d:%s\n", (*i)->id(),
- (*i)->op()->mnemonic());
- }
- }
- }
+ scheduler_->scheduled_nodes_[block->id().ToSize()].push_back(node);
+ scheduler_->UpdatePlacement(node, Scheduler::kScheduled);
}
Scheduler* scheduler_;
void Scheduler::ScheduleLate() {
- Trace("------------------- SCHEDULE LATE -----------------\n");
+ Trace("--- SCHEDULE LATE ------------------------------------------\n");
if (FLAG_trace_turbo_scheduler) {
Trace("roots: ");
- for (NodeVectorIter i = schedule_root_nodes_.begin();
- i != schedule_root_nodes_.end(); ++i) {
- Trace("#%d:%s ", (*i)->id(), (*i)->op()->mnemonic());
+ for (Node* node : schedule_root_nodes_) {
+ Trace("#%d:%s ", node->id(), node->op()->mnemonic());
}
Trace("\n");
}
// Schedule: Places nodes in dominator block of all their uses.
- ScheduleLateNodeVisitor schedule_late_visitor(this);
-
- {
- Zone zone(zone_->isolate());
- GenericGraphVisit::Visit<ScheduleLateNodeVisitor,
- NodeInputIterationTraits<Node> >(
- graph_, &zone, schedule_root_nodes_.begin(), schedule_root_nodes_.end(),
- &schedule_late_visitor);
- }
-
- // Add collected nodes for basic blocks to their blocks in the right order.
- int block_num = 0;
- for (NodeVectorVectorIter i = scheduled_nodes_.begin();
- i != scheduled_nodes_.end(); ++i) {
- for (NodeVectorRIter j = i->rbegin(); j != i->rend(); ++j) {
- schedule_->AddNode(schedule_->all_blocks_.at(block_num), *j);
- }
- block_num++;
- }
-}
-
-
-bool Scheduler::ConnectFloatingControl() {
- if (!has_floating_control_) return false;
-
- Trace("Connecting floating control...\n");
-
- // Process blocks and instructions backwards to find and connect floating
- // control nodes into the control graph according to the block they were
- // scheduled into.
- int max = static_cast<int>(schedule_->rpo_order()->size());
- for (int i = max - 1; i >= 0; i--) {
- BasicBlock* block = schedule_->rpo_order()->at(i);
- // TODO(titzer): we place at most one floating control structure per
- // basic block because scheduling currently can interleave phis from
- // one subgraph with the merges from another subgraph.
- bool one_placed = false;
- for (int j = static_cast<int>(block->nodes_.size()) - 1; j >= 0; j--) {
- Node* node = block->nodes_[j];
- SchedulerData* data = GetData(node);
- if (data->is_floating_control_ && !data->is_connected_control_ &&
- !one_placed) {
- Trace(" Floating control #%d:%s was scheduled in B%d\n", node->id(),
- node->op()->mnemonic(), block->id());
- ConnectFloatingControlSubgraph(block, node);
- one_placed = true;
- }
- }
- }
-
- return true;
+ ScheduleLateNodeVisitor schedule_late_visitor(zone_, this);
+ schedule_late_visitor.Run(&schedule_root_nodes_);
}
-void Scheduler::ConnectFloatingControlSubgraph(BasicBlock* block, Node* end) {
- Node* block_start = block->nodes_[0];
- DCHECK(IrOpcode::IsControlOpcode(block_start->opcode()));
- // Find the current "control successor" of the node that starts the block
- // by searching the control uses for a control input edge from a connected
- // control node.
- Node* control_succ = NULL;
- for (UseIter i = block_start->uses().begin(); i != block_start->uses().end();
- ++i) {
- Node::Edge edge = i.edge();
- if (NodeProperties::IsControlEdge(edge) &&
- GetData(edge.from())->is_connected_control_) {
- DCHECK_EQ(NULL, control_succ);
- control_succ = edge.from();
- control_succ->ReplaceInput(edge.index(), end);
- }
- }
- DCHECK_NE(NULL, control_succ);
- Trace(" Inserting floating control end %d:%s between %d:%s -> %d:%s\n",
- end->id(), end->op()->mnemonic(), control_succ->id(),
- control_succ->op()->mnemonic(), block_start->id(),
- block_start->op()->mnemonic());
-
- // Find the "start" node of the control subgraph, which should be the
- // unique node that is itself floating control but has a control input that
- // is not floating.
- Node* start = NULL;
- ZoneQueue<Node*> queue(zone_);
- queue.push(end);
- GetData(end)->is_connected_control_ = true;
- while (!queue.empty()) {
- Node* node = queue.front();
- queue.pop();
- Trace(" Search #%d:%s for control subgraph start\n", node->id(),
- node->op()->mnemonic());
- int max = NodeProperties::PastControlIndex(node);
- for (int i = NodeProperties::FirstControlIndex(node); i < max; i++) {
- Node* input = node->InputAt(i);
- SchedulerData* data = GetData(input);
- if (data->is_floating_control_) {
- // {input} is floating control.
- if (!data->is_connected_control_) {
- // First time seeing {input} during this traversal, queue it.
- queue.push(input);
- data->is_connected_control_ = true;
- }
- } else {
- // Otherwise, {node} is the start node, because it is floating control
- // but is connected to {input} that is not floating control.
- DCHECK_EQ(NULL, start); // There can be only one.
- start = node;
- }
- }
- }
+// -----------------------------------------------------------------------------
+// Phase 6: Seal the final schedule.
- DCHECK_NE(NULL, start);
- start->ReplaceInput(NodeProperties::FirstControlIndex(start), block_start);
- Trace(" Connecting floating control start %d:%s to %d:%s\n", start->id(),
- start->op()->mnemonic(), block_start->id(),
- block_start->op()->mnemonic());
-}
+void Scheduler::SealFinalSchedule() {
+ Trace("--- SEAL FINAL SCHEDULE ------------------------------------\n");
+ // Serialize the assembly order and reverse-post-order numbering.
+ special_rpo_->SerializeAOIntoSchedule();
+ special_rpo_->SerializeRPOIntoSchedule();
+ special_rpo_->PrintAndVerifySpecialRPO();
-// Numbering for BasicBlockData.rpo_number_ for this block traversal:
-static const int kBlockOnStack = -2;
-static const int kBlockVisited1 = -3;
-static const int kBlockVisited2 = -4;
-static const int kBlockUnvisited1 = -1;
-static const int kBlockUnvisited2 = kBlockVisited1;
-
-struct SpecialRPOStackFrame {
- BasicBlock* block;
- int index;
-};
-
-struct BlockList {
- BasicBlock* block;
- BlockList* next;
-
- BlockList* Add(Zone* zone, BasicBlock* b) {
- BlockList* list = static_cast<BlockList*>(zone->New(sizeof(BlockList)));
- list->block = b;
- list->next = this;
- return list;
- }
-
- void Serialize(BasicBlockVector* final_order) {
- for (BlockList* l = this; l != NULL; l = l->next) {
- l->block->rpo_number_ = static_cast<int>(final_order->size());
- final_order->push_back(l->block);
+ // Add collected nodes for basic blocks to their blocks in the right order.
+ int block_num = 0;
+ for (NodeVector& nodes : scheduled_nodes_) {
+ BasicBlock::Id id = BasicBlock::Id::FromInt(block_num++);
+ BasicBlock* block = schedule_->GetBlockById(id);
+ for (NodeVectorRIter i = nodes.rbegin(); i != nodes.rend(); ++i) {
+ schedule_->AddNode(block, *i);
}
}
-};
-
-struct LoopInfo {
- BasicBlock* header;
- ZoneList<BasicBlock*>* outgoing;
- BitVector* members;
- LoopInfo* prev;
- BlockList* end;
- BlockList* start;
-
- void AddOutgoing(Zone* zone, BasicBlock* block) {
- if (outgoing == NULL) outgoing = new (zone) ZoneList<BasicBlock*>(2, zone);
- outgoing->Add(block, zone);
- }
-};
-
-
-static int Push(SpecialRPOStackFrame* stack, int depth, BasicBlock* child,
- int unvisited) {
- if (child->rpo_number_ == unvisited) {
- stack[depth].block = child;
- stack[depth].index = 0;
- child->rpo_number_ = kBlockOnStack;
- return depth + 1;
- }
- return depth;
}
-// Computes loop membership from the backedges of the control flow graph.
-static LoopInfo* ComputeLoopInfo(
- Zone* zone, SpecialRPOStackFrame* queue, int num_loops, int num_blocks,
- ZoneList<std::pair<BasicBlock*, int> >* backedges) {
- LoopInfo* loops = zone->NewArray<LoopInfo>(num_loops);
- memset(loops, 0, num_loops * sizeof(LoopInfo));
-
- // Compute loop membership starting from backedges.
- // O(max(loop_depth) * max(|loop|)
- for (int i = 0; i < backedges->length(); i++) {
- BasicBlock* member = backedges->at(i).first;
- BasicBlock* header = member->SuccessorAt(backedges->at(i).second);
- int loop_num = header->loop_end_;
- if (loops[loop_num].header == NULL) {
- loops[loop_num].header = header;
- loops[loop_num].members = new (zone) BitVector(num_blocks, zone);
- }
+// -----------------------------------------------------------------------------
- int queue_length = 0;
- if (member != header) {
- // As long as the header doesn't have a backedge to itself,
- // Push the member onto the queue and process its predecessors.
- if (!loops[loop_num].members->Contains(member->id())) {
- loops[loop_num].members->Add(member->id());
- }
- queue[queue_length++].block = member;
- }
- // Propagate loop membership backwards. All predecessors of M up to the
- // loop header H are members of the loop too. O(|blocks between M and H|).
- while (queue_length > 0) {
- BasicBlock* block = queue[--queue_length].block;
- for (int i = 0; i < block->PredecessorCount(); i++) {
- BasicBlock* pred = block->PredecessorAt(i);
- if (pred != header) {
- if (!loops[loop_num].members->Contains(pred->id())) {
- loops[loop_num].members->Add(pred->id());
- queue[queue_length++].block = pred;
- }
- }
- }
- }
+void Scheduler::FuseFloatingControl(BasicBlock* block, Node* node) {
+ Trace("--- FUSE FLOATING CONTROL ----------------------------------\n");
+ if (FLAG_trace_turbo_scheduler) {
+ OFStream os(stdout);
+ os << "Schedule before control flow fusion:\n" << *schedule_;
}
- return loops;
-}
-
-#if DEBUG
-static void PrintRPO(int num_loops, LoopInfo* loops, BasicBlockVector* order) {
- PrintF("-- RPO with %d loops ", num_loops);
- if (num_loops > 0) {
- PrintF("(");
- for (int i = 0; i < num_loops; i++) {
- if (i > 0) PrintF(" ");
- PrintF("B%d", loops[i].header->id());
- }
- PrintF(") ");
- }
- PrintF("-- \n");
-
- for (int i = 0; i < static_cast<int>(order->size()); i++) {
- BasicBlock* block = (*order)[i];
- int bid = block->id();
- PrintF("%5d:", i);
- for (int i = 0; i < num_loops; i++) {
- bool membership = loops[i].members->Contains(bid);
- bool range = loops[i].header->LoopContains(block);
- PrintF(membership ? " |" : " ");
- PrintF(range ? "x" : " ");
- }
- PrintF(" B%d: ", bid);
- if (block->loop_end_ >= 0) {
- PrintF(" range: [%d, %d)", block->rpo_number_, block->loop_end_);
- }
- PrintF("\n");
+ // Iterate on phase 1: Build control-flow graph.
+ CFGBuilder cfg_builder(zone_, this);
+ cfg_builder.Run(block, node);
+
+ // Iterate on phase 2: Compute special RPO and dominator tree.
+ special_rpo_->UpdateSpecialRPO(block, schedule_->block(node));
+ // TODO(mstarzinger): Currently "iterate on" means "re-run". Fix that.
+ for (BasicBlock* block : schedule_->all_blocks_) {
+ block->set_dominator_depth(-1);
+ block->set_dominator(NULL);
}
-}
+ GenerateImmediateDominatorTree();
+ // Move previously planned nodes.
+ // TODO(mstarzinger): Improve that by supporting bulk moves.
+ scheduled_nodes_.resize(schedule_->BasicBlockCount(), NodeVector(zone_));
+ MovePlannedNodes(block, schedule_->block(node));
-static void VerifySpecialRPO(int num_loops, LoopInfo* loops,
- BasicBlockVector* order) {
- DCHECK(order->size() > 0);
- DCHECK((*order)[0]->id() == 0); // entry should be first.
-
- for (int i = 0; i < num_loops; i++) {
- LoopInfo* loop = &loops[i];
- BasicBlock* header = loop->header;
-
- DCHECK(header != NULL);
- DCHECK(header->rpo_number_ >= 0);
- DCHECK(header->rpo_number_ < static_cast<int>(order->size()));
- DCHECK(header->loop_end_ >= 0);
- DCHECK(header->loop_end_ <= static_cast<int>(order->size()));
- DCHECK(header->loop_end_ > header->rpo_number_);
-
- // Verify the start ... end list relationship.
- int links = 0;
- BlockList* l = loop->start;
- DCHECK(l != NULL && l->block == header);
- bool end_found;
- while (true) {
- if (l == NULL || l == loop->end) {
- end_found = (loop->end == l);
- break;
- }
- // The list should be in same order as the final result.
- DCHECK(l->block->rpo_number_ == links + loop->header->rpo_number_);
- links++;
- l = l->next;
- DCHECK(links < static_cast<int>(2 * order->size())); // cycle?
- }
- DCHECK(links > 0);
- DCHECK(links == (header->loop_end_ - header->rpo_number_));
- DCHECK(end_found);
-
- // Check the contiguousness of loops.
- int count = 0;
- for (int j = 0; j < static_cast<int>(order->size()); j++) {
- BasicBlock* block = order->at(j);
- DCHECK(block->rpo_number_ == j);
- if (j < header->rpo_number_ || j >= header->loop_end_) {
- DCHECK(!loop->members->Contains(block->id()));
- } else {
- if (block == header) {
- DCHECK(!loop->members->Contains(block->id()));
- } else {
- DCHECK(loop->members->Contains(block->id()));
- }
- count++;
- }
- }
- DCHECK(links == count);
+ if (FLAG_trace_turbo_scheduler) {
+ OFStream os(stdout);
+ os << "Schedule after control flow fusion:\n" << *schedule_;
}
}
-#endif // DEBUG
-
-
-// Compute the special reverse-post-order block ordering, which is essentially
-// a RPO of the graph where loop bodies are contiguous. Properties:
-// 1. If block A is a predecessor of B, then A appears before B in the order,
-// unless B is a loop header and A is in the loop headed at B
-// (i.e. A -> B is a backedge).
-// => If block A dominates block B, then A appears before B in the order.
-// => If block A is a loop header, A appears before all blocks in the loop
-// headed at A.
-// 2. All loops are contiguous in the order (i.e. no intervening blocks that
-// do not belong to the loop.)
-// Note a simple RPO traversal satisfies (1) but not (3).
-BasicBlockVector* Scheduler::ComputeSpecialRPO(Schedule* schedule) {
- Zone tmp_zone(schedule->zone()->isolate());
- Zone* zone = &tmp_zone;
- Trace("------------- COMPUTING SPECIAL RPO ---------------\n");
- // RPO should not have been computed for this schedule yet.
- CHECK_EQ(kBlockUnvisited1, schedule->start()->rpo_number_);
- CHECK_EQ(0, static_cast<int>(schedule->rpo_order_.size()));
-
- // Perform an iterative RPO traversal using an explicit stack,
- // recording backedges that form cycles. O(|B|).
- ZoneList<std::pair<BasicBlock*, int> > backedges(1, zone);
- SpecialRPOStackFrame* stack =
- zone->NewArray<SpecialRPOStackFrame>(schedule->BasicBlockCount());
- BasicBlock* entry = schedule->start();
- BlockList* order = NULL;
- int stack_depth = Push(stack, 0, entry, kBlockUnvisited1);
- int num_loops = 0;
-
- while (stack_depth > 0) {
- int current = stack_depth - 1;
- SpecialRPOStackFrame* frame = stack + current;
-
- if (frame->index < frame->block->SuccessorCount()) {
- // Process the next successor.
- BasicBlock* succ = frame->block->SuccessorAt(frame->index++);
- if (succ->rpo_number_ == kBlockVisited1) continue;
- if (succ->rpo_number_ == kBlockOnStack) {
- // The successor is on the stack, so this is a backedge (cycle).
- backedges.Add(
- std::pair<BasicBlock*, int>(frame->block, frame->index - 1), zone);
- if (succ->loop_end_ < 0) {
- // Assign a new loop number to the header if it doesn't have one.
- succ->loop_end_ = num_loops++;
- }
- } else {
- // Push the successor onto the stack.
- DCHECK(succ->rpo_number_ == kBlockUnvisited1);
- stack_depth = Push(stack, stack_depth, succ, kBlockUnvisited1);
- }
- } else {
- // Finished with all successors; pop the stack and add the block.
- order = order->Add(zone, frame->block);
- frame->block->rpo_number_ = kBlockVisited1;
- stack_depth--;
- }
- }
-
- // If no loops were encountered, then the order we computed was correct.
- LoopInfo* loops = NULL;
- if (num_loops != 0) {
- // Otherwise, compute the loop information from the backedges in order
- // to perform a traversal that groups loop bodies together.
- loops = ComputeLoopInfo(zone, stack, num_loops, schedule->BasicBlockCount(),
- &backedges);
-
- // Initialize the "loop stack". Note the entry could be a loop header.
- LoopInfo* loop = entry->IsLoopHeader() ? &loops[entry->loop_end_] : NULL;
- order = NULL;
-
- // Perform an iterative post-order traversal, visiting loop bodies before
- // edges that lead out of loops. Visits each block once, but linking loop
- // sections together is linear in the loop size, so overall is
- // O(|B| + max(loop_depth) * max(|loop|))
- stack_depth = Push(stack, 0, entry, kBlockUnvisited2);
- while (stack_depth > 0) {
- SpecialRPOStackFrame* frame = stack + (stack_depth - 1);
- BasicBlock* block = frame->block;
- BasicBlock* succ = NULL;
-
- if (frame->index < block->SuccessorCount()) {
- // Process the next normal successor.
- succ = block->SuccessorAt(frame->index++);
- } else if (block->IsLoopHeader()) {
- // Process additional outgoing edges from the loop header.
- if (block->rpo_number_ == kBlockOnStack) {
- // Finish the loop body the first time the header is left on the
- // stack.
- DCHECK(loop != NULL && loop->header == block);
- loop->start = order->Add(zone, block);
- order = loop->end;
- block->rpo_number_ = kBlockVisited2;
- // Pop the loop stack and continue visiting outgoing edges within the
- // the context of the outer loop, if any.
- loop = loop->prev;
- // We leave the loop header on the stack; the rest of this iteration
- // and later iterations will go through its outgoing edges list.
- }
- // Use the next outgoing edge if there are any.
- int outgoing_index = frame->index - block->SuccessorCount();
- LoopInfo* info = &loops[block->loop_end_];
- DCHECK(loop != info);
- if (info->outgoing != NULL &&
- outgoing_index < info->outgoing->length()) {
- succ = info->outgoing->at(outgoing_index);
- frame->index++;
- }
- }
- if (succ != NULL) {
- // Process the next successor.
- if (succ->rpo_number_ == kBlockOnStack) continue;
- if (succ->rpo_number_ == kBlockVisited2) continue;
- DCHECK(succ->rpo_number_ == kBlockUnvisited2);
- if (loop != NULL && !loop->members->Contains(succ->id())) {
- // The successor is not in the current loop or any nested loop.
- // Add it to the outgoing edges of this loop and visit it later.
- loop->AddOutgoing(zone, succ);
- } else {
- // Push the successor onto the stack.
- stack_depth = Push(stack, stack_depth, succ, kBlockUnvisited2);
- if (succ->IsLoopHeader()) {
- // Push the inner loop onto the loop stack.
- DCHECK(succ->loop_end_ >= 0 && succ->loop_end_ < num_loops);
- LoopInfo* next = &loops[succ->loop_end_];
- next->end = order;
- next->prev = loop;
- loop = next;
- }
- }
- } else {
- // Finished with all successors of the current block.
- if (block->IsLoopHeader()) {
- // If we are going to pop a loop header, then add its entire body.
- LoopInfo* info = &loops[block->loop_end_];
- for (BlockList* l = info->start; true; l = l->next) {
- if (l->next == info->end) {
- l->next = order;
- info->end = order;
- break;
- }
- }
- order = info->start;
- } else {
- // Pop a single node off the stack and add it to the order.
- order = order->Add(zone, block);
- block->rpo_number_ = kBlockVisited2;
- }
- stack_depth--;
- }
- }
+void Scheduler::MovePlannedNodes(BasicBlock* from, BasicBlock* to) {
+ Trace("Move planned nodes from B%d to B%d\n", from->id().ToInt(),
+ to->id().ToInt());
+ NodeVector* nodes = &(scheduled_nodes_[from->id().ToSize()]);
+ for (NodeVectorIter i = nodes->begin(); i != nodes->end(); ++i) {
+ schedule_->SetBlockForNode(to, *i);
+ scheduled_nodes_[to->id().ToSize()].push_back(*i);
}
-
- // Construct the final order from the list.
- BasicBlockVector* final_order = &schedule->rpo_order_;
- order->Serialize(final_order);
-
- // Compute the correct loop header for every block and set the correct loop
- // ends.
- LoopInfo* current_loop = NULL;
- BasicBlock* current_header = NULL;
- int loop_depth = 0;
- for (BasicBlockVectorIter i = final_order->begin(); i != final_order->end();
- ++i) {
- BasicBlock* current = *i;
- current->loop_header_ = current_header;
- if (current->IsLoopHeader()) {
- loop_depth++;
- current_loop = &loops[current->loop_end_];
- BlockList* end = current_loop->end;
- current->loop_end_ = end == NULL ? static_cast<int>(final_order->size())
- : end->block->rpo_number_;
- current_header = current_loop->header;
- Trace("B%d is a loop header, increment loop depth to %d\n", current->id(),
- loop_depth);
- } else {
- while (current_header != NULL &&
- current->rpo_number_ >= current_header->loop_end_) {
- DCHECK(current_header->IsLoopHeader());
- DCHECK(current_loop != NULL);
- current_loop = current_loop->prev;
- current_header = current_loop == NULL ? NULL : current_loop->header;
- --loop_depth;
- }
- }
- current->loop_depth_ = loop_depth;
- if (current->loop_header_ == NULL) {
- Trace("B%d is not in a loop (depth == %d)\n", current->id(),
- current->loop_depth_);
- } else {
- Trace("B%d has loop header B%d, (depth == %d)\n", current->id(),
- current->loop_header_->id(), current->loop_depth_);
- }
- }
-
-#if DEBUG
- if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
- VerifySpecialRPO(num_loops, loops, final_order);
-#endif
- return final_order;
-}
+ nodes->clear();
}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#include "src/compiler/opcodes.h"
#include "src/compiler/schedule.h"
+#include "src/compiler/zone-pool.h"
#include "src/zone-containers.h"
namespace v8 {
namespace internal {
namespace compiler {
+class SpecialRPONumberer;
+
// Computes a schedule from a graph, placing nodes into basic blocks and
// ordering the basic blocks in the special RPO order.
class Scheduler {
public:
- // The complete scheduling algorithm.
- // Create a new schedule and place all nodes from the graph into it.
- static Schedule* ComputeSchedule(Graph* graph);
+ // The complete scheduling algorithm. Creates a new schedule and places all
+ // nodes from the graph into it.
+ static Schedule* ComputeSchedule(ZonePool* zone_pool, Graph* graph);
// Compute the RPO of blocks in an existing schedule.
- static BasicBlockVector* ComputeSpecialRPO(Schedule* schedule);
-
- // (Exposed for testing only)
- // Build and connect the CFG for a node graph, but don't schedule nodes.
- static void ComputeCFG(Graph* graph, Schedule* schedule);
+ static BasicBlockVector* ComputeSpecialRPO(ZonePool* zone_pool,
+ Schedule* schedule);
private:
- enum Placement { kUnknown, kSchedulable, kFixed };
+ // Placement of a node changes during scheduling. The placement state
+ // transitions over time while the scheduler is choosing a position:
+ //
+ // +---------------------+-----+----> kFixed
+ // / / /
+ // kUnknown ----+------> kCoupled ----+ /
+ // \ /
+ // +----> kSchedulable ----+--------> kScheduled
+ //
+ // 1) GetPlacement(): kUnknown -> kCoupled|kSchedulable|kFixed
+ // 2) UpdatePlacement(): kCoupled|kSchedulable -> kFixed|kScheduled
+ enum Placement { kUnknown, kSchedulable, kFixed, kCoupled, kScheduled };
// Per-node data tracked during scheduling.
struct SchedulerData {
+ BasicBlock* minimum_block_; // Minimum legal RPO placement.
int unscheduled_count_; // Number of unscheduled uses of this node.
- int minimum_rpo_; // Minimum legal RPO placement.
bool is_connected_control_; // {true} if control-connected to the end node.
bool is_floating_control_; // {true} if control, but not control-connected
// to the end node.
- Placement placement_ : 3; // Whether the node is fixed, schedulable,
- // or not yet known.
+ Placement placement_; // Whether the node is fixed, schedulable,
+ // coupled to another node, or not yet known.
};
Zone* zone_;
Graph* graph_;
Schedule* schedule_;
- NodeVectorVector scheduled_nodes_;
- NodeVector schedule_root_nodes_;
- ZoneVector<SchedulerData> node_data_;
- bool has_floating_control_;
+ NodeVectorVector scheduled_nodes_; // Per-block list of nodes in reverse.
+ NodeVector schedule_root_nodes_; // Fixed root nodes seed the worklist.
+ ZoneQueue<Node*> schedule_queue_; // Worklist of schedulable nodes.
+ ZoneVector<SchedulerData> node_data_; // Per-node data for all nodes.
+ SpecialRPONumberer* special_rpo_; // Special RPO numbering of blocks.
Scheduler(Zone* zone, Graph* graph, Schedule* schedule);
- SchedulerData DefaultSchedulerData();
-
- SchedulerData* GetData(Node* node) {
- DCHECK(node->id() < static_cast<int>(node_data_.size()));
- return &node_data_[node->id()];
- }
-
- void BuildCFG();
+ inline SchedulerData DefaultSchedulerData();
+ inline SchedulerData* GetData(Node* node);
Placement GetPlacement(Node* node);
+ void UpdatePlacement(Node* node, Placement placement);
- int GetRPONumber(BasicBlock* block) {
- DCHECK(block->rpo_number_ >= 0 &&
- block->rpo_number_ < static_cast<int>(schedule_->rpo_order_.size()));
- DCHECK(schedule_->rpo_order_[block->rpo_number_] == block);
- return block->rpo_number_;
- }
+ inline bool IsCoupledControlEdge(Node* node, int index);
+ void IncrementUnscheduledUseCount(Node* node, int index, Node* from);
+ void DecrementUnscheduledUseCount(Node* node, int index, Node* from);
- void GenerateImmediateDominatorTree();
BasicBlock* GetCommonDominator(BasicBlock* b1, BasicBlock* b2);
+ // Phase 1: Build control-flow graph.
friend class CFGBuilder;
+ void BuildCFG();
- friend class ScheduleEarlyNodeVisitor;
- void ScheduleEarly();
+ // Phase 2: Compute special RPO and dominator tree.
+ friend class SpecialRPONumberer;
+ void ComputeSpecialRPONumbering();
+ void GenerateImmediateDominatorTree();
+ // Phase 3: Prepare use counts for nodes.
friend class PrepareUsesVisitor;
void PrepareUses();
+ // Phase 4: Schedule nodes early.
+ friend class ScheduleEarlyNodeVisitor;
+ void ScheduleEarly();
+
+ // Phase 5: Schedule nodes late.
friend class ScheduleLateNodeVisitor;
void ScheduleLate();
- bool ConnectFloatingControl();
+ // Phase 6: Seal the final schedule.
+ void SealFinalSchedule();
- void ConnectFloatingControlSubgraph(BasicBlock* block, Node* node);
+ void FuseFloatingControl(BasicBlock* block, Node* node);
+ void MovePlannedNodes(BasicBlock* from, BasicBlock* to);
};
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_SCHEDULER_H_
--- /dev/null
+// 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/select-lowering.h"
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/diamond.h"
+#include "src/compiler/generic-node-inl.h"
+#include "src/compiler/graph.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+SelectLowering::SelectLowering(Graph* graph, CommonOperatorBuilder* common)
+ : common_(common),
+ graph_(graph),
+ merges_(Merges::key_compare(), Merges::allocator_type(graph->zone())) {}
+
+
+SelectLowering::~SelectLowering() {}
+
+
+Reduction SelectLowering::Reduce(Node* node) {
+ if (node->opcode() != IrOpcode::kSelect) return NoChange();
+ SelectParameters const p = SelectParametersOf(node->op());
+
+ Node* const cond = node->InputAt(0);
+
+ // Check if we already have a diamond for this condition.
+ auto i = merges_.find(cond);
+ if (i == merges_.end()) {
+ // Create a new diamond for this condition and remember its merge node.
+ Diamond d(graph(), common(), cond, p.hint());
+ i = merges_.insert(std::make_pair(cond, d.merge)).first;
+ }
+
+ DCHECK_EQ(cond, i->first);
+
+ // Create a Phi hanging off the previously determined merge.
+ node->set_op(common()->Phi(p.type(), 2));
+ node->ReplaceInput(0, node->InputAt(1));
+ node->ReplaceInput(1, node->InputAt(2));
+ node->ReplaceInput(2, i->second);
+ return Changed(node);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_SELECT_LOWERING_H_
+#define V8_COMPILER_SELECT_LOWERING_H_
+
+#include <map>
+
+#include "src/compiler/graph-reducer.h"
+#include "src/zone-allocator.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// Forward declarations.
+class CommonOperatorBuilder;
+class Graph;
+
+
+// Lowers Select nodes to diamonds.
+class SelectLowering FINAL : public Reducer {
+ public:
+ SelectLowering(Graph* graph, CommonOperatorBuilder* common);
+ ~SelectLowering();
+
+ Reduction Reduce(Node* node) OVERRIDE;
+
+ private:
+ typedef std::map<Node*, Node*, std::less<Node*>,
+ zone_allocator<std::pair<Node* const, Node*>>> Merges;
+
+ CommonOperatorBuilder* common() const { return common_; }
+ Graph* graph() const { return graph_; }
+
+ CommonOperatorBuilder* common_;
+ Graph* graph_;
+ Merges merges_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_SELECT_LOWERING_H_
#include "src/compiler/simplified-lowering.h"
+#include <limits>
+
#include "src/base/bits.h"
#include "src/code-factory.h"
#include "src/compiler/common-operator.h"
+#include "src/compiler/diamond.h"
#include "src/compiler/graph-inl.h"
+#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/representation-change.h"
#include "src/compiler/simplified-lowering.h"
changer_(changer),
queue_(zone) {
memset(info_, 0, sizeof(NodeInfo) * count_);
+
+ Factory* f = zone->isolate()->factory();
+ safe_int_additive_range_ =
+ Type::Range(f->NewNumber(-std::pow(2.0, 52.0)),
+ f->NewNumber(std::pow(2.0, 52.0)), zone);
}
void Run(SimplifiedLowering* lowering) {
NodeProperties::GetBounds(node->InputAt(1)).upper->Is(type);
}
+ void ProcessTruncateWord32Input(Node* node, int index, MachineTypeUnion use) {
+ Node* input = node->InputAt(index);
+ if (phase_ == PROPAGATE) {
+ // In the propagate phase, propagate the usage information backward.
+ Enqueue(input, use);
+ } else {
+ // In the change phase, insert a change before the use if necessary.
+ MachineTypeUnion output = GetInfo(input)->output;
+ if ((output & kRepWord32) == 0) {
+ // Output representation doesn't match usage.
+ TRACE((" truncate-to-int32: #%d:%s(@%d #%d:%s) ", node->id(),
+ node->op()->mnemonic(), index, input->id(),
+ input->op()->mnemonic()));
+ TRACE((" from "));
+ PrintInfo(output);
+ TRACE((" to "));
+ PrintInfo(use);
+ TRACE(("\n"));
+ Node* n = changer_->GetTruncatedWord32For(input, output);
+ node->ReplaceInput(index, n);
+ }
+ }
+ }
+
void ProcessInput(Node* node, int index, MachineTypeUnion use) {
Node* input = node->InputAt(index);
if (phase_ == PROPAGATE) {
// {kRepTagged} representation and can observe all output values {kTypeAny}.
void VisitInputs(Node* node) {
InputIter i = node->inputs().begin();
- for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
- ++i, j--) {
+ for (int j = node->op()->ValueInputCount(); j > 0; ++i, j--) {
ProcessInput(node, i.index(), kMachAnyTagged); // Value inputs
}
for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
++i, j--) {
ProcessInput(node, i.index(), kMachAnyTagged); // Context inputs
}
- for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
- ++i, j--) {
+ for (int j = node->op()->EffectInputCount(); j > 0; ++i, j--) {
Enqueue(*i); // Effect inputs: just visit
}
- for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
- ++i, j--) {
+ for (int j = node->op()->ControlInputCount(); j > 0; ++i, j--) {
Enqueue(*i); // Control inputs: just visit
}
SetOutput(node, kMachAnyTagged);
void VisitInt64Cmp(Node* node) { VisitBinop(node, kMachInt64, kRepBit); }
void VisitUint64Cmp(Node* node) { VisitBinop(node, kMachUint64, kRepBit); }
- // Helper for handling phis.
- void VisitPhi(Node* node, MachineTypeUnion use,
- SimplifiedLowering* lowering) {
- // First, propagate the usage information to inputs of the phi.
- if (!lower()) {
- int values = OperatorProperties::GetValueInputCount(node->op());
- // Propagate {use} of the phi to value inputs, and 0 to control.
- Node::Inputs inputs = node->inputs();
- for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
- ++iter, --values) {
- // TODO(titzer): it'd be nice to have distinguished edge kinds here.
- ProcessInput(node, iter.index(), values > 0 ? use : 0);
- }
- }
- // Phis adapt to whatever output representation their uses demand,
- // pushing representation changes to their inputs.
- MachineTypeUnion use_rep = GetUseInfo(node) & kRepMask;
- MachineTypeUnion use_type = GetUseInfo(node) & kTypeMask;
- MachineTypeUnion rep = 0;
- if (use_rep & kRepTagged) {
- rep = kRepTagged; // Tagged overrides everything.
- } else if (use_rep & kRepFloat32) {
- rep = kRepFloat32;
- } else if (use_rep & kRepFloat64) {
- rep = kRepFloat64;
- } else if (use_rep & kRepWord64) {
- rep = kRepWord64;
- } else if (use_rep & kRepWord32) {
- rep = kRepWord32;
- } else if (use_rep & kRepBit) {
- rep = kRepBit;
- } else {
- // There was no representation associated with any of the uses.
- // TODO(titzer): Select the best rep using phi's type, not the usage type?
- if (use_type & kTypeAny) {
- rep = kRepTagged;
- } else if (use_type & kTypeNumber) {
- rep = kRepFloat64;
- } else if (use_type & kTypeInt64 || use_type & kTypeUint64) {
- rep = kRepWord64;
- } else if (use_type & kTypeInt32 || use_type & kTypeUint32) {
- rep = kRepWord32;
- } else if (use_type & kTypeBool) {
- rep = kRepBit;
+ // Infer representation for phi-like nodes.
+ MachineType GetRepresentationForPhi(Node* node, MachineTypeUnion use) {
+ // Phis adapt to the output representation their uses demand.
+ Type* upper = NodeProperties::GetBounds(node).upper;
+ if ((use & kRepMask) == kRepTagged) {
+ // only tagged uses.
+ return kRepTagged;
+ } else if (IsSafeIntAdditiveOperand(node)) {
+ // Integer within [-2^52, 2^52] range.
+ if ((use & kRepMask) == kRepFloat64) {
+ // only float64 uses.
+ return kRepFloat64;
+ } else if (upper->Is(Type::Signed32()) || upper->Is(Type::Unsigned32())) {
+ // multiple uses, but we are within 32 bits range => pick kRepWord32.
+ return kRepWord32;
+ } else if ((use & kRepMask) == kRepWord32 ||
+ (use & kTypeMask) == kTypeInt32 ||
+ (use & kTypeMask) == kTypeUint32) {
+ // The type is a safe integer, but we only use 32 bits.
+ return kRepWord32;
} else {
- UNREACHABLE(); // should have at least a usage type!
+ return kRepFloat64;
}
+ } else if (upper->Is(Type::Boolean())) {
+ // multiple uses => pick kRepBit.
+ return kRepBit;
+ } else if (upper->Is(Type::Number())) {
+ // multiple uses => pick kRepFloat64.
+ return kRepFloat64;
}
- // Preserve the usage type, but set the representation.
+ return kRepTagged;
+ }
+
+ // Helper for handling selects.
+ void VisitSelect(Node* node, MachineTypeUnion use,
+ SimplifiedLowering* lowering) {
+ ProcessInput(node, 0, kRepBit);
+ MachineType output = GetRepresentationForPhi(node, use);
+
Type* upper = NodeProperties::GetBounds(node).upper;
- MachineTypeUnion output_type = rep | changer_->TypeFromUpperBound(upper);
+ MachineType output_type =
+ static_cast<MachineType>(changer_->TypeFromUpperBound(upper) | output);
SetOutput(node, output_type);
if (lower()) {
- int values = OperatorProperties::GetValueInputCount(node->op());
+ // Update the select operator.
+ SelectParameters p = SelectParametersOf(node->op());
+ MachineType type = static_cast<MachineType>(output_type);
+ if (type != p.type()) {
+ node->set_op(lowering->common()->Select(type, p.hint()));
+ }
+ // Convert inputs to the output representation of this select.
+ ProcessInput(node, 1, output_type);
+ ProcessInput(node, 2, output_type);
+ } else {
+ // Propagate {use} of the select to value inputs.
+ MachineType use_type =
+ static_cast<MachineType>((use & kTypeMask) | output);
+ ProcessInput(node, 1, use_type);
+ ProcessInput(node, 2, use_type);
+ }
+ }
+
+ // Helper for handling phis.
+ void VisitPhi(Node* node, MachineTypeUnion use,
+ SimplifiedLowering* lowering) {
+ MachineType output = GetRepresentationForPhi(node, use);
+
+ Type* upper = NodeProperties::GetBounds(node).upper;
+ MachineType output_type =
+ static_cast<MachineType>(changer_->TypeFromUpperBound(upper) | output);
+ SetOutput(node, output_type);
+
+ int values = node->op()->ValueInputCount();
+
+ if (lower()) {
// Update the phi operator.
MachineType type = static_cast<MachineType>(output_type);
if (type != OpParameter<MachineType>(node)) {
// TODO(titzer): it'd be nice to have distinguished edge kinds here.
ProcessInput(node, iter.index(), values > 0 ? output_type : 0);
}
+ } else {
+ // Propagate {use} of the phi to value inputs, and 0 to control.
+ Node::Inputs inputs = node->inputs();
+ MachineType use_type =
+ static_cast<MachineType>((use & kTypeMask) | output);
+ for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
+ ++iter, --values) {
+ // TODO(titzer): it'd be nice to have distinguished edge kinds here.
+ ProcessInput(node, iter.index(), values > 0 ? use_type : 0);
+ }
}
}
return changer_->Float64OperatorFor(node->opcode());
}
+ bool CanLowerToInt32Binop(Node* node, MachineTypeUnion use) {
+ return BothInputsAre(node, Type::Signed32()) && !CanObserveNonInt32(use);
+ }
+
+ bool IsSafeIntAdditiveOperand(Node* node) {
+ Type* type = NodeProperties::GetBounds(node).upper;
+ // TODO(jarin): Unfortunately, bitset types are not subtypes of larger
+ // range types, so we have to explicitly check for Integral32 here
+ // (in addition to the safe integer range). Once we fix subtyping for
+ // ranges, we should simplify this.
+ return type->Is(safe_int_additive_range_) || type->Is(Type::Integral32());
+ }
+
+ bool CanLowerToInt32AdditiveBinop(Node* node, MachineTypeUnion use) {
+ return IsSafeIntAdditiveOperand(node->InputAt(0)) &&
+ IsSafeIntAdditiveOperand(node->InputAt(1)) &&
+ !CanObserveNonInt32(use);
+ }
+
+ bool CanLowerToUint32Binop(Node* node, MachineTypeUnion use) {
+ return BothInputsAre(node, Type::Unsigned32()) && !CanObserveNonUint32(use);
+ }
+
+ bool CanLowerToUint32AdditiveBinop(Node* node, MachineTypeUnion use) {
+ return IsSafeIntAdditiveOperand(node->InputAt(0)) &&
+ IsSafeIntAdditiveOperand(node->InputAt(1)) &&
+ !CanObserveNonUint32(use);
+ }
+
+ bool CanObserveNonInt32(MachineTypeUnion use) {
+ return (use & (kTypeUint32 | kTypeNumber | kTypeAny)) != 0;
+ }
+
+ bool CanObserveMinusZero(MachineTypeUnion use) {
+ // TODO(turbofan): technically Uint32 cannot observe minus zero either.
+ return (use & (kTypeUint32 | kTypeNumber | kTypeAny)) != 0;
+ }
+
+ bool CanObserveNaN(MachineTypeUnion use) {
+ return (use & (kTypeNumber | kTypeAny)) != 0;
+ }
+
+ bool CanObserveNonUint32(MachineTypeUnion use) {
+ return (use & (kTypeInt32 | kTypeNumber | kTypeAny)) != 0;
+ }
+
// Dispatching routine for visiting the node {node} with the usage {use}.
// Depending on the operator, propagate new usage info to the inputs.
void VisitNode(Node* node, MachineTypeUnion use,
ProcessInput(node, 0, kRepBit);
Enqueue(NodeProperties::GetControlInput(node, 0));
break;
+ case IrOpcode::kSelect:
+ return VisitSelect(node, use, lowering);
case IrOpcode::kPhi:
return VisitPhi(node, use, lowering);
if (lower()) {
MachineTypeUnion input = GetInfo(node->InputAt(0))->output;
if (input & kRepBit) {
- // BooleanNot(x: kRepBit) => WordEqual(x, #0)
- node->set_op(lowering->machine()->WordEqual());
+ // BooleanNot(x: kRepBit) => Word32Equal(x, #0)
+ node->set_op(lowering->machine()->Word32Equal());
node->AppendInput(jsgraph_->zone(), jsgraph_->Int32Constant(0));
} else {
// BooleanNot(x: kRepTagged) => WordEqual(x, #false)
case IrOpcode::kNumberSubtract: {
// Add and subtract reduce to Int32Add/Sub if the inputs
// are already integers and all uses are truncating.
- if (BothInputsAre(node, Type::Signed32()) &&
- (use & (kTypeUint32 | kTypeNumber | kTypeAny)) == 0) {
+ if (CanLowerToInt32Binop(node, use)) {
// => signed Int32Add/Sub
VisitInt32Binop(node);
if (lower()) node->set_op(Int32Op(node));
- } else if (BothInputsAre(node, Type::Unsigned32()) &&
- (use & (kTypeInt32 | kTypeNumber | kTypeAny)) == 0) {
+ } else if (CanLowerToInt32AdditiveBinop(node, use)) {
+ // => signed Int32Add/Sub, truncating inputs
+ ProcessTruncateWord32Input(node, 0, kTypeInt32);
+ ProcessTruncateWord32Input(node, 1, kTypeInt32);
+ SetOutput(node, kMachInt32);
+ if (lower()) node->set_op(Int32Op(node));
+ } else if (CanLowerToUint32Binop(node, use)) {
// => unsigned Int32Add/Sub
VisitUint32Binop(node);
if (lower()) node->set_op(Uint32Op(node));
+ } else if (CanLowerToUint32AdditiveBinop(node, use)) {
+ // => signed Int32Add/Sub, truncating inputs
+ ProcessTruncateWord32Input(node, 0, kTypeUint32);
+ ProcessTruncateWord32Input(node, 1, kTypeUint32);
+ SetOutput(node, kMachUint32);
+ if (lower()) node->set_op(Uint32Op(node));
} else {
// => Float64Add/Sub
VisitFloat64Binop(node);
}
break;
}
- case IrOpcode::kNumberMultiply:
- case IrOpcode::kNumberDivide:
+ case IrOpcode::kNumberMultiply: {
+ NumberMatcher right(node->InputAt(1));
+ if (right.IsInRange(-1048576, 1048576)) { // must fit double mantissa.
+ if (CanLowerToInt32Binop(node, use)) {
+ // => signed Int32Mul
+ VisitInt32Binop(node);
+ if (lower()) node->set_op(Int32Op(node));
+ break;
+ }
+ }
+ // => Float64Mul
+ VisitFloat64Binop(node);
+ if (lower()) node->set_op(Float64Op(node));
+ break;
+ }
+ case IrOpcode::kNumberDivide: {
+ if (CanLowerToInt32Binop(node, use)) {
+ // => signed Int32Div
+ VisitInt32Binop(node);
+ if (lower()) DeferReplacement(node, lowering->Int32Div(node));
+ break;
+ }
+ if (BothInputsAre(node, Type::Unsigned32()) && !CanObserveNaN(use)) {
+ // => unsigned Uint32Div
+ VisitUint32Binop(node);
+ if (lower()) DeferReplacement(node, lowering->Uint32Div(node));
+ break;
+ }
+ // => Float64Div
+ VisitFloat64Binop(node);
+ if (lower()) node->set_op(Float64Op(node));
+ break;
+ }
case IrOpcode::kNumberModulus: {
- // Float64Mul/Div/Mod
+ if (CanLowerToInt32Binop(node, use)) {
+ // => signed Int32Mod
+ VisitInt32Binop(node);
+ if (lower()) DeferReplacement(node, lowering->Int32Mod(node));
+ break;
+ }
+ if (BothInputsAre(node, Type::Unsigned32()) && !CanObserveNaN(use)) {
+ // => unsigned Uint32Mod
+ VisitUint32Binop(node);
+ if (lower()) DeferReplacement(node, lowering->Uint32Mod(node));
+ break;
+ }
+ // => Float64Mod
VisitFloat64Binop(node);
if (lower()) node->set_op(Float64Op(node));
break;
}
case IrOpcode::kNumberToInt32: {
MachineTypeUnion use_rep = use & kRepMask;
- if (lower()) {
- MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
- if ((in & kTypeMask) == kTypeInt32 || (in & kRepMask) == kRepWord32) {
- // If the input has type int32, or is already a word32, just change
- // representation if necessary.
- VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | use_rep);
- DeferReplacement(node, node->InputAt(0));
- } else {
- // Require the input in float64 format and perform truncation.
- // TODO(turbofan): avoid a truncation with a smi check.
- VisitUnop(node, kTypeInt32 | kRepFloat64, kTypeInt32 | kRepWord32);
- node->set_op(lowering->machine()->TruncateFloat64ToInt32());
- }
+ Node* input = node->InputAt(0);
+ Type* in_upper = NodeProperties::GetBounds(input).upper;
+ MachineTypeUnion in = GetInfo(input)->output;
+ if (in_upper->Is(Type::Signed32())) {
+ // If the input has type int32, pass through representation.
+ VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | use_rep);
+ if (lower()) DeferReplacement(node, node->InputAt(0));
+ } else if ((in & kTypeMask) == kTypeUint32 ||
+ (in & kTypeMask) == kTypeInt32 ||
+ in_upper->Is(Type::Unsigned32()) ||
+ (in & kRepMask) == kRepWord32) {
+ // Just change representation if necessary.
+ VisitUnop(node, kTypeInt32 | kRepWord32, kTypeInt32 | kRepWord32);
+ if (lower()) DeferReplacement(node, node->InputAt(0));
} else {
- // Propagate a type to the input, but pass through representation.
- VisitUnop(node, kTypeInt32, kTypeInt32 | use_rep);
+ // Require the input in float64 format and perform truncation.
+ // TODO(turbofan): avoid a truncation with a smi check.
+ VisitUnop(node, kTypeInt32 | kRepFloat64, kTypeInt32 | kRepWord32);
+ if (lower())
+ node->set_op(lowering->machine()->TruncateFloat64ToInt32());
}
break;
}
case IrOpcode::kNumberToUint32: {
MachineTypeUnion use_rep = use & kRepMask;
- if (lower()) {
- MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
- if ((in & kTypeMask) == kTypeUint32 ||
- (in & kRepMask) == kRepWord32) {
- // The input has type int32, just change representation.
- VisitUnop(node, kTypeUint32 | use_rep, kTypeUint32 | use_rep);
- DeferReplacement(node, node->InputAt(0));
- } else {
- // Require the input in float64 format to perform truncation.
- // TODO(turbofan): avoid the truncation with a smi check.
- VisitUnop(node, kTypeUint32 | kRepFloat64,
- kTypeUint32 | kRepWord32);
- node->set_op(lowering->machine()->TruncateFloat64ToInt32());
- }
+ Node* input = node->InputAt(0);
+ Type* in_upper = NodeProperties::GetBounds(input).upper;
+ MachineTypeUnion in = GetInfo(input)->output;
+ if (in_upper->Is(Type::Unsigned32())) {
+ // If the input has type uint32, pass through representation.
+ VisitUnop(node, kTypeUint32 | use_rep, kTypeUint32 | use_rep);
+ if (lower()) DeferReplacement(node, node->InputAt(0));
+ } else if ((in & kTypeMask) == kTypeUint32 ||
+ (in & kTypeMask) == kTypeInt32 ||
+ in_upper->Is(Type::Signed32()) ||
+ (in & kRepMask) == kRepWord32) {
+ // Just change representation if necessary.
+ VisitUnop(node, kTypeUint32 | kRepWord32, kTypeUint32 | kRepWord32);
+ if (lower()) DeferReplacement(node, node->InputAt(0));
} else {
- // Propagate a type to the input, but pass through representation.
- VisitUnop(node, kTypeUint32, kTypeUint32 | use_rep);
+ // Require the input in float64 format and perform truncation.
+ // TODO(turbofan): avoid a truncation with a smi check.
+ VisitUnop(node, kTypeUint32 | kRepFloat64, kTypeUint32 | kRepWord32);
+ if (lower())
+ node->set_op(lowering->machine()->TruncateFloat64ToInt32());
}
break;
}
ProcessInput(node, 1, kMachInt32); // element index
ProcessInput(node, 2, kMachInt32); // length
ProcessRemainingInputs(node, 3);
- SetOutput(node, access.machine_type);
- if (lower()) lowering->DoLoadElement(node);
+ // Tagged overrides everything if we have to do a typed array bounds
+ // check, because we may need to return undefined then.
+ MachineType output_type =
+ (access.bounds_check == kTypedArrayBoundsCheck &&
+ (use & kRepTagged))
+ ? kMachAnyTagged
+ : access.machine_type;
+ SetOutput(node, output_type);
+ if (lower()) lowering->DoLoadElement(node, output_type);
break;
}
case IrOpcode::kStoreElement: {
if (lower()) lowering->DoStoreElement(node);
break;
}
+ case IrOpcode::kObjectIsSmi: {
+ ProcessInput(node, 0, kMachAnyTagged);
+ SetOutput(node, kRepBit | kTypeBool);
+ if (lower()) {
+ Node* is_tagged = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->WordAnd(), node->InputAt(0),
+ jsgraph_->Int32Constant(static_cast<int>(kSmiTagMask)));
+ Node* is_smi = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->WordEqual(), is_tagged,
+ jsgraph_->Int32Constant(kSmiTag));
+ DeferReplacement(node, is_smi);
+ }
+ break;
+ }
+ case IrOpcode::kObjectIsNonNegativeSmi: {
+ ProcessInput(node, 0, kMachAnyTagged);
+ SetOutput(node, kRepBit | kTypeBool);
+ if (lower()) {
+ Node* is_tagged = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->WordAnd(), node->InputAt(0),
+ jsgraph_->Int32Constant(static_cast<int>(kSmiTagMask)));
+ Node* is_smi = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->WordEqual(), is_tagged,
+ jsgraph_->Int32Constant(kSmiTag));
+ Node* is_non_neg = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->IntLessThanOrEqual(),
+ jsgraph_->Int32Constant(0), node->InputAt(0));
+ Node* is_non_neg_smi = jsgraph_->graph()->NewNode(
+ jsgraph_->machine()->Word32And(), is_smi, is_non_neg);
+ DeferReplacement(node, is_non_neg_smi);
+ }
+ break;
+ }
//------------------------------------------------------------------
// Machine-level operators.
//------------------------------------------------------------------
case IrOpcode::kLoad: {
// TODO(titzer): machine loads/stores need to know BaseTaggedness!?
- MachineType tBase = kRepTagged;
+ MachineTypeUnion tBase = kRepTagged | kMachPtr;
LoadRepresentation rep = OpParameter<LoadRepresentation>(node);
ProcessInput(node, 0, tBase); // pointer or object
ProcessInput(node, 1, kMachInt32); // index
}
case IrOpcode::kStore: {
// TODO(titzer): machine loads/stores need to know BaseTaggedness!?
- MachineType tBase = kRepTagged;
+ MachineTypeUnion tBase = kRepTagged | kMachPtr;
StoreRepresentation rep = OpParameter<StoreRepresentation>(node);
ProcessInput(node, 0, tBase); // pointer or object
ProcessInput(node, 1, kMachInt32); // index
}
case IrOpcode::kWord32Shr:
// We output unsigned int32 for shift right because JavaScript.
- return VisitBinop(node, kRepWord32, kRepWord32 | kTypeUint32);
+ return VisitBinop(node, kMachUint32, kMachUint32);
case IrOpcode::kWord32And:
case IrOpcode::kWord32Or:
case IrOpcode::kWord32Xor:
case IrOpcode::kInt32Add:
case IrOpcode::kInt32Sub:
case IrOpcode::kInt32Mul:
+ case IrOpcode::kInt32MulHigh:
case IrOpcode::kInt32Div:
case IrOpcode::kInt32Mod:
return VisitInt32Binop(node);
- case IrOpcode::kInt32UDiv:
- case IrOpcode::kInt32UMod:
+ case IrOpcode::kUint32Div:
+ case IrOpcode::kUint32Mod:
+ case IrOpcode::kUint32MulHigh:
return VisitUint32Binop(node);
case IrOpcode::kInt32LessThan:
case IrOpcode::kInt32LessThanOrEqual:
case IrOpcode::kInt64LessThanOrEqual:
return VisitInt64Cmp(node);
- case IrOpcode::kInt64UDiv:
- case IrOpcode::kInt64UMod:
+ case IrOpcode::kUint64LessThan:
+ return VisitUint64Cmp(node);
+
+ case IrOpcode::kUint64Div:
+ case IrOpcode::kUint64Mod:
return VisitUint64Binop(node);
case IrOpcode::kWord64And:
case IrOpcode::kFloat64Mod:
return VisitFloat64Binop(node);
case IrOpcode::kFloat64Sqrt:
+ case IrOpcode::kFloat64Floor:
+ case IrOpcode::kFloat64Ceil:
+ case IrOpcode::kFloat64RoundTruncate:
+ case IrOpcode::kFloat64RoundTiesAway:
return VisitUnop(node, kMachFloat64, kMachFloat64);
case IrOpcode::kFloat64Equal:
case IrOpcode::kFloat64LessThan:
case IrOpcode::kFloat64LessThanOrEqual:
return VisitFloat64Cmp(node);
+ case IrOpcode::kLoadStackPointer:
+ return VisitLeaf(node, kMachPtr);
+ case IrOpcode::kStateValues:
+ for (int i = 0; i < node->InputCount(); i++) {
+ ProcessInput(node, i, kTypeAny);
+ }
+ SetOutput(node, kMachAnyTagged);
+ break;
default:
VisitInputs(node);
break;
}
void DeferReplacement(Node* node, Node* replacement) {
+ if (FLAG_trace_representation) {
+ TRACE(("defer replacement #%d:%s with #%d:%s\n", node->id(),
+ node->op()->mnemonic(), replacement->id(),
+ replacement->op()->mnemonic()));
+ }
if (replacement->id() < count_) {
// Replace with a previously existing node eagerly.
node->ReplaceUses(replacement);
Phase phase_; // current phase of algorithm
RepresentationChanger* changer_; // for inserting representation changes
ZoneQueue<Node*> queue_; // queue for traversing the graph
+ Type* safe_int_additive_range_;
NodeInfo* GetInfo(Node* node) {
DCHECK(node->id() >= 0);
void SimplifiedLowering::DoLoadField(Node* node) {
const FieldAccess& access = FieldAccessOf(node->op());
node->set_op(machine()->Load(access.machine_type));
- Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
- node->InsertInput(zone(), 1, offset);
+ Node* offset = jsgraph()->IntPtrConstant(access.offset - access.tag());
+ node->InsertInput(graph()->zone(), 1, offset);
}
access.base_is_tagged, access.machine_type, access.type);
node->set_op(
machine()->Store(StoreRepresentation(access.machine_type, kind)));
- Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
- node->InsertInput(zone(), 1, offset);
+ Node* offset = jsgraph()->IntPtrConstant(access.offset - access.tag());
+ node->InsertInput(graph()->zone(), 1, offset);
}
Node* SimplifiedLowering::ComputeIndex(const ElementAccess& access,
- Node* index) {
- int element_size = ElementSizeOf(access.machine_type);
- if (element_size != 1) {
- index = graph()->NewNode(machine()->Int32Mul(),
- jsgraph()->Int32Constant(element_size), index);
- }
- int fixed_offset = access.header_size - access.tag();
- if (fixed_offset == 0) return index;
- return graph()->NewNode(machine()->Int32Add(), index,
- jsgraph()->Int32Constant(fixed_offset));
+ Node* const key) {
+ Node* index = key;
+ const int element_size_shift = ElementSizeLog2Of(access.machine_type);
+ if (element_size_shift) {
+ index = graph()->NewNode(machine()->Word32Shl(), index,
+ jsgraph()->Int32Constant(element_size_shift));
+ }
+ const int fixed_offset = access.header_size - access.tag();
+ if (fixed_offset) {
+ index = graph()->NewNode(machine()->Int32Add(), index,
+ jsgraph()->Int32Constant(fixed_offset));
+ }
+ if (machine()->Is64()) {
+ // TODO(turbofan): This is probably only correct for typed arrays, and only
+ // if the typed arrays are at most 2GiB in size, which happens to match
+ // exactly our current situation.
+ index = graph()->NewNode(machine()->ChangeUint32ToUint64(), index);
+ }
+ return index;
+}
+
+
+namespace {
+
+intptr_t AddressForOutOfBoundsLoad(MachineType type) {
+ switch (RepresentationOf(type)) {
+ case kRepFloat32: {
+ static const float dummy = std::numeric_limits<float>::quiet_NaN();
+ return bit_cast<intptr_t>(&dummy);
+ }
+ case kRepFloat64: {
+ static const double dummy = std::numeric_limits<double>::quiet_NaN();
+ return bit_cast<intptr_t>(&dummy);
+ }
+ case kRepBit:
+ case kRepWord8:
+ case kRepWord16:
+ case kRepWord32: {
+ static const int32_t dummy = 0;
+ return bit_cast<intptr_t>(&dummy);
+ }
+ default:
+ break;
+ }
+ UNREACHABLE();
+ return 0;
+}
+
+
+intptr_t AddressForOutOfBoundsStore() {
+ static volatile double dummy = 0;
+ return bit_cast<intptr_t>(&dummy);
}
+} // namespace
-void SimplifiedLowering::DoLoadElement(Node* node) {
+
+void SimplifiedLowering::DoLoadElement(Node* node, MachineType output_type) {
const ElementAccess& access = ElementAccessOf(node->op());
- node->set_op(machine()->Load(access.machine_type));
- node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
- node->RemoveInput(2);
+ const Operator* op = machine()->Load(access.machine_type);
+ Node* key = node->InputAt(1);
+ Node* index = ComputeIndex(access, key);
+ Node* effect = node->InputAt(3);
+ if (access.bounds_check == kNoBoundsCheck) {
+ DCHECK_EQ(access.machine_type, output_type);
+ node->set_op(op);
+ node->ReplaceInput(1, index);
+ node->ReplaceInput(2, effect);
+ node->ReplaceInput(3, graph()->start());
+ } else {
+ DCHECK_EQ(kTypedArrayBoundsCheck, access.bounds_check);
+
+ Node* base = node->InputAt(0);
+ Node* length = node->InputAt(2);
+ Node* check = graph()->NewNode(machine()->Uint32LessThan(), key, length);
+
+ IntPtrMatcher mbase(base);
+ if (mbase.HasValue() && (output_type & kRepTagged) == 0) {
+ Node* select = graph()->NewNode(
+ common()->Select(kMachIntPtr, BranchHint::kTrue), check, index,
+ jsgraph()->IntPtrConstant(AddressForOutOfBoundsLoad(output_type) -
+ mbase.Value()));
+
+ node->set_op(op);
+ node->ReplaceInput(1, select);
+ node->ReplaceInput(2, effect);
+ node->ReplaceInput(3, graph()->start());
+ } else {
+ Diamond d(graph(), common(), check, BranchHint::kTrue);
+
+ Node* load = graph()->NewNode(op, base, index, effect, d.if_true);
+ Node* result = load;
+ if (output_type & kRepTagged) {
+ // TODO(turbofan): This is ugly as hell!
+ SimplifiedOperatorBuilder simplified(graph()->zone());
+ RepresentationChanger changer(jsgraph(), &simplified,
+ graph()->zone()->isolate());
+ result =
+ changer.GetTaggedRepresentationFor(result, access.machine_type);
+ }
+
+ Node* undefined;
+ if (output_type & kRepTagged) {
+ DCHECK_EQ(0, access.machine_type & kRepTagged);
+ undefined = jsgraph()->UndefinedConstant();
+ } else if (output_type & kRepFloat32) {
+ undefined =
+ jsgraph()->Float32Constant(std::numeric_limits<float>::quiet_NaN());
+ } else if (output_type & kRepFloat64) {
+ undefined = jsgraph()->Float64Constant(
+ std::numeric_limits<double>::quiet_NaN());
+ } else {
+ undefined = jsgraph()->Int32Constant(0);
+ }
+
+ // Replace effect uses of node with the effect phi.
+ NodeProperties::ReplaceWithValue(node, node, d.EffectPhi(load, effect));
+
+ d.OverwriteWithPhi(node, output_type, result, undefined);
+ }
+ }
}
void SimplifiedLowering::DoStoreElement(Node* node) {
const ElementAccess& access = ElementAccessOf(node->op());
- WriteBarrierKind kind = ComputeWriteBarrierKind(
- access.base_is_tagged, access.machine_type, access.type);
- node->set_op(
- machine()->Store(StoreRepresentation(access.machine_type, kind)));
- node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
- node->RemoveInput(2);
+ const Operator* op = machine()->Store(StoreRepresentation(
+ access.machine_type,
+ ComputeWriteBarrierKind(access.base_is_tagged, access.machine_type,
+ access.type)));
+ Node* key = node->InputAt(1);
+ Node* index = ComputeIndex(access, key);
+ if (access.bounds_check == kNoBoundsCheck) {
+ node->set_op(op);
+ node->ReplaceInput(1, index);
+ node->RemoveInput(2);
+ } else {
+ DCHECK_EQ(kTypedArrayBoundsCheck, access.bounds_check);
+
+ Node* base = node->InputAt(0);
+ Node* length = node->InputAt(2);
+ Node* value = node->InputAt(3);
+ Node* effect = node->InputAt(4);
+ Node* control = node->InputAt(5);
+ Node* check = graph()->NewNode(machine()->Uint32LessThan(), key, length);
+
+ IntPtrMatcher mbase(base);
+ if (mbase.HasValue()) {
+ Node* select = graph()->NewNode(
+ common()->Select(kMachIntPtr, BranchHint::kTrue), check, index,
+ jsgraph()->IntPtrConstant(AddressForOutOfBoundsStore() -
+ mbase.Value()));
+
+ node->set_op(op);
+ node->ReplaceInput(1, select);
+ node->RemoveInput(2);
+ } else {
+ Diamond d(graph(), common(), check, BranchHint::kTrue);
+ d.Chain(control);
+ Node* store = graph()->NewNode(op, base, index, value, effect, d.if_true);
+ d.OverwriteWithEffectPhi(node, store, effect);
+ }
+ }
}
CallDescriptor* desc =
Linkage::GetStubCallDescriptor(callable.descriptor(), 0, flags, zone());
node->set_op(common()->Call(desc));
- node->InsertInput(zone(), 0, jsgraph()->HeapConstant(callable.code()));
- node->AppendInput(zone(), jsgraph()->UndefinedConstant());
- node->AppendInput(zone(), graph()->start());
- node->AppendInput(zone(), graph()->start());
+ node->InsertInput(graph()->zone(), 0,
+ jsgraph()->HeapConstant(callable.code()));
+ node->AppendInput(graph()->zone(), jsgraph()->UndefinedConstant());
+ node->AppendInput(graph()->zone(), graph()->start());
+ node->AppendInput(graph()->zone(), graph()->start());
}
}
+Node* SimplifiedLowering::Int32Div(Node* const node) {
+ Int32BinopMatcher m(node);
+ Node* const zero = jsgraph()->Int32Constant(0);
+ Node* const lhs = m.left().node();
+ Node* const rhs = m.right().node();
+
+ if (m.right().Is(-1)) {
+ return graph()->NewNode(machine()->Int32Sub(), zero, lhs);
+ } else if (m.right().Is(0)) {
+ return rhs;
+ } else if (machine()->Int32DivIsSafe() || m.right().HasValue()) {
+ return graph()->NewNode(machine()->Int32Div(), lhs, rhs, graph()->start());
+ }
+
+ Diamond if_zero(graph(), common(),
+ graph()->NewNode(machine()->Word32Equal(), rhs, zero),
+ BranchHint::kFalse);
+
+ Diamond if_minus_one(graph(), common(),
+ graph()->NewNode(machine()->Word32Equal(), rhs,
+ jsgraph()->Int32Constant(-1)),
+ BranchHint::kFalse);
+ if_minus_one.Nest(if_zero, false);
+ Node* sub = graph()->NewNode(machine()->Int32Sub(), zero, lhs);
+ Node* div =
+ graph()->NewNode(machine()->Int32Div(), lhs, rhs, if_minus_one.if_false);
+
+ return if_zero.Phi(kMachInt32, zero, if_minus_one.Phi(kMachInt32, sub, div));
+}
+
+
+Node* SimplifiedLowering::Int32Mod(Node* const node) {
+ Int32BinopMatcher m(node);
+ Node* const zero = jsgraph()->Int32Constant(0);
+ Node* const lhs = m.left().node();
+ Node* const rhs = m.right().node();
+
+ if (m.right().Is(-1) || m.right().Is(0)) {
+ return zero;
+ } else if (machine()->Int32ModIsSafe() || m.right().HasValue()) {
+ return graph()->NewNode(machine()->Int32Mod(), lhs, rhs, graph()->start());
+ }
+
+ Diamond if_zero(graph(), common(),
+ graph()->NewNode(machine()->Word32Equal(), rhs, zero),
+ BranchHint::kFalse);
+
+ Diamond if_minus_one(graph(), common(),
+ graph()->NewNode(machine()->Word32Equal(), rhs,
+ jsgraph()->Int32Constant(-1)),
+ BranchHint::kFalse);
+ if_minus_one.Nest(if_zero, false);
+ Node* mod =
+ graph()->NewNode(machine()->Int32Mod(), lhs, rhs, if_minus_one.if_false);
+
+ return if_zero.Phi(kMachInt32, zero, if_minus_one.Phi(kMachInt32, zero, mod));
+}
+
+
+Node* SimplifiedLowering::Uint32Div(Node* const node) {
+ Uint32BinopMatcher m(node);
+ Node* const zero = jsgraph()->Uint32Constant(0);
+ Node* const lhs = m.left().node();
+ Node* const rhs = m.right().node();
+
+ if (m.right().Is(0)) {
+ return zero;
+ } else if (machine()->Uint32DivIsSafe() || m.right().HasValue()) {
+ return graph()->NewNode(machine()->Uint32Div(), lhs, rhs, graph()->start());
+ }
+
+ Node* check = graph()->NewNode(machine()->Word32Equal(), rhs, zero);
+ Diamond d(graph(), common(), check, BranchHint::kFalse);
+ Node* div = graph()->NewNode(machine()->Uint32Div(), lhs, rhs, d.if_false);
+ return d.Phi(kMachUint32, zero, div);
+}
+
+
+Node* SimplifiedLowering::Uint32Mod(Node* const node) {
+ Uint32BinopMatcher m(node);
+ Node* const zero = jsgraph()->Uint32Constant(0);
+ Node* const lhs = m.left().node();
+ Node* const rhs = m.right().node();
+
+ if (m.right().Is(0)) {
+ return zero;
+ } else if (machine()->Uint32ModIsSafe() || m.right().HasValue()) {
+ return graph()->NewNode(machine()->Uint32Mod(), lhs, rhs, graph()->start());
+ }
+
+ Node* check = graph()->NewNode(machine()->Word32Equal(), rhs, zero);
+ Diamond d(graph(), common(), check, BranchHint::kFalse);
+ Node* mod = graph()->NewNode(machine()->Uint32Mod(), lhs, rhs, d.if_false);
+ return d.Phi(kMachUint32, zero, mod);
+}
+
+
void SimplifiedLowering::DoStringEqual(Node* node) {
node->set_op(machine()->WordEqual());
node->ReplaceInput(0, StringComparison(node, false));
node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
}
-
} // namespace compiler
} // namespace internal
} // namespace v8
namespace internal {
namespace compiler {
-class SimplifiedLowering {
+class SimplifiedLowering FINAL {
public:
explicit SimplifiedLowering(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
- virtual ~SimplifiedLowering() {}
+ ~SimplifiedLowering() {}
void LowerAllNodes();
// TODO(titzer): These are exposed for direct testing. Use a friend class.
void DoLoadField(Node* node);
void DoStoreField(Node* node);
- void DoLoadElement(Node* node);
+ // TODO(turbofan): The output_type can be removed once the result of the
+ // representation analysis is stored in the node bounds.
+ void DoLoadElement(Node* node, MachineType output_type);
void DoStoreElement(Node* node);
void DoStringAdd(Node* node);
void DoStringEqual(Node* node);
Node* IsTagged(Node* node);
Node* Untag(Node* node);
Node* OffsetMinusTagConstant(int32_t offset);
- Node* ComputeIndex(const ElementAccess& access, Node* index);
+ Node* ComputeIndex(const ElementAccess& access, Node* const key);
Node* StringComparison(Node* node, bool requires_ordering);
+ Node* Int32Div(Node* const node);
+ Node* Int32Mod(Node* const node);
+ Node* Uint32Div(Node* const node);
+ Node* Uint32Mod(Node* const node);
friend class RepresentationSelector;
namespace internal {
namespace compiler {
+SimplifiedOperatorReducer::SimplifiedOperatorReducer(JSGraph* jsgraph)
+ : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {}
+
+
SimplifiedOperatorReducer::~SimplifiedOperatorReducer() {}
if (m.HasValue()) return ReplaceNumber(FastUI2D(m.Value()));
break;
}
+ case IrOpcode::kLoadElement: {
+ ElementAccess access = ElementAccessOf(node->op());
+ if (access.bounds_check == kTypedArrayBoundsCheck) {
+ NumberMatcher mkey(node->InputAt(1));
+ NumberMatcher mlength(node->InputAt(2));
+ if (mkey.HasValue() && mlength.HasValue()) {
+ // Skip the typed array bounds check if key and length are constant.
+ if (mkey.Value() >= 0 && mkey.Value() < mlength.Value()) {
+ access.bounds_check = kNoBoundsCheck;
+ node->set_op(simplified()->LoadElement(access));
+ return Changed(node);
+ }
+ }
+ }
+ break;
+ }
+ case IrOpcode::kStoreElement: {
+ ElementAccess access = ElementAccessOf(node->op());
+ if (access.bounds_check == kTypedArrayBoundsCheck) {
+ NumberMatcher mkey(node->InputAt(1));
+ NumberMatcher mlength(node->InputAt(2));
+ if (mkey.HasValue() && mlength.HasValue()) {
+ // Skip the typed array bounds check if key and length are constant.
+ if (mkey.Value() >= 0 && mkey.Value() < mlength.Value()) {
+ access.bounds_check = kNoBoundsCheck;
+ node->set_op(simplified()->StoreElement(access));
+ return Changed(node);
+ }
+ }
+ }
+ break;
+ }
default:
break;
}
#define V8_COMPILER_SIMPLIFIED_OPERATOR_REDUCER_H_
#include "src/compiler/graph-reducer.h"
+#include "src/compiler/simplified-operator.h"
namespace v8 {
namespace internal {
class SimplifiedOperatorReducer FINAL : public Reducer {
public:
- explicit SimplifiedOperatorReducer(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
+ explicit SimplifiedOperatorReducer(JSGraph* jsgraph);
virtual ~SimplifiedOperatorReducer();
virtual Reduction Reduce(Node* node) OVERRIDE;
Factory* factory() const;
JSGraph* jsgraph() const { return jsgraph_; }
MachineOperatorBuilder* machine() const;
+ SimplifiedOperatorBuilder* simplified() { return &simplified_; }
JSGraph* jsgraph_;
+ SimplifiedOperatorBuilder simplified_;
DISALLOW_COPY_AND_ASSIGN(SimplifiedOperatorReducer);
};
namespace internal {
namespace compiler {
-OStream& operator<<(OStream& os, BaseTaggedness base_taggedness) {
+std::ostream& operator<<(std::ostream& os, BaseTaggedness base_taggedness) {
switch (base_taggedness) {
case kUntaggedBase:
return os << "untagged base";
}
+bool operator==(FieldAccess const& lhs, FieldAccess const& rhs) {
+ return lhs.base_is_tagged == rhs.base_is_tagged && lhs.offset == rhs.offset &&
+ lhs.machine_type == rhs.machine_type;
+}
+
+
+bool operator!=(FieldAccess const& lhs, FieldAccess const& rhs) {
+ return !(lhs == rhs);
+}
+
+
+size_t hash_value(FieldAccess const& access) {
+ return base::hash_combine(access.base_is_tagged, access.offset,
+ access.machine_type);
+}
+
+
+std::ostream& operator<<(std::ostream& os, FieldAccess const& access) {
+ os << "[" << access.base_is_tagged << ", " << access.offset << ", ";
+#ifdef OBJECT_PRINT
+ Handle<Name> name;
+ if (access.name.ToHandle(&name)) {
+ name->Print(os);
+ os << ", ";
+ }
+#endif
+ access.type->PrintTo(os);
+ os << ", " << access.machine_type << "]";
+ return os;
+}
+
+
+std::ostream& operator<<(std::ostream& os, BoundsCheckMode bounds_check_mode) {
+ switch (bounds_check_mode) {
+ case kNoBoundsCheck:
+ return os << "no bounds check";
+ case kTypedArrayBoundsCheck:
+ return os << "ignore out of bounds";
+ }
+ UNREACHABLE();
+ return os;
+}
+
+
bool operator==(ElementAccess const& lhs, ElementAccess const& rhs) {
return lhs.base_is_tagged == rhs.base_is_tagged &&
- lhs.header_size == rhs.header_size && lhs.type == rhs.type &&
+ lhs.header_size == rhs.header_size &&
lhs.machine_type == rhs.machine_type;
}
}
-OStream& operator<<(OStream& os, ElementAccess const& access) {
- os << "[" << access.base_is_tagged << ", " << access.header_size << ", ";
+size_t hash_value(ElementAccess const& access) {
+ return base::hash_combine(access.base_is_tagged, access.header_size,
+ access.machine_type);
+}
+
+
+std::ostream& operator<<(std::ostream& os, ElementAccess const& access) {
+ os << access.base_is_tagged << ", " << access.header_size << ", ";
access.type->PrintTo(os);
- os << ", " << access.machine_type << "]";
+ os << ", " << access.machine_type << ", " << access.bounds_check;
return os;
}
}
-// Specialization for static parameters of type {FieldAccess}.
-template <>
-struct StaticParameterTraits<FieldAccess> {
- static OStream& PrintTo(OStream& os, const FieldAccess& val) {
- return os << val.offset;
- }
- static int HashCode(const FieldAccess& val) {
- return (val.offset < 16) | (val.machine_type & 0xffff);
- }
- static bool Equals(const FieldAccess& lhs, const FieldAccess& rhs) {
- return lhs.base_is_tagged == rhs.base_is_tagged &&
- lhs.offset == rhs.offset && lhs.machine_type == rhs.machine_type &&
- lhs.type->Is(rhs.type);
- }
-};
-
-
-// Specialization for static parameters of type {ElementAccess}.
-template <>
-struct StaticParameterTraits<ElementAccess> {
- static OStream& PrintTo(OStream& os, const ElementAccess& access) {
- return os << access;
- }
- static int HashCode(const ElementAccess& access) {
- return (access.header_size < 16) | (access.machine_type & 0xffff);
- }
- static bool Equals(const ElementAccess& lhs, const ElementAccess& rhs) {
- return lhs.base_is_tagged == rhs.base_is_tagged &&
- lhs.header_size == rhs.header_size &&
- lhs.machine_type == rhs.machine_type && lhs.type->Is(rhs.type);
- }
-};
-
-
#define PURE_OP_LIST(V) \
V(BooleanNot, Operator::kNoProperties, 1) \
V(BooleanToNumber, Operator::kNoProperties, 1) \
V(ChangeUint32ToTagged, Operator::kNoProperties, 1) \
V(ChangeFloat64ToTagged, Operator::kNoProperties, 1) \
V(ChangeBoolToBit, Operator::kNoProperties, 1) \
- V(ChangeBitToBool, Operator::kNoProperties, 1)
-
-
-#define ACCESS_OP_LIST(V) \
- V(LoadField, FieldAccess, Operator::kNoWrite, 1, 1) \
- V(StoreField, FieldAccess, Operator::kNoRead, 2, 0) \
- V(LoadElement, ElementAccess, Operator::kNoWrite, 3, 1) \
- V(StoreElement, ElementAccess, Operator::kNoRead, 4, 0)
-
-
-struct SimplifiedOperatorBuilderImpl FINAL {
-#define PURE(Name, properties, input_count) \
- struct Name##Operator FINAL : public SimpleOperator { \
- Name##Operator() \
- : SimpleOperator(IrOpcode::k##Name, Operator::kPure | properties, \
- input_count, 1, #Name) {} \
- }; \
+ V(ChangeBitToBool, Operator::kNoProperties, 1) \
+ V(ObjectIsSmi, Operator::kNoProperties, 1) \
+ V(ObjectIsNonNegativeSmi, Operator::kNoProperties, 1)
+
+
+struct SimplifiedOperatorGlobalCache FINAL {
+#define PURE(Name, properties, input_count) \
+ struct Name##Operator FINAL : public Operator { \
+ Name##Operator() \
+ : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
+ input_count, 0, 0, 1, 0, 0) {} \
+ }; \
Name##Operator k##Name;
PURE_OP_LIST(PURE)
#undef PURE
};
-static base::LazyInstance<SimplifiedOperatorBuilderImpl>::type kImpl =
+static base::LazyInstance<SimplifiedOperatorGlobalCache>::type kCache =
LAZY_INSTANCE_INITIALIZER;
SimplifiedOperatorBuilder::SimplifiedOperatorBuilder(Zone* zone)
- : impl_(kImpl.Get()), zone_(zone) {}
+ : cache_(kCache.Get()), zone_(zone) {}
#define PURE(Name, properties, input_count) \
- const Operator* SimplifiedOperatorBuilder::Name() { return &impl_.k##Name; }
+ const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
PURE_OP_LIST(PURE)
#undef PURE
const Operator* SimplifiedOperatorBuilder::ReferenceEqual(Type* type) {
// TODO(titzer): What about the type parameter?
- return new (zone()) SimpleOperator(IrOpcode::kReferenceEqual,
- Operator::kCommutative | Operator::kPure,
- 2, 1, "ReferenceEqual");
+ return new (zone()) Operator(IrOpcode::kReferenceEqual,
+ Operator::kCommutative | Operator::kPure,
+ "ReferenceEqual", 2, 0, 0, 1, 0, 0);
}
-#define ACCESS(Name, Type, properties, input_count, output_count) \
- const Operator* SimplifiedOperatorBuilder::Name(const Type& access) { \
- return new (zone()) \
- Operator1<Type>(IrOpcode::k##Name, Operator::kNoThrow | properties, \
- input_count, output_count, #Name, access); \
+#define ACCESS_OP_LIST(V) \
+ V(LoadField, FieldAccess, Operator::kNoWrite, 1, 1, 1) \
+ V(StoreField, FieldAccess, Operator::kNoRead, 2, 1, 0) \
+ V(LoadElement, ElementAccess, Operator::kNoWrite, 3, 0, 1) \
+ V(StoreElement, ElementAccess, Operator::kNoRead, 4, 1, 0)
+
+
+#define ACCESS(Name, Type, properties, value_input_count, control_input_count, \
+ output_count) \
+ const Operator* SimplifiedOperatorBuilder::Name(const Type& access) { \
+ return new (zone()) \
+ Operator1<Type>(IrOpcode::k##Name, Operator::kNoThrow | properties, \
+ #Name, value_input_count, 1, control_input_count, \
+ output_count, 1, 0, access); \
}
ACCESS_OP_LIST(ACCESS)
#undef ACCESS
#ifndef V8_COMPILER_SIMPLIFIED_OPERATOR_H_
#define V8_COMPILER_SIMPLIFIED_OPERATOR_H_
+#include <iosfwd>
+
#include "src/compiler/machine-type.h"
#include "src/handles.h"
// Forward declarations.
class Operator;
-struct SimplifiedOperatorBuilderImpl;
+struct SimplifiedOperatorGlobalCache;
enum BaseTaggedness { kUntaggedBase, kTaggedBase };
-OStream& operator<<(OStream&, BaseTaggedness);
+std::ostream& operator<<(std::ostream&, BaseTaggedness);
+
// An access descriptor for loads/stores of fixed structures like field
// accesses of heap objects. Accesses from either tagged or untagged base
struct FieldAccess {
BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
int offset; // offset of the field, without tag.
- Handle<Name> name; // debugging only.
+ MaybeHandle<Name> name; // debugging only.
Type* type; // type of the field.
MachineType machine_type; // machine type of the field.
int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
};
+bool operator==(FieldAccess const&, FieldAccess const&);
+bool operator!=(FieldAccess const&, FieldAccess const&);
+
+size_t hash_value(FieldAccess const&);
+
+std::ostream& operator<<(std::ostream&, FieldAccess const&);
+
+
+// The bound checking mode for ElementAccess below.
+enum BoundsCheckMode { kNoBoundsCheck, kTypedArrayBoundsCheck };
+
+std::ostream& operator<<(std::ostream&, BoundsCheckMode);
+
// An access descriptor for loads/stores of indexed structures like characters
// in strings or off-heap backing stores. Accesses from either tagged or
// untagged base pointers are supported; untagging is done automatically during
// lowering.
struct ElementAccess {
+ BoundsCheckMode bounds_check; // specifies the bounds checking mode.
BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
int header_size; // size of the header, without tag.
Type* type; // type of the element.
int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
};
-bool operator==(ElementAccess const& lhs, ElementAccess const& rhs);
-bool operator!=(ElementAccess const& lhs, ElementAccess const& rhs);
+bool operator==(ElementAccess const&, ElementAccess const&);
+bool operator!=(ElementAccess const&, ElementAccess const&);
-OStream& operator<<(OStream&, ElementAccess const&);
+size_t hash_value(ElementAccess const&);
+
+std::ostream& operator<<(std::ostream&, ElementAccess const&);
// If the accessed object is not a heap object, add this to the header_size.
const Operator* ChangeBoolToBit();
const Operator* ChangeBitToBool();
+ const Operator* ObjectIsSmi();
+ const Operator* ObjectIsNonNegativeSmi();
+
const Operator* LoadField(const FieldAccess&);
const Operator* StoreField(const FieldAccess&);
private:
Zone* zone() const { return zone_; }
- const SimplifiedOperatorBuilderImpl& impl_;
+ const SimplifiedOperatorGlobalCache& cache_;
Zone* const zone_;
DISALLOW_COPY_AND_ASSIGN(SimplifiedOperatorBuilder);
}
-SourcePosition SourcePositionTable::GetSourcePosition(Node* node) {
+SourcePosition SourcePositionTable::GetSourcePosition(Node* node) const {
return table_.Get(node);
}
void AddDecorator();
void RemoveDecorator();
- SourcePosition GetSourcePosition(Node* node);
+ SourcePosition GetSourcePosition(Node* node) const;
private:
class Decorator;
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/bootstrapper.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/js-operator.h"
#include "src/compiler/node.h"
namespace internal {
namespace compiler {
-Typer::Typer(Zone* zone) : zone_(zone) {
+class Typer::Decorator : public GraphDecorator {
+ public:
+ explicit Decorator(Typer* typer) : typer_(typer) {}
+ virtual void Decorate(Node* node);
+
+ private:
+ Typer* typer_;
+};
+
+
+Typer::Typer(Graph* graph, MaybeHandle<Context> context)
+ : graph_(graph),
+ context_(context),
+ decorator_(NULL),
+ weaken_min_limits_(graph->zone()),
+ weaken_max_limits_(graph->zone()) {
+ Zone* zone = this->zone();
Factory* f = zone->isolate()->factory();
+ Handle<Object> zero = f->NewNumber(0);
+ Handle<Object> one = f->NewNumber(1);
+ Handle<Object> infinity = f->NewNumber(+V8_INFINITY);
+ Handle<Object> minusinfinity = f->NewNumber(-V8_INFINITY);
+
+ negative_signed32 = Type::Union(
+ Type::SignedSmall(), Type::OtherSigned32(), zone);
+ non_negative_signed32 = Type::Union(
+ Type::UnsignedSmall(), Type::OtherUnsigned31(), zone);
+ undefined_or_null = Type::Union(Type::Undefined(), Type::Null(), zone);
+ singleton_false = Type::Constant(f->false_value(), zone);
+ singleton_true = Type::Constant(f->true_value(), zone);
+ singleton_zero = Type::Range(zero, zero, zone);
+ singleton_one = Type::Range(one, one, zone);
+ zero_or_one = Type::Union(singleton_zero, singleton_one, zone);
+ zeroish = Type::Union(
+ singleton_zero, Type::Union(Type::NaN(), Type::MinusZero(), zone), zone);
+ falsish = Type::Union(Type::Undetectable(),
+ Type::Union(zeroish, undefined_or_null, zone), zone);
+ integer = Type::Range(minusinfinity, infinity, zone);
+ weakint = Type::Union(
+ integer, Type::Union(Type::NaN(), Type::MinusZero(), zone), zone);
+
Type* number = Type::Number();
Type* signed32 = Type::Signed32();
Type* unsigned32 = Type::Unsigned32();
Type* integral32 = Type::Integral32();
Type* object = Type::Object();
Type* undefined = Type::Undefined();
- Type* weakint = Type::Union(
- Type::Range(f->NewNumber(-V8_INFINITY), f->NewNumber(+V8_INFINITY), zone),
- Type::Union(Type::NaN(), Type::MinusZero(), zone), zone);
number_fun0_ = Type::Function(number, zone);
number_fun1_ = Type::Function(number, number, zone);
number_fun2_ = Type::Function(number, number, number, zone);
weakint_fun1_ = Type::Function(weakint, number, zone);
imul_fun_ = Type::Function(signed32, integral32, integral32, zone);
+ clz32_fun_ = Type::Function(
+ Type::Range(zero, f->NewNumber(32), zone), number, zone);
random_fun_ = Type::Function(Type::Union(
Type::UnsignedSmall(), Type::OtherNumber(), zone), zone);
+ Type* int8 = Type::Intersect(
+ Type::Range(f->NewNumber(-0x7F), f->NewNumber(0x7F-1), zone),
+ Type::UntaggedInt8(), zone);
+ Type* int16 = Type::Intersect(
+ Type::Range(f->NewNumber(-0x7FFF), f->NewNumber(0x7FFF-1), zone),
+ Type::UntaggedInt16(), zone);
+ Type* uint8 = Type::Intersect(
+ Type::Range(zero, f->NewNumber(0xFF-1), zone),
+ Type::UntaggedInt8(), zone);
+ Type* uint16 = Type::Intersect(
+ Type::Range(zero, f->NewNumber(0xFFFF-1), zone),
+ Type::UntaggedInt16(), zone);
#define NATIVE_TYPE(sem, rep) \
- Type::Intersect(Type::sem(zone), Type::rep(zone), zone)
- // TODO(rossberg): Use range types for more precision, once we have them.
- Type* int8 = NATIVE_TYPE(SignedSmall, UntaggedInt8);
- Type* int16 = NATIVE_TYPE(SignedSmall, UntaggedInt16);
+ Type::Intersect(Type::sem(), Type::rep(), zone)
Type* int32 = NATIVE_TYPE(Signed32, UntaggedInt32);
- Type* uint8 = NATIVE_TYPE(UnsignedSmall, UntaggedInt8);
- Type* uint16 = NATIVE_TYPE(UnsignedSmall, UntaggedInt16);
Type* uint32 = NATIVE_TYPE(Unsigned32, UntaggedInt32);
Type* float32 = NATIVE_TYPE(Number, UntaggedFloat32);
Type* float64 = NATIVE_TYPE(Number, UntaggedFloat64);
#undef NATIVE_TYPE
+
Type* buffer = Type::Buffer(zone);
Type* int8_array = Type::Array(int8, zone);
Type* int16_array = Type::Array(int16, zone);
uint32_array_fun_ = Type::Function(uint32_array, arg1, arg2, arg3, zone);
float32_array_fun_ = Type::Function(float32_array, arg1, arg2, arg3, zone);
float64_array_fun_ = Type::Function(float64_array, arg1, arg2, arg3, zone);
+
+ const int limits_count = 20;
+
+ weaken_min_limits_.reserve(limits_count + 1);
+ weaken_max_limits_.reserve(limits_count + 1);
+
+ double limit = 1 << 30;
+ weaken_min_limits_.push_back(f->NewNumber(0));
+ weaken_max_limits_.push_back(f->NewNumber(0));
+ for (int i = 0; i < limits_count; i++) {
+ weaken_min_limits_.push_back(f->NewNumber(-limit));
+ weaken_max_limits_.push_back(f->NewNumber(limit - 1));
+ limit *= 2;
+ }
+
+ decorator_ = new (zone) Decorator(this);
+ graph_->AddDecorator(decorator_);
+}
+
+
+Typer::~Typer() {
+ graph_->RemoveDecorator(decorator_);
}
class Typer::Visitor : public NullNodeVisitor {
public:
- Visitor(Typer* typer, MaybeHandle<Context> context)
- : typer_(typer), context_(context) {}
+ explicit Visitor(Typer* typer) : typer_(typer) {}
Bounds TypeNode(Node* node) {
switch (node->opcode()) {
+#define DECLARE_CASE(x) \
+ case IrOpcode::k##x: return TypeBinaryOp(node, x##Typer);
+ JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
+#undef DECLARE_CASE
+
#define DECLARE_CASE(x) case IrOpcode::k##x: return Type##x(node);
DECLARE_CASE(Start)
- VALUE_OP_LIST(DECLARE_CASE)
+ // VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
+ COMMON_OP_LIST(DECLARE_CASE)
+ SIMPLIFIED_OP_LIST(DECLARE_CASE)
+ MACHINE_OP_LIST(DECLARE_CASE)
+ JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
+ JS_OBJECT_OP_LIST(DECLARE_CASE)
+ JS_CONTEXT_OP_LIST(DECLARE_CASE)
+ JS_OTHER_OP_LIST(DECLARE_CASE)
#undef DECLARE_CASE
#define DECLARE_CASE(x) case IrOpcode::k##x:
VALUE_OP_LIST(DECLARE_METHOD)
#undef DECLARE_METHOD
- Bounds OperandType(Node* node, int i) {
- return NodeProperties::GetBounds(NodeProperties::GetValueInput(node, i));
+ Bounds BoundsOrNone(Node* node) {
+ return NodeProperties::IsTyped(node) ? NodeProperties::GetBounds(node)
+ : Bounds(Type::None());
}
- Type* ContextType(Node* node) {
- Bounds result =
- NodeProperties::GetBounds(NodeProperties::GetContextInput(node));
+ Bounds Operand(Node* node, int i) {
+ Node* operand_node = NodeProperties::GetValueInput(node, i);
+ return BoundsOrNone(operand_node);
+ }
+
+ Bounds ContextOperand(Node* node) {
+ Bounds result = BoundsOrNone(NodeProperties::GetContextInput(node));
DCHECK(result.upper->Maybe(Type::Internal()));
// TODO(rossberg): More precisely, instead of the above assertion, we should
// back-propagate the constraint that it has to be a subtype of Internal.
- return result.upper;
+ return result;
}
+ Type* Weaken(Type* current_type, Type* previous_type);
+
Zone* zone() { return typer_->zone(); }
Isolate* isolate() { return typer_->isolate(); }
- MaybeHandle<Context> context() { return context_; }
+ Graph* graph() { return typer_->graph(); }
+ MaybeHandle<Context> context() { return typer_->context(); }
private:
Typer* typer_;
MaybeHandle<Context> context_;
+
+ typedef Type* (*UnaryTyperFun)(Type*, Typer* t);
+ typedef Type* (*BinaryTyperFun)(Type*, Type*, Typer* t);
+
+ Bounds TypeUnaryOp(Node* node, UnaryTyperFun);
+ Bounds TypeBinaryOp(Node* node, BinaryTyperFun);
+
+ static Type* Invert(Type*, Typer*);
+ static Type* FalsifyUndefined(Type*, Typer*);
+ static Type* Rangify(Type*, Typer*);
+
+ static Type* ToPrimitive(Type*, Typer*);
+ static Type* ToBoolean(Type*, Typer*);
+ static Type* ToNumber(Type*, Typer*);
+ static Type* ToString(Type*, Typer*);
+ static Type* NumberToInt32(Type*, Typer*);
+ static Type* NumberToUint32(Type*, Typer*);
+
+ static Type* JSAddRanger(Type::RangeType*, Type::RangeType*, Typer*);
+ static Type* JSSubtractRanger(Type::RangeType*, Type::RangeType*, Typer*);
+ static Type* JSMultiplyRanger(Type::RangeType*, Type::RangeType*, Typer*);
+ static Type* JSDivideRanger(Type::RangeType*, Type::RangeType*, Typer*);
+ static Type* JSModulusRanger(Type::RangeType*, Type::RangeType*, Typer*);
+
+ static Type* JSCompareTyper(Type*, Type*, Typer*);
+
+#define DECLARE_METHOD(x) static Type* x##Typer(Type*, Type*, Typer*);
+ JS_SIMPLE_BINOP_LIST(DECLARE_METHOD)
+#undef DECLARE_METHOD
+
+ static Type* JSUnaryNotTyper(Type*, Typer*);
+ static Type* JSLoadPropertyTyper(Type*, Type*, Typer*);
+ static Type* JSCallFunctionTyper(Type*, Typer*);
};
class Typer::RunVisitor : public Typer::Visitor {
public:
- RunVisitor(Typer* typer, MaybeHandle<Context> context)
- : Visitor(typer, context),
+ explicit RunVisitor(Typer* typer)
+ : Visitor(typer),
redo(NodeSet::key_compare(), NodeSet::allocator_type(typer->zone())) {}
- GenericGraphVisit::Control Post(Node* node) {
- if (OperatorProperties::HasValueOutput(node->op())) {
+ void Post(Node* node) {
+ if (node->op()->ValueOutputCount() > 0) {
Bounds bounds = TypeNode(node);
NodeProperties::SetBounds(node, bounds);
// Remember incompletely typed nodes for least fixpoint iteration.
- int arity = OperatorProperties::GetValueInputCount(node->op());
- for (int i = 0; i < arity; ++i) {
- // TODO(rossberg): change once IsTyped is available.
- // if (!NodeProperties::IsTyped(NodeProperties::GetValueInput(node, i)))
- if (OperandType(node, i).upper->Is(Type::None())) {
- redo.insert(node);
- break;
- }
- }
+ if (!NodeProperties::AllValueInputsAreTyped(node)) redo.insert(node);
}
- return GenericGraphVisit::CONTINUE;
}
NodeSet redo;
};
-class Typer::NarrowVisitor : public Typer::Visitor {
+class Typer::WidenVisitor : public Typer::Visitor {
public:
- NarrowVisitor(Typer* typer, MaybeHandle<Context> context)
- : Visitor(typer, context) {}
-
- GenericGraphVisit::Control Pre(Node* node) {
- if (OperatorProperties::HasValueOutput(node->op())) {
- Bounds previous = NodeProperties::GetBounds(node);
- Bounds bounds = TypeNode(node);
- NodeProperties::SetBounds(node, Bounds::Both(bounds, previous, zone()));
- DCHECK(bounds.Narrows(previous));
- // Stop when nothing changed (but allow re-entry in case it does later).
- return previous.Narrows(bounds)
- ? GenericGraphVisit::DEFER : GenericGraphVisit::REENTER;
- } else {
- return GenericGraphVisit::SKIP;
+ explicit WidenVisitor(Typer* typer)
+ : Visitor(typer),
+ local_zone_(zone()->isolate()),
+ enabled_(graph()->NodeCount(), true, &local_zone_),
+ queue_(&local_zone_) {}
+
+ void Run(NodeSet* nodes) {
+ // Queue all the roots.
+ for (Node* node : *nodes) {
+ Queue(node);
}
- }
- GenericGraphVisit::Control Post(Node* node) {
- return GenericGraphVisit::REENTER;
- }
-};
+ while (!queue_.empty()) {
+ Node* node = queue_.front();
+ queue_.pop();
+ if (node->op()->ValueOutputCount() > 0) {
+ // Enable future queuing (and thus re-typing) of this node.
+ enabled_[node->id()] = true;
-class Typer::WidenVisitor : public Typer::Visitor {
- public:
- WidenVisitor(Typer* typer, MaybeHandle<Context> context)
- : Visitor(typer, context) {}
+ // Compute the new type.
+ Bounds previous = BoundsOrNone(node);
+ Bounds current = TypeNode(node);
- GenericGraphVisit::Control Pre(Node* node) {
- if (OperatorProperties::HasValueOutput(node->op())) {
- Bounds previous = NodeProperties::GetBounds(node);
- Bounds bounds = TypeNode(node);
- DCHECK(previous.lower->Is(bounds.lower));
- DCHECK(previous.upper->Is(bounds.upper));
- NodeProperties::SetBounds(node, bounds); // TODO(rossberg): Either?
- // Stop when nothing changed (but allow re-entry in case it does later).
- return bounds.Narrows(previous)
- ? GenericGraphVisit::DEFER : GenericGraphVisit::REENTER;
- } else {
- return GenericGraphVisit::SKIP;
+ // Speed up termination in the presence of range types:
+ current.upper = Weaken(current.upper, previous.upper);
+ current.lower = Weaken(current.lower, previous.lower);
+
+ // Types should not get less precise.
+ DCHECK(previous.lower->Is(current.lower));
+ DCHECK(previous.upper->Is(current.upper));
+
+ NodeProperties::SetBounds(node, current);
+ // If something changed, push all uses into the queue.
+ if (!(previous.Narrows(current) && current.Narrows(previous))) {
+ for (Node* use : node->uses()) {
+ Queue(use);
+ }
+ }
+ }
+ // If there is no value output, we deliberately leave the node disabled
+ // for queuing - there is no need to type it.
}
}
- GenericGraphVisit::Control Post(Node* node) {
- return GenericGraphVisit::REENTER;
+ void Queue(Node* node) {
+ // If the node is enabled for queuing, push it to the queue and disable it
+ // (to avoid queuing it multiple times).
+ if (enabled_[node->id()]) {
+ queue_.push(node);
+ enabled_[node->id()] = false;
+ }
}
+
+ private:
+ Zone local_zone_;
+ BoolVector enabled_;
+ ZoneQueue<Node*> queue_;
};
-void Typer::Run(Graph* graph, MaybeHandle<Context> context) {
- RunVisitor typing(this, context);
- graph->VisitNodeInputsFromEnd(&typing);
+void Typer::Run() {
+ RunVisitor typing(this);
+ graph_->VisitNodeInputsFromEnd(&typing);
// Find least fixpoint.
- for (NodeSetIter i = typing.redo.begin(); i != typing.redo.end(); ++i) {
- Widen(graph, *i, context);
+ WidenVisitor widen(this);
+ widen.Run(&typing.redo);
+}
+
+
+void Typer::Decorator::Decorate(Node* node) {
+ if (node->op()->ValueOutputCount() > 0) {
+ // Only eagerly type-decorate nodes with known input types.
+ // Other cases will generally require a proper fixpoint iteration with Run.
+ bool is_typed = NodeProperties::IsTyped(node);
+ if (is_typed || NodeProperties::AllValueInputsAreTyped(node)) {
+ Visitor typing(typer_);
+ Bounds bounds = typing.TypeNode(node);
+ if (is_typed) {
+ bounds =
+ Bounds::Both(bounds, NodeProperties::GetBounds(node), typer_->zone());
+ }
+ NodeProperties::SetBounds(node, bounds);
+ }
}
}
-void Typer::Narrow(Graph* graph, Node* start, MaybeHandle<Context> context) {
- NarrowVisitor typing(this, context);
- graph->VisitNodeUsesFrom(start, &typing);
+// -----------------------------------------------------------------------------
+
+// Helper functions that lift a function f on types to a function on bounds,
+// and uses that to type the given node. Note that f is never called with None
+// as an argument.
+
+
+Bounds Typer::Visitor::TypeUnaryOp(Node* node, UnaryTyperFun f) {
+ Bounds input = Operand(node, 0);
+ Type* upper = input.upper->Is(Type::None())
+ ? Type::None()
+ : f(input.upper, typer_);
+ Type* lower = input.lower->Is(Type::None())
+ ? Type::None()
+ : (input.lower == input.upper || upper->IsConstant())
+ ? upper // TODO(neis): Extend this to Range(x,x), NaN, MinusZero, ...?
+ : f(input.lower, typer_);
+ // TODO(neis): Figure out what to do with lower bound.
+ return Bounds(lower, upper);
}
-void Typer::Widen(Graph* graph, Node* start, MaybeHandle<Context> context) {
- WidenVisitor typing(this, context);
- graph->VisitNodeUsesFrom(start, &typing);
+Bounds Typer::Visitor::TypeBinaryOp(Node* node, BinaryTyperFun f) {
+ Bounds left = Operand(node, 0);
+ Bounds right = Operand(node, 1);
+ Type* upper = left.upper->Is(Type::None()) || right.upper->Is(Type::None())
+ ? Type::None()
+ : f(left.upper, right.upper, typer_);
+ Type* lower = left.lower->Is(Type::None()) || right.lower->Is(Type::None())
+ ? Type::None()
+ : ((left.lower == left.upper && right.lower == right.upper) ||
+ upper->IsConstant())
+ ? upper
+ : f(left.lower, right.lower, typer_);
+ // TODO(neis): Figure out what to do with lower bound.
+ return Bounds(lower, upper);
}
-void Typer::Init(Node* node) {
- if (OperatorProperties::HasValueOutput(node->op())) {
- Visitor typing(this, MaybeHandle<Context>());
- Bounds bounds = typing.TypeNode(node);
- NodeProperties::SetBounds(node, bounds);
+Type* Typer::Visitor::Invert(Type* type, Typer* t) {
+ if (type->Is(t->singleton_false)) return t->singleton_true;
+ if (type->Is(t->singleton_true)) return t->singleton_false;
+ return type;
+}
+
+
+Type* Typer::Visitor::FalsifyUndefined(Type* type, Typer* t) {
+ if (type->Is(Type::Undefined())) return t->singleton_false;
+ return type;
+}
+
+
+Type* Typer::Visitor::Rangify(Type* type, Typer* t) {
+ if (type->IsRange()) return type; // Shortcut.
+ if (!type->Is(t->integer) && !type->Is(Type::Integral32())) {
+ return type; // Give up on non-integer types.
+ }
+ double min = type->Min();
+ double max = type->Max();
+ // Handle the degenerate case of empty bitset types (such as
+ // OtherUnsigned31 and OtherSigned32 on 64-bit architectures).
+ if (std::isnan(min)) {
+ DCHECK(std::isnan(max));
+ return type;
+ }
+ Factory* f = t->isolate()->factory();
+ return Type::Range(f->NewNumber(min), f->NewNumber(max), t->zone());
+}
+
+
+// Type conversion.
+
+
+Type* Typer::Visitor::ToPrimitive(Type* type, Typer* t) {
+ if (type->Is(Type::Primitive()) && !type->Maybe(Type::Receiver())) {
+ return type;
+ }
+ return Type::Primitive();
+}
+
+
+Type* Typer::Visitor::ToBoolean(Type* type, Typer* t) {
+ if (type->Is(Type::Boolean())) return type;
+ if (type->Is(t->falsish)) return t->singleton_false;
+ if (type->Is(Type::DetectableReceiver())) return t->singleton_true;
+ if (type->Is(Type::OrderedNumber()) && (type->Max() < 0 || 0 < type->Min())) {
+ return t->singleton_true; // Ruled out nan, -0 and +0.
}
+ return Type::Boolean();
+}
+
+
+Type* Typer::Visitor::ToNumber(Type* type, Typer* t) {
+ if (type->Is(Type::Number())) return type;
+ if (type->Is(Type::Undefined())) return Type::NaN();
+ if (type->Is(t->singleton_false)) return t->singleton_zero;
+ if (type->Is(t->singleton_true)) return t->singleton_one;
+ if (type->Is(Type::Boolean())) return t->zero_or_one;
+ return Type::Number();
+}
+
+
+Type* Typer::Visitor::ToString(Type* type, Typer* t) {
+ if (type->Is(Type::String())) return type;
+ return Type::String();
+}
+
+
+Type* Typer::Visitor::NumberToInt32(Type* type, Typer* t) {
+ // TODO(neis): DCHECK(type->Is(Type::Number()));
+ if (type->Is(Type::Signed32())) return type;
+ if (type->Is(t->zeroish)) return t->singleton_zero;
+ return Type::Signed32();
+}
+
+
+Type* Typer::Visitor::NumberToUint32(Type* type, Typer* t) {
+ // TODO(neis): DCHECK(type->Is(Type::Number()));
+ if (type->Is(Type::Unsigned32())) return type;
+ if (type->Is(t->zeroish)) return t->singleton_zero;
+ return Type::Unsigned32();
}
// Control operators.
+
Bounds Typer::Visitor::TypeStart(Node* node) {
- return Bounds(Type::Internal(zone()));
+ return Bounds(Type::None(zone()), Type::Internal(zone()));
}
// Common operators.
+
Bounds Typer::Visitor::TypeParameter(Node* node) {
return Bounds::Unbounded(zone());
}
Bounds Typer::Visitor::TypeInt32Constant(Node* node) {
- // TODO(titzer): only call Type::Of() if the type is not already known.
- return Bounds(Type::Of(OpParameter<int32_t>(node), zone()));
+ Factory* f = isolate()->factory();
+ Handle<Object> number = f->NewNumber(OpParameter<int32_t>(node));
+ return Bounds(Type::Intersect(
+ Type::Range(number, number, zone()), Type::UntaggedInt32(), zone()));
}
Bounds Typer::Visitor::TypeInt64Constant(Node* node) {
- // TODO(titzer): only call Type::Of() if the type is not already known.
- return Bounds(
- Type::Of(static_cast<double>(OpParameter<int64_t>(node)), zone()));
+ return Bounds(Type::Internal()); // TODO(rossberg): Add int64 bitset type?
}
Bounds Typer::Visitor::TypeFloat32Constant(Node* node) {
- // TODO(titzer): only call Type::Of() if the type is not already known.
- return Bounds(Type::Of(OpParameter<float>(node), zone()));
+ return Bounds(Type::Intersect(
+ Type::Of(OpParameter<float>(node), zone()),
+ Type::UntaggedFloat32(), zone()));
}
Bounds Typer::Visitor::TypeFloat64Constant(Node* node) {
- // TODO(titzer): only call Type::Of() if the type is not already known.
- return Bounds(Type::Of(OpParameter<double>(node), zone()));
+ return Bounds(Type::Intersect(
+ Type::Of(OpParameter<double>(node), zone()),
+ Type::UntaggedFloat64(), zone()));
}
Bounds Typer::Visitor::TypeNumberConstant(Node* node) {
- // TODO(titzer): only call Type::Of() if the type is not already known.
- return Bounds(Type::Of(OpParameter<double>(node), zone()));
+ Factory* f = isolate()->factory();
+ return Bounds(Type::Constant(
+ f->NewNumber(OpParameter<double>(node)), zone()));
}
Bounds Typer::Visitor::TypeExternalConstant(Node* node) {
- return Bounds(Type::Internal(zone()));
+ return Bounds(Type::None(zone()), Type::Internal(zone()));
+}
+
+
+Bounds Typer::Visitor::TypeSelect(Node* node) {
+ return Bounds::Either(Operand(node, 1), Operand(node, 2), zone());
}
Bounds Typer::Visitor::TypePhi(Node* node) {
- int arity = OperatorProperties::GetValueInputCount(node->op());
- Bounds bounds = OperandType(node, 0);
+ int arity = node->op()->ValueInputCount();
+ Bounds bounds = Operand(node, 0);
for (int i = 1; i < arity; ++i) {
- bounds = Bounds::Either(bounds, OperandType(node, i), zone());
+ bounds = Bounds::Either(bounds, Operand(node, i), zone());
}
return bounds;
}
}
-Bounds Typer::Visitor::TypeControlEffect(Node* node) {
- UNREACHABLE();
- return Bounds();
-}
-
-
Bounds Typer::Visitor::TypeValueEffect(Node* node) {
UNREACHABLE();
return Bounds();
Bounds Typer::Visitor::TypeFinish(Node* node) {
- return OperandType(node, 0);
+ return Operand(node, 0);
}
Bounds Typer::Visitor::TypeFrameState(Node* node) {
// TODO(rossberg): Ideally FrameState wouldn't have a value output.
- return Bounds(Type::Internal(zone()));
+ return Bounds(Type::None(zone()), Type::Internal(zone()));
}
Bounds Typer::Visitor::TypeStateValues(Node* node) {
- return Bounds(Type::Internal(zone()));
+ return Bounds(Type::None(zone()), Type::Internal(zone()));
}
// JS comparison operators.
-#define DEFINE_METHOD(x) \
- Bounds Typer::Visitor::Type##x(Node* node) { \
- return Bounds(Type::Boolean(zone())); \
+
+Type* Typer::Visitor::JSEqualTyper(Type* lhs, Type* rhs, Typer* t) {
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false;
+ if (lhs->Is(t->undefined_or_null) && rhs->Is(t->undefined_or_null)) {
+ return t->singleton_true;
+ }
+ if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
+ (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
+ return t->singleton_false;
+ }
+ if (lhs->IsConstant() && rhs->Is(lhs)) {
+ // Types are equal and are inhabited only by a single semantic value,
+ // which is not nan due to the earlier check.
+ // TODO(neis): Extend this to Range(x,x), MinusZero, ...?
+ return t->singleton_true;
}
-JS_COMPARE_BINOP_LIST(DEFINE_METHOD)
-#undef DEFINE_METHOD
+ return Type::Boolean();
+}
-// JS bitwise operators.
+Type* Typer::Visitor::JSNotEqualTyper(Type* lhs, Type* rhs, Typer* t) {
+ return Invert(JSEqualTyper(lhs, rhs, t), t);
+}
-Bounds Typer::Visitor::TypeJSBitwiseOr(Node* node) {
- Bounds left = OperandType(node, 0);
- Bounds right = OperandType(node, 1);
- Type* upper = Type::Union(left.upper, right.upper, zone());
- if (!upper->Is(Type::Signed32())) upper = Type::Signed32(zone());
- Type* lower = Type::Intersect(Type::SignedSmall(zone()), upper, zone());
- return Bounds(lower, upper);
+
+static Type* JSType(Type* type) {
+ if (type->Is(Type::Boolean())) return Type::Boolean();
+ if (type->Is(Type::String())) return Type::String();
+ if (type->Is(Type::Number())) return Type::Number();
+ if (type->Is(Type::Undefined())) return Type::Undefined();
+ if (type->Is(Type::Null())) return Type::Null();
+ if (type->Is(Type::Symbol())) return Type::Symbol();
+ if (type->Is(Type::Receiver())) return Type::Receiver(); // JS "Object"
+ return Type::Any();
}
-Bounds Typer::Visitor::TypeJSBitwiseAnd(Node* node) {
- Bounds left = OperandType(node, 0);
- Bounds right = OperandType(node, 1);
- Type* upper = Type::Union(left.upper, right.upper, zone());
- if (!upper->Is(Type::Signed32())) upper = Type::Signed32(zone());
- Type* lower = Type::Intersect(Type::SignedSmall(zone()), upper, zone());
- return Bounds(lower, upper);
+Type* Typer::Visitor::JSStrictEqualTyper(Type* lhs, Type* rhs, Typer* t) {
+ if (!JSType(lhs)->Maybe(JSType(rhs))) return t->singleton_false;
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false;
+ if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
+ (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
+ return t->singleton_false;
+ }
+ if (lhs->IsConstant() && rhs->Is(lhs)) {
+ // Types are equal and are inhabited only by a single semantic value,
+ // which is not nan due to the earlier check.
+ return t->singleton_true;
+ }
+ return Type::Boolean();
+}
+
+
+Type* Typer::Visitor::JSStrictNotEqualTyper(Type* lhs, Type* rhs, Typer* t) {
+ return Invert(JSStrictEqualTyper(lhs, rhs, t), t);
}
-Bounds Typer::Visitor::TypeJSBitwiseXor(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
+// The EcmaScript specification defines the four relational comparison operators
+// (<, <=, >=, >) with the help of a single abstract one. It behaves like <
+// but returns undefined when the inputs cannot be compared.
+// We implement the typing analogously.
+Type* Typer::Visitor::JSCompareTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = ToPrimitive(lhs, t);
+ rhs = ToPrimitive(rhs, t);
+ if (lhs->Maybe(Type::String()) && rhs->Maybe(Type::String())) {
+ return Type::Boolean();
+ }
+ lhs = ToNumber(lhs, t);
+ rhs = ToNumber(rhs, t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::Undefined();
+ if (lhs->IsConstant() && rhs->Is(lhs)) {
+ // Types are equal and are inhabited only by a single semantic value,
+ // which is not NaN due to the previous check.
+ return t->singleton_false;
+ }
+ if (lhs->Min() >= rhs->Max()) return t->singleton_false;
+ if (lhs->Max() < rhs->Min() &&
+ !lhs->Maybe(Type::NaN()) && !rhs->Maybe(Type::NaN())) {
+ return t->singleton_true;
+ }
+ return Type::Boolean();
}
-Bounds Typer::Visitor::TypeJSShiftLeft(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
+Type* Typer::Visitor::JSLessThanTyper(Type* lhs, Type* rhs, Typer* t) {
+ return FalsifyUndefined(JSCompareTyper(lhs, rhs, t), t);
}
-Bounds Typer::Visitor::TypeJSShiftRight(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
+Type* Typer::Visitor::JSGreaterThanTyper(Type* lhs, Type* rhs, Typer* t) {
+ return FalsifyUndefined(JSCompareTyper(rhs, lhs, t), t);
}
-Bounds Typer::Visitor::TypeJSShiftRightLogical(Node* node) {
- return Bounds(Type::UnsignedSmall(zone()), Type::Unsigned32(zone()));
+Type* Typer::Visitor::JSLessThanOrEqualTyper(Type* lhs, Type* rhs, Typer* t) {
+ return FalsifyUndefined(Invert(JSCompareTyper(rhs, lhs, t), t), t);
}
-// JS arithmetic operators.
+Type* Typer::Visitor::JSGreaterThanOrEqualTyper(
+ Type* lhs, Type* rhs, Typer* t) {
+ return FalsifyUndefined(Invert(JSCompareTyper(lhs, rhs, t), t), t);
+}
-Bounds Typer::Visitor::TypeJSAdd(Node* node) {
- Bounds left = OperandType(node, 0);
- Bounds right = OperandType(node, 1);
- Type* lower =
- left.lower->Is(Type::None()) || right.lower->Is(Type::None()) ?
- Type::None(zone()) :
- left.lower->Is(Type::Number()) && right.lower->Is(Type::Number()) ?
- Type::SignedSmall(zone()) :
- left.lower->Is(Type::String()) || right.lower->Is(Type::String()) ?
- Type::String(zone()) : Type::None(zone());
- Type* upper =
- left.upper->Is(Type::None()) && right.upper->Is(Type::None()) ?
- Type::None(zone()) :
- left.upper->Is(Type::Number()) && right.upper->Is(Type::Number()) ?
- Type::Number(zone()) :
- left.upper->Is(Type::String()) || right.upper->Is(Type::String()) ?
- Type::String(zone()) : Type::NumberOrString(zone());
- return Bounds(lower, upper);
+
+// JS bitwise operators.
+
+
+Type* Typer::Visitor::JSBitwiseOrTyper(Type* lhs, Type* rhs, Typer* t) {
+ Factory* f = t->isolate()->factory();
+ lhs = NumberToInt32(ToNumber(lhs, t), t);
+ rhs = NumberToInt32(ToNumber(rhs, t), t);
+ double lmin = lhs->Min();
+ double rmin = rhs->Min();
+ double lmax = lhs->Max();
+ double rmax = rhs->Max();
+ // Or-ing any two values results in a value no smaller than their minimum.
+ // Even no smaller than their maximum if both values are non-negative.
+ Handle<Object> min = f->NewNumber(
+ lmin >= 0 && rmin >= 0 ? std::max(lmin, rmin) : std::min(lmin, rmin));
+ if (lmax < 0 || rmax < 0) {
+ // Or-ing two values of which at least one is negative results in a negative
+ // value.
+ Handle<Object> max = f->NewNumber(-1);
+ return Type::Range(min, max, t->zone());
+ }
+ Handle<Object> max = f->NewNumber(Type::Signed32()->Max());
+ return Type::Range(min, max, t->zone());
+ // TODO(neis): Be precise for singleton inputs, here and elsewhere.
+}
+
+
+Type* Typer::Visitor::JSBitwiseAndTyper(Type* lhs, Type* rhs, Typer* t) {
+ Factory* f = t->isolate()->factory();
+ lhs = NumberToInt32(ToNumber(lhs, t), t);
+ rhs = NumberToInt32(ToNumber(rhs, t), t);
+ double lmin = lhs->Min();
+ double rmin = rhs->Min();
+ double lmax = lhs->Max();
+ double rmax = rhs->Max();
+ // And-ing any two values results in a value no larger than their maximum.
+ // Even no larger than their minimum if both values are non-negative.
+ Handle<Object> max = f->NewNumber(
+ lmin >= 0 && rmin >= 0 ? std::min(lmax, rmax) : std::max(lmax, rmax));
+ if (lmin >= 0 || rmin >= 0) {
+ // And-ing two values of which at least one is non-negative results in a
+ // non-negative value.
+ Handle<Object> min = f->NewNumber(0);
+ return Type::Range(min, max, t->zone());
+ }
+ Handle<Object> min = f->NewNumber(Type::Signed32()->Min());
+ return Type::Range(min, max, t->zone());
+}
+
+
+Type* Typer::Visitor::JSBitwiseXorTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = NumberToInt32(ToNumber(lhs, t), t);
+ rhs = NumberToInt32(ToNumber(rhs, t), t);
+ double lmin = lhs->Min();
+ double rmin = rhs->Min();
+ double lmax = lhs->Max();
+ double rmax = rhs->Max();
+ if ((lmin >= 0 && rmin >= 0) || (lmax < 0 && rmax < 0)) {
+ // Xor-ing negative or non-negative values results in a non-negative value.
+ return t->non_negative_signed32;
+ }
+ if ((lmax < 0 && rmin >= 0) || (lmin >= 0 && rmax < 0)) {
+ // Xor-ing a negative and a non-negative value results in a negative value.
+ return t->negative_signed32;
+ }
+ return Type::Signed32();
+}
+
+
+Type* Typer::Visitor::JSShiftLeftTyper(Type* lhs, Type* rhs, Typer* t) {
+ return Type::Signed32();
+}
+
+
+Type* Typer::Visitor::JSShiftRightTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = NumberToInt32(ToNumber(lhs, t), t);
+ Factory* f = t->isolate()->factory();
+ if (lhs->Min() >= 0) {
+ // Right-shifting a non-negative value cannot make it negative, nor larger.
+ Handle<Object> min = f->NewNumber(0);
+ Handle<Object> max = f->NewNumber(lhs->Max());
+ return Type::Range(min, max, t->zone());
+ }
+ if (lhs->Max() < 0) {
+ // Right-shifting a negative value cannot make it non-negative, nor smaller.
+ Handle<Object> min = f->NewNumber(lhs->Min());
+ Handle<Object> max = f->NewNumber(-1);
+ return Type::Range(min, max, t->zone());
+ }
+ return Type::Signed32();
}
-Bounds Typer::Visitor::TypeJSSubtract(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
+Type* Typer::Visitor::JSShiftRightLogicalTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = NumberToUint32(ToNumber(lhs, t), t);
+ Factory* f = t->isolate()->factory();
+ // Logical right-shifting any value cannot make it larger.
+ Handle<Object> min = f->NewNumber(0);
+ Handle<Object> max = f->NewNumber(lhs->Max());
+ return Type::Range(min, max, t->zone());
}
-Bounds Typer::Visitor::TypeJSMultiply(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
+// JS arithmetic operators.
+
+
+// Returns the array's least element, ignoring NaN.
+// There must be at least one non-NaN element.
+// Any -0 is converted to 0.
+static double array_min(double a[], size_t n) {
+ DCHECK(n != 0);
+ double x = +V8_INFINITY;
+ for (size_t i = 0; i < n; ++i) {
+ if (!std::isnan(a[i])) {
+ x = std::min(a[i], x);
+ }
+ }
+ DCHECK(!std::isnan(x));
+ return x == 0 ? 0 : x; // -0 -> 0
}
-Bounds Typer::Visitor::TypeJSDivide(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
+// Returns the array's greatest element, ignoring NaN.
+// There must be at least one non-NaN element.
+// Any -0 is converted to 0.
+static double array_max(double a[], size_t n) {
+ DCHECK(n != 0);
+ double x = -V8_INFINITY;
+ for (size_t i = 0; i < n; ++i) {
+ if (!std::isnan(a[i])) {
+ x = std::max(a[i], x);
+ }
+ }
+ DCHECK(!std::isnan(x));
+ return x == 0 ? 0 : x; // -0 -> 0
+}
+
+
+Type* Typer::Visitor::JSAddRanger(Type::RangeType* lhs, Type::RangeType* rhs,
+ Typer* t) {
+ double results[4];
+ results[0] = lhs->Min()->Number() + rhs->Min()->Number();
+ results[1] = lhs->Min()->Number() + rhs->Max()->Number();
+ results[2] = lhs->Max()->Number() + rhs->Min()->Number();
+ results[3] = lhs->Max()->Number() + rhs->Max()->Number();
+ // Since none of the inputs can be -0, the result cannot be -0 either.
+ // However, it can be nan (the sum of two infinities of opposite sign).
+ // On the other hand, if none of the "results" above is nan, then the actual
+ // result cannot be nan either.
+ int nans = 0;
+ for (int i = 0; i < 4; ++i) {
+ if (std::isnan(results[i])) ++nans;
+ }
+ if (nans == 4) return Type::NaN(); // [-inf..-inf] + [inf..inf] or vice versa
+ Factory* f = t->isolate()->factory();
+ Type* range = Type::Range(f->NewNumber(array_min(results, 4)),
+ f->NewNumber(array_max(results, 4)), t->zone());
+ return nans == 0 ? range : Type::Union(range, Type::NaN(), t->zone());
+ // Examples:
+ // [-inf, -inf] + [+inf, +inf] = NaN
+ // [-inf, -inf] + [n, +inf] = [-inf, -inf] \/ NaN
+ // [-inf, +inf] + [n, +inf] = [-inf, +inf] \/ NaN
+ // [-inf, m] + [n, +inf] = [-inf, +inf] \/ NaN
+}
+
+
+Type* Typer::Visitor::JSAddTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = ToPrimitive(lhs, t);
+ rhs = ToPrimitive(rhs, t);
+ if (lhs->Maybe(Type::String()) || rhs->Maybe(Type::String())) {
+ if (lhs->Is(Type::String()) || rhs->Is(Type::String())) {
+ return Type::String();
+ } else {
+ return Type::NumberOrString();
+ }
+ }
+ lhs = Rangify(ToNumber(lhs, t), t);
+ rhs = Rangify(ToNumber(rhs, t), t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
+ if (lhs->IsRange() && rhs->IsRange()) {
+ return JSAddRanger(lhs->AsRange(), rhs->AsRange(), t);
+ }
+ // TODO(neis): Deal with numeric bitsets here and elsewhere.
+ return Type::Number();
+}
+
+
+Type* Typer::Visitor::JSSubtractRanger(Type::RangeType* lhs,
+ Type::RangeType* rhs, Typer* t) {
+ double results[4];
+ results[0] = lhs->Min()->Number() - rhs->Min()->Number();
+ results[1] = lhs->Min()->Number() - rhs->Max()->Number();
+ results[2] = lhs->Max()->Number() - rhs->Min()->Number();
+ results[3] = lhs->Max()->Number() - rhs->Max()->Number();
+ // Since none of the inputs can be -0, the result cannot be -0.
+ // However, it can be nan (the subtraction of two infinities of same sign).
+ // On the other hand, if none of the "results" above is nan, then the actual
+ // result cannot be nan either.
+ int nans = 0;
+ for (int i = 0; i < 4; ++i) {
+ if (std::isnan(results[i])) ++nans;
+ }
+ if (nans == 4) return Type::NaN(); // [inf..inf] - [inf..inf] (all same sign)
+ Factory* f = t->isolate()->factory();
+ Type* range = Type::Range(f->NewNumber(array_min(results, 4)),
+ f->NewNumber(array_max(results, 4)), t->zone());
+ return nans == 0 ? range : Type::Union(range, Type::NaN(), t->zone());
+ // Examples:
+ // [-inf, +inf] - [-inf, +inf] = [-inf, +inf] \/ NaN
+ // [-inf, -inf] - [-inf, -inf] = NaN
+ // [-inf, -inf] - [n, +inf] = [-inf, -inf] \/ NaN
+ // [m, +inf] - [-inf, n] = [-inf, +inf] \/ NaN
+}
+
+
+Type* Typer::Visitor::JSSubtractTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = Rangify(ToNumber(lhs, t), t);
+ rhs = Rangify(ToNumber(rhs, t), t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
+ if (lhs->IsRange() && rhs->IsRange()) {
+ return JSSubtractRanger(lhs->AsRange(), rhs->AsRange(), t);
+ }
+ return Type::Number();
+}
+
+
+Type* Typer::Visitor::JSMultiplyRanger(Type::RangeType* lhs,
+ Type::RangeType* rhs, Typer* t) {
+ double results[4];
+ double lmin = lhs->Min()->Number();
+ double lmax = lhs->Max()->Number();
+ double rmin = rhs->Min()->Number();
+ double rmax = rhs->Max()->Number();
+ results[0] = lmin * rmin;
+ results[1] = lmin * rmax;
+ results[2] = lmax * rmin;
+ results[3] = lmax * rmax;
+ // If the result may be nan, we give up on calculating a precise type, because
+ // the discontinuity makes it too complicated. Note that even if none of the
+ // "results" above is nan, the actual result may still be, so we have to do a
+ // different check:
+ bool maybe_nan = (lhs->Maybe(t->singleton_zero) &&
+ (rmin == -V8_INFINITY || rmax == +V8_INFINITY)) ||
+ (rhs->Maybe(t->singleton_zero) &&
+ (lmin == -V8_INFINITY || lmax == +V8_INFINITY));
+ if (maybe_nan) return t->weakint; // Giving up.
+ bool maybe_minuszero = (lhs->Maybe(t->singleton_zero) && rmin < 0) ||
+ (rhs->Maybe(t->singleton_zero) && lmin < 0);
+ Factory* f = t->isolate()->factory();
+ Type* range = Type::Range(f->NewNumber(array_min(results, 4)),
+ f->NewNumber(array_max(results, 4)), t->zone());
+ return maybe_minuszero ? Type::Union(range, Type::MinusZero(), t->zone())
+ : range;
+}
+
+
+Type* Typer::Visitor::JSMultiplyTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = Rangify(ToNumber(lhs, t), t);
+ rhs = Rangify(ToNumber(rhs, t), t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
+ if (lhs->IsRange() && rhs->IsRange()) {
+ return JSMultiplyRanger(lhs->AsRange(), rhs->AsRange(), t);
+ }
+ return Type::Number();
+}
+
+
+Type* Typer::Visitor::JSDivideTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = ToNumber(lhs, t);
+ rhs = ToNumber(rhs, t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
+ // Division is tricky, so all we do is try ruling out nan.
+ // TODO(neis): try ruling out -0 as well?
+ bool maybe_nan =
+ lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish) ||
+ ((lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) &&
+ (rhs->Min() == -V8_INFINITY || rhs->Max() == +V8_INFINITY));
+ return maybe_nan ? Type::Number() : Type::OrderedNumber();
+}
+
+
+Type* Typer::Visitor::JSModulusRanger(Type::RangeType* lhs,
+ Type::RangeType* rhs, Typer* t) {
+ double lmin = lhs->Min()->Number();
+ double lmax = lhs->Max()->Number();
+ double rmin = rhs->Min()->Number();
+ double rmax = rhs->Max()->Number();
+
+ double labs = std::max(std::abs(lmin), std::abs(lmax));
+ double rabs = std::max(std::abs(rmin), std::abs(rmax)) - 1;
+ double abs = std::min(labs, rabs);
+ bool maybe_minus_zero = false;
+ double omin = 0;
+ double omax = 0;
+ if (lmin >= 0) { // {lhs} positive.
+ omin = 0;
+ omax = abs;
+ } else if (lmax <= 0) { // {lhs} negative.
+ omin = 0 - abs;
+ omax = 0;
+ maybe_minus_zero = true;
+ } else {
+ omin = 0 - abs;
+ omax = abs;
+ maybe_minus_zero = true;
+ }
+
+ Factory* f = t->isolate()->factory();
+ Type* result = Type::Range(f->NewNumber(omin), f->NewNumber(omax), t->zone());
+ if (maybe_minus_zero)
+ result = Type::Union(result, Type::MinusZero(), t->zone());
+ return result;
}
-Bounds Typer::Visitor::TypeJSModulus(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
+Type* Typer::Visitor::JSModulusTyper(Type* lhs, Type* rhs, Typer* t) {
+ lhs = ToNumber(lhs, t);
+ rhs = ToNumber(rhs, t);
+ if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return Type::NaN();
+
+ if (lhs->Maybe(Type::NaN()) || rhs->Maybe(t->zeroish) ||
+ lhs->Min() == -V8_INFINITY || lhs->Max() == +V8_INFINITY) {
+ // Result maybe NaN.
+ return Type::Number();
+ }
+
+ lhs = Rangify(lhs, t);
+ rhs = Rangify(rhs, t);
+ if (lhs->IsRange() && rhs->IsRange()) {
+ // TODO(titzer): fix me.
+ // return JSModulusRanger(lhs->AsRange(), rhs->AsRange(), t);
+ }
+ return Type::OrderedNumber();
}
// JS unary operators.
+
+Type* Typer::Visitor::JSUnaryNotTyper(Type* type, Typer* t) {
+ return Invert(ToBoolean(type, t), t);
+}
+
+
Bounds Typer::Visitor::TypeJSUnaryNot(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return TypeUnaryOp(node, JSUnaryNotTyper);
}
Bounds Typer::Visitor::TypeJSTypeOf(Node* node) {
- return Bounds(Type::InternalizedString(zone()));
+ return Bounds(Type::None(zone()), Type::InternalizedString(zone()));
}
// JS conversion operators.
+
Bounds Typer::Visitor::TypeJSToBoolean(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeJSToNumber(Node* node) {
- return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeJSToString(Node* node) {
- return Bounds(Type::None(zone()), Type::String(zone()));
+ return TypeUnaryOp(node, ToString);
}
Bounds Typer::Visitor::TypeJSToName(Node* node) {
- return Bounds(Type::None(zone()), Type::Name(zone()));
+ return Bounds(Type::None(), Type::Name());
}
Bounds Typer::Visitor::TypeJSToObject(Node* node) {
- return Bounds(Type::None(zone()), Type::Receiver(zone()));
+ return Bounds(Type::None(), Type::Receiver());
}
// JS object operators.
+
Bounds Typer::Visitor::TypeJSCreate(Node* node) {
- return Bounds(Type::None(zone()), Type::Object(zone()));
+ return Bounds(Type::None(), Type::Object());
}
-Bounds Typer::Visitor::TypeJSLoadProperty(Node* node) {
- Bounds object = OperandType(node, 0);
- Bounds name = OperandType(node, 1);
- Bounds result = Bounds::Unbounded(zone());
+Type* Typer::Visitor::JSLoadPropertyTyper(Type* object, Type* name, Typer* t) {
// TODO(rossberg): Use range types and sized array types to filter undefined.
- if (object.lower->IsArray() && name.lower->Is(Type::Integral32())) {
- result.lower = Type::Union(
- object.lower->AsArray()->Element(), Type::Undefined(zone()), zone());
- }
- if (object.upper->IsArray() && name.upper->Is(Type::Integral32())) {
- result.upper = Type::Union(
- object.upper->AsArray()->Element(), Type::Undefined(zone()), zone());
+ if (object->IsArray() && name->Is(Type::Integral32())) {
+ return Type::Union(
+ object->AsArray()->Element(), Type::Undefined(), t->zone());
}
- return result;
+ return Type::Any();
+}
+
+
+Bounds Typer::Visitor::TypeJSLoadProperty(Node* node) {
+ return TypeBinaryOp(node, JSLoadPropertyTyper);
}
}
+// Returns a somewhat larger range if we previously assigned
+// a (smaller) range to this node. This is used to speed up
+// the fixpoint calculation in case there appears to be a loop
+// in the graph. In the current implementation, we are
+// increasing the limits to the closest power of two.
+Type* Typer::Visitor::Weaken(Type* current_type, Type* previous_type) {
+ if (current_type->IsRange() && previous_type->IsRange()) {
+ Type::RangeType* previous = previous_type->AsRange();
+ Type::RangeType* current = current_type->AsRange();
+
+ double current_min = current->Min()->Number();
+ Handle<Object> new_min = current->Min();
+
+ // Find the closest lower entry in the list of allowed
+ // minima (or negative infinity if there is no such entry).
+ if (current_min != previous->Min()->Number()) {
+ new_min = typer_->integer->AsRange()->Min();
+ for (const auto val : typer_->weaken_min_limits_) {
+ if (val->Number() <= current_min) {
+ new_min = val;
+ break;
+ }
+ }
+ }
+
+ double current_max = current->Max()->Number();
+ Handle<Object> new_max = current->Max();
+ // Find the closest greater entry in the list of allowed
+ // maxima (or infinity if there is no such entry).
+ if (current_max != previous->Max()->Number()) {
+ new_max = typer_->integer->AsRange()->Max();
+ for (const auto val : typer_->weaken_max_limits_) {
+ if (val->Number() >= current_max) {
+ new_max = val;
+ break;
+ }
+ }
+ }
+
+ return Type::Range(new_min, new_max, typer_->zone());
+ }
+ return current_type;
+}
+
+
Bounds Typer::Visitor::TypeJSStoreProperty(Node* node) {
UNREACHABLE();
return Bounds();
Bounds Typer::Visitor::TypeJSDeleteProperty(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeJSHasProperty(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeJSInstanceOf(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
// JS context operators.
+
Bounds Typer::Visitor::TypeJSLoadContext(Node* node) {
- Bounds outer = OperandType(node, 0);
+ Bounds outer = Operand(node, 0);
DCHECK(outer.upper->Maybe(Type::Internal()));
// TODO(rossberg): More precisely, instead of the above assertion, we should
// back-propagate the constraint that it has to be a subtype of Internal.
// bound.
// TODO(rossberg): Could use scope info to fix upper bounds for constant
// bindings if we know that this code is never shared.
- for (int i = access.depth(); i > 0; --i) {
+ for (size_t i = access.depth(); i > 0; --i) {
if (context_type->IsContext()) {
context_type = context_type->AsContext()->Outer();
if (context_type->IsConstant()) {
return Bounds::Unbounded(zone());
} else {
Handle<Object> value =
- handle(context.ToHandleChecked()->get(access.index()), isolate());
+ handle(context.ToHandleChecked()->get(static_cast<int>(access.index())),
+ isolate());
Type* lower = TypeConstant(value);
- return Bounds(lower, Type::Any(zone()));
+ return Bounds(lower, Type::Any());
}
}
Bounds Typer::Visitor::TypeJSCreateFunctionContext(Node* node) {
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
Bounds Typer::Visitor::TypeJSCreateCatchContext(Node* node) {
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
Bounds Typer::Visitor::TypeJSCreateWithContext(Node* node) {
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
Bounds Typer::Visitor::TypeJSCreateBlockContext(Node* node) {
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
Bounds Typer::Visitor::TypeJSCreateModuleContext(Node* node) {
// TODO(rossberg): this is probably incorrect
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
Bounds Typer::Visitor::TypeJSCreateGlobalContext(Node* node) {
- Type* outer = ContextType(node);
- return Bounds(Type::Context(outer, zone()));
+ Bounds outer = ContextOperand(node);
+ return Bounds(Type::Context(outer.upper, zone()));
}
// JS other operators.
+
Bounds Typer::Visitor::TypeJSYield(Node* node) {
return Bounds::Unbounded(zone());
}
Bounds Typer::Visitor::TypeJSCallConstruct(Node* node) {
- return Bounds(Type::None(zone()), Type::Receiver(zone()));
+ return Bounds(Type::None(), Type::Receiver());
+}
+
+
+Type* Typer::Visitor::JSCallFunctionTyper(Type* fun, Typer* t) {
+ return fun->IsFunction() ? fun->AsFunction()->Result() : Type::Any();
}
Bounds Typer::Visitor::TypeJSCallFunction(Node* node) {
- Bounds fun = OperandType(node, 0);
- Type* lower = fun.lower->IsFunction()
- ? fun.lower->AsFunction()->Result() : Type::None(zone());
- Type* upper = fun.upper->IsFunction()
- ? fun.upper->AsFunction()->Result() : Type::Any(zone());
- return Bounds(lower, upper);
+ return TypeUnaryOp(node, JSCallFunctionTyper); // We ignore argument types.
}
// Simplified operators.
+
Bounds Typer::Visitor::TypeBooleanNot(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeBooleanToNumber(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), typer_->zero_or_one);
}
Bounds Typer::Visitor::TypeNumberEqual(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeNumberLessThan(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeNumberLessThanOrEqual(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeNumberAdd(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeNumberSubtract(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeNumberMultiply(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeNumberDivide(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeNumberModulus(Node* node) {
- return Bounds(Type::Number(zone()));
+ return Bounds(Type::None(zone()), Type::Number(zone()));
}
Bounds Typer::Visitor::TypeNumberToInt32(Node* node) {
- Bounds arg = OperandType(node, 0);
- Type* s32 = Type::Signed32(zone());
- Type* lower = arg.lower->Is(s32) ? arg.lower : s32;
- Type* upper = arg.upper->Is(s32) ? arg.upper : s32;
- return Bounds(lower, upper);
+ return TypeUnaryOp(node, NumberToInt32);
}
Bounds Typer::Visitor::TypeNumberToUint32(Node* node) {
- Bounds arg = OperandType(node, 0);
- Type* u32 = Type::Unsigned32(zone());
- Type* lower = arg.lower->Is(u32) ? arg.lower : u32;
- Type* upper = arg.upper->Is(u32) ? arg.upper : u32;
- return Bounds(lower, upper);
+ return TypeUnaryOp(node, NumberToUint32);
}
Bounds Typer::Visitor::TypeReferenceEqual(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeStringEqual(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeStringLessThan(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeStringLessThanOrEqual(Node* node) {
- return Bounds(Type::Boolean(zone()));
+ return Bounds(Type::None(zone()), Type::Boolean(zone()));
}
Bounds Typer::Visitor::TypeStringAdd(Node* node) {
- return Bounds(Type::String(zone()));
+ return Bounds(Type::None(zone()), Type::String(zone()));
+}
+
+
+static Type* ChangeRepresentation(Type* type, Type* rep, Zone* zone) {
+ // TODO(neis): Enable when expressible.
+ /*
+ return Type::Union(
+ Type::Intersect(type, Type::Semantic(), zone),
+ Type::Intersect(rep, Type::Representation(), zone), zone);
+ */
+ return type;
}
Bounds Typer::Visitor::TypeChangeTaggedToInt32(Node* node) {
- // TODO(titzer): type is type of input, representation is Word32.
- return Bounds(Type::Integral32());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Signed32()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::UntaggedInt32(), zone()),
+ ChangeRepresentation(arg.upper, Type::UntaggedInt32(), zone()));
}
Bounds Typer::Visitor::TypeChangeTaggedToUint32(Node* node) {
- return Bounds(Type::Integral32()); // TODO(titzer): add appropriate rep
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Unsigned32()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::UntaggedInt32(), zone()),
+ ChangeRepresentation(arg.upper, Type::UntaggedInt32(), zone()));
}
Bounds Typer::Visitor::TypeChangeTaggedToFloat64(Node* node) {
- // TODO(titzer): type is type of input, representation is Float64.
- return Bounds(Type::Number());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Number()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::UntaggedFloat64(), zone()),
+ ChangeRepresentation(arg.upper, Type::UntaggedFloat64(), zone()));
}
Bounds Typer::Visitor::TypeChangeInt32ToTagged(Node* node) {
- // TODO(titzer): type is type of input, representation is Tagged.
- return Bounds(Type::Integral32());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Signed32()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::Tagged(), zone()),
+ ChangeRepresentation(arg.upper, Type::Tagged(), zone()));
}
Bounds Typer::Visitor::TypeChangeUint32ToTagged(Node* node) {
- // TODO(titzer): type is type of input, representation is Tagged.
- return Bounds(Type::Unsigned32());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Unsigned32()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::Tagged(), zone()),
+ ChangeRepresentation(arg.upper, Type::Tagged(), zone()));
}
Bounds Typer::Visitor::TypeChangeFloat64ToTagged(Node* node) {
- // TODO(titzer): type is type of input, representation is Tagged.
- return Bounds(Type::Number());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): CHECK(arg.upper->Is(Type::Number()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::Tagged(), zone()),
+ ChangeRepresentation(arg.upper, Type::Tagged(), zone()));
}
Bounds Typer::Visitor::TypeChangeBoolToBit(Node* node) {
- // TODO(titzer): type is type of input, representation is Bit.
- return Bounds(Type::Boolean());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::UntaggedInt1(), zone()),
+ ChangeRepresentation(arg.upper, Type::UntaggedInt1(), zone()));
}
Bounds Typer::Visitor::TypeChangeBitToBool(Node* node) {
- // TODO(titzer): type is type of input, representation is Tagged.
- return Bounds(Type::Boolean());
+ Bounds arg = Operand(node, 0);
+ // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
+ return Bounds(
+ ChangeRepresentation(arg.lower, Type::TaggedPtr(), zone()),
+ ChangeRepresentation(arg.upper, Type::TaggedPtr(), zone()));
}
}
+Bounds Typer::Visitor::TypeObjectIsSmi(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeObjectIsNonNegativeSmi(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
// Machine operators.
-// TODO(rossberg): implement
-#define DEFINE_METHOD(x) \
- Bounds Typer::Visitor::Type##x(Node* node) { return Bounds(Type::None()); }
-MACHINE_OP_LIST(DEFINE_METHOD)
-#undef DEFINE_METHOD
+Bounds Typer::Visitor::TypeLoad(Node* node) {
+ return Bounds::Unbounded(zone());
+}
-// Heap constants.
+Bounds Typer::Visitor::TypeStore(Node* node) {
+ UNREACHABLE();
+ return Bounds();
+}
-Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
- if (value->IsJSFunction() && JSFunction::cast(*value)->IsBuiltin() &&
- !context().is_null()) {
- Handle<Context> native =
- handle(context().ToHandleChecked()->native_context(), isolate());
- if (*value == native->math_abs_fun()) {
- return typer_->number_fun1_; // TODO(rossberg): can't express overloading
- } else if (*value == native->math_acos_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_asin_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_atan_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_atan2_fun()) {
- return typer_->number_fun2_;
- } else if (*value == native->math_ceil_fun()) {
- return typer_->weakint_fun1_;
- } else if (*value == native->math_cos_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_exp_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_floor_fun()) {
- return typer_->weakint_fun1_;
- } else if (*value == native->math_imul_fun()) {
- return typer_->imul_fun_;
- } else if (*value == native->math_log_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_pow_fun()) {
- return typer_->number_fun2_;
- } else if (*value == native->math_random_fun()) {
- return typer_->random_fun_;
- } else if (*value == native->math_round_fun()) {
- return typer_->weakint_fun1_;
- } else if (*value == native->math_sin_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_sqrt_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->math_tan_fun()) {
- return typer_->number_fun1_;
- } else if (*value == native->array_buffer_fun()) {
- return typer_->array_buffer_fun_;
- } else if (*value == native->int8_array_fun()) {
- return typer_->int8_array_fun_;
- } else if (*value == native->int16_array_fun()) {
- return typer_->int16_array_fun_;
- } else if (*value == native->int32_array_fun()) {
- return typer_->int32_array_fun_;
- } else if (*value == native->uint8_array_fun()) {
- return typer_->uint8_array_fun_;
- } else if (*value == native->uint16_array_fun()) {
- return typer_->uint16_array_fun_;
- } else if (*value == native->uint32_array_fun()) {
- return typer_->uint32_array_fun_;
- } else if (*value == native->float32_array_fun()) {
- return typer_->float32_array_fun_;
- } else if (*value == native->float64_array_fun()) {
- return typer_->float64_array_fun_;
- }
- }
- return Type::Constant(value, zone());
+
+Bounds Typer::Visitor::TypeWord32And(Node* node) {
+ return Bounds(Type::Integral32());
}
-namespace {
+Bounds Typer::Visitor::TypeWord32Or(Node* node) {
+ return Bounds(Type::Integral32());
+}
-class TyperDecorator : public GraphDecorator {
- public:
- explicit TyperDecorator(Typer* typer) : typer_(typer) {}
- virtual void Decorate(Node* node) { typer_->Init(node); }
- private:
- Typer* typer_;
-};
+Bounds Typer::Visitor::TypeWord32Xor(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeWord32Shl(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeWord32Shr(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeWord32Sar(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeWord32Ror(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeWord32Equal(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+Bounds Typer::Visitor::TypeWord64And(Node* node) {
+ return Bounds(Type::Internal());
}
-void Typer::DecorateGraph(Graph* graph) {
- graph->AddDecorator(new (zone()) TyperDecorator(this));
+Bounds Typer::Visitor::TypeWord64Or(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Xor(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Shl(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Shr(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Sar(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Ror(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeWord64Equal(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeInt32Add(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32AddWithOverflow(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt32Sub(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32SubWithOverflow(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt32Mul(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32MulHigh(Node* node) {
+ return Bounds(Type::Signed32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32Div(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32Mod(Node* node) {
+ return Bounds(Type::Integral32());
+}
+
+
+Bounds Typer::Visitor::TypeInt32LessThan(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeInt32LessThanOrEqual(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeUint32Div(Node* node) {
+ return Bounds(Type::Unsigned32());
+}
+
+
+Bounds Typer::Visitor::TypeUint32LessThan(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeUint32LessThanOrEqual(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeUint32Mod(Node* node) {
+ return Bounds(Type::Unsigned32());
+}
+
+
+Bounds Typer::Visitor::TypeUint32MulHigh(Node* node) {
+ return Bounds(Type::Unsigned32());
+}
+
+
+Bounds Typer::Visitor::TypeInt64Add(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt64Sub(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt64Mul(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt64Div(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt64Mod(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeInt64LessThan(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeInt64LessThanOrEqual(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeUint64Div(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeUint64LessThan(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeUint64Mod(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeChangeFloat32ToFloat64(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Number(), Type::UntaggedFloat64(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeChangeFloat64ToInt32(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Signed32(), Type::UntaggedInt32(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeChangeFloat64ToUint32(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Unsigned32(), Type::UntaggedInt32(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeChangeInt32ToFloat64(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Signed32(), Type::UntaggedFloat64(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeChangeInt32ToInt64(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeChangeUint32ToFloat64(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Unsigned32(), Type::UntaggedFloat64(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeChangeUint32ToUint64(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+Bounds Typer::Visitor::TypeTruncateFloat64ToFloat32(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Number(), Type::UntaggedFloat32(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeTruncateFloat64ToInt32(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Signed32(), Type::UntaggedInt32(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeTruncateInt64ToInt32(Node* node) {
+ return Bounds(Type::Intersect(
+ Type::Signed32(), Type::UntaggedInt32(), zone()));
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Add(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Sub(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Mul(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Div(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Mod(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Sqrt(Node* node) {
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Equal(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64LessThan(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64LessThanOrEqual(Node* node) {
+ return Bounds(Type::Boolean());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Floor(Node* node) {
+ // TODO(sigurds): We could have a tighter bound here.
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64Ceil(Node* node) {
+ // TODO(sigurds): We could have a tighter bound here.
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64RoundTruncate(Node* node) {
+ // TODO(sigurds): We could have a tighter bound here.
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeFloat64RoundTiesAway(Node* node) {
+ // TODO(sigurds): We could have a tighter bound here.
+ return Bounds(Type::Number());
+}
+
+
+Bounds Typer::Visitor::TypeLoadStackPointer(Node* node) {
+ return Bounds(Type::Internal());
+}
+
+
+// Heap constants.
+
+
+Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
+ if (value->IsJSFunction()) {
+ if (JSFunction::cast(*value)->shared()->HasBuiltinFunctionId()) {
+ switch (JSFunction::cast(*value)->shared()->builtin_function_id()) {
+ case kMathRandom:
+ return typer_->random_fun_;
+ case kMathFloor:
+ return typer_->weakint_fun1_;
+ case kMathRound:
+ return typer_->weakint_fun1_;
+ case kMathCeil:
+ return typer_->weakint_fun1_;
+ case kMathAbs:
+ // TODO(rossberg): can't express overloading
+ return typer_->number_fun1_;
+ case kMathLog:
+ return typer_->number_fun1_;
+ case kMathExp:
+ return typer_->number_fun1_;
+ case kMathSqrt:
+ return typer_->number_fun1_;
+ case kMathPow:
+ return typer_->number_fun2_;
+ case kMathMax:
+ return typer_->number_fun2_;
+ case kMathMin:
+ return typer_->number_fun2_;
+ case kMathCos:
+ return typer_->number_fun1_;
+ case kMathSin:
+ return typer_->number_fun1_;
+ case kMathTan:
+ return typer_->number_fun1_;
+ case kMathAcos:
+ return typer_->number_fun1_;
+ case kMathAsin:
+ return typer_->number_fun1_;
+ case kMathAtan:
+ return typer_->number_fun1_;
+ case kMathAtan2:
+ return typer_->number_fun2_;
+ case kMathImul:
+ return typer_->imul_fun_;
+ case kMathClz32:
+ return typer_->clz32_fun_;
+ case kMathFround:
+ return typer_->number_fun1_;
+ default:
+ break;
+ }
+ } else if (JSFunction::cast(*value)->IsBuiltin() && !context().is_null()) {
+ Handle<Context> native =
+ handle(context().ToHandleChecked()->native_context(), isolate());
+ if (*value == native->array_buffer_fun()) {
+ return typer_->array_buffer_fun_;
+ } else if (*value == native->int8_array_fun()) {
+ return typer_->int8_array_fun_;
+ } else if (*value == native->int16_array_fun()) {
+ return typer_->int16_array_fun_;
+ } else if (*value == native->int32_array_fun()) {
+ return typer_->int32_array_fun_;
+ } else if (*value == native->uint8_array_fun()) {
+ return typer_->uint8_array_fun_;
+ } else if (*value == native->uint16_array_fun()) {
+ return typer_->uint16_array_fun_;
+ } else if (*value == native->uint32_array_fun()) {
+ return typer_->uint32_array_fun_;
+ } else if (*value == native->float32_array_fun()) {
+ return typer_->float32_array_fun_;
+ } else if (*value == native->float64_array_fun()) {
+ return typer_->float64_array_fun_;
+ }
+ }
+ }
+ return Type::Constant(value, zone());
}
}
class Typer {
public:
- explicit Typer(Zone* zone);
+ explicit Typer(Graph* graph, MaybeHandle<Context> context);
+ ~Typer();
- void Init(Node* node);
- void Run(Graph* graph, MaybeHandle<Context> context);
- void Narrow(Graph* graph, Node* node, MaybeHandle<Context> context);
- void Widen(Graph* graph, Node* node, MaybeHandle<Context> context);
+ void Run();
- void DecorateGraph(Graph* graph);
-
- Zone* zone() { return zone_; }
- Isolate* isolate() { return zone_->isolate(); }
+ Graph* graph() { return graph_; }
+ MaybeHandle<Context> context() { return context_; }
+ Zone* zone() { return graph_->zone(); }
+ Isolate* isolate() { return zone()->isolate(); }
private:
class Visitor;
class RunVisitor;
- class NarrowVisitor;
class WidenVisitor;
+ class Decorator;
+
+ Graph* graph_;
+ MaybeHandle<Context> context_;
+ Decorator* decorator_;
Zone* zone_;
+ Type* negative_signed32;
+ Type* non_negative_signed32;
+ Type* undefined_or_null;
+ Type* singleton_false;
+ Type* singleton_true;
+ Type* singleton_zero;
+ Type* singleton_one;
+ Type* zero_or_one;
+ Type* zeroish;
+ Type* falsish;
+ Type* integer;
+ Type* weakint;
Type* number_fun0_;
Type* number_fun1_;
Type* number_fun2_;
Type* weakint_fun1_;
Type* imul_fun_;
+ Type* clz32_fun_;
Type* random_fun_;
Type* array_buffer_fun_;
Type* int8_array_fun_;
Type* uint32_array_fun_;
Type* float32_array_fun_;
Type* float64_array_fun_;
+
+ ZoneVector<Handle<Object> > weaken_min_limits_;
+ ZoneVector<Handle<Object> > weaken_max_limits_;
+ DISALLOW_COPY_AND_ASSIGN(Typer);
};
}
}
#include "src/compiler/value-numbering-reducer.h"
+#include <cstring>
+
+#include "src/base/functional.h"
#include "src/compiler/node.h"
namespace v8 {
namespace {
-size_t HashCode(Node* node) { return node->op()->HashCode(); }
+size_t HashCode(Node* node) {
+ size_t h = base::hash_combine(node->op()->HashCode(), node->InputCount());
+ for (int j = 0; j < node->InputCount(); ++j) {
+ h = base::hash_combine(h, node->InputAt(j)->id());
+ }
+ return h;
+}
bool Equals(Node* a, Node* b) {
} // namespace
-class ValueNumberingReducer::Entry FINAL : public ZoneObject {
- public:
- Entry(Node* node, Entry* next) : node_(node), next_(next) {}
+ValueNumberingReducer::ValueNumberingReducer(Zone* zone)
+ : entries_(nullptr), capacity_(0), size_(0), zone_(zone) {}
- Node* node() const { return node_; }
- Entry* next() const { return next_; }
- private:
- Node* node_;
- Entry* next_;
-};
+ValueNumberingReducer::~ValueNumberingReducer() {}
-ValueNumberingReducer::ValueNumberingReducer(Zone* zone) : zone_(zone) {
- for (size_t i = 0; i < arraysize(buckets_); ++i) {
- buckets_[i] = NULL;
+Reduction ValueNumberingReducer::Reduce(Node* node) {
+ if (!node->op()->HasProperty(Operator::kEliminatable)) return NoChange();
+
+ const size_t hash = HashCode(node);
+ if (!entries_) {
+ DCHECK(size_ == 0);
+ DCHECK(capacity_ == 0);
+ // Allocate the initial entries and insert the first entry.
+ capacity_ = kInitialCapacity;
+ entries_ = zone()->NewArray<Node*>(kInitialCapacity);
+ memset(entries_, 0, sizeof(*entries_) * kInitialCapacity);
+ entries_[hash & (kInitialCapacity - 1)] = node;
+ size_ = 1;
+ return NoChange();
}
-}
+ DCHECK(size_ < capacity_);
+ DCHECK(size_ * kCapacityToSizeRatio < capacity_);
+
+ const size_t mask = capacity_ - 1;
+ size_t dead = capacity_;
+
+ for (size_t i = hash & mask;; i = (i + 1) & mask) {
+ Node* entry = entries_[i];
+ if (!entry) {
+ if (dead != capacity_) {
+ // Reuse dead entry that we discovered on the way.
+ entries_[dead] = node;
+ } else {
+ // Have to insert a new entry.
+ entries_[i] = node;
+ size_++;
+
+ // Resize to keep load factor below 1/kCapacityToSizeRatio.
+ if (size_ * kCapacityToSizeRatio >= capacity_) Grow();
+ }
+ DCHECK(size_ * kCapacityToSizeRatio < capacity_);
+ return NoChange();
+ }
+ if (entry == node) {
+ return NoChange();
+ }
-ValueNumberingReducer::~ValueNumberingReducer() {}
+ // Skip dead entries, but remember their indices so we can reuse them.
+ if (entry->IsDead()) {
+ dead = i;
+ continue;
+ }
+ if (Equals(entry, node)) {
+ return Replace(entry);
+ }
+ }
+}
-Reduction ValueNumberingReducer::Reduce(Node* node) {
- Entry** head = &buckets_[HashCode(node) % arraysize(buckets_)];
- for (Entry* entry = *head; entry; entry = entry->next()) {
- if (entry->node()->IsDead()) continue;
- if (entry->node() == node) return NoChange();
- if (Equals(node, entry->node())) {
- return Replace(entry->node());
+void ValueNumberingReducer::Grow() {
+ // Allocate a new block of entries kCapacityToSizeRatio times the previous
+ // capacity.
+ Node** const old_entries = entries_;
+ size_t const old_capacity = capacity_;
+ capacity_ *= kCapacityToSizeRatio;
+ entries_ = zone()->NewArray<Node*>(static_cast<int>(capacity_));
+ memset(entries_, 0, sizeof(*entries_) * capacity_);
+ size_ = 0;
+ size_t const mask = capacity_ - 1;
+
+ // Insert the old entries into the new block (skipping dead nodes).
+ for (size_t i = 0; i < old_capacity; ++i) {
+ Node* const old_entry = old_entries[i];
+ if (!old_entry || old_entry->IsDead()) continue;
+ for (size_t j = HashCode(old_entry) & mask;; j = (j + 1) & mask) {
+ Node* const entry = entries_[j];
+ if (entry == old_entry) {
+ // Skip duplicate of the old entry.
+ break;
+ }
+ if (!entry) {
+ entries_[j] = old_entry;
+ size_++;
+ break;
+ }
}
}
- *head = new (zone()) Entry(node, *head);
- return NoChange();
}
} // namespace compiler
virtual Reduction Reduce(Node* node) OVERRIDE;
private:
+ enum { kInitialCapacity = 256u, kCapacityToSizeRatio = 2u };
+
+ void Grow();
Zone* zone() const { return zone_; }
- // TODO(turbofan): We currently use separate chaining with linked lists here,
- // we may want to replace that with a more sophisticated data structure at
- // some point in the future.
- class Entry;
- Entry* buckets_[117u];
+ Node** entries_;
+ size_t capacity_;
+ size_t size_;
Zone* zone_;
};
#include <deque>
#include <queue>
+#include <sstream>
+#include <string>
+#include "src/bit-vector.h"
#include "src/compiler/generic-algorithm.h"
#include "src/compiler/generic-node-inl.h"
#include "src/compiler/generic-node.h"
#include "src/compiler/opcodes.h"
#include "src/compiler/operator.h"
#include "src/compiler/schedule.h"
-#include "src/data-flow.h"
+#include "src/compiler/simplified-operator.h"
+#include "src/ostreams.h"
namespace v8 {
namespace internal {
class Verifier::Visitor : public NullNodeVisitor {
public:
- explicit Visitor(Zone* zone)
- : reached_from_start(NodeSet::key_compare(),
- NodeSet::allocator_type(zone)),
- reached_from_end(NodeSet::key_compare(),
- NodeSet::allocator_type(zone)) {}
+ Visitor(Zone* z, Typing typed) : zone(z), typing(typed) {}
// Fulfills the PreNodeCallback interface.
- GenericGraphVisit::Control Pre(Node* node);
+ void Pre(Node* node);
- bool from_start;
- NodeSet reached_from_start;
- NodeSet reached_from_end;
+ Zone* zone;
+ Typing typing;
+
+ private:
+ // TODO(rossberg): Get rid of these once we got rid of NodeProperties.
+ Bounds bounds(Node* node) { return NodeProperties::GetBounds(node); }
+ Node* ValueInput(Node* node, int i = 0) {
+ return NodeProperties::GetValueInput(node, i);
+ }
+ FieldAccess Field(Node* node) {
+ DCHECK(node->opcode() == IrOpcode::kLoadField ||
+ node->opcode() == IrOpcode::kStoreField);
+ return OpParameter<FieldAccess>(node);
+ }
+ ElementAccess Element(Node* node) {
+ DCHECK(node->opcode() == IrOpcode::kLoadElement ||
+ node->opcode() == IrOpcode::kStoreElement);
+ return OpParameter<ElementAccess>(node);
+ }
+ void CheckNotTyped(Node* node) {
+ if (NodeProperties::IsTyped(node)) {
+ std::ostringstream str;
+ str << "TypeError: node #" << node->opcode() << ":"
+ << node->op()->mnemonic() << " should never have a type";
+ V8_Fatal(__FILE__, __LINE__, str.str().c_str());
+ }
+ }
+ void CheckUpperIs(Node* node, Type* type) {
+ if (typing == TYPED && !bounds(node).upper->Is(type)) {
+ std::ostringstream str;
+ str << "TypeError: node #" << node->opcode() << ":"
+ << node->op()->mnemonic() << " upper bound ";
+ bounds(node).upper->PrintTo(str);
+ str << " is not ";
+ type->PrintTo(str);
+ V8_Fatal(__FILE__, __LINE__, str.str().c_str());
+ }
+ }
+ void CheckUpperMaybe(Node* node, Type* type) {
+ if (typing == TYPED && !bounds(node).upper->Maybe(type)) {
+ std::ostringstream str;
+ str << "TypeError: node #" << node->opcode() << ":"
+ << node->op()->mnemonic() << " upper bound ";
+ bounds(node).upper->PrintTo(str);
+ str << " must intersect ";
+ type->PrintTo(str);
+ V8_Fatal(__FILE__, __LINE__, str.str().c_str());
+ }
+ }
+ void CheckValueInputIs(Node* node, int i, Type* type) {
+ Node* input = ValueInput(node, i);
+ if (typing == TYPED && !bounds(input).upper->Is(type)) {
+ std::ostringstream str;
+ str << "TypeError: node #" << node->opcode() << ":"
+ << node->op()->mnemonic() << "(input @" << i << " = "
+ << input->opcode() << ":" << input->op()->mnemonic()
+ << ") upper bound ";
+ bounds(input).upper->PrintTo(str);
+ str << " is not ";
+ type->PrintTo(str);
+ V8_Fatal(__FILE__, __LINE__, str.str().c_str());
+ }
+ }
};
-GenericGraphVisit::Control Verifier::Visitor::Pre(Node* node) {
- int value_count = OperatorProperties::GetValueInputCount(node->op());
+void Verifier::Visitor::Pre(Node* node) {
+ int value_count = node->op()->ValueInputCount();
int context_count = OperatorProperties::GetContextInputCount(node->op());
int frame_state_count =
OperatorProperties::GetFrameStateInputCount(node->op());
- int effect_count = OperatorProperties::GetEffectInputCount(node->op());
- int control_count = OperatorProperties::GetControlInputCount(node->op());
+ int effect_count = node->op()->EffectInputCount();
+ int control_count = node->op()->ControlInputCount();
// Verify number of inputs matches up.
int input_count = value_count + context_count + frame_state_count +
// Verify all value inputs actually produce a value.
for (int i = 0; i < value_count; ++i) {
Node* value = NodeProperties::GetValueInput(node, i);
- CHECK(OperatorProperties::HasValueOutput(value->op()));
+ CHECK(value->op()->ValueOutputCount() > 0);
CHECK(IsDefUseChainLinkPresent(value, node));
CHECK(IsUseDefChainLinkPresent(value, node));
}
// Verify all context inputs are value nodes.
for (int i = 0; i < context_count; ++i) {
Node* context = NodeProperties::GetContextInput(node);
- CHECK(OperatorProperties::HasValueOutput(context->op()));
+ CHECK(context->op()->ValueOutputCount() > 0);
CHECK(IsDefUseChainLinkPresent(context, node));
CHECK(IsUseDefChainLinkPresent(context, node));
}
// Verify all effect inputs actually have an effect.
for (int i = 0; i < effect_count; ++i) {
Node* effect = NodeProperties::GetEffectInput(node);
- CHECK(OperatorProperties::HasEffectOutput(effect->op()));
+ CHECK(effect->op()->EffectOutputCount() > 0);
CHECK(IsDefUseChainLinkPresent(effect, node));
CHECK(IsUseDefChainLinkPresent(effect, node));
}
// Verify all control inputs are control nodes.
for (int i = 0; i < control_count; ++i) {
Node* control = NodeProperties::GetControlInput(node, i);
- CHECK(OperatorProperties::HasControlOutput(control->op()));
+ CHECK(control->op()->ControlOutputCount() > 0);
CHECK(IsDefUseChainLinkPresent(control, node));
CHECK(IsUseDefChainLinkPresent(control, node));
}
// Verify all successors are projections if multiple value outputs exist.
- if (OperatorProperties::GetValueOutputCount(node->op()) > 1) {
+ if (node->op()->ValueOutputCount() > 1) {
Node::Uses uses = node->uses();
for (Node::Uses::iterator it = uses.begin(); it != uses.end(); ++it) {
CHECK(!NodeProperties::IsValueEdge(it.edge()) ||
case IrOpcode::kStart:
// Start has no inputs.
CHECK_EQ(0, input_count);
+ // Type is a tuple.
+ // TODO(rossberg): Multiple outputs are currently typed as Internal.
+ CheckUpperIs(node, Type::Internal());
break;
case IrOpcode::kEnd:
// End has no outputs.
- CHECK(!OperatorProperties::HasValueOutput(node->op()));
- CHECK(!OperatorProperties::HasEffectOutput(node->op()));
- CHECK(!OperatorProperties::HasControlOutput(node->op()));
+ CHECK(node->op()->ValueOutputCount() == 0);
+ CHECK(node->op()->EffectOutputCount() == 0);
+ CHECK(node->op()->ControlOutputCount() == 0);
+ // Type is empty.
+ CheckNotTyped(node);
break;
case IrOpcode::kDead:
// Dead is never connected to the graph.
case IrOpcode::kBranch: {
// Branch uses are IfTrue and IfFalse.
Node::Uses uses = node->uses();
- bool got_true = false, got_false = false;
+ int count_true = 0, count_false = 0;
for (Node::Uses::iterator it = uses.begin(); it != uses.end(); ++it) {
- CHECK(((*it)->opcode() == IrOpcode::kIfTrue && !got_true) ||
- ((*it)->opcode() == IrOpcode::kIfFalse && !got_false));
- if ((*it)->opcode() == IrOpcode::kIfTrue) got_true = true;
- if ((*it)->opcode() == IrOpcode::kIfFalse) got_false = true;
+ CHECK((*it)->opcode() == IrOpcode::kIfTrue ||
+ (*it)->opcode() == IrOpcode::kIfFalse);
+ if ((*it)->opcode() == IrOpcode::kIfTrue) ++count_true;
+ if ((*it)->opcode() == IrOpcode::kIfFalse) ++count_false;
}
- // TODO(rossberg): Currently fails for various tests.
- // CHECK(got_true && got_false);
+ CHECK(count_true == 1 && count_false == 1);
+ // Type is empty.
+ CheckNotTyped(node);
break;
}
case IrOpcode::kIfTrue:
case IrOpcode::kIfFalse:
CHECK_EQ(IrOpcode::kBranch,
NodeProperties::GetControlInput(node, 0)->opcode());
+ // Type is empty.
+ CheckNotTyped(node);
break;
case IrOpcode::kLoop:
case IrOpcode::kMerge:
+ CHECK_EQ(control_count, input_count);
+ // Type is empty.
+ CheckNotTyped(node);
break;
case IrOpcode::kReturn:
// TODO(rossberg): check successor is End
+ // Type is empty.
+ CheckNotTyped(node);
break;
case IrOpcode::kThrow:
// TODO(rossberg): what are the constraints on these?
+ // Type is empty.
+ CheckNotTyped(node);
break;
+ case IrOpcode::kTerminate:
+ // Type is empty.
+ CheckNotTyped(node);
+ CHECK_EQ(1, control_count);
+ CHECK_EQ(input_count, 1 + effect_count);
+ break;
+
+ // Common operators
+ // ----------------
case IrOpcode::kParameter: {
// Parameters have the start node as inputs.
CHECK_EQ(1, input_count);
int index = OpParameter<int>(node);
Node* input = NodeProperties::GetValueInput(node, 0);
// Currently, parameter indices start at -1 instead of 0.
- CHECK_GT(OperatorProperties::GetValueOutputCount(input->op()), index + 1);
+ CHECK_GT(input->op()->ValueOutputCount(), index + 1);
+ // Type can be anything.
+ CheckUpperIs(node, Type::Any());
break;
}
- case IrOpcode::kInt32Constant:
+ case IrOpcode::kInt32Constant: // TODO(rossberg): rename Word32Constant?
+ // Constants have no inputs.
+ CHECK_EQ(0, input_count);
+ // Type is a 32 bit integer, signed or unsigned.
+ CheckUpperIs(node, Type::Integral32());
+ break;
case IrOpcode::kInt64Constant:
+ // Constants have no inputs.
+ CHECK_EQ(0, input_count);
+ // Type is internal.
+ // TODO(rossberg): Introduce proper Int64 type.
+ CheckUpperIs(node, Type::Internal());
+ break;
+ case IrOpcode::kFloat32Constant:
case IrOpcode::kFloat64Constant:
- case IrOpcode::kExternalConstant:
case IrOpcode::kNumberConstant:
+ // Constants have no inputs.
+ CHECK_EQ(0, input_count);
+ // Type is a number.
+ CheckUpperIs(node, Type::Number());
+ break;
case IrOpcode::kHeapConstant:
// Constants have no inputs.
CHECK_EQ(0, input_count);
+ // Type can be anything represented as a heap pointer.
+ CheckUpperIs(node, Type::TaggedPtr());
+ break;
+ case IrOpcode::kExternalConstant:
+ // Constants have no inputs.
+ CHECK_EQ(0, input_count);
+ // Type is considered internal.
+ CheckUpperIs(node, Type::Internal());
break;
+ case IrOpcode::kProjection: {
+ // Projection has an input that produces enough values.
+ int index = static_cast<int>(OpParameter<size_t>(node->op()));
+ Node* input = NodeProperties::GetValueInput(node, 0);
+ CHECK_GT(input->op()->ValueOutputCount(), index);
+ // Type can be anything.
+ // TODO(rossberg): Introduce tuple types for this.
+ // TODO(titzer): Convince rossberg not to.
+ CheckUpperIs(node, Type::Any());
+ break;
+ }
+ case IrOpcode::kSelect: {
+ CHECK_EQ(0, effect_count);
+ CHECK_EQ(0, control_count);
+ CHECK_EQ(3, value_count);
+ break;
+ }
case IrOpcode::kPhi: {
// Phi input count matches parent control node.
+ CHECK_EQ(0, effect_count);
CHECK_EQ(1, control_count);
Node* control = NodeProperties::GetControlInput(node, 0);
- CHECK_EQ(value_count,
- OperatorProperties::GetControlInputCount(control->op()));
+ CHECK_EQ(value_count, control->op()->ControlInputCount());
+ CHECK_EQ(input_count, 1 + value_count);
+ // Type must be subsumed by all input types.
+ // TODO(rossberg): for now at least, narrowing does not really hold.
+ /*
+ for (int i = 0; i < value_count; ++i) {
+ // TODO(rossberg, jarin): Figure out what to do about lower bounds.
+ // CHECK(bounds(node).lower->Is(bounds(ValueInput(node, i)).lower));
+ CHECK(bounds(ValueInput(node, i)).upper->Is(bounds(node).upper));
+ }
+ */
break;
}
case IrOpcode::kEffectPhi: {
// EffectPhi input count matches parent control node.
+ CHECK_EQ(0, value_count);
CHECK_EQ(1, control_count);
Node* control = NodeProperties::GetControlInput(node, 0);
- CHECK_EQ(effect_count,
- OperatorProperties::GetControlInputCount(control->op()));
+ CHECK_EQ(effect_count, control->op()->ControlInputCount());
+ CHECK_EQ(input_count, 1 + effect_count);
+ break;
+ }
+ case IrOpcode::kValueEffect:
+ // TODO(rossberg): what are the constraints on these?
+ break;
+ case IrOpcode::kFinish: {
+ // TODO(rossberg): what are the constraints on these?
+ // Type must be subsumed by input type.
+ if (typing == TYPED) {
+ CHECK(bounds(ValueInput(node)).lower->Is(bounds(node).lower));
+ CHECK(bounds(ValueInput(node)).upper->Is(bounds(node).upper));
+ }
break;
}
case IrOpcode::kFrameState:
// TODO(jarin): what are the constraints on these?
break;
+ case IrOpcode::kStateValues:
+ // TODO(jarin): what are the constraints on these?
+ break;
case IrOpcode::kCall:
// TODO(rossberg): what are the constraints on these?
break;
- case IrOpcode::kProjection: {
- // Projection has an input that produces enough values.
- size_t index = OpParameter<size_t>(node);
- Node* input = NodeProperties::GetValueInput(node, 0);
- CHECK_GT(OperatorProperties::GetValueOutputCount(input->op()),
- static_cast<int>(index));
+
+ // JavaScript operators
+ // --------------------
+ case IrOpcode::kJSEqual:
+ case IrOpcode::kJSNotEqual:
+ case IrOpcode::kJSStrictEqual:
+ case IrOpcode::kJSStrictNotEqual:
+ case IrOpcode::kJSLessThan:
+ case IrOpcode::kJSGreaterThan:
+ case IrOpcode::kJSLessThanOrEqual:
+ case IrOpcode::kJSGreaterThanOrEqual:
+ case IrOpcode::kJSUnaryNot:
+ // Type is Boolean.
+ CheckUpperIs(node, Type::Boolean());
+ break;
+
+ case IrOpcode::kJSBitwiseOr:
+ case IrOpcode::kJSBitwiseXor:
+ case IrOpcode::kJSBitwiseAnd:
+ case IrOpcode::kJSShiftLeft:
+ case IrOpcode::kJSShiftRight:
+ case IrOpcode::kJSShiftRightLogical:
+ // Type is 32 bit integral.
+ CheckUpperIs(node, Type::Integral32());
+ break;
+ case IrOpcode::kJSAdd:
+ // Type is Number or String.
+ CheckUpperIs(node, Type::NumberOrString());
+ break;
+ case IrOpcode::kJSSubtract:
+ case IrOpcode::kJSMultiply:
+ case IrOpcode::kJSDivide:
+ case IrOpcode::kJSModulus:
+ // Type is Number.
+ CheckUpperIs(node, Type::Number());
+ break;
+
+ case IrOpcode::kJSToBoolean:
+ // Type is Boolean.
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kJSToNumber:
+ // Type is Number.
+ CheckUpperIs(node, Type::Number());
+ break;
+ case IrOpcode::kJSToString:
+ // Type is String.
+ CheckUpperIs(node, Type::String());
+ break;
+ case IrOpcode::kJSToName:
+ // Type is Name.
+ CheckUpperIs(node, Type::Name());
+ break;
+ case IrOpcode::kJSToObject:
+ // Type is Receiver.
+ CheckUpperIs(node, Type::Receiver());
+ break;
+
+ case IrOpcode::kJSCreate:
+ // Type is Object.
+ CheckUpperIs(node, Type::Object());
+ break;
+ case IrOpcode::kJSLoadProperty:
+ case IrOpcode::kJSLoadNamed:
+ // Type can be anything.
+ CheckUpperIs(node, Type::Any());
+ break;
+ case IrOpcode::kJSStoreProperty:
+ case IrOpcode::kJSStoreNamed:
+ // Type is empty.
+ CheckNotTyped(node);
+ break;
+ case IrOpcode::kJSDeleteProperty:
+ case IrOpcode::kJSHasProperty:
+ case IrOpcode::kJSInstanceOf:
+ // Type is Boolean.
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kJSTypeOf:
+ // Type is String.
+ CheckUpperIs(node, Type::String());
+ break;
+
+ case IrOpcode::kJSLoadContext:
+ // Type can be anything.
+ CheckUpperIs(node, Type::Any());
+ break;
+ case IrOpcode::kJSStoreContext:
+ // Type is empty.
+ CheckNotTyped(node);
+ break;
+ case IrOpcode::kJSCreateFunctionContext:
+ case IrOpcode::kJSCreateCatchContext:
+ case IrOpcode::kJSCreateWithContext:
+ case IrOpcode::kJSCreateBlockContext:
+ case IrOpcode::kJSCreateModuleContext:
+ case IrOpcode::kJSCreateGlobalContext: {
+ // Type is Context, and operand is Internal.
+ Node* context = NodeProperties::GetContextInput(node);
+ // TODO(rossberg): This should really be Is(Internal), but the typer
+ // currently can't do backwards propagation.
+ CheckUpperMaybe(context, Type::Internal());
+ if (typing == TYPED) CHECK(bounds(node).upper->IsContext());
break;
}
- default:
- // TODO(rossberg): Check other node kinds.
+
+ case IrOpcode::kJSCallConstruct:
+ // Type is Receiver.
+ CheckUpperIs(node, Type::Receiver());
+ break;
+ case IrOpcode::kJSCallFunction:
+ case IrOpcode::kJSCallRuntime:
+ case IrOpcode::kJSYield:
+ case IrOpcode::kJSDebugger:
+ // Type can be anything.
+ CheckUpperIs(node, Type::Any());
break;
- }
- if (from_start) {
- reached_from_start.insert(node);
- } else {
- reached_from_end.insert(node);
- }
+ // Simplified operators
+ // -------------------------------
+ case IrOpcode::kBooleanNot:
+ // Boolean -> Boolean
+ CheckValueInputIs(node, 0, Type::Boolean());
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kBooleanToNumber:
+ // Boolean -> Number
+ CheckValueInputIs(node, 0, Type::Boolean());
+ CheckUpperIs(node, Type::Number());
+ break;
+ case IrOpcode::kNumberEqual:
+ case IrOpcode::kNumberLessThan:
+ case IrOpcode::kNumberLessThanOrEqual:
+ // (Number, Number) -> Boolean
+ CheckValueInputIs(node, 0, Type::Number());
+ CheckValueInputIs(node, 1, Type::Number());
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kNumberAdd:
+ case IrOpcode::kNumberSubtract:
+ case IrOpcode::kNumberMultiply:
+ case IrOpcode::kNumberDivide:
+ case IrOpcode::kNumberModulus:
+ // (Number, Number) -> Number
+ CheckValueInputIs(node, 0, Type::Number());
+ CheckValueInputIs(node, 1, Type::Number());
+ // TODO(rossberg): activate once we retype after opcode changes.
+ // CheckUpperIs(node, Type::Number());
+ break;
+ case IrOpcode::kNumberToInt32:
+ // Number -> Signed32
+ CheckValueInputIs(node, 0, Type::Number());
+ CheckUpperIs(node, Type::Signed32());
+ break;
+ case IrOpcode::kNumberToUint32:
+ // Number -> Unsigned32
+ CheckValueInputIs(node, 0, Type::Number());
+ CheckUpperIs(node, Type::Unsigned32());
+ break;
+ case IrOpcode::kStringEqual:
+ case IrOpcode::kStringLessThan:
+ case IrOpcode::kStringLessThanOrEqual:
+ // (String, String) -> Boolean
+ CheckValueInputIs(node, 0, Type::String());
+ CheckValueInputIs(node, 1, Type::String());
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kStringAdd:
+ // (String, String) -> String
+ CheckValueInputIs(node, 0, Type::String());
+ CheckValueInputIs(node, 1, Type::String());
+ CheckUpperIs(node, Type::String());
+ break;
+ case IrOpcode::kReferenceEqual: {
+ // (Unique, Any) -> Boolean and
+ // (Any, Unique) -> Boolean
+ if (typing == TYPED) {
+ CHECK(bounds(ValueInput(node, 0)).upper->Is(Type::Unique()) ||
+ bounds(ValueInput(node, 1)).upper->Is(Type::Unique()));
+ }
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ }
+ case IrOpcode::kObjectIsSmi:
+ CheckValueInputIs(node, 0, Type::Any());
+ CheckUpperIs(node, Type::Boolean());
+ break;
+ case IrOpcode::kObjectIsNonNegativeSmi:
+ CheckValueInputIs(node, 0, Type::Any());
+ CheckUpperIs(node, Type::Boolean());
+ break;
- return GenericGraphVisit::CONTINUE;
-}
+ case IrOpcode::kChangeTaggedToInt32: {
+ // Signed32 /\ Tagged -> Signed32 /\ UntaggedInt32
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from = Type::Intersect(Type::Signed32(), Type::Tagged());
+ // Type* to = Type::Intersect(Type::Signed32(), Type::UntaggedInt32());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeTaggedToUint32: {
+ // Unsigned32 /\ Tagged -> Unsigned32 /\ UntaggedInt32
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from = Type::Intersect(Type::Unsigned32(), Type::Tagged());
+ // Type* to =Type::Intersect(Type::Unsigned32(), Type::UntaggedInt32());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeTaggedToFloat64: {
+ // Number /\ Tagged -> Number /\ UntaggedFloat64
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from = Type::Intersect(Type::Number(), Type::Tagged());
+ // Type* to = Type::Intersect(Type::Number(), Type::UntaggedFloat64());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeInt32ToTagged: {
+ // Signed32 /\ UntaggedInt32 -> Signed32 /\ Tagged
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from =Type::Intersect(Type::Signed32(), Type::UntaggedInt32());
+ // Type* to = Type::Intersect(Type::Signed32(), Type::Tagged());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeUint32ToTagged: {
+ // Unsigned32 /\ UntaggedInt32 -> Unsigned32 /\ Tagged
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from=Type::Intersect(Type::Unsigned32(),Type::UntaggedInt32());
+ // Type* to = Type::Intersect(Type::Unsigned32(), Type::Tagged());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeFloat64ToTagged: {
+ // Number /\ UntaggedFloat64 -> Number /\ Tagged
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from =Type::Intersect(Type::Number(), Type::UntaggedFloat64());
+ // Type* to = Type::Intersect(Type::Number(), Type::Tagged());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeBoolToBit: {
+ // Boolean /\ TaggedPtr -> Boolean /\ UntaggedInt1
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from = Type::Intersect(Type::Boolean(), Type::TaggedPtr());
+ // Type* to = Type::Intersect(Type::Boolean(), Type::UntaggedInt1());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kChangeBitToBool: {
+ // Boolean /\ UntaggedInt1 -> Boolean /\ TaggedPtr
+ // TODO(neis): Activate once ChangeRepresentation works in typer.
+ // Type* from = Type::Intersect(Type::Boolean(), Type::UntaggedInt1());
+ // Type* to = Type::Intersect(Type::Boolean(), Type::TaggedPtr());
+ // CheckValueInputIs(node, 0, from));
+ // CheckUpperIs(node, to));
+ break;
+ }
+ case IrOpcode::kLoadField:
+ // Object -> fieldtype
+ // TODO(rossberg): activate once machine ops are typed.
+ // CheckValueInputIs(node, 0, Type::Object());
+ // CheckUpperIs(node, Field(node).type));
+ break;
+ case IrOpcode::kLoadElement:
+ // Object -> elementtype
+ // TODO(rossberg): activate once machine ops are typed.
+ // CheckValueInputIs(node, 0, Type::Object());
+ // CheckUpperIs(node, Element(node).type));
+ break;
+ case IrOpcode::kStoreField:
+ // (Object, fieldtype) -> _|_
+ // TODO(rossberg): activate once machine ops are typed.
+ // CheckValueInputIs(node, 0, Type::Object());
+ // CheckValueInputIs(node, 1, Field(node).type));
+ CheckNotTyped(node);
+ break;
+ case IrOpcode::kStoreElement:
+ // (Object, elementtype) -> _|_
+ // TODO(rossberg): activate once machine ops are typed.
+ // CheckValueInputIs(node, 0, Type::Object());
+ // CheckValueInputIs(node, 1, Element(node).type));
+ CheckNotTyped(node);
+ break;
-void Verifier::Run(Graph* graph) {
- Visitor visitor(graph->zone());
+ // Machine operators
+ // -----------------------
+ case IrOpcode::kLoad:
+ case IrOpcode::kStore:
+ case IrOpcode::kWord32And:
+ case IrOpcode::kWord32Or:
+ case IrOpcode::kWord32Xor:
+ case IrOpcode::kWord32Shl:
+ case IrOpcode::kWord32Shr:
+ case IrOpcode::kWord32Sar:
+ case IrOpcode::kWord32Ror:
+ case IrOpcode::kWord32Equal:
+ case IrOpcode::kWord64And:
+ case IrOpcode::kWord64Or:
+ case IrOpcode::kWord64Xor:
+ case IrOpcode::kWord64Shl:
+ case IrOpcode::kWord64Shr:
+ case IrOpcode::kWord64Sar:
+ case IrOpcode::kWord64Ror:
+ case IrOpcode::kWord64Equal:
+ case IrOpcode::kInt32Add:
+ case IrOpcode::kInt32AddWithOverflow:
+ case IrOpcode::kInt32Sub:
+ case IrOpcode::kInt32SubWithOverflow:
+ case IrOpcode::kInt32Mul:
+ case IrOpcode::kInt32MulHigh:
+ case IrOpcode::kInt32Div:
+ case IrOpcode::kInt32Mod:
+ case IrOpcode::kInt32LessThan:
+ case IrOpcode::kInt32LessThanOrEqual:
+ case IrOpcode::kUint32Div:
+ case IrOpcode::kUint32Mod:
+ case IrOpcode::kUint32MulHigh:
+ case IrOpcode::kUint32LessThan:
+ case IrOpcode::kUint32LessThanOrEqual:
+ case IrOpcode::kInt64Add:
+ case IrOpcode::kInt64Sub:
+ case IrOpcode::kInt64Mul:
+ case IrOpcode::kInt64Div:
+ case IrOpcode::kInt64Mod:
+ case IrOpcode::kInt64LessThan:
+ case IrOpcode::kInt64LessThanOrEqual:
+ case IrOpcode::kUint64Div:
+ case IrOpcode::kUint64Mod:
+ case IrOpcode::kUint64LessThan:
+ case IrOpcode::kFloat64Add:
+ case IrOpcode::kFloat64Sub:
+ case IrOpcode::kFloat64Mul:
+ case IrOpcode::kFloat64Div:
+ case IrOpcode::kFloat64Mod:
+ case IrOpcode::kFloat64Sqrt:
+ case IrOpcode::kFloat64Floor:
+ case IrOpcode::kFloat64Ceil:
+ case IrOpcode::kFloat64RoundTruncate:
+ case IrOpcode::kFloat64RoundTiesAway:
+ case IrOpcode::kFloat64Equal:
+ case IrOpcode::kFloat64LessThan:
+ case IrOpcode::kFloat64LessThanOrEqual:
+ case IrOpcode::kTruncateInt64ToInt32:
+ case IrOpcode::kTruncateFloat64ToFloat32:
+ case IrOpcode::kTruncateFloat64ToInt32:
+ case IrOpcode::kChangeInt32ToInt64:
+ case IrOpcode::kChangeUint32ToUint64:
+ case IrOpcode::kChangeInt32ToFloat64:
+ case IrOpcode::kChangeUint32ToFloat64:
+ case IrOpcode::kChangeFloat32ToFloat64:
+ case IrOpcode::kChangeFloat64ToInt32:
+ case IrOpcode::kChangeFloat64ToUint32:
+ case IrOpcode::kLoadStackPointer:
+ // TODO(rossberg): Check.
+ break;
+ }
+}
+
+void Verifier::Run(Graph* graph, Typing typing) {
+ Visitor visitor(graph->zone(), typing);
CHECK_NE(NULL, graph->start());
- visitor.from_start = true;
- graph->VisitNodeUsesFromStart(&visitor);
CHECK_NE(NULL, graph->end());
- visitor.from_start = false;
graph->VisitNodeInputsFromEnd(&visitor);
-
- // All control nodes reachable from end are reachable from start.
- for (NodeSet::iterator it = visitor.reached_from_end.begin();
- it != visitor.reached_from_end.end(); ++it) {
- CHECK(!NodeProperties::IsControl(*it) ||
- visitor.reached_from_start.count(*it));
- }
}
+// -----------------------------------------------------------------------------
+
static bool HasDominatingDef(Schedule* schedule, Node* node,
BasicBlock* container, BasicBlock* use_block,
int use_pos) {
BasicBlock* block = use_block;
while (true) {
while (use_pos >= 0) {
- if (block->nodes_[use_pos] == node) return true;
+ if (block->NodeAt(use_pos) == node) return true;
use_pos--;
}
- block = block->dominator_;
+ block = block->dominator();
if (block == NULL) break;
- use_pos = static_cast<int>(block->nodes_.size()) - 1;
- if (node == block->control_input_) return true;
+ use_pos = static_cast<int>(block->NodeCount()) - 1;
+ if (node == block->control_input()) return true;
+ }
+ return false;
+}
+
+
+static bool Dominates(Schedule* schedule, Node* dominator, Node* dominatee) {
+ BasicBlock* dom = schedule->block(dominator);
+ BasicBlock* sub = schedule->block(dominatee);
+ while (sub != NULL) {
+ if (sub == dom) {
+ return true;
+ }
+ sub = sub->dominator();
}
return false;
}
static void CheckInputsDominate(Schedule* schedule, BasicBlock* block,
Node* node, int use_pos) {
- for (int j = OperatorProperties::GetValueInputCount(node->op()) - 1; j >= 0;
- j--) {
+ for (int j = node->op()->ValueInputCount() - 1; j >= 0; j--) {
BasicBlock* use_block = block;
if (node->opcode() == IrOpcode::kPhi) {
use_block = use_block->PredecessorAt(j);
- use_pos = static_cast<int>(use_block->nodes_.size()) - 1;
+ use_pos = static_cast<int>(use_block->NodeCount()) - 1;
}
Node* input = node->InputAt(j);
if (!HasDominatingDef(schedule, node->InputAt(j), block, use_block,
use_pos)) {
V8_Fatal(__FILE__, __LINE__,
"Node #%d:%s in B%d is not dominated by input@%d #%d:%s",
- node->id(), node->op()->mnemonic(), block->id(), j, input->id(),
- input->op()->mnemonic());
+ node->id(), node->op()->mnemonic(), block->id().ToInt(), j,
+ input->id(), input->op()->mnemonic());
+ }
+ }
+ // Ensure that nodes are dominated by their control inputs;
+ // kEnd is an exception, as unreachable blocks resulting from kMerge
+ // are not in the RPO.
+ if (node->op()->ControlInputCount() == 1 &&
+ node->opcode() != IrOpcode::kEnd) {
+ Node* ctl = NodeProperties::GetControlInput(node);
+ if (!Dominates(schedule, ctl, node)) {
+ V8_Fatal(__FILE__, __LINE__,
+ "Node #%d:%s in B%d is not dominated by control input #%d:%s",
+ node->id(), node->op()->mnemonic(), block->id(), ctl->id(),
+ ctl->op()->mnemonic());
}
}
}
void ScheduleVerifier::Run(Schedule* schedule) {
- const int count = schedule->BasicBlockCount();
+ const size_t count = schedule->BasicBlockCount();
Zone tmp_zone(schedule->zone()->isolate());
Zone* zone = &tmp_zone;
BasicBlock* start = schedule->start();
BasicBlockVector* rpo_order = schedule->rpo_order();
// Verify the RPO order contains only blocks from this schedule.
- CHECK_GE(count, static_cast<int>(rpo_order->size()));
+ CHECK_GE(count, rpo_order->size());
for (BasicBlockVector::iterator b = rpo_order->begin(); b != rpo_order->end();
++b) {
CHECK_EQ((*b), schedule->GetBlockById((*b)->id()));
+ // All predecessors and successors should be in rpo and in this schedule.
+ for (BasicBlock::Predecessors::iterator j = (*b)->predecessors_begin();
+ j != (*b)->predecessors_end(); ++j) {
+ CHECK_GE((*j)->rpo_number(), 0);
+ CHECK_EQ((*j), schedule->GetBlockById((*j)->id()));
+ }
+ for (BasicBlock::Successors::iterator j = (*b)->successors_begin();
+ j != (*b)->successors_end(); ++j) {
+ CHECK_GE((*j)->rpo_number(), 0);
+ CHECK_EQ((*j), schedule->GetBlockById((*j)->id()));
+ }
}
// Verify RPO numbers of blocks.
CHECK_EQ(start, rpo_order->at(0)); // Start should be first.
for (size_t b = 0; b < rpo_order->size(); b++) {
BasicBlock* block = rpo_order->at(b);
- CHECK_EQ(static_cast<int>(b), block->rpo_number_);
- BasicBlock* dom = block->dominator_;
+ CHECK_EQ(static_cast<int>(b), block->rpo_number());
+ BasicBlock* dom = block->dominator();
if (b == 0) {
// All blocks except start should have a dominator.
CHECK_EQ(NULL, dom);
} else {
// Check that the immediate dominator appears somewhere before the block.
CHECK_NE(NULL, dom);
- CHECK_LT(dom->rpo_number_, block->rpo_number_);
+ CHECK_LT(dom->rpo_number(), block->rpo_number());
}
}
// Verify that all blocks reachable from start are in the RPO.
- BoolVector marked(count, false, zone);
+ BoolVector marked(static_cast<int>(count), false, zone);
{
ZoneQueue<BasicBlock*> queue(zone);
queue.push(start);
- marked[start->id()] = true;
+ marked[start->id().ToSize()] = true;
while (!queue.empty()) {
BasicBlock* block = queue.front();
queue.pop();
- for (int s = 0; s < block->SuccessorCount(); s++) {
+ for (size_t s = 0; s < block->SuccessorCount(); s++) {
BasicBlock* succ = block->SuccessorAt(s);
- if (!marked[succ->id()]) {
- marked[succ->id()] = true;
+ if (!marked[succ->id().ToSize()]) {
+ marked[succ->id().ToSize()] = true;
queue.push(succ);
}
}
}
}
// Verify marked blocks are in the RPO.
- for (int i = 0; i < count; i++) {
- BasicBlock* block = schedule->GetBlockById(i);
+ for (size_t i = 0; i < count; i++) {
+ BasicBlock* block = schedule->GetBlockById(BasicBlock::Id::FromSize(i));
if (marked[i]) {
- CHECK_GE(block->rpo_number_, 0);
- CHECK_EQ(block, rpo_order->at(block->rpo_number_));
+ CHECK_GE(block->rpo_number(), 0);
+ CHECK_EQ(block, rpo_order->at(block->rpo_number()));
}
}
// Verify RPO blocks are marked.
for (size_t b = 0; b < rpo_order->size(); b++) {
- CHECK(marked[rpo_order->at(b)->id()]);
+ CHECK(marked[rpo_order->at(b)->id().ToSize()]);
}
{
// Verify the dominance relation.
- ZoneList<BitVector*> dominators(count, zone);
- dominators.Initialize(count, zone);
- dominators.AddBlock(NULL, count, zone);
+ ZoneVector<BitVector*> dominators(zone);
+ dominators.resize(count, NULL);
// Compute a set of all the nodes that dominate a given node by using
// a forward fixpoint. O(n^2).
ZoneQueue<BasicBlock*> queue(zone);
queue.push(start);
- dominators[start->id()] = new (zone) BitVector(count, zone);
+ dominators[start->id().ToSize()] =
+ new (zone) BitVector(static_cast<int>(count), zone);
while (!queue.empty()) {
BasicBlock* block = queue.front();
queue.pop();
- BitVector* block_doms = dominators[block->id()];
- BasicBlock* idom = block->dominator_;
- if (idom != NULL && !block_doms->Contains(idom->id())) {
+ BitVector* block_doms = dominators[block->id().ToSize()];
+ BasicBlock* idom = block->dominator();
+ if (idom != NULL && !block_doms->Contains(idom->id().ToInt())) {
V8_Fatal(__FILE__, __LINE__, "Block B%d is not dominated by B%d",
- block->id(), idom->id());
+ block->id().ToInt(), idom->id().ToInt());
}
- for (int s = 0; s < block->SuccessorCount(); s++) {
+ for (size_t s = 0; s < block->SuccessorCount(); s++) {
BasicBlock* succ = block->SuccessorAt(s);
- BitVector* succ_doms = dominators[succ->id()];
+ BitVector* succ_doms = dominators[succ->id().ToSize()];
if (succ_doms == NULL) {
// First time visiting the node. S.doms = B U B.doms
- succ_doms = new (zone) BitVector(count, zone);
+ succ_doms = new (zone) BitVector(static_cast<int>(count), zone);
succ_doms->CopyFrom(*block_doms);
- succ_doms->Add(block->id());
- dominators[succ->id()] = succ_doms;
+ succ_doms->Add(block->id().ToInt());
+ dominators[succ->id().ToSize()] = succ_doms;
queue.push(succ);
} else {
// Nth time visiting the successor. S.doms = S.doms ^ (B U B.doms)
- bool had = succ_doms->Contains(block->id());
- if (had) succ_doms->Remove(block->id());
+ bool had = succ_doms->Contains(block->id().ToInt());
+ if (had) succ_doms->Remove(block->id().ToInt());
if (succ_doms->IntersectIsChanged(*block_doms)) queue.push(succ);
- if (had) succ_doms->Add(block->id());
+ if (had) succ_doms->Add(block->id().ToInt());
}
}
}
for (BasicBlockVector::iterator b = rpo_order->begin();
b != rpo_order->end(); ++b) {
BasicBlock* block = *b;
- BasicBlock* idom = block->dominator_;
+ BasicBlock* idom = block->dominator();
if (idom == NULL) continue;
- BitVector* block_doms = dominators[block->id()];
+ BitVector* block_doms = dominators[block->id().ToSize()];
for (BitVector::Iterator it(block_doms); !it.Done(); it.Advance()) {
- BasicBlock* dom = schedule->GetBlockById(it.Current());
- if (dom != idom && !dominators[idom->id()]->Contains(dom->id())) {
+ BasicBlock* dom =
+ schedule->GetBlockById(BasicBlock::Id::FromInt(it.Current()));
+ if (dom != idom &&
+ !dominators[idom->id().ToSize()]->Contains(dom->id().ToInt())) {
V8_Fatal(__FILE__, __LINE__,
- "Block B%d is not immediately dominated by B%d", block->id(),
- idom->id());
+ "Block B%d is not immediately dominated by B%d",
+ block->id().ToInt(), idom->id().ToInt());
}
}
}
if (phi->opcode() != IrOpcode::kPhi) continue;
// TODO(titzer): Nasty special case. Phis from RawMachineAssembler
// schedules don't have control inputs.
- if (phi->InputCount() >
- OperatorProperties::GetValueInputCount(phi->op())) {
+ if (phi->InputCount() > phi->op()->ValueInputCount()) {
Node* control = NodeProperties::GetControlInput(phi);
CHECK(control->opcode() == IrOpcode::kMerge ||
control->opcode() == IrOpcode::kLoop);
BasicBlock* block = *b;
// Check inputs to control for this block.
- Node* control = block->control_input_;
+ Node* control = block->control_input();
if (control != NULL) {
CHECK_EQ(block, schedule->block(control));
CheckInputsDominate(schedule, block, control,
- static_cast<int>(block->nodes_.size()) - 1);
+ static_cast<int>(block->NodeCount()) - 1);
}
// Check inputs for all nodes in the block.
- for (size_t i = 0; i < block->nodes_.size(); i++) {
- Node* node = block->nodes_[i];
+ for (size_t i = 0; i < block->NodeCount(); i++) {
+ Node* node = block->NodeAt(i);
CheckInputsDominate(schedule, block, node, static_cast<int>(i) - 1);
}
}
// each node, etc.
class Verifier {
public:
- static void Run(Graph* graph);
+ enum Typing { TYPED, UNTYPED };
+
+ static void Run(Graph* graph, Typing typing = TYPED);
private:
class Visitor;
#define __ masm()->
-// TODO(turbofan): Cleanup these hacks.
-enum Immediate64Type { kImm64Value, kImm64Handle, kImm64Reference };
-
-
-struct Immediate64 {
- uint64_t value;
- Handle<Object> handle;
- ExternalReference reference;
- Immediate64Type type;
-};
-
-
-enum RegisterOrOperandType { kRegister, kDoubleRegister, kOperand };
-
-
-struct RegisterOrOperand {
- RegisterOrOperand() : operand(no_reg, 0) {}
- Register reg;
- DoubleRegister double_reg;
- Operand operand;
- RegisterOrOperandType type;
-};
-
-
// Adds X64 specific methods for decoding operands.
class X64OperandConverter : public InstructionOperandConverter {
public:
X64OperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
- RegisterOrOperand InputRegisterOrOperand(int index) {
- return ToRegisterOrOperand(instr_->InputAt(index));
- }
-
Immediate InputImmediate(int index) {
return ToImmediate(instr_->InputAt(index));
}
- RegisterOrOperand OutputRegisterOrOperand() {
- return ToRegisterOrOperand(instr_->Output());
- }
+ Operand InputOperand(int index) { return ToOperand(instr_->InputAt(index)); }
- Immediate64 InputImmediate64(int index) {
- return ToImmediate64(instr_->InputAt(index));
- }
-
- Immediate64 ToImmediate64(InstructionOperand* operand) {
- Constant constant = ToConstant(operand);
- Immediate64 immediate;
- immediate.value = 0xbeefdeaddeefbeed;
- immediate.type = kImm64Value;
- switch (constant.type()) {
- case Constant::kInt32:
- case Constant::kInt64:
- immediate.value = constant.ToInt64();
- return immediate;
- case Constant::kFloat32:
- immediate.type = kImm64Handle;
- immediate.handle =
- isolate()->factory()->NewNumber(constant.ToFloat32(), TENURED);
- return immediate;
- case Constant::kFloat64:
- immediate.type = kImm64Handle;
- immediate.handle =
- isolate()->factory()->NewNumber(constant.ToFloat64(), TENURED);
- return immediate;
- case Constant::kExternalReference:
- immediate.type = kImm64Reference;
- immediate.reference = constant.ToExternalReference();
- return immediate;
- case Constant::kHeapObject:
- immediate.type = kImm64Handle;
- immediate.handle = constant.ToHeapObject();
- return immediate;
- }
- UNREACHABLE();
- return immediate;
- }
+ Operand OutputOperand() { return ToOperand(instr_->Output()); }
Immediate ToImmediate(InstructionOperand* operand) {
- Constant constant = ToConstant(operand);
- switch (constant.type()) {
- case Constant::kInt32:
- return Immediate(constant.ToInt32());
- case Constant::kInt64:
- case Constant::kFloat32:
- case Constant::kFloat64:
- case Constant::kExternalReference:
- case Constant::kHeapObject:
- break;
- }
- UNREACHABLE();
- return Immediate(-1);
+ return Immediate(ToConstant(operand).ToInt32());
}
Operand ToOperand(InstructionOperand* op, int extra = 0) {
- RegisterOrOperand result = ToRegisterOrOperand(op, extra);
- DCHECK_EQ(kOperand, result.type);
- return result.operand;
- }
-
- RegisterOrOperand ToRegisterOrOperand(InstructionOperand* op, int extra = 0) {
- RegisterOrOperand result;
- if (op->IsRegister()) {
- DCHECK(extra == 0);
- result.type = kRegister;
- result.reg = ToRegister(op);
- return result;
- } else if (op->IsDoubleRegister()) {
- DCHECK(extra == 0);
- DCHECK(extra == 0);
- result.type = kDoubleRegister;
- result.double_reg = ToDoubleRegister(op);
- return result;
- }
-
DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
-
- result.type = kOperand;
// The linkage computes where all spill slots are located.
FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), extra);
- result.operand =
- Operand(offset.from_stack_pointer() ? rsp : rbp, offset.offset());
- return result;
+ return Operand(offset.from_stack_pointer() ? rsp : rbp, offset.offset());
}
static int NextOffset(int* offset) {
}
-#define ASSEMBLE_BINOP(asm_instr) \
- do { \
- if (HasImmediateInput(instr, 1)) { \
- RegisterOrOperand input = i.InputRegisterOrOperand(0); \
- if (input.type == kRegister) { \
- __ asm_instr(input.reg, i.InputImmediate(1)); \
- } else { \
- __ asm_instr(input.operand, i.InputImmediate(1)); \
- } \
- } else { \
- RegisterOrOperand input = i.InputRegisterOrOperand(1); \
- if (input.type == kRegister) { \
- __ asm_instr(i.InputRegister(0), input.reg); \
- } else { \
- __ asm_instr(i.InputRegister(0), input.operand); \
- } \
- } \
+#define ASSEMBLE_UNOP(asm_instr) \
+ do { \
+ if (instr->Output()->IsRegister()) { \
+ __ asm_instr(i.OutputRegister()); \
+ } else { \
+ __ asm_instr(i.OutputOperand()); \
+ } \
+ } while (0)
+
+
+#define ASSEMBLE_BINOP(asm_instr) \
+ do { \
+ if (HasImmediateInput(instr, 1)) { \
+ if (instr->InputAt(0)->IsRegister()) { \
+ __ asm_instr(i.InputRegister(0), i.InputImmediate(1)); \
+ } else { \
+ __ asm_instr(i.InputOperand(0), i.InputImmediate(1)); \
+ } \
+ } else { \
+ if (instr->InputAt(1)->IsRegister()) { \
+ __ asm_instr(i.InputRegister(0), i.InputRegister(1)); \
+ } else { \
+ __ asm_instr(i.InputRegister(0), i.InputOperand(1)); \
+ } \
+ } \
+ } while (0)
+
+
+#define ASSEMBLE_MULT(asm_instr) \
+ do { \
+ if (HasImmediateInput(instr, 1)) { \
+ if (instr->InputAt(0)->IsRegister()) { \
+ __ asm_instr(i.OutputRegister(), i.InputRegister(0), \
+ i.InputImmediate(1)); \
+ } else { \
+ __ asm_instr(i.OutputRegister(), i.InputOperand(0), \
+ i.InputImmediate(1)); \
+ } \
+ } else { \
+ if (instr->InputAt(1)->IsRegister()) { \
+ __ asm_instr(i.OutputRegister(), i.InputRegister(1)); \
+ } else { \
+ __ asm_instr(i.OutputRegister(), i.InputOperand(1)); \
+ } \
+ } \
} while (0)
-#define ASSEMBLE_SHIFT(asm_instr, width) \
- do { \
- if (HasImmediateInput(instr, 1)) { \
- __ asm_instr(i.OutputRegister(), Immediate(i.InputInt##width(1))); \
- } else { \
- __ asm_instr##_cl(i.OutputRegister()); \
- } \
+#define ASSEMBLE_SHIFT(asm_instr, width) \
+ do { \
+ if (HasImmediateInput(instr, 1)) { \
+ if (instr->Output()->IsRegister()) { \
+ __ asm_instr(i.OutputRegister(), Immediate(i.InputInt##width(1))); \
+ } else { \
+ __ asm_instr(i.OutputOperand(), Immediate(i.InputInt##width(1))); \
+ } \
+ } else { \
+ if (instr->Output()->IsRegister()) { \
+ __ asm_instr##_cl(i.OutputRegister()); \
+ } else { \
+ __ asm_instr##_cl(i.OutputOperand()); \
+ } \
+ } \
+ } while (0)
+
+
+#define ASSEMBLE_DOUBLE_BINOP(asm_instr) \
+ do { \
+ if (instr->InputAt(1)->IsDoubleRegister()) { \
+ __ asm_instr(i.InputDoubleRegister(0), i.InputDoubleRegister(1)); \
+ } else { \
+ __ asm_instr(i.InputDoubleRegister(0), i.InputOperand(1)); \
+ } \
} while (0)
break;
}
case kArchJmp:
- __ jmp(code_->GetLabel(i.InputBlock(0)));
+ __ jmp(GetLabel(i.InputRpo(0)));
break;
case kArchNop:
// don't emit code for nops.
case kArchRet:
AssembleReturn();
break;
+ case kArchStackPointer:
+ __ movq(i.OutputRegister(), rsp);
+ break;
case kArchTruncateDoubleToI:
__ TruncateDoubleToI(i.OutputRegister(), i.InputDoubleRegister(0));
break;
ASSEMBLE_BINOP(testq);
break;
case kX64Imul32:
- if (HasImmediateInput(instr, 1)) {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ imull(i.OutputRegister(), input.reg, i.InputImmediate(1));
- } else {
- __ imull(i.OutputRegister(), input.operand, i.InputImmediate(1));
- }
+ ASSEMBLE_MULT(imull);
+ break;
+ case kX64Imul:
+ ASSEMBLE_MULT(imulq);
+ break;
+ case kX64ImulHigh32:
+ if (instr->InputAt(1)->IsRegister()) {
+ __ imull(i.InputRegister(1));
} else {
- RegisterOrOperand input = i.InputRegisterOrOperand(1);
- if (input.type == kRegister) {
- __ imull(i.OutputRegister(), input.reg);
- } else {
- __ imull(i.OutputRegister(), input.operand);
- }
+ __ imull(i.InputOperand(1));
}
break;
- case kX64Imul:
- if (HasImmediateInput(instr, 1)) {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ imulq(i.OutputRegister(), input.reg, i.InputImmediate(1));
- } else {
- __ imulq(i.OutputRegister(), input.operand, i.InputImmediate(1));
- }
+ case kX64UmulHigh32:
+ if (instr->InputAt(1)->IsRegister()) {
+ __ mull(i.InputRegister(1));
} else {
- RegisterOrOperand input = i.InputRegisterOrOperand(1);
- if (input.type == kRegister) {
- __ imulq(i.OutputRegister(), input.reg);
- } else {
- __ imulq(i.OutputRegister(), input.operand);
- }
+ __ mull(i.InputOperand(1));
}
break;
case kX64Idiv32:
__ xorq(rdx, rdx);
__ divq(i.InputRegister(1));
break;
- case kX64Not: {
- RegisterOrOperand output = i.OutputRegisterOrOperand();
- if (output.type == kRegister) {
- __ notq(output.reg);
- } else {
- __ notq(output.operand);
- }
+ case kX64Not:
+ ASSEMBLE_UNOP(notq);
break;
- }
- case kX64Not32: {
- RegisterOrOperand output = i.OutputRegisterOrOperand();
- if (output.type == kRegister) {
- __ notl(output.reg);
- } else {
- __ notl(output.operand);
- }
+ case kX64Not32:
+ ASSEMBLE_UNOP(notl);
break;
- }
- case kX64Neg: {
- RegisterOrOperand output = i.OutputRegisterOrOperand();
- if (output.type == kRegister) {
- __ negq(output.reg);
- } else {
- __ negq(output.operand);
- }
+ case kX64Neg:
+ ASSEMBLE_UNOP(negq);
break;
- }
- case kX64Neg32: {
- RegisterOrOperand output = i.OutputRegisterOrOperand();
- if (output.type == kRegister) {
- __ negl(output.reg);
- } else {
- __ negl(output.operand);
- }
+ case kX64Neg32:
+ ASSEMBLE_UNOP(negl);
break;
- }
case kX64Or32:
ASSEMBLE_BINOP(orl);
break;
case kX64Ror:
ASSEMBLE_SHIFT(rorq, 6);
break;
- case kSSEFloat64Cmp: {
- RegisterOrOperand input = i.InputRegisterOrOperand(1);
- if (input.type == kDoubleRegister) {
- __ ucomisd(i.InputDoubleRegister(0), input.double_reg);
- } else {
- __ ucomisd(i.InputDoubleRegister(0), input.operand);
- }
+ case kSSEFloat64Cmp:
+ ASSEMBLE_DOUBLE_BINOP(ucomisd);
break;
- }
case kSSEFloat64Add:
- __ addsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ ASSEMBLE_DOUBLE_BINOP(addsd);
break;
case kSSEFloat64Sub:
- __ subsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ ASSEMBLE_DOUBLE_BINOP(subsd);
break;
case kSSEFloat64Mul:
- __ mulsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ ASSEMBLE_DOUBLE_BINOP(mulsd);
break;
case kSSEFloat64Div:
- __ divsd(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
+ ASSEMBLE_DOUBLE_BINOP(divsd);
break;
case kSSEFloat64Mod: {
__ subq(rsp, Immediate(kDoubleSize));
__ addq(rsp, Immediate(kDoubleSize));
break;
}
- case kSSEFloat64Sqrt: {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kDoubleRegister) {
- __ sqrtsd(i.OutputDoubleRegister(), input.double_reg);
+ case kSSEFloat64Sqrt:
+ if (instr->InputAt(0)->IsDoubleRegister()) {
+ __ sqrtsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
} else {
- __ sqrtsd(i.OutputDoubleRegister(), input.operand);
+ __ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
}
break;
+ case kSSEFloat64Floor: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundDown);
+ break;
+ }
+ case kSSEFloat64Ceil: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundUp);
+ break;
+ }
+ case kSSEFloat64RoundTruncate: {
+ CpuFeatureScope sse_scope(masm(), SSE4_1);
+ __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
+ v8::internal::Assembler::kRoundToZero);
+ break;
}
case kSSECvtss2sd:
- __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ if (instr->InputAt(0)->IsDoubleRegister()) {
+ __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ } else {
+ __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
+ }
break;
case kSSECvtsd2ss:
- __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ if (instr->InputAt(0)->IsDoubleRegister()) {
+ __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+ } else {
+ __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
+ }
break;
- case kSSEFloat64ToInt32: {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kDoubleRegister) {
- __ cvttsd2si(i.OutputRegister(), input.double_reg);
+ case kSSEFloat64ToInt32:
+ if (instr->InputAt(0)->IsDoubleRegister()) {
+ __ cvttsd2si(i.OutputRegister(), i.InputDoubleRegister(0));
} else {
- __ cvttsd2si(i.OutputRegister(), input.operand);
+ __ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
}
break;
- }
case kSSEFloat64ToUint32: {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kDoubleRegister) {
- __ cvttsd2siq(i.OutputRegister(), input.double_reg);
+ if (instr->InputAt(0)->IsDoubleRegister()) {
+ __ cvttsd2siq(i.OutputRegister(), i.InputDoubleRegister(0));
} else {
- __ cvttsd2siq(i.OutputRegister(), input.operand);
+ __ cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
}
- __ andl(i.OutputRegister(), i.OutputRegister()); // clear upper bits.
- // TODO(turbofan): generated code should not look at the upper 32 bits
- // of the result, but those bits could escape to the outside world.
+ __ AssertZeroExtended(i.OutputRegister());
break;
}
- case kSSEInt32ToFloat64: {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ cvtlsi2sd(i.OutputDoubleRegister(), input.reg);
+ case kSSEInt32ToFloat64:
+ if (instr->InputAt(0)->IsRegister()) {
+ __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
} else {
- __ cvtlsi2sd(i.OutputDoubleRegister(), input.operand);
+ __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
}
break;
- }
- case kSSEUint32ToFloat64: {
- // TODO(turbofan): X64 SSE cvtqsi2sd should support operands.
- __ cvtqsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
+ case kSSEUint32ToFloat64:
+ if (instr->InputAt(0)->IsRegister()) {
+ __ movl(kScratchRegister, i.InputRegister(0));
+ } else {
+ __ movl(kScratchRegister, i.InputOperand(0));
+ }
+ __ cvtqsi2sd(i.OutputDoubleRegister(), kScratchRegister);
break;
- }
case kX64Movsxbl:
__ movsxbl(i.OutputRegister(), i.MemoryOperand());
break;
case kX64Movl:
if (instr->HasOutput()) {
if (instr->addressing_mode() == kMode_None) {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ movl(i.OutputRegister(), input.reg);
+ if (instr->InputAt(0)->IsRegister()) {
+ __ movl(i.OutputRegister(), i.InputRegister(0));
} else {
- __ movl(i.OutputRegister(), input.operand);
+ __ movl(i.OutputRegister(), i.InputOperand(0));
}
} else {
__ movl(i.OutputRegister(), i.MemoryOperand());
}
break;
case kX64Movsxlq: {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ movsxlq(i.OutputRegister(), input.reg);
+ if (instr->InputAt(0)->IsRegister()) {
+ __ movsxlq(i.OutputRegister(), i.InputRegister(0));
} else {
- __ movsxlq(i.OutputRegister(), input.operand);
+ __ movsxlq(i.OutputRegister(), i.InputOperand(0));
}
break;
}
__ movsd(operand, i.InputDoubleRegister(index));
}
break;
+ case kX64Lea32:
+ __ leal(i.OutputRegister(), i.MemoryOperand());
+ break;
+ case kX64Lea:
+ __ leaq(i.OutputRegister(), i.MemoryOperand());
+ break;
case kX64Push:
if (HasImmediateInput(instr, 0)) {
__ pushq(i.InputImmediate(0));
} else {
- RegisterOrOperand input = i.InputRegisterOrOperand(0);
- if (input.type == kRegister) {
- __ pushq(input.reg);
+ if (instr->InputAt(0)->IsRegister()) {
+ __ pushq(i.InputRegister(0));
} else {
- __ pushq(input.operand);
+ __ pushq(i.InputOperand(0));
}
}
break;
__ movsxlq(index, index);
__ movq(Operand(object, index, times_1, 0), value);
__ leaq(index, Operand(object, index, times_1, 0));
- SaveFPRegsMode mode = code_->frame()->DidAllocateDoubleRegisters()
- ? kSaveFPRegs
- : kDontSaveFPRegs;
+ SaveFPRegsMode mode =
+ frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
__ RecordWrite(object, index, value, mode);
break;
}
// Emit a branch. The true and false targets are always the last two inputs
// to the instruction.
- BasicBlock* tblock = i.InputBlock(static_cast<int>(instr->InputCount()) - 2);
- BasicBlock* fblock = i.InputBlock(static_cast<int>(instr->InputCount()) - 1);
+ BasicBlock::RpoNumber tblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
+ BasicBlock::RpoNumber fblock =
+ i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
bool fallthru = IsNextInAssemblyOrder(fblock);
- Label* tlabel = code()->GetLabel(tblock);
- Label* flabel = fallthru ? &done : code()->GetLabel(fblock);
+ Label* tlabel = GetLabel(tblock);
+ Label* flabel = fallthru ? &done : GetLabel(fblock);
Label::Distance flabel_distance = fallthru ? Label::kNear : Label::kFar;
switch (condition) {
case kUnorderedEqual:
// Materialize a full 64-bit 1 or 0 value. The result register is always the
// last output of the instruction.
Label check;
- DCHECK_NE(0, instr->OutputCount());
+ DCHECK_NE(0, static_cast<int>(instr->OutputCount()));
Register reg = i.OutputRegister(static_cast<int>(instr->OutputCount() - 1));
Condition cc = no_condition;
switch (condition) {
frame()->SetRegisterSaveAreaSize(register_save_area_size);
}
} else if (descriptor->IsJSFunctionCall()) {
- CompilationInfo* info = linkage()->info();
+ CompilationInfo* info = this->info();
__ Prologue(info->IsCodePreAgingActive());
frame()->SetRegisterSaveAreaSize(
StandardFrameConstants::kFixedFrameSizeFromFp);
if (destination->IsRegister() || destination->IsStackSlot()) {
Register dst = destination->IsRegister() ? g.ToRegister(destination)
: kScratchRegister;
- Immediate64 imm = g.ToImmediate64(constant_source);
- switch (imm.type) {
- case kImm64Value:
- __ Set(dst, imm.value);
+ switch (src.type()) {
+ case Constant::kInt32:
+ // TODO(dcarney): don't need scratch in this case.
+ __ Set(dst, src.ToInt32());
+ break;
+ case Constant::kInt64:
+ __ Set(dst, src.ToInt64());
+ break;
+ case Constant::kFloat32:
+ __ Move(dst,
+ isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
+ break;
+ case Constant::kFloat64:
+ __ Move(dst,
+ isolate()->factory()->NewNumber(src.ToFloat64(), TENURED));
break;
- case kImm64Reference:
- __ Move(dst, imm.reference);
+ case Constant::kExternalReference:
+ __ Move(dst, src.ToExternalReference());
break;
- case kImm64Handle:
- __ Move(dst, imm.handle);
+ case Constant::kHeapObject:
+ __ Move(dst, src.ToHeapObject());
break;
}
if (destination->IsStackSlot()) {
}
} else if (src.type() == Constant::kFloat32) {
// TODO(turbofan): Can we do better here?
- __ movl(kScratchRegister, Immediate(bit_cast<int32_t>(src.ToFloat32())));
+ uint32_t src_const = bit_cast<uint32_t>(src.ToFloat32());
if (destination->IsDoubleRegister()) {
- XMMRegister dst = g.ToDoubleRegister(destination);
- __ movq(dst, kScratchRegister);
+ __ Move(g.ToDoubleRegister(destination), src_const);
} else {
DCHECK(destination->IsDoubleStackSlot());
Operand dst = g.ToOperand(destination);
- __ movl(dst, kScratchRegister);
+ __ movl(dst, Immediate(src_const));
}
} else {
DCHECK_EQ(Constant::kFloat64, src.type());
- __ movq(kScratchRegister, bit_cast<int64_t>(src.ToFloat64()));
+ uint64_t src_const = bit_cast<uint64_t>(src.ToFloat64());
if (destination->IsDoubleRegister()) {
- __ movq(g.ToDoubleRegister(destination), kScratchRegister);
+ __ Move(g.ToDoubleRegister(destination), src_const);
} else {
DCHECK(destination->IsDoubleStackSlot());
+ __ movq(kScratchRegister, src_const);
__ movq(g.ToOperand(destination), kScratchRegister);
}
}
void CodeGenerator::EnsureSpaceForLazyDeopt() {
int space_needed = Deoptimizer::patch_size();
- if (!linkage()->info()->IsStub()) {
+ if (!info()->IsStub()) {
// Ensure that we have enough space after the previous lazy-bailout
// instruction for patching the code here.
int current_pc = masm()->pc_offset();
V(X64Sub32) \
V(X64Imul) \
V(X64Imul32) \
+ V(X64ImulHigh32) \
+ V(X64UmulHigh32) \
V(X64Idiv) \
V(X64Idiv32) \
V(X64Udiv) \
V(SSEFloat64Div) \
V(SSEFloat64Mod) \
V(SSEFloat64Sqrt) \
+ V(SSEFloat64Floor) \
+ V(SSEFloat64Ceil) \
+ V(SSEFloat64RoundTruncate) \
V(SSECvtss2sd) \
V(SSECvtsd2ss) \
V(SSEFloat64ToInt32) \
V(X64Movq) \
V(X64Movsd) \
V(X64Movss) \
+ V(X64Lea32) \
+ V(X64Lea) \
V(X64Push) \
V(X64StoreWriteBarrier)
// M = memory operand
// R = base register
// N = index register * N for N in {1, 2, 4, 8}
-// I = immediate displacement (int32_t)
+// I = immediate displacement (32-bit signed integer)
#define TARGET_ADDRESSING_MODE_LIST(V) \
V(MR) /* [%r1 ] */ \
+++ /dev/null
-// 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/instruction-selector-unittest.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-// -----------------------------------------------------------------------------
-// Conversions.
-
-
-TEST_F(InstructionSelectorTest, ChangeFloat32ToFloat64WithParameter) {
- StreamBuilder m(this, kMachFloat32, kMachFloat64);
- m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kSSECvtss2sd, s[0]->arch_opcode());
- EXPECT_EQ(1U, s[0]->InputCount());
- EXPECT_EQ(1U, s[0]->OutputCount());
-}
-
-
-TEST_F(InstructionSelectorTest, ChangeInt32ToInt64WithParameter) {
- StreamBuilder m(this, kMachInt64, kMachInt32);
- m.Return(m.ChangeInt32ToInt64(m.Parameter(0)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kX64Movsxlq, s[0]->arch_opcode());
-}
-
-
-TEST_F(InstructionSelectorTest, ChangeUint32ToUint64WithParameter) {
- StreamBuilder m(this, kMachUint64, kMachUint32);
- m.Return(m.ChangeUint32ToUint64(m.Parameter(0)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
-}
-
-
-TEST_F(InstructionSelectorTest, TruncateFloat64ToFloat32WithParameter) {
- StreamBuilder m(this, kMachFloat64, kMachFloat32);
- m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kSSECvtsd2ss, s[0]->arch_opcode());
- EXPECT_EQ(1U, s[0]->InputCount());
- EXPECT_EQ(1U, s[0]->OutputCount());
-}
-
-
-TEST_F(InstructionSelectorTest, TruncateInt64ToInt32WithParameter) {
- StreamBuilder m(this, kMachInt32, kMachInt64);
- m.Return(m.TruncateInt64ToInt32(m.Parameter(0)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
-}
-
-
-// -----------------------------------------------------------------------------
-// Better left operand for commutative binops
-
-TEST_F(InstructionSelectorTest, BetterLeftOperandTestAddBinop) {
- StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- Node* param1 = m.Parameter(0);
- Node* param2 = m.Parameter(1);
- Node* add = m.Int32Add(param1, param2);
- m.Return(m.Int32Add(add, param1));
- Stream s = m.Build();
- ASSERT_EQ(2U, s.size());
- EXPECT_EQ(kX64Add32, s[0]->arch_opcode());
- ASSERT_EQ(2U, s[0]->InputCount());
- ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
- EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
-}
-
-
-TEST_F(InstructionSelectorTest, BetterLeftOperandTestMulBinop) {
- StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- Node* param1 = m.Parameter(0);
- Node* param2 = m.Parameter(1);
- Node* mul = m.Int32Mul(param1, param2);
- m.Return(m.Int32Mul(mul, param1));
- Stream s = m.Build();
- ASSERT_EQ(2U, s.size());
- EXPECT_EQ(kX64Imul32, s[0]->arch_opcode());
- ASSERT_EQ(2U, s[0]->InputCount());
- ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
- EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
-}
-
-
-// -----------------------------------------------------------------------------
-// Loads and stores
-
-namespace {
-
-struct MemoryAccess {
- MachineType type;
- ArchOpcode load_opcode;
- ArchOpcode store_opcode;
-};
-
-
-std::ostream& operator<<(std::ostream& os, const MemoryAccess& memacc) {
- OStringStream ost;
- ost << memacc.type;
- return os << ost.c_str();
-}
-
-
-static const MemoryAccess kMemoryAccesses[] = {
- {kMachInt8, kX64Movsxbl, kX64Movb},
- {kMachUint8, kX64Movzxbl, kX64Movb},
- {kMachInt16, kX64Movsxwl, kX64Movw},
- {kMachUint16, kX64Movzxwl, kX64Movw},
- {kMachInt32, kX64Movl, kX64Movl},
- {kMachUint32, kX64Movl, kX64Movl},
- {kMachInt64, kX64Movq, kX64Movq},
- {kMachUint64, kX64Movq, kX64Movq},
- {kMachFloat32, kX64Movss, kX64Movss},
- {kMachFloat64, kX64Movsd, kX64Movsd}};
-
-} // namespace
-
-
-typedef InstructionSelectorTestWithParam<MemoryAccess>
- InstructionSelectorMemoryAccessTest;
-
-
-TEST_P(InstructionSelectorMemoryAccessTest, LoadWithParameters) {
- const MemoryAccess memacc = GetParam();
- StreamBuilder m(this, memacc.type, kMachPtr, kMachInt32);
- m.Return(m.Load(memacc.type, m.Parameter(0), m.Parameter(1)));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(memacc.load_opcode, s[0]->arch_opcode());
- EXPECT_EQ(2U, s[0]->InputCount());
- EXPECT_EQ(1U, s[0]->OutputCount());
-}
-
-
-TEST_P(InstructionSelectorMemoryAccessTest, StoreWithParameters) {
- const MemoryAccess memacc = GetParam();
- StreamBuilder m(this, kMachInt32, kMachPtr, kMachInt32, memacc.type);
- m.Store(memacc.type, m.Parameter(0), m.Parameter(1), m.Parameter(2));
- m.Return(m.Int32Constant(0));
- Stream s = m.Build();
- ASSERT_EQ(1U, s.size());
- EXPECT_EQ(memacc.store_opcode, s[0]->arch_opcode());
- EXPECT_EQ(3U, s[0]->InputCount());
- EXPECT_EQ(0U, s[0]->OutputCount());
-}
-
-
-INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
- InstructionSelectorMemoryAccessTest,
- ::testing::ValuesIn(kMemoryAccesses));
-
-// -----------------------------------------------------------------------------
-// AddressingMode for loads and stores.
-
-class AddressingModeUnitTest : public InstructionSelectorTest {
- public:
- AddressingModeUnitTest() : m(NULL) { Reset(); }
- ~AddressingModeUnitTest() { delete m; }
-
- void Run(Node* base, Node* index, AddressingMode mode) {
- Node* load = m->Load(kMachInt32, base, index);
- m->Store(kMachInt32, base, index, load);
- m->Return(m->Int32Constant(0));
- Stream s = m->Build();
- ASSERT_EQ(2U, s.size());
- EXPECT_EQ(mode, s[0]->addressing_mode());
- EXPECT_EQ(mode, s[1]->addressing_mode());
- }
-
- Node* zero;
- Node* null_ptr;
- Node* non_zero;
- Node* base_reg; // opaque value to generate base as register
- Node* index_reg; // opaque value to generate index as register
- Node* scales[4];
- StreamBuilder* m;
-
- void Reset() {
- delete m;
- m = new StreamBuilder(this, kMachInt32, kMachInt32, kMachInt32);
- zero = m->Int32Constant(0);
- null_ptr = m->Int64Constant(0);
- non_zero = m->Int32Constant(127);
- base_reg = m->Parameter(0);
- index_reg = m->Parameter(0);
-
- scales[0] = m->Int32Constant(1);
- scales[1] = m->Int32Constant(2);
- scales[2] = m->Int32Constant(4);
- scales[3] = m->Int32Constant(8);
- }
-};
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MR) {
- Node* base = base_reg;
- Node* index = zero;
- Run(base, index, kMode_MR);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MRI) {
- Node* base = base_reg;
- Node* index = non_zero;
- Run(base, index, kMode_MRI);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MR1) {
- Node* base = base_reg;
- Node* index = index_reg;
- Run(base, index, kMode_MR1);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MRN) {
- AddressingMode expected[] = {kMode_MR1, kMode_MR2, kMode_MR4, kMode_MR8};
- for (size_t i = 0; i < arraysize(scales); ++i) {
- Reset();
- Node* base = base_reg;
- Node* index = m->Int32Mul(index_reg, scales[i]);
- Run(base, index, expected[i]);
- }
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MR1I) {
- Node* base = base_reg;
- Node* index = m->Int32Add(index_reg, non_zero);
- Run(base, index, kMode_MR1I);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MRNI) {
- AddressingMode expected[] = {kMode_MR1I, kMode_MR2I, kMode_MR4I, kMode_MR8I};
- for (size_t i = 0; i < arraysize(scales); ++i) {
- Reset();
- Node* base = base_reg;
- Node* index = m->Int32Add(m->Int32Mul(index_reg, scales[i]), non_zero);
- Run(base, index, expected[i]);
- }
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_M1) {
- Node* base = null_ptr;
- Node* index = index_reg;
- Run(base, index, kMode_M1);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MN) {
- AddressingMode expected[] = {kMode_M1, kMode_M2, kMode_M4, kMode_M8};
- for (size_t i = 0; i < arraysize(scales); ++i) {
- Reset();
- Node* base = null_ptr;
- Node* index = m->Int32Mul(index_reg, scales[i]);
- Run(base, index, expected[i]);
- }
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_M1I) {
- Node* base = null_ptr;
- Node* index = m->Int32Add(index_reg, non_zero);
- Run(base, index, kMode_M1I);
-}
-
-
-TEST_F(AddressingModeUnitTest, AddressingMode_MNI) {
- AddressingMode expected[] = {kMode_M1I, kMode_M2I, kMode_M4I, kMode_M8I};
- for (size_t i = 0; i < arraysize(scales); ++i) {
- Reset();
- Node* base = null_ptr;
- Node* index = m->Int32Add(m->Int32Mul(index_reg, scales[i]), non_zero);
- Run(base, index, expected[i]);
- }
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/compiler/generic-node-inl.h"
#include "src/compiler/instruction-selector-impl.h"
#include "src/compiler/node-matchers.h"
Register::ToAllocationIndex(reg));
}
- InstructionOperand* UseImmediate64(Node* node) { return UseImmediate(node); }
-
bool CanBeImmediate(Node* node) {
switch (node->opcode()) {
case IrOpcode::kInt32Constant:
return true;
- default:
- return false;
- }
- }
-
- bool CanBeImmediate64(Node* node) {
- switch (node->opcode()) {
- case IrOpcode::kInt32Constant:
- return true;
- case IrOpcode::kNumberConstant:
- return true;
- case IrOpcode::kHeapConstant: {
- // Constants in new space cannot be used as immediates in V8 because
- // the GC does not scan code objects when collecting the new generation.
- Unique<HeapObject> value = OpParameter<Unique<HeapObject> >(node);
- return !isolate()->heap()->InNewSpace(*value.handle());
+ case IrOpcode::kInt64Constant: {
+ const int64_t value = OpParameter<int64_t>(node);
+ return value == static_cast<int64_t>(static_cast<int32_t>(value));
}
default:
return false;
};
-class AddressingModeMatcher {
- public:
- AddressingModeMatcher(X64OperandGenerator* g, Node* base, Node* index)
- : base_operand_(NULL),
- index_operand_(NULL),
- displacement_operand_(NULL),
- mode_(kMode_None) {
- Int32Matcher index_imm(index);
- if (index_imm.HasValue()) {
- int32_t value = index_imm.Value();
- if (value == 0) {
- mode_ = kMode_MR;
- } else {
- mode_ = kMode_MRI;
- index_operand_ = g->UseImmediate(index);
- }
- base_operand_ = g->UseRegister(base);
- } else {
- // Compute base operand.
- Int64Matcher base_imm(base);
- if (!base_imm.HasValue() || base_imm.Value() != 0) {
- base_operand_ = g->UseRegister(base);
- }
- // Compute index and displacement.
- IndexAndDisplacementMatcher matcher(index);
- index_operand_ = g->UseRegister(matcher.index_node());
- if (matcher.displacement() != 0) {
- displacement_operand_ = g->TempImmediate(matcher.displacement());
- }
- // Compute mode with scale factor one.
- if (base_operand_ == NULL) {
- if (displacement_operand_ == NULL) {
- mode_ = kMode_M1;
- } else {
- mode_ = kMode_M1I;
- }
- } else {
- if (displacement_operand_ == NULL) {
- mode_ = kMode_MR1;
- } else {
- mode_ = kMode_MR1I;
- }
- }
- // Adjust mode to actual scale factor.
- mode_ = GetMode(mode_, matcher.power());
- }
- DCHECK_NE(kMode_None, mode_);
- }
-
- AddressingMode GetMode(AddressingMode one, int power) {
- return static_cast<AddressingMode>(static_cast<int>(one) + power);
- }
-
- size_t SetInputs(InstructionOperand** inputs) {
- size_t input_count = 0;
- // Compute inputs_ and input_count.
- if (base_operand_ != NULL) {
- inputs[input_count++] = base_operand_;
- }
- if (index_operand_ != NULL) {
- inputs[input_count++] = index_operand_;
- }
- if (displacement_operand_ != NULL) {
- // Pure displacement mode not supported by x64.
- DCHECK_NE(input_count, 0);
- inputs[input_count++] = displacement_operand_;
- }
- DCHECK_NE(input_count, 0);
- return input_count;
- }
-
- static const int kMaxInputCount = 3;
- InstructionOperand* base_operand_;
- InstructionOperand* index_operand_;
- InstructionOperand* displacement_operand_;
- AddressingMode mode_;
-};
-
-
void InstructionSelector::VisitLoad(Node* node) {
MachineType rep = RepresentationOf(OpParameter<LoadRepresentation>(node));
MachineType typ = TypeOf(OpParameter<LoadRepresentation>(node));
- Node* base = node->InputAt(0);
- Node* index = node->InputAt(1);
+ X64OperandGenerator g(this);
+ Node* const base = node->InputAt(0);
+ Node* const index = node->InputAt(1);
ArchOpcode opcode;
- // TODO(titzer): signed/unsigned small loads
switch (rep) {
case kRepFloat32:
opcode = kX64Movss;
UNREACHABLE();
return;
}
-
- X64OperandGenerator g(this);
- AddressingModeMatcher matcher(&g, base, index);
- InstructionCode code = opcode | AddressingModeField::encode(matcher.mode_);
- InstructionOperand* outputs[] = {g.DefineAsRegister(node)};
- InstructionOperand* inputs[AddressingModeMatcher::kMaxInputCount];
- size_t input_count = matcher.SetInputs(inputs);
- Emit(code, 1, outputs, input_count, inputs);
+ if (g.CanBeImmediate(base)) {
+ // load [#base + %index]
+ Emit(opcode | AddressingModeField::encode(kMode_MRI),
+ g.DefineAsRegister(node), g.UseRegister(index), g.UseImmediate(base));
+ } else if (g.CanBeImmediate(index)) {
+ // load [%base + #index]
+ Emit(opcode | AddressingModeField::encode(kMode_MRI),
+ g.DefineAsRegister(node), g.UseRegister(base), g.UseImmediate(index));
+ } else {
+ // load [%base + %index*1]
+ Emit(opcode | AddressingModeField::encode(kMode_MR1),
+ g.DefineAsRegister(node), g.UseRegister(base), g.UseRegister(index));
+ }
}
UNREACHABLE();
return;
}
-
- InstructionOperand* val;
- if (g.CanBeImmediate(value)) {
- val = g.UseImmediate(value);
+ InstructionOperand* value_operand =
+ g.CanBeImmediate(value) ? g.UseImmediate(value) : g.UseRegister(value);
+ if (g.CanBeImmediate(base)) {
+ // store [#base + %index], %|#value
+ Emit(opcode | AddressingModeField::encode(kMode_MRI), nullptr,
+ g.UseRegister(index), g.UseImmediate(base), value_operand);
+ } else if (g.CanBeImmediate(index)) {
+ // store [%base + #index], %|#value
+ Emit(opcode | AddressingModeField::encode(kMode_MRI), nullptr,
+ g.UseRegister(base), g.UseImmediate(index), value_operand);
} else {
- val = g.UseRegister(value);
+ // store [%base + %index*1], %|#value
+ Emit(opcode | AddressingModeField::encode(kMode_MR1), nullptr,
+ g.UseRegister(base), g.UseRegister(index), value_operand);
}
-
- AddressingModeMatcher matcher(&g, base, index);
- InstructionCode code = opcode | AddressingModeField::encode(matcher.mode_);
- InstructionOperand* inputs[AddressingModeMatcher::kMaxInputCount + 1];
- size_t input_count = matcher.SetInputs(inputs);
- inputs[input_count++] = val;
- Emit(code, 0, static_cast<InstructionOperand**>(NULL), input_count, inputs);
}
size_t output_count = 0;
// TODO(turbofan): match complex addressing modes.
- if (g.CanBeImmediate(right)) {
- inputs[input_count++] = g.Use(left);
+ if (left == right) {
+ // If both inputs refer to the same operand, enforce allocating a register
+ // for both of them to ensure that we don't end up generating code like
+ // this:
+ //
+ // mov rax, [rbp-0x10]
+ // add rax, [rbp-0x10]
+ // jo label
+ InstructionOperand* const input = g.UseRegister(left);
+ inputs[input_count++] = input;
+ inputs[input_count++] = input;
+ } else if (g.CanBeImmediate(right)) {
+ inputs[input_count++] = g.UseRegister(left);
inputs[input_count++] = g.UseImmediate(right);
} else {
if (node->op()->HasProperty(Operator::kCommutative) &&
outputs[output_count++] = g.DefineAsRegister(cont->result());
}
- DCHECK_NE(0, input_count);
- DCHECK_NE(0, output_count);
+ DCHECK_NE(0, static_cast<int>(input_count));
+ DCHECK_NE(0, static_cast<int>(output_count));
DCHECK_GE(arraysize(inputs), input_count);
DCHECK_GE(arraysize(outputs), output_count);
X64OperandGenerator g(this);
Uint32BinopMatcher m(node);
if (m.right().Is(-1)) {
- Emit(kX64Not32, g.DefineSameAsFirst(node), g.Use(m.left().node()));
+ Emit(kX64Not32, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
} else {
VisitBinop(this, node, kX64Xor32);
}
X64OperandGenerator g(this);
Uint64BinopMatcher m(node);
if (m.right().Is(-1)) {
- Emit(kX64Not, g.DefineSameAsFirst(node), g.Use(m.left().node()));
+ Emit(kX64Not, g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
} else {
VisitBinop(this, node, kX64Xor);
}
}
+namespace {
+
// Shared routine for multiple 32-bit shift operations.
// TODO(bmeurer): Merge this with VisitWord64Shift using template magic?
-static void VisitWord32Shift(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
+void VisitWord32Shift(InstructionSelector* selector, Node* node,
+ ArchOpcode opcode) {
X64OperandGenerator g(selector);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
+ Int32BinopMatcher m(node);
+ Node* left = m.left().node();
+ Node* right = m.right().node();
- // TODO(turbofan): assembler only supports some addressing modes for shifts.
if (g.CanBeImmediate(right)) {
selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
g.UseImmediate(right));
} else {
- Int32BinopMatcher m(node);
if (m.right().IsWord32And()) {
Int32BinopMatcher mright(right);
if (mright.right().Is(0x1F)) {
// Shared routine for multiple 64-bit shift operations.
// TODO(bmeurer): Merge this with VisitWord32Shift using template magic?
-static void VisitWord64Shift(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
+void VisitWord64Shift(InstructionSelector* selector, Node* node,
+ ArchOpcode opcode) {
X64OperandGenerator g(selector);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
+ Int64BinopMatcher m(node);
+ Node* left = m.left().node();
+ Node* right = m.right().node();
- // TODO(turbofan): assembler only supports some addressing modes for shifts.
if (g.CanBeImmediate(right)) {
selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
g.UseImmediate(right));
} else {
- Int64BinopMatcher m(node);
if (m.right().IsWord64And()) {
Int64BinopMatcher mright(right);
if (mright.right().Is(0x3F)) {
}
}
+} // namespace
+
void InstructionSelector::VisitWord32Shl(Node* node) {
VisitWord32Shift(this, node, kX64Shl32);
void InstructionSelector::VisitWord64Shl(Node* node) {
+ X64OperandGenerator g(this);
+ Int64BinopMatcher m(node);
+ if ((m.left().IsChangeInt32ToInt64() || m.left().IsChangeUint32ToUint64()) &&
+ m.right().IsInRange(32, 63)) {
+ // There's no need to sign/zero-extend to 64-bit if we shift out the upper
+ // 32 bits anyway.
+ Emit(kX64Shl, g.DefineSameAsFirst(node),
+ g.UseRegister(m.left().node()->InputAt(0)),
+ g.UseImmediate(m.right().node()));
+ return;
+ }
VisitWord64Shift(this, node, kX64Shl);
}
X64OperandGenerator g(this);
Int32BinopMatcher m(node);
if (m.left().Is(0)) {
- Emit(kX64Neg32, g.DefineSameAsFirst(node), g.Use(m.right().node()));
+ Emit(kX64Neg32, g.DefineSameAsFirst(node), g.UseRegister(m.right().node()));
} else {
VisitBinop(this, node, kX64Sub32);
}
X64OperandGenerator g(this);
Int64BinopMatcher m(node);
if (m.left().Is(0)) {
- Emit(kX64Neg, g.DefineSameAsFirst(node), g.Use(m.right().node()));
+ Emit(kX64Neg, g.DefineSameAsFirst(node), g.UseRegister(m.right().node()));
} else {
VisitBinop(this, node, kX64Sub);
}
}
-static void VisitMul(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
+namespace {
+
+void VisitMul(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
X64OperandGenerator g(selector);
Int32BinopMatcher m(node);
Node* left = m.left().node();
}
+void VisitMulHigh(InstructionSelector* selector, Node* node,
+ ArchOpcode opcode) {
+ X64OperandGenerator g(selector);
+ Node* left = node->InputAt(0);
+ Node* right = node->InputAt(1);
+ if (selector->IsLive(left) && !selector->IsLive(right)) {
+ std::swap(left, right);
+ }
+ // TODO(turbofan): We use UseUniqueRegister here to improve register
+ // allocation.
+ selector->Emit(opcode, g.DefineAsFixed(node, rdx), g.UseFixed(left, rax),
+ g.UseUniqueRegister(right));
+}
+
+
+void VisitDiv(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
+ X64OperandGenerator g(selector);
+ InstructionOperand* temps[] = {g.TempRegister(rdx)};
+ selector->Emit(
+ opcode, g.DefineAsFixed(node, rax), g.UseFixed(node->InputAt(0), rax),
+ g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
+}
+
+
+void VisitMod(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
+ X64OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsFixed(node, rdx),
+ g.UseFixed(node->InputAt(0), rax),
+ g.UseUniqueRegister(node->InputAt(1)));
+}
+
+} // namespace
+
+
void InstructionSelector::VisitInt32Mul(Node* node) {
VisitMul(this, node, kX64Imul32);
}
}
-static void VisitDiv(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
- X64OperandGenerator g(selector);
- InstructionOperand* temps[] = {g.TempRegister(rdx)};
- selector->Emit(
- opcode, g.DefineAsFixed(node, rax), g.UseFixed(node->InputAt(0), rax),
- g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
+void InstructionSelector::VisitInt32MulHigh(Node* node) {
+ VisitMulHigh(this, node, kX64ImulHigh32);
}
}
-void InstructionSelector::VisitInt32UDiv(Node* node) {
+void InstructionSelector::VisitUint32Div(Node* node) {
VisitDiv(this, node, kX64Udiv32);
}
-void InstructionSelector::VisitInt64UDiv(Node* node) {
+void InstructionSelector::VisitUint64Div(Node* node) {
VisitDiv(this, node, kX64Udiv);
}
-static void VisitMod(InstructionSelector* selector, Node* node,
- ArchOpcode opcode) {
- X64OperandGenerator g(selector);
- InstructionOperand* temps[] = {g.TempRegister(rax), g.TempRegister(rdx)};
- selector->Emit(
- opcode, g.DefineAsFixed(node, rdx), g.UseFixed(node->InputAt(0), rax),
- g.UseUniqueRegister(node->InputAt(1)), arraysize(temps), temps);
-}
-
-
void InstructionSelector::VisitInt32Mod(Node* node) {
VisitMod(this, node, kX64Idiv32);
}
}
-void InstructionSelector::VisitInt32UMod(Node* node) {
+void InstructionSelector::VisitUint32Mod(Node* node) {
VisitMod(this, node, kX64Udiv32);
}
-void InstructionSelector::VisitInt64UMod(Node* node) {
+void InstructionSelector::VisitUint64Mod(Node* node) {
VisitMod(this, node, kX64Udiv);
}
+void InstructionSelector::VisitUint32MulHigh(Node* node) {
+ VisitMulHigh(this, node, kX64UmulHigh32);
+}
+
+
void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
X64OperandGenerator g(this);
- // TODO(turbofan): X64 SSE conversions should take an operand.
- Emit(kSSECvtss2sd, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+ Emit(kSSECvtss2sd, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
X64OperandGenerator g(this);
- // TODO(turbofan): X64 SSE cvtqsi2sd should support operands.
- Emit(kSSEUint32ToFloat64, g.DefineAsRegister(node),
- g.UseRegister(node->InputAt(0)));
+ Emit(kSSEUint32ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
X64OperandGenerator g(this);
- Emit(kX64Movl, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
+ Node* value = node->InputAt(0);
+ switch (value->opcode()) {
+ case IrOpcode::kWord32And:
+ case IrOpcode::kWord32Or:
+ case IrOpcode::kWord32Xor:
+ case IrOpcode::kWord32Shl:
+ case IrOpcode::kWord32Shr:
+ case IrOpcode::kWord32Sar:
+ case IrOpcode::kWord32Ror:
+ case IrOpcode::kWord32Equal:
+ case IrOpcode::kInt32Add:
+ case IrOpcode::kInt32Sub:
+ case IrOpcode::kInt32Mul:
+ case IrOpcode::kInt32MulHigh:
+ case IrOpcode::kInt32Div:
+ case IrOpcode::kInt32LessThan:
+ case IrOpcode::kInt32LessThanOrEqual:
+ case IrOpcode::kInt32Mod:
+ case IrOpcode::kUint32Div:
+ case IrOpcode::kUint32LessThan:
+ case IrOpcode::kUint32LessThanOrEqual:
+ case IrOpcode::kUint32Mod:
+ case IrOpcode::kUint32MulHigh: {
+ // These 32-bit operations implicitly zero-extend to 64-bit on x64, so the
+ // zero-extension is a no-op.
+ Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
+ return;
+ }
+ default:
+ break;
+ }
+ Emit(kX64Movl, g.DefineAsRegister(node), g.Use(value));
}
void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
X64OperandGenerator g(this);
- // TODO(turbofan): X64 SSE conversions should take an operand.
- Emit(kSSECvtsd2ss, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
+ Emit(kSSECvtsd2ss, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
}
void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
X64OperandGenerator g(this);
- Emit(kX64Movl, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
+ Node* value = node->InputAt(0);
+ if (CanCover(node, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord64Sar:
+ case IrOpcode::kWord64Shr: {
+ Int64BinopMatcher m(value);
+ if (m.right().Is(32)) {
+ Emit(kX64Shr, g.DefineSameAsFirst(node),
+ g.UseRegister(m.left().node()), g.TempImmediate(32));
+ return;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ Emit(kX64Movl, g.DefineAsRegister(node), g.Use(value));
}
void InstructionSelector::VisitFloat64Add(Node* node) {
X64OperandGenerator g(this);
Emit(kSSEFloat64Add, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Sub(Node* node) {
X64OperandGenerator g(this);
Emit(kSSEFloat64Sub, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Mul(Node* node) {
X64OperandGenerator g(this);
Emit(kSSEFloat64Mul, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
void InstructionSelector::VisitFloat64Div(Node* node) {
X64OperandGenerator g(this);
Emit(kSSEFloat64Div, g.DefineSameAsFirst(node),
- g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)));
+ g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)));
}
}
-void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kX64Add32, cont);
+namespace {
+
+void VisitRRFloat64(InstructionSelector* selector, ArchOpcode opcode,
+ Node* node) {
+ X64OperandGenerator g(selector);
+ selector->Emit(opcode, g.DefineAsRegister(node),
+ g.UseRegister(node->InputAt(0)));
+}
+
+} // namespace
+
+
+void InstructionSelector::VisitFloat64Floor(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64Floor, node);
+}
+
+
+void InstructionSelector::VisitFloat64Ceil(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64Ceil, node);
+}
+
+
+void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
+ DCHECK(CpuFeatures::IsSupported(SSE4_1));
+ VisitRRFloat64(this, kSSEFloat64RoundTruncate, node);
}
-void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
- FlagsContinuation* cont) {
- VisitBinop(this, node, kX64Sub32, cont);
+void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
+ UNREACHABLE();
+}
+
+
+void InstructionSelector::VisitCall(Node* node) {
+ X64OperandGenerator g(this);
+ CallDescriptor* descriptor = OpParameter<CallDescriptor*>(node);
+
+ FrameStateDescriptor* frame_state_descriptor = NULL;
+ if (descriptor->NeedsFrameState()) {
+ frame_state_descriptor = GetFrameStateDescriptor(
+ node->InputAt(static_cast<int>(descriptor->InputCount())));
+ }
+
+ CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
+
+ // Compute InstructionOperands for inputs and outputs.
+ InitializeCallBuffer(node, &buffer, true, true);
+
+ // Push any stack arguments.
+ for (NodeVectorRIter input = buffer.pushed_nodes.rbegin();
+ input != buffer.pushed_nodes.rend(); input++) {
+ // TODO(titzer): handle pushing double parameters.
+ Emit(kX64Push, NULL,
+ g.CanBeImmediate(*input) ? g.UseImmediate(*input) : g.Use(*input));
+ }
+
+ // Select the appropriate opcode based on the call type.
+ InstructionCode opcode;
+ switch (descriptor->kind()) {
+ case CallDescriptor::kCallCodeObject: {
+ opcode = kArchCallCodeObject;
+ break;
+ }
+ case CallDescriptor::kCallJSFunction:
+ opcode = kArchCallJSFunction;
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+ opcode |= MiscField::encode(descriptor->flags());
+
+ // Emit the call instruction.
+ InstructionOperand** first_output =
+ buffer.outputs.size() > 0 ? &buffer.outputs.front() : NULL;
+ Instruction* call_instr =
+ Emit(opcode, buffer.outputs.size(), first_output,
+ buffer.instruction_args.size(), &buffer.instruction_args.front());
+ call_instr->MarkAsCall();
}
}
+// Shared routine for multiple compare operations.
+static void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
+ Node* left, Node* right, FlagsContinuation* cont,
+ bool commutative) {
+ X64OperandGenerator g(selector);
+ if (commutative && g.CanBeBetterLeftOperand(right)) {
+ std::swap(left, right);
+ }
+ VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
+}
+
+
// Shared routine for multiple word compare operations.
static void VisitWordCompare(InstructionSelector* selector, Node* node,
- InstructionCode opcode, FlagsContinuation* cont,
- bool commutative) {
+ InstructionCode opcode, FlagsContinuation* cont) {
X64OperandGenerator g(selector);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
+ Node* const left = node->InputAt(0);
+ Node* const right = node->InputAt(1);
// Match immediates on left or right side of comparison.
if (g.CanBeImmediate(right)) {
VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right), cont);
} else if (g.CanBeImmediate(left)) {
- if (!commutative) cont->Commute();
+ if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
VisitCompare(selector, opcode, g.Use(right), g.UseImmediate(left), cont);
} else {
- VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
+ VisitCompare(selector, opcode, left, right, cont,
+ node->op()->HasProperty(Operator::kCommutative));
}
}
-void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kInt32Sub:
- return VisitWordCompare(this, node, kX64Cmp32, cont, false);
- case IrOpcode::kWord32And:
- return VisitWordCompare(this, node, kX64Test32, cont, true);
- default:
- break;
- }
+// Shared routine for comparison with zero.
+static void VisitCompareZero(InstructionSelector* selector, Node* node,
+ InstructionCode opcode, FlagsContinuation* cont) {
+ X64OperandGenerator g(selector);
+ VisitCompare(selector, opcode, g.Use(node), g.TempImmediate(0), cont);
+}
- X64OperandGenerator g(this);
- VisitCompare(this, kX64Test32, g.Use(node), g.TempImmediate(-1), cont);
+
+// Shared routine for multiple float64 compare operations.
+static void VisitFloat64Compare(InstructionSelector* selector, Node* node,
+ FlagsContinuation* cont) {
+ VisitCompare(selector, kSSEFloat64Cmp, node->InputAt(0), node->InputAt(1),
+ cont, node->op()->HasProperty(Operator::kCommutative));
}
-void InstructionSelector::VisitWord64Test(Node* node, FlagsContinuation* cont) {
- switch (node->opcode()) {
- case IrOpcode::kInt64Sub:
- return VisitWordCompare(this, node, kX64Cmp, cont, false);
- case IrOpcode::kWord64And:
- return VisitWordCompare(this, node, kX64Test, cont, true);
- default:
+void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch,
+ BasicBlock* fbranch) {
+ X64OperandGenerator g(this);
+ Node* user = branch;
+ Node* value = branch->InputAt(0);
+
+ FlagsContinuation cont(kNotEqual, tbranch, fbranch);
+
+ // If we can fall through to the true block, invert the branch.
+ if (IsNextInAssemblyOrder(tbranch)) {
+ cont.Negate();
+ cont.SwapBlocks();
+ }
+
+ // Try to combine with comparisons against 0 by simply inverting the branch.
+ while (CanCover(user, value)) {
+ if (value->opcode() == IrOpcode::kWord32Equal) {
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ } else if (value->opcode() == IrOpcode::kWord64Equal) {
+ Int64BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ } else {
break;
+ }
}
- X64OperandGenerator g(this);
- VisitCompare(this, kX64Test, g.Use(node), g.TempImmediate(-1), cont);
+ // Try to combine the branch with a comparison.
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kWord32Equal:
+ cont.OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kInt32LessThan:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kInt32LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kUint32LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kUint32LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThanOrEqual);
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kWord64Equal:
+ cont.OverwriteAndNegateIfEqual(kEqual);
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kInt64LessThan:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThan);
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kInt64LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kSignedLessThanOrEqual);
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kUint64LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnsignedLessThan);
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kFloat64Equal:
+ cont.OverwriteAndNegateIfEqual(kUnorderedEqual);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kFloat64LessThan:
+ cont.OverwriteAndNegateIfEqual(kUnorderedLessThan);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kFloat64LessThanOrEqual:
+ cont.OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
+ return VisitFloat64Compare(this, value, &cont);
+ case IrOpcode::kProjection:
+ // Check if this is the overflow output projection of an
+ // <Operation>WithOverflow node.
+ if (OpParameter<size_t>(value) == 1u) {
+ // We cannot combine the <Operation>WithOverflow with this branch
+ // unless the 0th projection (the use of the actual value of the
+ // <Operation> is either NULL, which means there's no use of the
+ // actual value, or was already defined, which means it is scheduled
+ // *AFTER* this branch).
+ Node* node = value->InputAt(0);
+ Node* result = node->FindProjection(0);
+ if (result == NULL || IsDefined(result)) {
+ switch (node->opcode()) {
+ case IrOpcode::kInt32AddWithOverflow:
+ cont.OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(this, node, kX64Add32, &cont);
+ case IrOpcode::kInt32SubWithOverflow:
+ cont.OverwriteAndNegateIfEqual(kOverflow);
+ return VisitBinop(this, node, kX64Sub32, &cont);
+ default:
+ break;
+ }
+ }
+ }
+ break;
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kInt64Sub:
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(this, value, kX64Test32, &cont);
+ case IrOpcode::kWord64And:
+ return VisitWordCompare(this, value, kX64Test, &cont);
+ default:
+ break;
+ }
+ }
+
+ // Branch could not be combined with a compare, emit compare against 0.
+ VisitCompareZero(this, value, kX64Cmp32, &cont);
}
-void InstructionSelector::VisitWord32Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kX64Cmp32, cont, false);
+void InstructionSelector::VisitWord32Equal(Node* const node) {
+ Node* user = node;
+ FlagsContinuation cont(kEqual, node);
+ Int32BinopMatcher m(user);
+ if (m.right().Is(0)) {
+ Node* value = m.left().node();
+
+ // Try to combine with comparisons against 0 by simply inverting the branch.
+ while (CanCover(user, value) && value->opcode() == IrOpcode::kWord32Equal) {
+ Int32BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ }
+
+ // Try to combine the branch with a comparison.
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kInt32Sub:
+ return VisitWordCompare(this, value, kX64Cmp32, &cont);
+ case IrOpcode::kWord32And:
+ return VisitWordCompare(this, value, kX64Test32, &cont);
+ default:
+ break;
+ }
+ }
+ return VisitCompareZero(this, value, kX64Cmp32, &cont);
+ }
+ VisitWordCompare(this, node, kX64Cmp32, &cont);
}
-void InstructionSelector::VisitWord64Compare(Node* node,
- FlagsContinuation* cont) {
- VisitWordCompare(this, node, kX64Cmp, cont, false);
+void InstructionSelector::VisitInt32LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, kX64Cmp32, &cont);
}
-void InstructionSelector::VisitFloat64Compare(Node* node,
- FlagsContinuation* cont) {
- X64OperandGenerator g(this);
- Node* left = node->InputAt(0);
- Node* right = node->InputAt(1);
- VisitCompare(this, kSSEFloat64Cmp, g.UseRegister(left), g.Use(right), cont);
+void InstructionSelector::VisitInt32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, kX64Cmp32, &cont);
}
-void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
- BasicBlock* deoptimization) {
- X64OperandGenerator g(this);
- CallDescriptor* descriptor = OpParameter<CallDescriptor*>(call);
+void InstructionSelector::VisitUint32LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, kX64Cmp32, &cont);
+}
- FrameStateDescriptor* frame_state_descriptor = NULL;
- if (descriptor->NeedsFrameState()) {
- frame_state_descriptor = GetFrameStateDescriptor(
- call->InputAt(static_cast<int>(descriptor->InputCount())));
- }
- CallBuffer buffer(zone(), descriptor, frame_state_descriptor);
+void InstructionSelector::VisitUint32LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, kX64Cmp32, &cont);
+}
- // Compute InstructionOperands for inputs and outputs.
- InitializeCallBuffer(call, &buffer, true, true);
- // Push any stack arguments.
- for (NodeVectorRIter input = buffer.pushed_nodes.rbegin();
- input != buffer.pushed_nodes.rend(); input++) {
- // TODO(titzer): handle pushing double parameters.
- Emit(kX64Push, NULL,
- g.CanBeImmediate(*input) ? g.UseImmediate(*input) : g.Use(*input));
- }
+void InstructionSelector::VisitWord64Equal(Node* const node) {
+ Node* user = node;
+ FlagsContinuation cont(kEqual, node);
+ Int64BinopMatcher m(user);
+ if (m.right().Is(0)) {
+ Node* value = m.left().node();
+
+ // Try to combine with comparisons against 0 by simply inverting the branch.
+ while (CanCover(user, value) && value->opcode() == IrOpcode::kWord64Equal) {
+ Int64BinopMatcher m(value);
+ if (m.right().Is(0)) {
+ user = value;
+ value = m.left().node();
+ cont.Negate();
+ } else {
+ break;
+ }
+ }
- // Select the appropriate opcode based on the call type.
- InstructionCode opcode;
- switch (descriptor->kind()) {
- case CallDescriptor::kCallCodeObject: {
- opcode = kArchCallCodeObject;
- break;
+ // Try to combine the branch with a comparison.
+ if (CanCover(user, value)) {
+ switch (value->opcode()) {
+ case IrOpcode::kInt64Sub:
+ return VisitWordCompare(this, value, kX64Cmp, &cont);
+ case IrOpcode::kWord64And:
+ return VisitWordCompare(this, value, kX64Test, &cont);
+ default:
+ break;
+ }
}
- case CallDescriptor::kCallJSFunction:
- opcode = kArchCallJSFunction;
- break;
- default:
- UNREACHABLE();
- return;
+ return VisitCompareZero(this, value, kX64Cmp, &cont);
}
- opcode |= MiscField::encode(descriptor->flags());
+ VisitWordCompare(this, node, kX64Cmp, &cont);
+}
- // Emit the call instruction.
- Instruction* call_instr =
- Emit(opcode, buffer.outputs.size(), &buffer.outputs.front(),
- buffer.instruction_args.size(), &buffer.instruction_args.front());
- call_instr->MarkAsCall();
- if (deoptimization != NULL) {
- DCHECK(continuation != NULL);
- call_instr->MarkAsControl();
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ VisitBinop(this, node, kX64Add32, &cont);
}
+ FlagsContinuation cont;
+ VisitBinop(this, node, kX64Add32, &cont);
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+ if (Node* ovf = node->FindProjection(1)) {
+ FlagsContinuation cont(kOverflow, ovf);
+ return VisitBinop(this, node, kX64Sub32, &cont);
+ }
+ FlagsContinuation cont;
+ VisitBinop(this, node, kX64Sub32, &cont);
+}
+
+
+void InstructionSelector::VisitInt64LessThan(Node* node) {
+ FlagsContinuation cont(kSignedLessThan, node);
+ VisitWordCompare(this, node, kX64Cmp, &cont);
+}
+
+
+void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kSignedLessThanOrEqual, node);
+ VisitWordCompare(this, node, kX64Cmp, &cont);
+}
+
+
+void InstructionSelector::VisitUint64LessThan(Node* node) {
+ FlagsContinuation cont(kUnsignedLessThan, node);
+ VisitWordCompare(this, node, kX64Cmp, &cont);
}
+
+void InstructionSelector::VisitFloat64Equal(Node* node) {
+ FlagsContinuation cont(kUnorderedEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThan(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThan, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) {
+ FlagsContinuation cont(kUnorderedLessThanOrEqual, node);
+ VisitFloat64Compare(this, node, &cont);
+}
+
+
+// static
+MachineOperatorBuilder::Flags
+InstructionSelector::SupportedMachineOperatorFlags() {
+ if (CpuFeatures::IsSupported(SSE4_1)) {
+ return MachineOperatorBuilder::kFloat64Floor |
+ MachineOperatorBuilder::kFloat64Ceil |
+ MachineOperatorBuilder::kFloat64RoundTruncate;
+ }
+ return MachineOperatorBuilder::kNoFlags;
+}
} // namespace compiler
} // namespace internal
} // namespace v8
typedef LinkageHelper<X64LinkageHelperTraits> LH;
-CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone) {
- return LH::GetJSCallDescriptor(zone, parameter_count);
+CallDescriptor* Linkage::GetJSCallDescriptor(int parameter_count, Zone* zone,
+ CallDescriptor::Flags flags) {
+ return LH::GetJSCallDescriptor(zone, parameter_count, flags);
}
CallDescriptor* Linkage::GetStubCallDescriptor(
- CallInterfaceDescriptor descriptor, int stack_parameter_count,
+ const CallInterfaceDescriptor& descriptor, int stack_parameter_count,
CallDescriptor::Flags flags, Zone* zone) {
return LH::GetStubCallDescriptor(zone, descriptor, stack_parameter_count,
flags);
--- /dev/null
+// 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/zone-pool.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+ZonePool::StatsScope::StatsScope(ZonePool* zone_pool)
+ : zone_pool_(zone_pool),
+ total_allocated_bytes_at_start_(zone_pool->GetTotalAllocatedBytes()),
+ max_allocated_bytes_(0) {
+ zone_pool_->stats_.push_back(this);
+ for (auto zone : zone_pool_->used_) {
+ size_t size = static_cast<size_t>(zone->allocation_size());
+ std::pair<InitialValues::iterator, bool> res =
+ initial_values_.insert(std::make_pair(zone, size));
+ USE(res);
+ DCHECK(res.second);
+ }
+}
+
+
+ZonePool::StatsScope::~StatsScope() {
+ DCHECK_EQ(zone_pool_->stats_.back(), this);
+ zone_pool_->stats_.pop_back();
+}
+
+
+size_t ZonePool::StatsScope::GetMaxAllocatedBytes() {
+ return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
+}
+
+
+size_t ZonePool::StatsScope::GetCurrentAllocatedBytes() {
+ size_t total = 0;
+ for (Zone* zone : zone_pool_->used_) {
+ total += static_cast<size_t>(zone->allocation_size());
+ // Adjust for initial values.
+ InitialValues::iterator it = initial_values_.find(zone);
+ if (it != initial_values_.end()) {
+ total -= it->second;
+ }
+ }
+ return total;
+}
+
+
+size_t ZonePool::StatsScope::GetTotalAllocatedBytes() {
+ return zone_pool_->GetTotalAllocatedBytes() - total_allocated_bytes_at_start_;
+}
+
+
+void ZonePool::StatsScope::ZoneReturned(Zone* zone) {
+ size_t current_total = GetCurrentAllocatedBytes();
+ // Update max.
+ max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
+ // Drop zone from initial value map.
+ InitialValues::iterator it = initial_values_.find(zone);
+ if (it != initial_values_.end()) {
+ initial_values_.erase(it);
+ }
+}
+
+
+ZonePool::ZonePool(Isolate* isolate)
+ : isolate_(isolate), max_allocated_bytes_(0), total_deleted_bytes_(0) {}
+
+
+ZonePool::~ZonePool() {
+ DCHECK(used_.empty());
+ DCHECK(stats_.empty());
+ for (Zone* zone : unused_) {
+ delete zone;
+ }
+}
+
+
+size_t ZonePool::GetMaxAllocatedBytes() {
+ return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
+}
+
+
+size_t ZonePool::GetCurrentAllocatedBytes() {
+ size_t total = 0;
+ for (Zone* zone : used_) {
+ total += static_cast<size_t>(zone->allocation_size());
+ }
+ return total;
+}
+
+
+size_t ZonePool::GetTotalAllocatedBytes() {
+ return total_deleted_bytes_ + GetCurrentAllocatedBytes();
+}
+
+
+Zone* ZonePool::NewEmptyZone() {
+ Zone* zone;
+ // Grab a zone from pool if possible.
+ if (!unused_.empty()) {
+ zone = unused_.back();
+ unused_.pop_back();
+ } else {
+ zone = new Zone(isolate_);
+ }
+ used_.push_back(zone);
+ DCHECK_EQ(0, zone->allocation_size());
+ return zone;
+}
+
+
+void ZonePool::ReturnZone(Zone* zone) {
+ size_t current_total = GetCurrentAllocatedBytes();
+ // Update max.
+ max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
+ // Update stats.
+ for (auto stat_scope : stats_) {
+ stat_scope->ZoneReturned(zone);
+ }
+ // Remove from used.
+ Used::iterator it = std::find(used_.begin(), used_.end(), zone);
+ DCHECK(it != used_.end());
+ used_.erase(it);
+ total_deleted_bytes_ += static_cast<size_t>(zone->allocation_size());
+ // Delete zone or clear and stash on unused_.
+ if (unused_.size() >= kMaxUnusedSize) {
+ delete zone;
+ } else {
+ zone->DeleteAll();
+ DCHECK_EQ(0, zone->allocation_size());
+ unused_.push_back(zone);
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_COMPILER_ZONE_POOL_H_
+#define V8_COMPILER_ZONE_POOL_H_
+
+#include <map>
+#include <set>
+#include <vector>
+
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class ZonePool FINAL {
+ public:
+ class Scope FINAL {
+ public:
+ explicit Scope(ZonePool* zone_pool) : zone_pool_(zone_pool), zone_(NULL) {}
+ ~Scope() { Destroy(); }
+
+ Zone* zone() {
+ if (zone_ == NULL) zone_ = zone_pool_->NewEmptyZone();
+ return zone_;
+ }
+ void Destroy() {
+ if (zone_ != NULL) zone_pool_->ReturnZone(zone_);
+ zone_ = NULL;
+ }
+
+ private:
+ ZonePool* const zone_pool_;
+ Zone* zone_;
+ DISALLOW_COPY_AND_ASSIGN(Scope);
+ };
+
+ class StatsScope FINAL {
+ public:
+ explicit StatsScope(ZonePool* zone_pool);
+ ~StatsScope();
+
+ size_t GetMaxAllocatedBytes();
+ size_t GetCurrentAllocatedBytes();
+ size_t GetTotalAllocatedBytes();
+
+ private:
+ friend class ZonePool;
+ void ZoneReturned(Zone* zone);
+
+ typedef std::map<Zone*, size_t> InitialValues;
+
+ ZonePool* const zone_pool_;
+ InitialValues initial_values_;
+ size_t total_allocated_bytes_at_start_;
+ size_t max_allocated_bytes_;
+
+ DISALLOW_COPY_AND_ASSIGN(StatsScope);
+ };
+
+ explicit ZonePool(Isolate* isolate);
+ ~ZonePool();
+
+ size_t GetMaxAllocatedBytes();
+ size_t GetTotalAllocatedBytes();
+ size_t GetCurrentAllocatedBytes();
+
+ private:
+ Zone* NewEmptyZone();
+ void ReturnZone(Zone* zone);
+
+ static const size_t kMaxUnusedSize = 3;
+ typedef std::vector<Zone*> Unused;
+ typedef std::vector<Zone*> Used;
+ typedef std::vector<StatsScope*> Stats;
+
+ Isolate* const isolate_;
+ Unused unused_;
+ Used used_;
+ Stats stats_;
+ size_t max_allocated_bytes_;
+ size_t total_deleted_bytes_;
+
+ DISALLOW_COPY_AND_ASSIGN(ZonePool);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif
PrintF(")\n");
}
+ bool visited_global_context = false;
+
do {
if (FLAG_trace_contexts) {
PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
+ if (context->IsGlobalContext()) PrintF(" (global context)");
if (context->IsNativeContext()) PrintF(" (native context)");
PrintF("\n");
}
+ if (follow_context_chain && FLAG_harmony_scoping &&
+ !visited_global_context &&
+ (context->IsGlobalContext() || context->IsNativeContext())) {
+ // For lexical scoping, on a top level, we might resolve to the
+ // lexical bindings introduced by later scrips. Therefore we need to
+ // switch to the the last added global context during lookup here.
+ context = Handle<Context>(context->global_object()->global_context());
+ visited_global_context = true;
+ if (FLAG_trace_contexts) {
+ PrintF(" - switching to current global context %p\n",
+ reinterpret_cast<void*>(*context));
+ }
+ }
+
// 1. Check global objects, subjects of with, and extension objects.
if (context->IsNativeContext() ||
context->IsWithContext() ||
}
// 2. Check the context proper if it has slots.
- if (context->IsFunctionContext() || context->IsBlockContext()) {
+ if (context->IsFunctionContext() || context->IsBlockContext() ||
+ (FLAG_harmony_scoping && context->IsGlobalContext())) {
// Use serialized scope information of functions and blocks to search
// for the context index.
Handle<ScopeInfo> scope_info;
V(GLOBAL_EVAL_FUN_INDEX, JSFunction, global_eval_fun) \
V(INSTANTIATE_FUN_INDEX, JSFunction, instantiate_fun) \
V(CONFIGURE_INSTANCE_FUN_INDEX, JSFunction, configure_instance_fun) \
- V(MATH_ABS_FUN_INDEX, JSFunction, math_abs_fun) \
- V(MATH_ACOS_FUN_INDEX, JSFunction, math_acos_fun) \
- V(MATH_ASIN_FUN_INDEX, JSFunction, math_asin_fun) \
- V(MATH_ATAN_FUN_INDEX, JSFunction, math_atan_fun) \
- V(MATH_ATAN2_FUN_INDEX, JSFunction, math_atan2_fun) \
- V(MATH_CEIL_FUN_INDEX, JSFunction, math_ceil_fun) \
- V(MATH_COS_FUN_INDEX, JSFunction, math_cos_fun) \
- V(MATH_EXP_FUN_INDEX, JSFunction, math_exp_fun) \
- V(MATH_FLOOR_FUN_INDEX, JSFunction, math_floor_fun) \
- V(MATH_IMUL_FUN_INDEX, JSFunction, math_imul_fun) \
- V(MATH_LOG_FUN_INDEX, JSFunction, math_log_fun) \
- V(MATH_MAX_FUN_INDEX, JSFunction, math_max_fun) \
- V(MATH_MIN_FUN_INDEX, JSFunction, math_min_fun) \
- V(MATH_POW_FUN_INDEX, JSFunction, math_pow_fun) \
- V(MATH_RANDOM_FUN_INDEX, JSFunction, math_random_fun) \
- V(MATH_ROUND_FUN_INDEX, JSFunction, math_round_fun) \
- V(MATH_SIN_FUN_INDEX, JSFunction, math_sin_fun) \
- V(MATH_SQRT_FUN_INDEX, JSFunction, math_sqrt_fun) \
- V(MATH_TAN_FUN_INDEX, JSFunction, math_tan_fun) \
V(ARRAY_BUFFER_FUN_INDEX, JSFunction, array_buffer_fun) \
V(UINT8_ARRAY_FUN_INDEX, JSFunction, uint8_array_fun) \
V(INT8_ARRAY_FUN_INDEX, JSFunction, int8_array_fun) \
GLOBAL_EVAL_FUN_INDEX,
INSTANTIATE_FUN_INDEX,
CONFIGURE_INSTANCE_FUN_INDEX,
- MATH_ABS_FUN_INDEX,
- MATH_ACOS_FUN_INDEX,
- MATH_ASIN_FUN_INDEX,
- MATH_ATAN_FUN_INDEX,
- MATH_ATAN2_FUN_INDEX,
- MATH_CEIL_FUN_INDEX,
- MATH_COS_FUN_INDEX,
- MATH_EXP_FUN_INDEX,
- MATH_FLOOR_FUN_INDEX,
- MATH_IMUL_FUN_INDEX,
- MATH_LOG_FUN_INDEX,
- MATH_MAX_FUN_INDEX,
- MATH_MIN_FUN_INDEX,
- MATH_POW_FUN_INDEX,
- MATH_RANDOM_FUN_INDEX,
- MATH_ROUND_FUN_INDEX,
- MATH_SIN_FUN_INDEX,
- MATH_SQRT_FUN_INDEX,
- MATH_TAN_FUN_INDEX,
ARRAY_BUFFER_FUN_INDEX,
UINT8_ARRAY_FUN_INDEX,
INT8_ARRAY_FUN_INDEX,
}
-double StringToDouble(UnicodeCache* unicode_cache,
- String* string,
- int flags,
- double empty_string_val) {
- DisallowHeapAllocation no_gc;
- String::FlatContent flat = string->GetFlatContent();
- // ECMA-262 section 15.1.2.3, empty string is NaN
- if (flat.IsOneByte()) {
- return StringToDouble(
- unicode_cache, flat.ToOneByteVector(), flags, empty_string_val);
- } else {
- return StringToDouble(
- unicode_cache, flat.ToUC16Vector(), flags, empty_string_val);
+double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
+ int flags, double empty_string_val) {
+ Handle<String> flattened = String::Flatten(string);
+ {
+ DisallowHeapAllocation no_gc;
+ String::FlatContent flat = flattened->GetFlatContent();
+ DCHECK(flat.IsFlat());
+ // ECMA-262 section 15.1.2.3, empty string is NaN
+ if (flat.IsOneByte()) {
+ return StringToDouble(unicode_cache, flat.ToOneByteVector(), flags,
+ empty_string_val);
+ } else {
+ return StringToDouble(unicode_cache, flat.ToUC16Vector(), flags,
+ empty_string_val);
+ }
}
}
}
-double StringToDouble(UnicodeCache* unicode_cache,
- String* string,
- int flags,
- double empty_string_val = 0.0);
+double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
+ int flags, double empty_string_val = 0.0);
inline bool TryNumberToSize(Isolate* isolate,
#include "src/base/platform/platform.h"
#include "src/counters.h"
#include "src/isolate.h"
+#include "src/log-inl.h"
namespace v8 {
namespace internal {
if (Enabled()) {
timer_.Start();
}
- isolate()->event_logger()(name(), Logger::START);
+ Logger::CallEventLogger(isolate(), name(), Logger::START, true);
}
AddSample(static_cast<int>(timer_.Elapsed().InMilliseconds()));
timer_.Stop();
}
- isolate()->event_logger()(name(), Logger::END);
+ Logger::CallEventLogger(isolate(), name(), Logger::END, true);
}
static const int kProfilerStackSize = 64 * KB;
-ProfilerEventsProcessor::ProfilerEventsProcessor(
- ProfileGenerator* generator,
- Sampler* sampler,
- base::TimeDelta period)
+ProfilerEventsProcessor::ProfilerEventsProcessor(ProfileGenerator* generator,
+ Sampler* sampler,
+ base::TimeDelta period)
: Thread(Thread::Options("v8:ProfEvntProc", kProfilerStackSize)),
generator_(generator),
sampler_(sampler),
- running_(true),
+ running_(1),
period_(period),
- last_code_event_id_(0), last_processed_code_event_id_(0) {
-}
+ last_code_event_id_(0),
+ last_processed_code_event_id_(0) {}
void ProfilerEventsProcessor::Enqueue(const CodeEventsContainer& event) {
regs.fp = frame->fp();
regs.pc = frame->pc();
}
- record.sample.Init(isolate, regs);
+ record.sample.Init(isolate, regs, TickSample::kSkipCEntryFrame);
ticks_from_vm_buffer_.Enqueue(record);
}
void ProfilerEventsProcessor::StopSynchronously() {
- if (!running_) return;
- running_ = false;
+ if (!base::NoBarrier_AtomicExchange(&running_, 0)) return;
Join();
}
void ProfilerEventsProcessor::Run() {
- while (running_) {
+ while (!!base::NoBarrier_Load(&running_)) {
base::ElapsedTimer timer;
timer.Start();
// Keep processing existing events until we need to do next sample.
CodeEventsContainer evt_rec(CodeEventRecord::CODE_CREATION);
CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
rec->start = code->address();
- rec->entry = profiles_->NewCodeEntry(tag, profiles_->GetFunctionName(name));
+ rec->entry = profiles_->NewCodeEntry(
+ tag, profiles_->GetFunctionName(name), CodeEntry::kEmptyNamePrefix,
+ CodeEntry::kEmptyResourceName, CpuProfileNode::kNoLineNumberInfo,
+ CpuProfileNode::kNoColumnNumberInfo, NULL, code->instruction_start());
rec->size = code->ExecutableSize();
rec->shared = NULL;
processor_->Enqueue(evt_rec);
CodeEventsContainer evt_rec(CodeEventRecord::CODE_CREATION);
CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
rec->start = code->address();
- rec->entry = profiles_->NewCodeEntry(tag, profiles_->GetFunctionName(name));
+ rec->entry = profiles_->NewCodeEntry(
+ tag, profiles_->GetFunctionName(name), CodeEntry::kEmptyNamePrefix,
+ CodeEntry::kEmptyResourceName, CpuProfileNode::kNoLineNumberInfo,
+ CpuProfileNode::kNoColumnNumberInfo, NULL, code->instruction_start());
rec->size = code->ExecutableSize();
rec->shared = NULL;
processor_->Enqueue(evt_rec);
rec->start = code->address();
rec->entry = profiles_->NewCodeEntry(
tag, profiles_->GetFunctionName(shared->DebugName()),
- CodeEntry::kEmptyNamePrefix, profiles_->GetName(script_name));
+ CodeEntry::kEmptyNamePrefix, profiles_->GetName(script_name),
+ CpuProfileNode::kNoLineNumberInfo, CpuProfileNode::kNoColumnNumberInfo,
+ NULL, code->instruction_start());
if (info) {
rec->entry->set_no_frame_ranges(info->ReleaseNoFrameRanges());
}
CodeEventsContainer evt_rec(CodeEventRecord::CODE_CREATION);
CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
rec->start = code->address();
+ Script* script = Script::cast(shared->script());
+ JITLineInfoTable* line_table = NULL;
+ if (script) {
+ line_table = new JITLineInfoTable();
+ for (RelocIterator it(code); !it.done(); it.next()) {
+ RelocInfo::Mode mode = it.rinfo()->rmode();
+ if (RelocInfo::IsPosition(mode)) {
+ int position = static_cast<int>(it.rinfo()->data());
+ if (position >= 0) {
+ int pc_offset = static_cast<int>(it.rinfo()->pc() - code->address());
+ int line_number = script->GetLineNumber(position) + 1;
+ line_table->SetPosition(pc_offset, line_number);
+ }
+ }
+ }
+ }
rec->entry = profiles_->NewCodeEntry(
tag, profiles_->GetFunctionName(shared->DebugName()),
CodeEntry::kEmptyNamePrefix, profiles_->GetName(script_name), line,
- column);
+ column, line_table, code->instruction_start());
if (info) {
rec->entry->set_no_frame_ranges(info->ReleaseNoFrameRanges());
}
- DCHECK(Script::cast(shared->script()));
- Script* script = Script::cast(shared->script());
rec->entry->set_script_id(script->id()->value());
rec->size = code->ExecutableSize();
rec->shared = shared->address();
CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
rec->start = code->address();
rec->entry = profiles_->NewCodeEntry(
- tag,
- profiles_->GetName(args_count),
- "args_count: ");
+ tag, profiles_->GetName(args_count), "args_count: ",
+ CodeEntry::kEmptyResourceName, CpuProfileNode::kNoLineNumberInfo,
+ CpuProfileNode::kNoColumnNumberInfo, NULL, code->instruction_start());
rec->size = code->ExecutableSize();
rec->shared = NULL;
processor_->Enqueue(evt_rec);
CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
rec->start = code->address();
rec->entry = profiles_->NewCodeEntry(
- Logger::REG_EXP_TAG,
- profiles_->GetName(source),
- "RegExp: ");
+ Logger::REG_EXP_TAG, profiles_->GetName(source), "RegExp: ",
+ CodeEntry::kEmptyResourceName, CpuProfileNode::kNoLineNumberInfo,
+ CpuProfileNode::kNoColumnNumberInfo, NULL, code->instruction_start());
rec->size = code->ExecutableSize();
processor_->Enqueue(evt_rec);
}
// Thread control.
virtual void Run();
void StopSynchronously();
- INLINE(bool running()) { return running_; }
+ INLINE(bool running()) { return !!base::NoBarrier_Load(&running_); }
void Enqueue(const CodeEventsContainer& event);
// Puts current stack into tick sample events buffer.
ProfileGenerator* generator_;
Sampler* sampler_;
- bool running_;
+ base::Atomic32 running_;
// Sampling period in microseconds.
const base::TimeDelta period_;
UnboundQueue<CodeEventsContainer> events_buffer_;
printf("%s\n", *text_str);
}
running = response_details->Get(String::NewFromUtf8(isolate, "running"))
- ->ToBoolean()
+ ->ToBoolean(isolate)
->Value();
}
}
}
+ScriptCompiler::CachedData* CompileForCachedData(
+ Local<String> source, Local<Value> name,
+ ScriptCompiler::CompileOptions compile_options) {
+ int source_length = source->Length();
+ uint16_t* source_buffer = new uint16_t[source_length];
+ source->Write(source_buffer, 0, source_length);
+ int name_length = 0;
+ uint16_t* name_buffer = NULL;
+ if (name->IsString()) {
+ Local<String> name_string = Local<String>::Cast(name);
+ name_length = name_string->Length();
+ name_buffer = new uint16_t[name_length];
+ name_string->Write(name_buffer, 0, name_length);
+ }
+ Isolate* temp_isolate = Isolate::New();
+ ScriptCompiler::CachedData* result = NULL;
+ {
+ Isolate::Scope isolate_scope(temp_isolate);
+ HandleScope handle_scope(temp_isolate);
+ Context::Scope context_scope(Context::New(temp_isolate));
+ Local<String> source_copy = v8::String::NewFromTwoByte(
+ temp_isolate, source_buffer, v8::String::kNormalString, source_length);
+ Local<Value> name_copy;
+ if (name_buffer) {
+ name_copy = v8::String::NewFromTwoByte(
+ temp_isolate, name_buffer, v8::String::kNormalString, name_length);
+ } else {
+ name_copy = v8::Undefined(temp_isolate);
+ }
+ ScriptCompiler::Source script_source(source_copy, ScriptOrigin(name_copy));
+ ScriptCompiler::CompileUnbound(temp_isolate, &script_source,
+ compile_options);
+ if (script_source.GetCachedData()) {
+ int length = script_source.GetCachedData()->length;
+ uint8_t* cache = new uint8_t[length];
+ memcpy(cache, script_source.GetCachedData()->data, length);
+ result = new ScriptCompiler::CachedData(
+ cache, length, ScriptCompiler::CachedData::BufferOwned);
+ }
+ }
+ temp_isolate->Dispose();
+ delete[] source_buffer;
+ delete[] name_buffer;
+ return result;
+}
+
+
// Compile a string within the current v8 context.
Local<UnboundScript> Shell::CompileString(
Isolate* isolate, Local<String> source, Local<Value> name,
- v8::ScriptCompiler::CompileOptions compile_options) {
+ ScriptCompiler::CompileOptions compile_options) {
ScriptOrigin origin(name);
- ScriptCompiler::Source script_source(source, origin);
- Local<UnboundScript> script =
- ScriptCompiler::CompileUnbound(isolate, &script_source, compile_options);
-
- // Was caching requested & successful? Then compile again, now with cache.
- if (script_source.GetCachedData()) {
- if (compile_options == ScriptCompiler::kProduceCodeCache) {
- compile_options = ScriptCompiler::kConsumeCodeCache;
- } else if (compile_options == ScriptCompiler::kProduceParserCache) {
- compile_options = ScriptCompiler::kConsumeParserCache;
- } else {
- DCHECK(false); // A new compile option?
- }
- ScriptCompiler::Source cached_source(
- source, origin, new v8::ScriptCompiler::CachedData(
- script_source.GetCachedData()->data,
- script_source.GetCachedData()->length,
- v8::ScriptCompiler::CachedData::BufferNotOwned));
- script = ScriptCompiler::CompileUnbound(isolate, &cached_source,
- compile_options);
+ if (compile_options == ScriptCompiler::kNoCompileOptions) {
+ ScriptCompiler::Source script_source(source, origin);
+ return ScriptCompiler::CompileUnbound(isolate, &script_source,
+ compile_options);
+ }
+
+ ScriptCompiler::CachedData* data =
+ CompileForCachedData(source, name, compile_options);
+ ScriptCompiler::Source cached_source(source, origin, data);
+ if (compile_options == ScriptCompiler::kProduceCodeCache) {
+ compile_options = ScriptCompiler::kConsumeCodeCache;
+ } else if (compile_options == ScriptCompiler::kProduceParserCache) {
+ compile_options = ScriptCompiler::kConsumeParserCache;
+ } else {
+ DCHECK(false); // A new compile option?
}
- return script;
+ if (data == NULL) compile_options = ScriptCompiler::kNoCompileOptions;
+ return ScriptCompiler::CompileUnbound(isolate, &cached_source,
+ compile_options);
}
Throw(args.GetIsolate(), "Invalid argument");
return;
}
- int index = data->RealmFind(args[0]->ToObject()->CreationContext());
+ int index = data->RealmFind(args[0]->ToObject(isolate)->CreationContext());
if (index == -1) return;
args.GetReturnValue().Set(index);
}
Throw(args.GetIsolate(), "Invalid argument");
return;
}
- ScriptCompiler::Source script_source(args[1]->ToString());
+ ScriptCompiler::Source script_source(args[1]->ToString(isolate));
Handle<UnboundScript> script = ScriptCompiler::CompileUnbound(
isolate, &script_source);
if (script.IsEmpty()) return;
// Explicitly catch potential exceptions in toString().
v8::TryCatch try_catch;
- Handle<String> str_obj = args[i]->ToString();
+ Handle<String> str_obj = args[i]->ToString(args.GetIsolate());
if (try_catch.HasCaught()) {
try_catch.ReThrow();
return;
StartupDataHandler startup_data(options.natives_blob, options.snapshot_blob);
#endif
SetFlagsFromString("--trace-hydrogen-file=hydrogen.cfg");
+ SetFlagsFromString("--trace-turbo-cfg-file=turbo.cfg");
SetFlagsFromString("--redirect-code-traces-to=code.asm");
ShellArrayBufferAllocator array_buffer_allocator;
MockArrayBufferAllocator mock_arraybuffer_allocator;
}
#endif
#ifdef ENABLE_VTUNE_JIT_INTERFACE
- vTune::InitializeVtuneForV8(create_params);
+ create_params.code_event_handler = vTune::GetVtuneCodeEventHandler();
#endif
#ifndef V8_SHARED
create_params.constraints.ConfigureDefaults(
// ECMA 262 - 15.9.1.9
// LocalTime(t) = t + LocalTZA + DaylightSavingTA(t)
- // ECMA 262 assumes that DaylightSavingTA is computed using UTC time,
- // but we fetch DST from OS using local time, therefore we need:
- // LocalTime(t) = t + LocalTZA + DaylightSavingTA(t + LocalTZA).
int64_t ToLocal(int64_t time_ms) {
- time_ms += LocalOffsetInMs();
- return time_ms + DaylightSavingsOffsetInMs(time_ms);
+ return time_ms + LocalOffsetInMs() + DaylightSavingsOffsetInMs(time_ms);
}
// ECMA 262 - 15.9.1.9
// UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
- // ECMA 262 assumes that DaylightSavingTA is computed using UTC time,
- // but we fetch DST from OS using local time, therefore we need:
- // UTC(t) = t - LocalTZA - DaylightSavingTA(t).
int64_t ToUTC(int64_t time_ms) {
- return time_ms - LocalOffsetInMs() - DaylightSavingsOffsetInMs(time_ms);
+ // We need to compute UTC time that corresponds to the given local time.
+ // Literally following spec here leads to incorrect time computation at
+ // the points were we transition to and from DST.
+ //
+ // The following shows that using DST for (t - LocalTZA - hour) produces
+ // correct conversion.
+ //
+ // Consider transition to DST at local time L1.
+ // Let L0 = L1 - hour, L2 = L1 + hour,
+ // U1 = UTC time that corresponds to L1,
+ // U0 = U1 - hour.
+ // Transitioning to DST moves local clock one hour forward L1 => L2, so
+ // U0 = UTC time that corresponds to L0 = L0 - LocalTZA,
+ // U1 = UTC time that corresponds to L1 = L1 - LocalTZA,
+ // U1 = UTC time that corresponds to L2 = L2 - LocalTZA - hour.
+ // Note that DST(U0 - hour) = 0, DST(U0) = 0, DST(U1) = 1.
+ // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour),
+ // U1 = L1 - LocalTZA - DST(L1 - LocalTZA - hour),
+ // U1 = L2 - LocalTZA - DST(L2 - LocalTZA - hour).
+ //
+ // Consider transition from DST at local time L1.
+ // Let L0 = L1 - hour,
+ // U1 = UTC time that corresponds to L1,
+ // U0 = U1 - hour, U2 = U1 + hour.
+ // Transitioning from DST moves local clock one hour back L1 => L0, so
+ // U0 = UTC time that corresponds to L0 (before transition)
+ // = L0 - LocalTZA - hour.
+ // U1 = UTC time that corresponds to L0 (after transition)
+ // = L0 - LocalTZA = L1 - LocalTZA - hour
+ // U2 = UTC time that corresponds to L1 = L1 - LocalTZA.
+ // Note that DST(U0) = 1, DST(U1) = 0, DST(U2) = 0.
+ // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour) = L0 - LocalTZA - DST(U0).
+ // U2 = L1 - LocalTZA - DST(L1 - LocalTZA - hour) = L1 - LocalTZA - DST(U1).
+ // It is impossible to get U1 from local time.
+
+ const int kMsPerHour = 3600 * 1000;
+ time_ms -= LocalOffsetInMs();
+ return time_ms - DaylightSavingsOffsetInMs(time_ms - kMsPerHour);
}
StepNext: 1,
StepIn: 2,
StepMin: 3,
- StepInMin: 4 };
+ StepInMin: 4,
+ StepFrame: 5 };
// The different types of scripts matching enum ScriptType in objects.h.
Debug.ScriptType = { Native: 0,
DCHECK(statement_position_ >= 0);
}
- if (IsDebugBreakSlot()) {
- // There is always a possible break point at a debug break slot.
+ // Check for break at return.
+ if (RelocInfo::IsJSReturn(rmode())) {
+ // Set the positions to the end of the function.
+ if (debug_info_->shared()->HasSourceCode()) {
+ position_ = debug_info_->shared()->end_position() -
+ debug_info_->shared()->start_position() - 1;
+ } else {
+ position_ = 0;
+ }
+ statement_position_ = position_;
break_point_++;
return;
- } else if (RelocInfo::IsCodeTarget(rmode())) {
+ }
+
+ if (RelocInfo::IsCodeTarget(rmode())) {
// Check for breakable code target. Look in the original code as setting
// break points can cause the code targets in the running (debugged) code
// to be of a different kind than in the original code.
Address target = original_rinfo()->target_address();
Code* code = Code::GetCodeFromTargetAddress(target);
- if ((code->is_inline_cache_stub() &&
- !code->is_binary_op_stub() &&
- !code->is_compare_ic_stub() &&
- !code->is_to_boolean_ic_stub()) ||
- RelocInfo::IsConstructCall(rmode())) {
+
+ if (RelocInfo::IsConstructCall(rmode()) || code->is_call_stub()) {
+ break_point_++;
+ return;
+ }
+
+ // Skip below if we only want locations for calls and returns.
+ if (type_ == CALLS_AND_RETURNS) continue;
+
+ if ((code->is_inline_cache_stub() && !code->is_binary_op_stub() &&
+ !code->is_compare_ic_stub() && !code->is_to_boolean_ic_stub())) {
break_point_++;
return;
}
}
}
- // Check for break at return.
- if (RelocInfo::IsJSReturn(rmode())) {
- // Set the positions to the end of the function.
- if (debug_info_->shared()->HasSourceCode()) {
- position_ = debug_info_->shared()->end_position() -
- debug_info_->shared()->start_position() - 1;
- } else {
- position_ = 0;
- }
- statement_position_ = position_;
+ if (IsDebugBreakSlot() && type_ != CALLS_AND_RETURNS) {
+ // There is always a possible break point at a debug break slot.
break_point_++;
return;
}
thread_local_.step_into_fp_ = 0;
thread_local_.step_out_fp_ = 0;
// TODO(isolates): frames_are_dropped_?
- thread_local_.current_debug_scope_ = NULL;
+ base::NoBarrier_Store(&thread_local_.current_debug_scope_,
+ static_cast<base::AtomicWord>(NULL));
thread_local_.restarter_frame_function_pointer_ = NULL;
}
Heap* heap = isolate_->heap();
HandleScope scope(isolate_);
- // Perform two GCs to get rid of all unreferenced scripts. The first GC gets
- // rid of all the cached script wrappers and the second gets rid of the
- // scripts which are no longer referenced.
- heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "ScriptCache");
+ // Perform a GC to get rid of all unreferenced scripts.
heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "ScriptCache");
// Scan heap for Script objects.
Debug* debug = reinterpret_cast<Isolate*>(data.GetIsolate())->debug();
DebugInfoListNode* node =
reinterpret_cast<DebugInfoListNode*>(data.GetParameter());
- // We need to clear all breakpoints associated with the function to restore
- // original code and avoid patching the code twice later because
- // the function will live in the heap until next gc, and can be found by
- // Debug::FindSharedFunctionInfoInScript.
- BreakLocationIterator it(node->debug_info(), ALL_BREAK_LOCATIONS);
- it.ClearAllDebugBreak();
- debug->RemoveDebugInfo(node->debug_info());
+ debug->RemoveDebugInfo(node->debug_info().location());
#ifdef DEBUG
for (DebugInfoListNode* n = debug->debug_info_list_;
n != NULL;
GlobalHandles* global_handles = debug_info->GetIsolate()->global_handles();
debug_info_ = Handle<DebugInfo>::cast(global_handles->Create(debug_info));
GlobalHandles::MakeWeak(reinterpret_cast<Object**>(debug_info_.location()),
- this,
- Debug::HandleWeakDebugInfo);
+ this, Debug::HandleWeakDebugInfo,
+ GlobalHandles::Phantom);
}
it.FindBreakLocationFromPosition(*source_position, STATEMENT_ALIGNED);
it.SetBreakPoint(break_point_object);
- *source_position = it.position();
+ *source_position = it.statement_position();
// At least one active break point now.
return debug_info->GetBreakPointCount() > 0;
it.FindBreakLocationFromPosition(position, alignment);
it.SetBreakPoint(break_point_object);
- *source_position = it.position() + shared->start_position();
+ position = (alignment == STATEMENT_ALIGNED) ? it.statement_position()
+ : it.position();
+
+ *source_position = position + shared->start_position();
// At least one active break point now.
DCHECK(debug_info->GetBreakPointCount() > 0);
// If there are no more break points left remove the debug info for this
// function.
if (debug_info->GetBreakPointCount() == 0) {
- RemoveDebugInfo(debug_info);
+ RemoveDebugInfoAndClearFromShared(debug_info);
}
return;
// Remove all debug info.
while (debug_info_list_ != NULL) {
- RemoveDebugInfo(debug_info_list_->debug_info());
+ RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());
}
}
-void Debug::FloodWithOneShot(Handle<JSFunction> function) {
+void Debug::FloodWithOneShot(Handle<JSFunction> function,
+ BreakLocatorType type) {
PrepareForBreakPoints();
// Make sure the function is compiled and has set up the debug info.
}
// Flood the function with break points.
- BreakLocationIterator it(GetDebugInfo(shared), ALL_BREAK_LOCATIONS);
+ BreakLocationIterator it(GetDebugInfo(shared), type);
while (!it.Done()) {
it.SetOneShot();
it.Next();
if (!bindee.is_null() && bindee->IsJSFunction() &&
!JSFunction::cast(*bindee)->IsFromNativeScript()) {
Handle<JSFunction> bindee_function(JSFunction::cast(*bindee));
- Debug::FloodWithOneShot(bindee_function);
+ FloodWithOneShot(bindee_function);
}
}
}
-bool Debug::PromiseHasRejectHandler(Handle<JSObject> promise) {
- Handle<JSFunction> fun = Handle<JSFunction>::cast(
- JSObject::GetDataProperty(isolate_->js_builtins_object(),
- isolate_->factory()->NewStringFromStaticChars(
- "PromiseHasRejectHandler")));
- Handle<Object> result =
- Execution::Call(isolate_, fun, promise, 0, NULL).ToHandleChecked();
- return result->IsTrue();
-}
-
-
void Debug::PrepareStep(StepAction step_action,
int step_count,
StackFrame::Id frame_id) {
FloodHandlerWithOneShot();
// If the function on the top frame is unresolved perform step out. This will
- // be the case when calling unknown functions and having the debugger stopped
+ // be the case when calling unknown function and having the debugger stopped
// in an unhandled exception.
if (!frame->function()->IsJSFunction()) {
// Step out: Find the calling JavaScript frame and flood it with
if ((maybe_call_function_stub->kind() == Code::STUB &&
CodeStub::GetMajorKey(maybe_call_function_stub) ==
CodeStub::CallFunction) ||
- maybe_call_function_stub->kind() == Code::CALL_IC) {
+ maybe_call_function_stub->is_call_stub()) {
// Save reference to the code as we may need it to find out arguments
// count for 'step in' later.
call_function_stub = Handle<Code>(maybe_call_function_stub);
// Step next or step min.
// Fill the current function with one-shot break points.
- FloodWithOneShot(function);
+ // If we are stepping into another frame, only fill calls and returns.
+ FloodWithOneShot(function, step_action == StepFrame ? CALLS_AND_RETURNS
+ : ALL_BREAK_LOCATIONS);
// Remember source position and frame to handle step next.
thread_local_.last_statement_position_ =
if (fun->IsJSFunction()) {
Handle<JSFunction> js_function(JSFunction::cast(fun));
if (js_function->shared()->bound()) {
- Debug::FloodBoundFunctionWithOneShot(js_function);
+ FloodBoundFunctionWithOneShot(js_function);
} else if (!js_function->IsFromNativeScript()) {
// Don't step into builtins.
// It will also compile target function if it's not compiled yet.
// a call target as the function called might be a native function for
// which step in will not stop. It also prepares for stepping in
// getters/setters.
- FloodWithOneShot(function);
+ // If we are stepping into another frame, only fill calls and returns.
+ FloodWithOneShot(function, step_action == StepFrame ? CALLS_AND_RETURNS
+ : ALL_BREAK_LOCATIONS);
if (is_load_or_store) {
// Remember source position and frame to handle step in getter/setter. If
JavaScriptFrame* frame) {
// StepNext and StepOut shouldn't bring us deeper in code, so last frame
// shouldn't be a parent of current frame.
- if (thread_local_.last_step_action_ == StepNext ||
- thread_local_.last_step_action_ == StepOut) {
+ StepAction step_action = thread_local_.last_step_action_;
+
+ if (step_action == StepNext || step_action == StepOut) {
if (frame->fp() < thread_local_.last_fp_) return true;
}
+ // We stepped into a new frame if the frame pointer changed.
+ if (step_action == StepFrame) {
+ return frame->UnpaddedFP() == thread_local_.last_fp_;
+ }
+
// If the step last action was step next or step in make sure that a new
// statement is hit.
- if (thread_local_.last_step_action_ == StepNext ||
- thread_local_.last_step_action_ == StepIn) {
+ if (step_action == StepNext || step_action == StepIn) {
// Never continue if returning from function.
if (break_location_iterator->IsExit()) return false;
BreakPointInfo* break_point_info =
BreakPointInfo::cast(debug_info->break_points()->get(i));
if (break_point_info->GetBreakPointCount() > 0) {
- Smi* position;
+ Smi* position = NULL;
switch (position_alignment) {
- case STATEMENT_ALIGNED:
- position = break_point_info->statement_position();
- break;
- case BREAK_POSITION_ALIGNED:
- position = break_point_info->source_position();
- break;
- default:
- UNREACHABLE();
- position = break_point_info->statement_position();
+ case STATEMENT_ALIGNED:
+ position = break_point_info->statement_position();
+ break;
+ case BREAK_POSITION_ALIGNED:
+ position = break_point_info->source_position();
+ break;
}
locations->set(count++, position);
// Handle stepping into a function.
-void Debug::HandleStepIn(Handle<JSFunction> function,
- Handle<Object> holder,
- Address fp,
- bool is_constructor) {
+void Debug::HandleStepIn(Handle<Object> function_obj, Handle<Object> holder,
+ Address fp, bool is_constructor) {
+ // Flood getter/setter if we either step in or step to another frame.
+ bool step_frame = thread_local_.last_step_action_ == StepFrame;
+ if (!StepInActive() && !step_frame) return;
+ if (!function_obj->IsJSFunction()) return;
+ Handle<JSFunction> function = Handle<JSFunction>::cast(function_obj);
Isolate* isolate = function->GetIsolate();
// If the frame pointer is not supplied by the caller find it.
if (fp == 0) {
}
// Flood the function with one-shot break points if it is called from where
- // step into was requested.
- if (fp == thread_local_.step_into_fp_) {
+ // step into was requested, or when stepping into a new frame.
+ if (fp == thread_local_.step_into_fp_ || step_frame) {
if (function->shared()->bound()) {
// Handle Function.prototype.bind
- Debug::FloodBoundFunctionWithOneShot(function);
+ FloodBoundFunctionWithOneShot(function);
} else if (!function->IsFromNativeScript()) {
// Don't allow step into functions in the native context.
if (function->shared()->code() ==
if (!holder.is_null() && holder->IsJSFunction()) {
Handle<JSFunction> js_function = Handle<JSFunction>::cast(holder);
if (!js_function->IsFromNativeScript()) {
- Debug::FloodWithOneShot(js_function);
+ FloodWithOneShot(js_function);
} else if (js_function->shared()->bound()) {
// Handle Function.prototype.bind
- Debug::FloodBoundFunctionWithOneShot(js_function);
+ FloodBoundFunctionWithOneShot(js_function);
}
}
} else {
- Debug::FloodWithOneShot(function);
+ FloodWithOneShot(function);
}
}
}
}
+static bool SkipSharedFunctionInfo(SharedFunctionInfo* shared,
+ Object* active_code_marker) {
+ if (!shared->allows_lazy_compilation()) return true;
+ if (!shared->script()->IsScript()) return true;
+ Object* script = shared->script();
+ if (!script->IsScript()) return true;
+ if (Script::cast(script)->type()->value() == Script::TYPE_NATIVE) return true;
+ Code* shared_code = shared->code();
+ return shared_code->gc_metadata() == active_code_marker;
+}
+
+
+static inline bool HasDebugBreakSlots(Code* code) {
+ return code->kind() == Code::FUNCTION && code->has_debug_break_slots();
+}
+
+
void Debug::PrepareForBreakPoints() {
// If preparing for the first break point make sure to deoptimize all
// functions as debugging does not work with optimized code.
if (obj->IsJSFunction()) {
JSFunction* function = JSFunction::cast(obj);
SharedFunctionInfo* shared = function->shared();
-
- if (!shared->allows_lazy_compilation()) continue;
- if (!shared->script()->IsScript()) continue;
- if (function->IsFromNativeScript()) continue;
- if (shared->code()->gc_metadata() == active_code_marker) continue;
-
+ if (SkipSharedFunctionInfo(shared, active_code_marker)) continue;
if (shared->is_generator()) {
generator_functions.Add(Handle<JSFunction>(function, isolate_));
continue;
}
-
+ if (HasDebugBreakSlots(function->code())) continue;
+ Code* fallback = HasDebugBreakSlots(shared->code()) ? shared->code()
+ : *lazy_compile;
Code::Kind kind = function->code()->kind();
- if (kind == Code::FUNCTION &&
- !function->code()->has_debug_break_slots()) {
- function->ReplaceCode(*lazy_compile);
- function->shared()->ReplaceCode(*lazy_compile);
- } else if (kind == Code::BUILTIN &&
- (function->IsInOptimizationQueue() ||
- function->IsMarkedForOptimization() ||
- function->IsMarkedForConcurrentOptimization())) {
- // Abort in-flight compilation.
- Code* shared_code = function->shared()->code();
- if (shared_code->kind() == Code::FUNCTION &&
- shared_code->has_debug_break_slots()) {
- function->ReplaceCode(shared_code);
- } else {
- function->ReplaceCode(*lazy_compile);
- function->shared()->ReplaceCode(*lazy_compile);
- }
+ if (kind == Code::FUNCTION ||
+ (kind == Code::BUILTIN && // Abort in-flight compilation.
+ (function->IsInOptimizationQueue() ||
+ function->IsMarkedForOptimization() ||
+ function->IsMarkedForConcurrentOptimization()))) {
+ function->ReplaceCode(fallback);
+ }
+ if (kind == Code::OPTIMIZED_FUNCTION) {
+ // Optimized code can only get here if DeoptimizeAll did not
+ // deoptimize turbo fan code.
+ DCHECK(!FLAG_turbo_deoptimization);
+ DCHECK(function->code()->is_turbofanned());
+ function->ReplaceCode(fallback);
}
} else if (obj->IsJSGeneratorObject()) {
JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
gen->set_continuation(code_offset);
suspended_generators.Add(Handle<JSGeneratorObject>(gen, isolate_));
+ } else if (obj->IsSharedFunctionInfo()) {
+ SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
+ if (SkipSharedFunctionInfo(shared, active_code_marker)) continue;
+ if (shared->is_generator()) continue;
+ if (HasDebugBreakSlots(shared->code())) continue;
+ shared->ReplaceCode(*lazy_compile);
}
}
}
-void Debug::RemoveDebugInfo(Handle<DebugInfo> debug_info) {
+// This uses the location of a handle to look up the debug info in the debug
+// info list, but it doesn't use the actual debug info for anything. Therefore
+// if the debug info has been collected by the GC, we can be sure that this
+// method will not attempt to resurrect it.
+void Debug::RemoveDebugInfo(DebugInfo** debug_info) {
DCHECK(debug_info_list_ != NULL);
// Run through the debug info objects to find this one and remove it.
DebugInfoListNode* prev = NULL;
DebugInfoListNode* current = debug_info_list_;
while (current != NULL) {
- if (*current->debug_info() == *debug_info) {
+ if (current->debug_info().location() == debug_info) {
// Unlink from list. If prev is NULL we are looking at the first element.
if (prev == NULL) {
debug_info_list_ = current->next();
} else {
prev->set_next(current->next());
}
- current->debug_info()->shared()->set_debug_info(
- isolate_->heap()->undefined_value());
delete current;
// If there are no more debug info objects there are not more break
}
+void Debug::RemoveDebugInfoAndClearFromShared(Handle<DebugInfo> debug_info) {
+ HandleScope scope(isolate_);
+ Handle<SharedFunctionInfo> shared(debug_info->shared());
+
+ RemoveDebugInfo(debug_info.location());
+
+ shared->set_debug_info(isolate_->heap()->undefined_value());
+}
+
+
void Debug::SetAfterBreakTarget(JavaScriptFrame* frame) {
after_break_target_ = NULL;
HandleScope scope(isolate_);
// If there are no break points this cannot be break at return, as
- // the debugger statement and stack guard bebug break cannot be at
+ // the debugger statement and stack guard debug break cannot be at
// return.
if (!has_break_points_) {
return false;
void Debug::OnPromiseReject(Handle<JSObject> promise, Handle<Object> value) {
if (in_debug_scope() || ignore_events()) return;
HandleScope scope(isolate_);
- OnException(value, false, promise);
+ // Check whether the promise has been marked as having triggered a message.
+ Handle<Symbol> key = isolate_->factory()->promise_debug_marker_symbol();
+ if (JSObject::GetDataProperty(promise, key)->IsUndefined()) {
+ OnException(value, false, promise);
+ }
+}
+
+
+MaybeHandle<Object> Debug::PromiseHasUserDefinedRejectHandler(
+ Handle<JSObject> promise) {
+ Handle<JSFunction> fun = Handle<JSFunction>::cast(
+ JSObject::GetDataProperty(isolate_->js_builtins_object(),
+ isolate_->factory()->NewStringFromStaticChars(
+ "PromiseHasUserDefinedRejectHandler")));
+ return Execution::Call(isolate_, fun, promise, 0, NULL);
}
void Debug::OnException(Handle<Object> exception, bool uncaught,
Handle<Object> promise) {
- if (promise->IsJSObject()) {
- uncaught |= !PromiseHasRejectHandler(Handle<JSObject>::cast(promise));
+ if (!uncaught && promise->IsJSObject()) {
+ Handle<JSObject> jspromise = Handle<JSObject>::cast(promise);
+ // Mark the promise as already having triggered a message.
+ Handle<Symbol> key = isolate_->factory()->promise_debug_marker_symbol();
+ JSObject::SetProperty(jspromise, key, key, STRICT).Assert();
+ // Check whether the promise reject is considered an uncaught exception.
+ Handle<Object> has_reject_handler;
+ ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+ isolate_, has_reject_handler,
+ PromiseHasUserDefinedRejectHandler(jspromise), /* void */);
+ uncaught = has_reject_handler->IsFalse();
}
// Bail out if exception breaks are not active
if (uncaught) {
Handle<Object> exec_state,
Handle<Object> event_data,
v8::Debug::ClientData* client_data) {
+ DisableBreak no_break(this, true);
if (event_listener_->IsForeign()) {
// Invoke the C debug event listener.
v8::Debug::EventCallback callback =
no_termination_exceptons_(debug_->isolate_,
StackGuard::TERMINATE_EXECUTION) {
// Link recursive debugger entry.
- debug_->thread_local_.current_debug_scope_ = this;
+ base::NoBarrier_Store(&debug_->thread_local_.current_debug_scope_,
+ reinterpret_cast<base::AtomicWord>(this));
// Store the previous break id and frame id.
break_id_ = debug_->break_id();
}
// Leaving this debugger entry.
- debug_->thread_local_.current_debug_scope_ = prev_;
+ base::NoBarrier_Store(&debug_->thread_local_.current_debug_scope_,
+ reinterpret_cast<base::AtomicWord>(prev_));
// Restore to the previous break state.
debug_->thread_local_.break_frame_id_ = break_frame_id_;
v8::Handle<v8::Context> MessageImpl::GetEventContext() const {
Isolate* isolate = event_data_->GetIsolate();
v8::Handle<v8::Context> context = GetDebugEventContext(isolate);
- // Isolate::context() may be NULL when "script collected" event occures.
+ // Isolate::context() may be NULL when "script collected" event occurs.
DCHECK(!context.IsEmpty());
return context;
}
#include "src/allocation.h"
#include "src/arguments.h"
#include "src/assembler.h"
+#include "src/base/atomicops.h"
#include "src/base/platform/platform.h"
#include "src/execution.h"
#include "src/factory.h"
// Step actions. NOTE: These values are in macros.py as well.
enum StepAction {
StepNone = -1, // Stepping not prepared.
- StepOut = 0, // Step out of the current function.
- StepNext = 1, // Step to the next statement in the current function.
- StepIn = 2, // Step into new functions invoked or the next statement
- // in the current function.
- StepMin = 3, // Perform a minimum step in the current function.
- StepInMin = 4 // Step into new functions invoked or perform a minimum step
- // in the current function.
+ StepOut = 0, // Step out of the current function.
+ StepNext = 1, // Step to the next statement in the current function.
+ StepIn = 2, // Step into new functions invoked or the next statement
+ // in the current function.
+ StepMin = 3, // Perform a minimum step in the current function.
+ StepInMin = 4, // Step into new functions invoked or perform a minimum step
+ // in the current function.
+ StepFrame = 5 // Step into a new frame or return to previous frame.
};
};
-// Type of exception break. NOTE: These values are in macros.py as well.
+// Type of exception break.
enum BreakLocatorType {
ALL_BREAK_LOCATIONS = 0,
- SOURCE_BREAK_LOCATIONS = 1
+ SOURCE_BREAK_LOCATIONS = 1,
+ CALLS_AND_RETURNS = 2
};
BreakPositionAlignment alignment);
void ClearBreakPoint(Handle<Object> break_point_object);
void ClearAllBreakPoints();
- void FloodWithOneShot(Handle<JSFunction> function);
+ void FloodWithOneShot(Handle<JSFunction> function,
+ BreakLocatorType type = ALL_BREAK_LOCATIONS);
void FloodBoundFunctionWithOneShot(Handle<JSFunction> function);
void FloodHandlerWithOneShot();
void ChangeBreakOnException(ExceptionBreakType type, bool enable);
bool StepNextContinue(BreakLocationIterator* break_location_iterator,
JavaScriptFrame* frame);
bool StepInActive() { return thread_local_.step_into_fp_ != 0; }
- void HandleStepIn(Handle<JSFunction> function,
- Handle<Object> holder,
- Address fp,
- bool is_constructor);
+ void HandleStepIn(Handle<Object> function_obj, Handle<Object> holder,
+ Address fp, bool is_constructor);
bool StepOutActive() { return thread_local_.step_out_fp_ != 0; }
// Purge all code objects that have no debug break slots.
// Record function from which eval was called.
static void RecordEvalCaller(Handle<Script> script);
+ bool CheckExecutionState(int id) {
+ return !debug_context().is_null() && break_id() != 0 && break_id() == id;
+ }
+
// Flags and states.
- DebugScope* debugger_entry() { return thread_local_.current_debug_scope_; }
+ DebugScope* debugger_entry() {
+ return reinterpret_cast<DebugScope*>(
+ base::NoBarrier_Load(&thread_local_.current_debug_scope_));
+ }
inline Handle<Context> debug_context() { return debug_context_; }
void set_live_edit_enabled(bool v) { live_edit_enabled_ = v; }
bool live_edit_enabled() const {
inline bool is_loaded() const { return !debug_context_.is_null(); }
inline bool has_break_points() const { return has_break_points_; }
inline bool in_debug_scope() const {
- return thread_local_.current_debug_scope_ != NULL;
+ return !!base::NoBarrier_Load(&thread_local_.current_debug_scope_);
}
void set_disable_break(bool v) { break_disabled_ = v; }
// Mirror cache handling.
void ClearMirrorCache();
- // Returns a promise if the pushed try-catch handler matches the current one.
- bool PromiseHasRejectHandler(Handle<JSObject> promise);
+ MaybeHandle<Object> PromiseHasUserDefinedRejectHandler(
+ Handle<JSObject> promise);
void CallEventCallback(v8::DebugEvent event,
Handle<Object> exec_state,
void ClearStepIn();
void ActivateStepOut(StackFrame* frame);
void ClearStepNext();
- // Returns whether the compile succeeded.
- void RemoveDebugInfo(Handle<DebugInfo> debug_info);
+ void RemoveDebugInfoAndClearFromShared(Handle<DebugInfo> debug_info);
+ void RemoveDebugInfo(DebugInfo** debug_info);
Handle<Object> CheckBreakPoints(Handle<Object> break_point);
bool CheckBreakPoint(Handle<Object> break_point_object);
class ThreadLocal {
public:
// Top debugger entry.
- DebugScope* current_debug_scope_;
+ base::AtomicWord current_debug_scope_;
// Counter for generating next break id.
int break_count_;
// Number of steps left to perform before debug event.
int step_count_;
- // Frame pointer from last step next action.
+ // Frame pointer from last step next or step frame action.
Address last_fp_;
// Number of queued steps left to perform before debug event.
DeoptimizerData* data = isolate->deoptimizer_data();
MemoryChunk* base = data->deopt_entry_code_[type];
Address start = base->area_start();
- if (base == NULL ||
- addr < start ||
+ if (addr < start ||
addr >= start + (kMaxNumberOfEntries * table_entry_size_)) {
return kNotDeoptimizationEntry;
}
OFStream os(stderr);
os << "[couldn't find pc offset for node=" << id.ToInt() << "]\n"
<< "[method: " << shared->DebugName()->ToCString().get() << "]\n"
- << "[source:\n" << SourceCodeOf(shared) << "\n]" << endl;
+ << "[source:\n" << SourceCodeOf(shared) << "\n]" << std::endl;
FATAL("unable to find pc offset during deoptimization");
return -1;
}
-static void DumpBuffer(OStream* os, StringBuilder* out) {
- (*os) << out->Finalize() << endl;
+static void DumpBuffer(std::ostream* os, StringBuilder* out) {
+ (*os) << out->Finalize() << std::endl;
out->Reset();
}
static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
static const int kRelocInfoPosition = 57;
-static int DecodeIt(Isolate* isolate, OStream* os,
+static int DecodeIt(Isolate* isolate, std::ostream* os,
const V8NameConverter& converter, byte* begin, byte* end) {
SealHandleScope shs(isolate);
DisallowHeapAllocation no_alloc;
}
-int Disassembler::Decode(Isolate* isolate, OStream* os, byte* begin, byte* end,
- Code* code) {
+int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
+ byte* end, Code* code) {
V8NameConverter v8NameConverter(code);
return DecodeIt(isolate, os, v8NameConverter, begin, end);
}
#else // ENABLE_DISASSEMBLER
-int Disassembler::Decode(Isolate* isolate, OStream* os, byte* begin, byte* end,
- Code* code) {
+int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
+ byte* end, Code* code) {
return 0;
}
// code into os. Returns the number of bytes disassembled or 1 if no
// instruction could be decoded.
// the code object is used for name resolution and may be null.
- static int Decode(Isolate* isolate, OStream* os, byte* begin, byte* end,
+ static int Decode(Isolate* isolate, std::ostream* os, byte* begin, byte* end,
Code* code = NULL);
};
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/logging.h"
#include "src/diy-fp.h"
#include "src/globals.h"
#include <cmath>
-#include "include/v8stdint.h"
#include "src/base/logging.h"
#include "src/utils.h"
}
+static void PrintDeserializedCodeInfo(Handle<JSFunction> function) {
+ if (function->code() == function->shared()->code() &&
+ function->shared()->deserialized()) {
+ PrintF("Running deserialized script ");
+ Object* script = function->shared()->script();
+ if (script->IsScript()) Script::cast(script)->name()->ShortPrint();
+ PrintF("\n");
+ }
+}
+
+
MUST_USE_RESULT static MaybeHandle<Object> Invoke(
bool is_construct,
Handle<JSFunction> function,
JSFunction* func = *function;
Object* recv = *receiver;
Object*** argv = reinterpret_cast<Object***>(args);
+ if (FLAG_profile_deserialization) PrintDeserializedCodeInfo(function);
value =
CALL_GENERATED_CODE(stub_entry, function_entry, func, recv, argc, argv);
}
Heap* heap = isolate->heap();
if (args.Length() > 0) { // GC if first argument evaluates to true.
- if (args[0]->IsBoolean() && args[0]->ToBoolean()->Value()) {
+ if (args[0]->IsBoolean() &&
+ args[0]->ToBoolean(args.GetIsolate())->Value()) {
heap->CollectAllGarbage(Heap::kNoGCFlags, "counters extension");
}
}
heap->set_last_script_id(Smi::FromInt(id));
// Create and initialize script object.
- Handle<Foreign> wrapper = NewForeign(0, TENURED);
Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
script->set_source(*source);
script->set_name(heap->undefined_value());
script->set_column_offset(Smi::FromInt(0));
script->set_context_data(heap->undefined_value());
script->set_type(Smi::FromInt(Script::TYPE_NORMAL));
- script->set_wrapper(*wrapper);
+ script->set_wrapper(heap->undefined_value());
script->set_line_ends(heap->undefined_value());
script->set_eval_from_shared(heap->undefined_value());
script->set_eval_from_instructions_offset(Smi::FromInt(0));
}
+Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value) {
+ AllowDeferredHandleDereference convert_to_cell;
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateWeakCell(*value),
+ WeakCell);
+}
+
+
Handle<AllocationSite> Factory::NewAllocationSite() {
Handle<Map> map = allocation_site_map();
Handle<AllocationSite> site = New<AllocationSite>(map, OLD_POINTER_SPACE);
}
-static JSFunction* GetTypedArrayFun(ExternalArrayType type,
- Isolate* isolate) {
+Handle<JSMapIterator> Factory::NewJSMapIterator() {
+ Handle<Map> map(isolate()->native_context()->map_iterator_map());
+ CALL_HEAP_FUNCTION(isolate(),
+ isolate()->heap()->AllocateJSObjectFromMap(*map),
+ JSMapIterator);
+}
+
+
+Handle<JSSetIterator> Factory::NewJSSetIterator() {
+ Handle<Map> map(isolate()->native_context()->set_iterator_map());
+ CALL_HEAP_FUNCTION(isolate(),
+ isolate()->heap()->AllocateJSObjectFromMap(*map),
+ JSSetIterator);
+}
+
+
+namespace {
+
+ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
+ switch (type) {
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case kExternal##Type##Array: \
+ return EXTERNAL_##TYPE##_ELEMENTS;
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+ }
+ UNREACHABLE();
+ return FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND;
+#undef TYPED_ARRAY_CASE
+}
+
+
+size_t GetExternalArrayElementSize(ExternalArrayType type) {
+ switch (type) {
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case kExternal##Type##Array: \
+ return size;
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+ }
+ UNREACHABLE();
+ return 0;
+#undef TYPED_ARRAY_CASE
+}
+
+
+JSFunction* GetTypedArrayFun(ExternalArrayType type, Isolate* isolate) {
Context* native_context = isolate->context()->native_context();
switch (type) {
#define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size) \
}
+void SetupArrayBufferView(i::Isolate* isolate,
+ i::Handle<i::JSArrayBufferView> obj,
+ i::Handle<i::JSArrayBuffer> buffer,
+ size_t byte_offset, size_t byte_length) {
+ DCHECK(byte_offset + byte_length <=
+ static_cast<size_t>(buffer->byte_length()->Number()));
+
+ obj->set_buffer(*buffer);
+
+ obj->set_weak_next(buffer->weak_first_view());
+ buffer->set_weak_first_view(*obj);
+
+ i::Handle<i::Object> byte_offset_object =
+ isolate->factory()->NewNumberFromSize(byte_offset);
+ obj->set_byte_offset(*byte_offset_object);
+
+ i::Handle<i::Object> byte_length_object =
+ isolate->factory()->NewNumberFromSize(byte_length);
+ obj->set_byte_length(*byte_length_object);
+}
+
+
+} // namespace
+
+
Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
}
+Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
+ Handle<JSArrayBuffer> buffer,
+ size_t byte_offset,
+ size_t length) {
+ Handle<JSTypedArray> obj = NewJSTypedArray(type);
+
+ size_t element_size = GetExternalArrayElementSize(type);
+ ElementsKind elements_kind = GetExternalArrayElementsKind(type);
+
+ CHECK(byte_offset % element_size == 0);
+
+ CHECK(length <= (std::numeric_limits<size_t>::max() / element_size));
+ CHECK(length <= static_cast<size_t>(Smi::kMaxValue));
+ size_t byte_length = length * element_size;
+ SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
+
+ Handle<Object> length_object = NewNumberFromSize(length);
+ obj->set_length(*length_object);
+
+ Handle<ExternalArray> elements = NewExternalArray(
+ static_cast<int>(length), type,
+ static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
+ Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
+ JSObject::SetMapAndElements(obj, map, elements);
+ return obj;
+}
+
+
+Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
+ size_t byte_offset,
+ size_t byte_length) {
+ Handle<JSDataView> obj = NewJSDataView();
+ SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
+ return obj;
+}
+
+
Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
Handle<Object> prototype) {
// Allocate map.
}
-Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(int slot_count) {
- // Ensure we can skip the write barrier
- DCHECK_EQ(isolate()->heap()->uninitialized_symbol(),
- *TypeFeedbackVector::UninitializedSentinel(isolate()));
-
- if (slot_count == 0) {
- return Handle<TypeFeedbackVector>::cast(empty_fixed_array());
- }
-
- CALL_HEAP_FUNCTION(isolate(),
- isolate()->heap()->AllocateFixedArrayWithFiller(
- slot_count, TENURED,
- *TypeFeedbackVector::UninitializedSentinel(isolate())),
- TypeFeedbackVector);
+Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(int slot_count,
+ int ic_slot_count) {
+ return TypeFeedbackVector::Allocate(isolate(), slot_count, ic_slot_count);
}
share->set_script(*undefined_value(), SKIP_WRITE_BARRIER);
share->set_debug_info(*undefined_value(), SKIP_WRITE_BARRIER);
share->set_inferred_name(*empty_string(), SKIP_WRITE_BARRIER);
- Handle<TypeFeedbackVector> feedback_vector = NewTypeFeedbackVector(0);
+ Handle<TypeFeedbackVector> feedback_vector = NewTypeFeedbackVector(0, 0);
share->set_feedback_vector(*feedback_vector, SKIP_WRITE_BARRIER);
share->set_profiler_ticks(0);
share->set_ast_node_count(0);
Handle<PropertyCell> NewPropertyCell(Handle<Object> value);
+ Handle<WeakCell> NewWeakCell(Handle<HeapObject> value);
+
// Allocate a tenured AllocationSite. It's payload is null.
Handle<AllocationSite> NewAllocationSite();
Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type);
+ // Creates a new JSTypedArray with the specified buffer.
+ Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type,
+ Handle<JSArrayBuffer> buffer,
+ size_t byte_offset, size_t length);
+
Handle<JSDataView> NewJSDataView();
+ Handle<JSDataView> NewJSDataView(Handle<JSArrayBuffer> buffer,
+ size_t byte_offset, size_t byte_length);
+
+ // TODO(aandrey): Maybe these should take table, index and kind arguments.
+ Handle<JSMapIterator> NewJSMapIterator();
+ Handle<JSSetIterator> NewJSSetIterator();
// Allocates a Harmony proxy.
Handle<JSProxy> NewJSProxy(Handle<Object> handler, Handle<Object> prototype);
INTERNALIZED_STRING_LIST(STRING_ACCESSOR)
#undef STRING_ACCESSOR
+#define SYMBOL_ACCESSOR(name) \
+ inline Handle<Symbol> name() { \
+ return Handle<Symbol>(bit_cast<Symbol**>( \
+ &isolate()->heap()->roots_[Heap::k##name##RootIndex])); \
+ }
+ PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR)
+#undef SYMBOL_ACCESSOR
+
inline void set_string_table(Handle<StringTable> table) {
isolate()->heap()->set_string_table(*table);
}
MaybeHandle<Code> code);
// Allocate a new type feedback vector
- Handle<TypeFeedbackVector> NewTypeFeedbackVector(int slot_count);
+ Handle<TypeFeedbackVector> NewTypeFeedbackVector(int slot_count,
+ int ic_slot_count);
// Allocates a new JSMessageObject object.
Handle<JSMessageObject> NewJSMessageObject(
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/logging.h"
#include "src/utils.h"
+++ /dev/null
-// 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.
-
-#ifndef V8_FEEDBACK_SLOTS_H_
-#define V8_FEEDBACK_SLOTS_H_
-
-#include "src/v8.h"
-
-#include "src/isolate.h"
-
-namespace v8 {
-namespace internal {
-
-class FeedbackSlotInterface {
- public:
- static const int kInvalidFeedbackSlot = -1;
-
- virtual ~FeedbackSlotInterface() {}
-
- virtual int ComputeFeedbackSlotCount() = 0;
- virtual void SetFirstFeedbackSlot(int slot) = 0;
-};
-
-} } // namespace v8::internal
-
-#endif // V8_FEEDBACK_SLOTS_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <stdint.h>
+
#include <cmath>
-#include "include/v8stdint.h"
#include "src/base/logging.h"
#include "src/utils.h"
#else
#define ENABLE_ARMV7_DEFAULT false
#endif
+#if (defined CAN_USE_ARMV8_INSTRUCTIONS) || !(defined ARM_TEST_NO_FEATURE_PROBE)
+#define ENABLE_ARMV8_DEFAULT true
+#else
+#define ENABLE_ARMV8_DEFAULT false
+#endif
#if (defined CAN_USE_VFP32DREGS) || !(defined ARM_TEST_NO_FEATURE_PROBE)
#define ENABLE_32DREGS_DEFAULT true
#else
#endif
#define DEFINE_BOOL(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt)
+#define DEFINE_BOOL_READONLY(nam, def, cmt) \
+ FLAG_READONLY(BOOL, bool, nam, def, cmt)
#define DEFINE_MAYBE_BOOL(nam, cmt) \
FLAG(MAYBE_BOOL, MaybeBoolFlag, nam, {false COMMA false}, cmt)
#define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt)
// Flags for language modes and experimental language features.
DEFINE_BOOL(use_strict, false, "enforce strict mode")
-DEFINE_BOOL(es_staging, false, "enable upcoming ES6+ features")
-
-DEFINE_BOOL(harmony_scoping, false, "enable harmony block scoping")
-DEFINE_BOOL(harmony_modules, false,
- "enable harmony modules (implies block scoping)")
-DEFINE_BOOL(harmony_proxies, false, "enable harmony proxies")
-DEFINE_BOOL(harmony_numeric_literals, false,
- "enable harmony numeric literals (0o77, 0b11)")
-DEFINE_BOOL(harmony_strings, false, "enable harmony string")
-DEFINE_BOOL(harmony_arrays, false, "enable harmony arrays")
-DEFINE_BOOL(harmony_arrow_functions, false, "enable harmony arrow functions")
-DEFINE_BOOL(harmony_classes, false, "enable harmony classes")
-DEFINE_BOOL(harmony_object_literals, false,
- "enable harmony object literal extensions")
-DEFINE_BOOL(harmony_regexps, false, "enable regexp-related harmony features")
-DEFINE_BOOL(harmony, false, "enable all harmony features (except proxies)")
+DEFINE_BOOL(es_staging, false, "enable all completed harmony features")
+DEFINE_BOOL(harmony, false, "enable all completed harmony features")
+DEFINE_IMPLICATION(harmony, es_staging)
+// TODO(rossberg): activate once we have staged scoping:
+// DEFINE_IMPLICATION(es_staging, harmony)
+
+// Features that are still work in progress (behind individual flags).
+#define HARMONY_INPROGRESS(V) \
+ V(harmony_scoping, "harmony block scoping") \
+ V(harmony_modules, "harmony modules (implies block scoping)") \
+ V(harmony_arrays, "harmony array methods") \
+ V(harmony_classes, \
+ "harmony classes (implies block scoping & object literal extension)") \
+ V(harmony_object_literals, "harmony object literal extensions") \
+ V(harmony_regexps, "harmony regular expression extensions") \
+ V(harmony_arrow_functions, "harmony arrow functions") \
+ V(harmony_tostring, "harmony toString") \
+ V(harmony_proxies, "harmony proxies")
+
+// Features that are complete (but still behind --harmony/es-staging flag).
+#define HARMONY_STAGED(V) V(harmony_strings, "harmony string methods")
+
+// Features that are shipping (turned on by default, but internal flag remains).
+#define HARMONY_SHIPPING(V) \
+ V(harmony_numeric_literals, "harmony numeric literals")
+
+// Once a shipping feature has proved stable in the wild, it will be dropped
+// from HARMONY_SHIPPING, all occurrences of the FLAG_ variable are removed,
+// and associated tests are moved from the harmony directory to the appropriate
+// esN directory.
+
+
+#define FLAG_INPROGRESS_FEATURES(id, description) \
+ DEFINE_BOOL(id, false, "enable " #description " (in progress)")
+HARMONY_INPROGRESS(FLAG_INPROGRESS_FEATURES)
+#undef FLAG_INPROGRESS_FEATURES
+
+// TODO(rossberg): temporary, remove once we have staged scoping.
+// After that, --harmony will be synonymous to --es-staging.
DEFINE_IMPLICATION(harmony, harmony_scoping)
-DEFINE_IMPLICATION(harmony, harmony_modules)
-// TODO(rossberg): Reenable when problems are sorted out.
-// DEFINE_IMPLICATION(harmony, harmony_proxies)
-DEFINE_IMPLICATION(harmony, harmony_numeric_literals)
-DEFINE_IMPLICATION(harmony, harmony_strings)
-DEFINE_IMPLICATION(harmony, harmony_arrays)
-DEFINE_IMPLICATION(harmony, harmony_arrow_functions)
-DEFINE_IMPLICATION(harmony, harmony_classes)
-DEFINE_IMPLICATION(harmony, harmony_object_literals)
-DEFINE_IMPLICATION(harmony, harmony_regexps)
+
+#define FLAG_STAGED_FEATURES(id, description) \
+ DEFINE_BOOL(id, false, "enable " #description) \
+ DEFINE_IMPLICATION(es_staging, id)
+HARMONY_STAGED(FLAG_STAGED_FEATURES)
+#undef FLAG_STAGED_FEATURES
+
+#define FLAG_SHIPPING_FEATURES(id, description) \
+ DEFINE_BOOL_READONLY(id, true, "enable " #description)
+HARMONY_SHIPPING(FLAG_SHIPPING_FEATURES)
+#undef FLAG_SHIPPING_FEATURES
+
+
+// Feature dependencies.
DEFINE_IMPLICATION(harmony_modules, harmony_scoping)
DEFINE_IMPLICATION(harmony_classes, harmony_scoping)
DEFINE_IMPLICATION(harmony_classes, harmony_object_literals)
-DEFINE_IMPLICATION(harmony, es_staging)
// Flags for experimental implementation features.
DEFINE_BOOL(compiled_keyed_generic_loads, false,
"maximum number of escape analysis fix-point iterations")
DEFINE_BOOL(optimize_for_in, true, "optimize functions containing for-in loops")
-DEFINE_BOOL(opt_safe_uint32_operations, true,
- "allow uint32 values on optimize frames if they are used only in "
- "safe operations")
DEFINE_BOOL(concurrent_recompilation, true,
"optimizing hot functions asynchronously on a separate thread")
+DEFINE_BOOL(job_based_recompilation, false,
+ "post tasks to v8::Platform instead of using a thread for "
+ "concurrent recompilation")
+DEFINE_IMPLICATION(job_based_recompilation, concurrent_recompilation)
+DEFINE_NEG_IMPLICATION(job_based_recompilation, block_concurrent_recompilation)
DEFINE_BOOL(trace_concurrent_recompilation, false,
"track concurrent recompilation")
DEFINE_INT(concurrent_recompilation_queue_length, 8,
// Flags for TurboFan.
DEFINE_STRING(turbo_filter, "~", "optimization filter for TurboFan compiler")
DEFINE_BOOL(trace_turbo, false, "trace generated TurboFan IR")
-DEFINE_BOOL(trace_turbo_types, true, "trace generated TurboFan types")
-DEFINE_BOOL(trace_turbo_scheduler, false, "trace generated TurboFan scheduler")
+DEFINE_STRING(trace_turbo_cfg_file, NULL,
+ "trace turbo cfg graph (for C1 visualizer) to a given file name")
+DEFINE_BOOL(trace_turbo_types, true, "trace TurboFan's types")
+DEFINE_BOOL(trace_turbo_scheduler, false, "trace TurboFan's scheduler")
+DEFINE_BOOL(trace_turbo_reduction, false, "trace TurboFan's various reducers")
DEFINE_BOOL(turbo_asm, false, "enable TurboFan for asm.js code")
DEFINE_BOOL(turbo_verify, false, "verify TurboFan graphs at each phase")
DEFINE_BOOL(turbo_stats, false, "print TurboFan statistics")
"enable context specialization in TurboFan")
DEFINE_BOOL(turbo_deoptimization, false, "enable deoptimization in TurboFan")
DEFINE_BOOL(turbo_inlining, false, "enable inlining in TurboFan")
+DEFINE_BOOL(turbo_inlining_intrinsics, false,
+ "enable inlining of intrinsics in TurboFan")
DEFINE_BOOL(trace_turbo_inlining, false, "trace TurboFan inlining")
+DEFINE_BOOL(loop_assignment_analysis, true, "perform loop assignment analysis")
+DEFINE_IMPLICATION(turbo_inlining_intrinsics, turbo_inlining)
DEFINE_IMPLICATION(turbo_inlining, turbo_types)
DEFINE_BOOL(turbo_profiling, false, "enable profiling in TurboFan")
"enable use of VFP3 instructions if available")
DEFINE_BOOL(enable_armv7, ENABLE_ARMV7_DEFAULT,
"enable use of ARMv7 instructions if available (ARM only)")
+DEFINE_BOOL(enable_armv8, ENABLE_ARMV8_DEFAULT,
+ "enable use of ARMv8 instructions if available (ARM 32-bit only)")
DEFINE_BOOL(enable_neon, ENABLE_NEON_DEFAULT,
"enable use of NEON instructions if available (ARM only)")
DEFINE_BOOL(enable_sudiv, true,
DEFINE_BOOL(trace_stub_failures, false,
"trace deoptimization of generated code stubs")
-DEFINE_BOOL(serialize_toplevel, false, "enable caching of toplevel scripts")
-DEFINE_BOOL(trace_code_serializer, false, "trace code serializer")
+DEFINE_BOOL(serialize_toplevel, true, "enable caching of toplevel scripts")
+DEFINE_BOOL(trace_code_serializer, false, "print code serializer trace")
// compiler.cc
DEFINE_INT(min_preparse_length, 1024,
DEFINE_INT(min_semi_space_size, 0,
"min size of a semi-space (in MBytes), the new space consists of two"
"semi-spaces")
+DEFINE_INT(target_semi_space_size, 0,
+ "target size of a semi-space (in MBytes) before triggering a GC")
DEFINE_INT(max_semi_space_size, 0,
"max size of a semi-space (in MBytes), the new space consists of two"
"semi-spaces")
"trace progress of the incremental marking")
DEFINE_BOOL(track_gc_object_stats, false,
"track object counts and memory usage")
-DEFINE_BOOL(parallel_sweeping, false, "enable parallel sweeping")
-DEFINE_BOOL(concurrent_sweeping, true, "enable concurrent sweeping")
-DEFINE_INT(sweeper_threads, 0,
- "number of parallel and concurrent sweeping threads")
-DEFINE_BOOL(job_based_sweeping, true, "enable job based sweeping")
#ifdef VERIFY_HEAP
DEFINE_BOOL(verify_heap, false, "verify heap pointers before and after GC")
#endif
DEFINE_BOOL(predictable, false, "enable predictable mode")
DEFINE_NEG_IMPLICATION(predictable, concurrent_recompilation)
DEFINE_NEG_IMPLICATION(predictable, concurrent_osr)
-DEFINE_NEG_IMPLICATION(predictable, concurrent_sweeping)
-DEFINE_NEG_IMPLICATION(predictable, parallel_sweeping)
-DEFINE_NEG_IMPLICATION(predictable, job_based_sweeping)
//
DEFINE_BOOL(gc_verbose, false, "print stuff during garbage collection")
DEFINE_BOOL(heap_stats, false, "report heap statistics before and after GC")
DEFINE_BOOL(code_stats, false, "report code statistics after GC")
-DEFINE_BOOL(verify_native_context_separation, false,
- "verify that code holds on to at most one native context after GC")
DEFINE_BOOL(print_handles, false, "report handles after GC")
DEFINE_BOOL(print_global_handles, false, "report global handles after GC")
#undef FLAG
#define FLAG FLAG_READONLY
-// assembler-arm.h
+// assembler.h
DEFINE_BOOL(enable_ool_constant_pool, V8_OOL_CONSTANT_POOL,
"enable use of out-of-line constant pools (ARM only)")
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <ctype.h>
-#include <stdlib.h>
+#include <cctype>
+#include <cstdlib>
+#include <sstream>
#include "src/v8.h"
}
-OStream& operator<<(OStream& os, const Flag& flag) { // NOLINT
+std::ostream& operator<<(std::ostream& os, const Flag& flag) { // NOLINT
switch (flag.type()) {
case Flag::TYPE_BOOL:
os << (*flag.bool_variable() ? "true" : "false");
}
{
bool disabled = f->type() == Flag::TYPE_BOOL && !*f->bool_variable();
- OStringStream os;
+ std::ostringstream os;
os << (disabled ? "--no" : "--") << f->name();
- args->Add(StrDup(os.c_str()));
+ args->Add(StrDup(os.str().c_str()));
}
if (f->type() != Flag::TYPE_BOOL) {
- OStringStream os;
+ std::ostringstream os;
os << *f;
- args->Add(StrDup(os.c_str()));
+ args->Add(StrDup(os.str().c_str()));
}
}
}
if (args_flag != NULL) {
- OStringStream os;
+ std::ostringstream os;
os << "--" << args_flag->name();
- args->Add(StrDup(os.c_str()));
+ args->Add(StrDup(os.str().c_str()));
JSArguments jsargs = *args_flag->args_variable();
for (int j = 0; j < jsargs.argc; j++) {
args->Add(StrDup(jsargs[j]));
inline StackHandler::Kind StackHandler::kind() const {
- const int offset = StackHandlerConstants::kStateOffset;
+ const int offset = StackHandlerConstants::kStateIntOffset;
return KindField::decode(Memory::unsigned_at(address() + offset));
}
inline unsigned StackHandler::index() const {
- const int offset = StackHandlerConstants::kStateOffset;
+ const int offset = StackHandlerConstants::kStateIntOffset;
return IndexField::decode(Memory::unsigned_at(address() + offset));
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/frames.h"
+
+#include <sstream>
+
#include "src/v8.h"
#include "src/ast.h"
// Print details about the function.
if (FLAG_max_stack_trace_source_length != 0 && code != NULL) {
- OStringStream os;
+ std::ostringstream os;
SharedFunctionInfo* shared = function->shared();
os << "--------- s o u r c e c o d e ---------\n"
<< SourceCodeOf(shared, FLAG_max_stack_trace_source_length)
<< "\n-----------------------------------------\n";
- accumulator->Add(os.c_str());
+ accumulator->Add(os.str().c_str());
}
accumulator->Add("}\n\n");
static const int kNextOffset = 0 * kPointerSize;
static const int kCodeOffset = 1 * kPointerSize;
static const int kStateOffset = 2 * kPointerSize;
+#if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
+ static const int kStateIntOffset = kStateOffset;
+#else
+ static const int kStateIntOffset = kStateOffset + kIntSize;
+#endif
static const int kContextOffset = 3 * kPointerSize;
static const int kFPOffset = 4 * kPointerSize;
#include "src/v8.h"
+#include "src/ast.h"
+#include "src/ast-numbering.h"
#include "src/code-factory.h"
#include "src/codegen.h"
#include "src/compiler.h"
info->SetCode(code);
void* line_info = masm.positions_recorder()->DetachJITHandlerData();
LOG_CODE_EVENT(isolate, CodeEndLinePosInfoRecordEvent(*code, line_info));
+
+#ifdef DEBUG
+ // Check that no context-specific object has been embedded.
+ code->VerifyEmbeddedObjectsInFullCode();
+#endif // DEBUG
return true;
}
}
-void FullCodeGenerator::EnsureSlotContainsAllocationSite(int slot) {
- Handle<FixedArray> vector = FeedbackVector();
- if (!vector->get(slot)->IsAllocationSite()) {
+void FullCodeGenerator::EnsureSlotContainsAllocationSite(
+ FeedbackVectorSlot slot) {
+ Handle<TypeFeedbackVector> vector = FeedbackVector();
+ if (!vector->Get(slot)->IsAllocationSite()) {
Handle<AllocationSite> allocation_site =
isolate()->factory()->NewAllocationSite();
- vector->set(slot, *allocation_site);
+ vector->Set(slot, *allocation_site);
+ }
+}
+
+
+void FullCodeGenerator::EnsureSlotContainsAllocationSite(
+ FeedbackVectorICSlot slot) {
+ Handle<TypeFeedbackVector> vector = FeedbackVector();
+ if (!vector->Get(slot)->IsAllocationSite()) {
+ Handle<AllocationSite> allocation_site =
+ isolate()->factory()->NewAllocationSite();
+ vector->Set(slot, *allocation_site);
}
}
}
-void FullCodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
- // TODO(arv): Implement
+void FullCodeGenerator::VisitClassLiteral(ClassLiteral* lit) {
Comment cmnt(masm_, "[ ClassLiteral");
- if (expr->extends() != NULL) {
- VisitForEffect(expr->extends());
+
+ if (lit->raw_name() != NULL) {
+ __ Push(lit->name());
+ } else {
+ __ Push(isolate()->factory()->undefined_value());
+ }
+
+ if (lit->extends() != NULL) {
+ VisitForStackValue(lit->extends());
+ } else {
+ __ Push(isolate()->factory()->the_hole_value());
+ }
+
+ if (lit->constructor() != NULL) {
+ VisitForStackValue(lit->constructor());
+ } else {
+ __ Push(isolate()->factory()->undefined_value());
}
- context()->Plug(isolate()->factory()->undefined_value());
+
+ __ Push(script());
+ __ Push(Smi::FromInt(lit->start_position()));
+ __ Push(Smi::FromInt(lit->end_position()));
+
+ __ CallRuntime(Runtime::kDefineClass, 6);
+ EmitClassDefineProperties(lit);
+
+ context()->Plug(result_register());
}
#include "src/allocation.h"
#include "src/assert-scope.h"
#include "src/ast.h"
+#include "src/bit-vector.h"
#include "src/code-stubs.h"
#include "src/codegen.h"
#include "src/compiler.h"
-#include "src/data-flow.h"
#include "src/globals.h"
#include "src/objects.h"
private:
// AST node visit functions.
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
void VisitInDuplicateContext(Expression* expr);
- void VisitDeclarations(ZoneList<Declaration*>* declarations);
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
void DeclareModules(Handle<FixedArray> descriptions);
void DeclareGlobals(Handle<FixedArray> pairs);
int DeclareGlobalsFlags();
// Feedback slot support. The feedback vector will be cleared during gc and
// collected by the type-feedback oracle.
- Handle<FixedArray> FeedbackVector() {
+ Handle<TypeFeedbackVector> FeedbackVector() const {
return info_->feedback_vector();
}
- void EnsureSlotContainsAllocationSite(int slot);
+ void EnsureSlotContainsAllocationSite(FeedbackVectorSlot slot);
+ void EnsureSlotContainsAllocationSite(FeedbackVectorICSlot slot);
+
+ // Returns a smi for the index into the FixedArray that backs the feedback
+ // vector
+ Smi* SmiFromSlot(FeedbackVectorSlot slot) const {
+ return Smi::FromInt(FeedbackVector()->GetIndex(slot));
+ }
+
+ Smi* SmiFromSlot(FeedbackVectorICSlot slot) const {
+ return Smi::FromInt(FeedbackVector()->GetIndex(slot));
+ }
// Record a call's return site offset, used to rebuild the frame if the
// called function was inlined at the site.
void EmitCallWithLoadIC(Call* expr);
void EmitSuperCallWithLoadIC(Call* expr);
void EmitKeyedCallWithLoadIC(Call* expr, Expression* key);
+ void EmitKeyedSuperCallWithLoadIC(Call* expr);
// Platform-specific code for inline runtime calls.
InlineFunctionGenerator FindInlineFunctionGenerator(Runtime::FunctionId id);
// Platform-specific support for compiling assignments.
+ // Left-hand side can only be a property, a global or a (parameter or local)
+ // slot.
+ enum LhsKind {
+ VARIABLE,
+ NAMED_PROPERTY,
+ KEYED_PROPERTY,
+ NAMED_SUPER_PROPERTY,
+ KEYED_SUPER_PROPERTY
+ };
+
+ static LhsKind GetAssignType(Property* property) {
+ if (property == NULL) return VARIABLE;
+ bool super_access = property->IsSuperAccess();
+ return (property->key()->IsPropertyName())
+ ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
+ : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
+ }
+
// Load a value from a named property.
// The receiver is left on the stack by the IC.
void EmitNamedPropertyLoad(Property* expr);
- // Load a value from super.named prroperty.
+ // Load a value from super.named property.
// Expect receiver ('this' value) and home_object on the stack.
void EmitNamedSuperPropertyLoad(Property* expr);
+ // Load a value from super[keyed] property.
+ // Expect receiver ('this' value), home_object and key on the stack.
+ void EmitKeyedSuperPropertyLoad(Property* expr);
+
// Load a value from a keyed property.
// The receiver and the key is left on the stack by the IC.
void EmitKeyedPropertyLoad(Property* expr);
+ // Adds the properties to the class (function) object and to its prototype.
+ // Expects the class (function) in the accumulator. The class (function) is
+ // in the accumulator after installing all the properties.
+ void EmitClassDefineProperties(ClassLiteral* lit);
+
// Apply the compound assignment operator. Expects the left operand on top
// of the stack and the right one in the accumulator.
void EmitBinaryOp(BinaryOperation* expr,
// Complete a super named property assignment. The right-hand-side value
// is expected in accumulator.
- void EmitNamedSuperPropertyAssignment(Assignment* expr);
+ void EmitNamedSuperPropertyStore(Property* prop);
+
+ // Complete a super named property assignment. The right-hand-side value
+ // is expected in accumulator.
+ void EmitKeyedSuperPropertyStore(Property* prop);
// Complete a keyed property assignment. The receiver and key are
// expected on top of the stack and the right-hand-side value in the
void EmitLoadHomeObject(SuperReference* expr);
+ void EmitLoadSuperConstructor(SuperReference* expr);
+
void CallIC(Handle<Code> code,
TypeFeedbackId id = TypeFeedbackId::None());
void PushFunctionArgumentForContextAllocation();
// AST node visit functions.
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
void __gdb_print_v8_object(Object* object) {
OFStream os(stdout);
object->Print(os);
- os << flush;
+ os << std::flush;
}
#endif
}
GeneratorObjectIterator, DONT_ENUM | DONT_DELETE | READ_ONLY);
%AddNamedProperty(GeneratorObjectPrototype, "constructor",
GeneratorFunctionPrototype, DONT_ENUM | DONT_DELETE | READ_ONLY);
+ %AddNamedProperty(GeneratorObjectPrototype,
+ symbolToStringTag, "Generator", DONT_ENUM | READ_ONLY);
%InternalSetPrototype(GeneratorFunctionPrototype, $Function.prototype);
%SetCode(GeneratorFunctionPrototype, GeneratorFunctionPrototypeConstructor);
%AddNamedProperty(GeneratorFunctionPrototype, "constructor",
flags_ = IsInNewSpaceList::update(flags_, v);
}
+ bool is_zapped_during_weak_callback() {
+ return IsZappedDuringWeakCallback::decode(flags_);
+ }
+ void set_is_zapped_during_weak_callback(bool v) {
+ flags_ = IsZappedDuringWeakCallback::update(flags_, v);
+ }
+
bool IsNearDeath() const {
// Check for PENDING to ensure correct answer when processing callbacks.
return state() == PENDING || state() == NEAR_DEATH;
parameter_or_next_free_.next_free = value;
}
- void MakeWeak(void* parameter, WeakCallback weak_callback) {
+ void MakeWeak(void* parameter, WeakCallback weak_callback,
+ bool is_zapped_during_weak_callback = false) {
DCHECK(weak_callback != NULL);
DCHECK(state() != FREE);
CHECK(object_ != NULL);
set_state(WEAK);
set_parameter(parameter);
+ set_is_zapped_during_weak_callback(is_zapped_during_weak_callback);
weak_callback_ = weak_callback;
}
Release();
return false;
}
- void* par = parameter();
+ void* param = parameter();
set_state(NEAR_DEATH);
set_parameter(NULL);
DCHECK(!object_->IsExternalTwoByteString() ||
ExternalTwoByteString::cast(object_)->resource() != NULL);
// Leaving V8.
- VMState<EXTERNAL> state(isolate);
+ VMState<EXTERNAL> vmstate(isolate);
HandleScope handle_scope(isolate);
- Handle<Object> handle(*object, isolate);
- v8::WeakCallbackData<v8::Value, void> data(
- reinterpret_cast<v8::Isolate*>(isolate),
- v8::Utils::ToLocal(handle),
- par);
- weak_callback_(data);
+ if (is_zapped_during_weak_callback()) {
+ // Phantom weak pointer case.
+ DCHECK(*object == Smi::FromInt(kPhantomReferenceZap));
+ // Make data with a null handle.
+ v8::WeakCallbackData<v8::Value, void> data(
+ reinterpret_cast<v8::Isolate*>(isolate), v8::Local<v8::Object>(),
+ param);
+ weak_callback_(data);
+ if (state() != FREE) {
+ // Callback does not have to clear the global handle if it is a
+ // phantom handle.
+ Release();
+ }
+ } else {
+ Handle<Object> handle(*object, isolate);
+ v8::WeakCallbackData<v8::Value, void> data(
+ reinterpret_cast<v8::Isolate*>(isolate), v8::Utils::ToLocal(handle),
+ param);
+ weak_callback_(data);
+ }
}
// Absence of explicit cleanup or revival of weak handle
// in most of the cases would lead to memory leak.
// This stores three flags (independent, partially_dependent and
// in_new_space_list) and a State.
- class NodeState: public BitField<State, 0, 4> {};
- class IsIndependent: public BitField<bool, 4, 1> {};
- class IsPartiallyDependent: public BitField<bool, 5, 1> {};
- class IsInNewSpaceList: public BitField<bool, 6, 1> {};
+ class NodeState : public BitField<State, 0, 4> {};
+ class IsIndependent : public BitField<bool, 4, 1> {};
+ class IsPartiallyDependent : public BitField<bool, 5, 1> {};
+ class IsInNewSpaceList : public BitField<bool, 6, 1> {};
+ class IsZappedDuringWeakCallback : public BitField<bool, 7, 1> {};
uint8_t flags_;
}
-void GlobalHandles::MakeWeak(Object** location,
- void* parameter,
- WeakCallback weak_callback) {
- Node::FromLocation(location)->MakeWeak(parameter, weak_callback);
+void GlobalHandles::MakeWeak(Object** location, void* parameter,
+ WeakCallback weak_callback, PhantomState phantom) {
+ Node::FromLocation(location)
+ ->MakeWeak(parameter, weak_callback, phantom == Phantom);
}
void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
for (NodeIterator it(this); !it.done(); it.Advance()) {
- if (it.node()->IsWeakRetainer()) v->VisitPointer(it.node()->location());
+ Node* node = it.node();
+ if (node->IsWeakRetainer()) {
+ if (node->state() == Node::PENDING &&
+ node->is_zapped_during_weak_callback()) {
+ *(node->location()) = Smi::FromInt(kPhantomReferenceZap);
+ } else {
+ v->VisitPointer(node->location());
+ }
+ }
}
}
DCHECK(node->is_in_new_space_list());
if ((node->is_independent() || node->is_partially_dependent()) &&
node->IsWeakRetainer()) {
- v->VisitPointer(node->location());
+ if (node->is_zapped_during_weak_callback()) {
+ *(node->location()) = Smi::FromInt(kPhantomReferenceZap);
+ } else {
+ v->VisitPointer(node->location());
+ }
}
}
}
typedef WeakCallbackData<v8::Value, void>::Callback WeakCallback;
+ // For a phantom weak reference, the callback does not have access to the
+ // dying object. Phantom weak references are preferred because they allow
+ // memory to be reclaimed in one GC cycle rather than two. However, for
+ // historical reasons the default is non-phantom.
+ enum PhantomState { Nonphantom, Phantom };
+
// Make the global handle weak and set the callback parameter for the
// handle. When the garbage collector recognizes that only weak global
- // handles point to an object the handles are cleared and the callback
- // function is invoked (for each handle) with the handle and corresponding
- // parameter as arguments. Note: cleared means set to Smi::FromInt(0). The
- // reason is that Smi::FromInt(0) does not change during garage collection.
- static void MakeWeak(Object** location,
- void* parameter,
- WeakCallback weak_callback);
+ // handles point to an object the callback function is invoked (for each
+ // handle) with the handle and corresponding parameter as arguments. By
+ // default the handle still contains a pointer to the object that is being
+ // collected. For this reason the object is not collected until the next
+ // GC. For a phantom weak handle the handle is cleared (set to a Smi)
+ // before the callback is invoked, but the handle can still be identified
+ // in the callback by using the location() of the handle.
+ static void MakeWeak(Object** location, void* parameter,
+ WeakCallback weak_callback,
+ PhantomState phantom = Nonphantom);
void RecordStats(HeapStats* stats);
#ifndef V8_GLOBALS_H_
#define V8_GLOBALS_H_
-#include "include/v8stdint.h"
+#include <stddef.h>
+#include <stdint.h>
#include "src/base/build_config.h"
#include "src/base/logging.h"
# define V8_INFINITY INFINITY
#endif
-#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_ARM || \
- V8_TARGET_ARCH_ARM64
+#if V8_TARGET_ARCH_IA32 || (V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_32_BIT) || \
+ V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_MIPS
#define V8_TURBOFAN_BACKEND 1
#else
#define V8_TURBOFAN_BACKEND 0
const uintptr_t kUintptrAllBitsSet = V8_UINT64_C(0xFFFFFFFFFFFFFFFF);
const bool kRequiresCodeRange = true;
const size_t kMaximalCodeRangeSize = 512 * MB;
+#if V8_OS_WIN
+const size_t kMinimumCodeRangeSize = 4 * MB;
+const size_t kReservedCodeRangePages = 1;
+#else
+const size_t kMinimumCodeRangeSize = 3 * MB;
+const size_t kReservedCodeRangePages = 0;
+#endif
#else
const int kPointerSizeLog2 = 2;
const intptr_t kIntptrSignBit = 0x80000000;
// x32 port also requires code range.
const bool kRequiresCodeRange = true;
const size_t kMaximalCodeRangeSize = 256 * MB;
+const size_t kMinimumCodeRangeSize = 3 * MB;
+const size_t kReservedCodeRangePages = 0;
#else
const bool kRequiresCodeRange = false;
const size_t kMaximalCodeRangeSize = 0 * MB;
+const size_t kMinimumCodeRangeSize = 0 * MB;
+const size_t kReservedCodeRangePages = 0;
#endif
#endif
#endif
const int kCodeZapValue = 0xbadc0de;
+const uint32_t kPhantomReferenceZap = 0xca11bac;
// On Intel architecture, cache line size is 64 bytes.
// On ARM it may be less (32 bytes), but as far this constant is
class String;
class Name;
class Struct;
+class Symbol;
class Variable;
class RelocInfo;
class Deserializer;
CELL_SPACE, // Only and all cell objects.
PROPERTY_CELL_SPACE, // Only and all global property cell objects.
LO_SPACE, // Promoted large objects.
- INVALID_SPACE, // Only used in AllocationResult to signal success.
FIRST_SPACE = NEW_SPACE,
LAST_SPACE = LO_SPACE,
};
-// Logging and profiling. A StateTag represents a possible state of
-// the VM. The logger maintains a stack of these. Creating a VMState
-// object enters a state by pushing on the stack, and destroying a
-// VMState object leaves a state by popping the current state from the
-// stack.
-
-enum StateTag {
- JS,
- GC,
- COMPILER,
- OTHER,
- EXTERNAL,
- IDLE
-};
-
-
// -----------------------------------------------------------------------------
// Macros
// CPU feature flags.
enum CpuFeature {
- // x86
- SSE4_1,
- SSE3,
- SAHF,
- // ARM
- VFP3,
- ARMv7,
- SUDIV,
- MLS,
- UNALIGNED_ACCESSES,
- MOVW_MOVT_IMMEDIATE_LOADS,
- VFP32DREGS,
- NEON,
- // MIPS, MIPS64
- FPU,
- FP64FPU,
- MIPSr1,
- MIPSr2,
- MIPSr6,
- // ARM64
- ALWAYS_ALIGN_CSP,
- NUMBER_OF_CPU_FEATURES
+ // x86
+ SSE4_1,
+ SSE3,
+ SAHF,
+ // ARM
+ VFP3,
+ ARMv7,
+ ARMv8,
+ SUDIV,
+ MLS,
+ UNALIGNED_ACCESSES,
+ MOVW_MOVT_IMMEDIATE_LOADS,
+ VFP32DREGS,
+ NEON,
+ // MIPS, MIPS64
+ FPU,
+ FP64FPU,
+ MIPSr1,
+ MIPSr2,
+ MIPSr6,
+ // ARM64
+ ALWAYS_ALIGN_CSP,
+ NUMBER_OF_CPU_FEATURES
};
GLOBAL_SCOPE, // The top-level scope for a program or a top-level eval.
CATCH_SCOPE, // The scope introduced by catch.
BLOCK_SCOPE, // The scope introduced by a new block.
- WITH_SCOPE // The scope introduced by with.
+ WITH_SCOPE, // The scope introduced by with.
+ ARROW_SCOPE // The top-level scope for an arrow function literal.
};
}
// Convert to a Handle with a type that can be upcasted to.
- template <class S> INLINE(bool ToHandle(Handle<S>* out)) {
+ template <class S>
+ V8_INLINE bool ToHandle(Handle<S>* out) const {
if (location_ == NULL) {
*out = Handle<T>::null();
return false;
thisArg = %_Arguments(1);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(thisArg)) {
thisArg = %GetDefaultReceiver(predicate) || thisArg;
- } else if (!IS_SPEC_OBJECT(thisArg) && %IsSloppyModeFunction(predicate)) {
- thisArg = ToObject(thisArg);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(predicate, thisArg);
}
for (var i = 0; i < length; i++) {
if (i in array) {
var element = array[i];
- if (%_CallFunction(thisArg, element, i, array, predicate)) {
+ var newThisArg = needs_wrapper ? ToObject(thisArg) : thisArg;
+ if (%_CallFunction(newThisArg, element, i, array, predicate)) {
return element;
}
}
thisArg = %_Arguments(1);
}
+ var needs_wrapper = false;
if (IS_NULL_OR_UNDEFINED(thisArg)) {
thisArg = %GetDefaultReceiver(predicate) || thisArg;
- } else if (!IS_SPEC_OBJECT(thisArg) && %IsSloppyModeFunction(predicate)) {
- thisArg = ToObject(thisArg);
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(predicate, thisArg);
}
for (var i = 0; i < length; i++) {
if (i in array) {
var element = array[i];
- if (%_CallFunction(thisArg, element, i, array, predicate)) {
+ var newThisArg = needs_wrapper ? ToObject(thisArg) : thisArg;
+ if (%_CallFunction(newThisArg, element, i, array, predicate)) {
return i;
}
}
var s = TO_STRING_INLINE(this);
var n = ToInteger(count);
- if (n < 0 || !NUMBER_IS_FINITE(n)) {
+ // The maximum string length is stored in a smi, so a longer repeat
+ // must result in a range error.
+ if (n < 0 || n > %_MaxSmi()) {
throw MakeRangeError("invalid_count_value", []);
}
- var elements = new InternalArray(n);
- for (var i = 0; i < n; i++) {
- elements[i] = s;
+ var r = "";
+ while (true) {
+ if (n & 1) r += s;
+ n >>= 1;
+ if (n === 0) return r;
+ s += s;
}
-
- return %StringBuilderConcat(elements, n, "");
}
--- /dev/null
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+'use strict';
+
+// This file relies on the fact that the following declaration has been made
+// in runtime.js and symbol.js:
+// var $Object = global.Object;
+// var $Symbol = global.Symbol;
+
+var symbolToStringTag = InternalSymbol("Symbol.toStringTag");
+
+var kBuiltinStringTags = {
+ "__proto__": null,
+ "Arguments": true,
+ "Array": true,
+ "Boolean": true,
+ "Date": true,
+ "Error": true,
+ "Function": true,
+ "Number": true,
+ "RegExp": true,
+ "String": true
+};
+
+DefaultObjectToString = ObjectToStringHarmony;
+// ES6 draft 08-24-14, section 19.1.3.6
+function ObjectToStringHarmony() {
+ if (IS_UNDEFINED(this) && !IS_UNDETECTABLE(this)) return "[object Undefined]";
+ if (IS_NULL(this)) return "[object Null]";
+ var O = ToObject(this);
+ var builtinTag = %_ClassOf(O);
+ var tag = O[symbolToStringTag];
+ if (IS_UNDEFINED(tag)) {
+ tag = builtinTag;
+ } else if (!IS_STRING(tag)) {
+ return "[object ???]"
+ } else if (tag !== builtinTag && kBuiltinStringTags[tag]) {
+ return "[object ~" + tag + "]";
+ }
+ return "[object " + tag + "]";
+}
+
+function HarmonyToStringExtendSymbolPrototype() {
+ %CheckIsBootstrapping();
+
+ InstallConstants($Symbol, $Array(
+ // TODO(dslomov, caitp): Move to symbol.js when shipping
+ "toStringTag", symbolToStringTag
+ ));
+}
+
+HarmonyToStringExtendSymbolPrototype();
+
+function HarmonyToStringExtendObjectPrototype() {
+ %CheckIsBootstrapping();
+
+ // Can't use InstallFunctions() because will fail in Debug mode.
+ // Emulate InstallFunctions() here.
+ %FunctionSetName(ObjectToStringHarmony, "toString");
+ %FunctionRemovePrototype(ObjectToStringHarmony);
+ %SetNativeFlag(ObjectToStringHarmony);
+
+ // Set up the non-enumerable functions on the Array prototype object.
+ var desc = ToPropertyDescriptor({
+ value: ObjectToStringHarmony
+ });
+ DefineOwnProperty($Object.prototype, "toString", desc, false);
+
+ %ToFastProperties($Object.prototype);
+}
+
+HarmonyToStringExtendObjectPrototype();
--- /dev/null
+// 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.
+
+'use strict';
+
+// This file relies on the fact that the following declaration has been made
+// in runtime.js:
+// var $Array = global.Array;
+
+// -------------------------------------------------------------------
+
+macro TYPED_ARRAYS(FUNCTION)
+// arrayIds below should be synchronized with Runtime_TypedArrayInitialize.
+FUNCTION(1, Uint8Array, 1)
+FUNCTION(2, Int8Array, 1)
+FUNCTION(3, Uint16Array, 2)
+FUNCTION(4, Int16Array, 2)
+FUNCTION(5, Uint32Array, 4)
+FUNCTION(6, Int32Array, 4)
+FUNCTION(7, Float32Array, 4)
+FUNCTION(8, Float64Array, 8)
+FUNCTION(9, Uint8ClampedArray, 1)
+endmacro
+
+
+macro TYPED_ARRAY_HARMONY_ADDITIONS(ARRAY_ID, NAME, ELEMENT_SIZE)
+
+// ES6 draft 08-24-14, section 22.2.3.12
+function NAMEForEach(f /* thisArg */) { // length == 1
+ if (!%IsTypedArray(this)) {
+ throw MakeTypeError('not_typed_array', []);
+ }
+ if (!IS_SPEC_FUNCTION(f)) {
+ throw MakeTypeError('called_non_callable', [ f ]);
+ }
+
+ var length = %_TypedArrayGetLength(this);
+ var receiver;
+
+ if (%_ArgumentsLength() > 1) {
+ receiver = %_Arguments(1);
+ }
+
+ var needs_wrapper = false;
+ if (IS_NULL_OR_UNDEFINED(receiver)) {
+ receiver = %GetDefaultReceiver(f) || receiver;
+ } else {
+ needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
+ }
+
+ var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
+ for (var i = 0; i < length; i++) {
+ var element = this[i];
+ // Prepare break slots for debugger step in.
+ if (stepping) %DebugPrepareStepInIfStepping(f);
+ var new_receiver = needs_wrapper ? ToObject(receiver) : receiver;
+ %_CallFunction(new_receiver, TO_OBJECT_INLINE(element), i, this, f);
+ }
+}
+endmacro
+
+TYPED_ARRAYS(TYPED_ARRAY_HARMONY_ADDITIONS)
+
+
+function HarmonyTypedArrayExtendPrototypes() {
+macro EXTEND_TYPED_ARRAY(ARRAY_ID, NAME, ELEMENT_SIZE)
+ %CheckIsBootstrapping();
+
+ // Set up non-enumerable functions on the prototype object.
+ InstallFunctions(global.NAME.prototype, DONT_ENUM, $Array(
+ "forEach", NAMEForEach
+ ));
+endmacro
+
+ TYPED_ARRAYS(EXTEND_TYPED_ARRAY)
+}
+
+HarmonyTypedArrayExtendPrototypes();
HeapEntry* HeapGraphEdge::from() const {
- return &snapshot()->entries()[from_index_];
+ return &snapshot()->entries()[from_index()];
}
HeapGraphEdge::HeapGraphEdge(Type type, const char* name, int from, int to)
- : type_(type),
- from_index_(from),
+ : bit_field_(TypeField::encode(type) | FromIndexField::encode(from)),
to_index_(to),
name_(name) {
DCHECK(type == kContextVariable
HeapGraphEdge::HeapGraphEdge(Type type, int index, int from, int to)
- : type_(type),
- from_index_(from),
+ : bit_field_(TypeField::encode(type) | FromIndexField::encode(from)),
to_index_(to),
index_(index) {
DCHECK(type == kElement || type == kHidden);
continue;
}
if (ExtractAccessorPairProperty(js_obj, entry, k, value)) continue;
- SetPropertyReference(js_obj, entry, String::cast(k), value);
+ SetPropertyReference(js_obj, entry, Name::cast(k), value);
}
}
}
AccessorPair* accessors = AccessorPair::cast(callback_obj);
Object* getter = accessors->getter();
if (!getter->IsOddball()) {
- SetPropertyReference(js_obj, entry, String::cast(key), getter, "get %s");
+ SetPropertyReference(js_obj, entry, Name::cast(key), getter, "get %s");
}
Object* setter = accessors->setter();
if (!setter->IsOddball()) {
- SetPropertyReference(js_obj, entry, String::cast(key), setter, "set %s");
+ SetPropertyReference(js_obj, entry, Name::cast(key), setter, "set %s");
}
return true;
}
#define STRING_NAME(name, str) NAME_ENTRY(name)
INTERNALIZED_STRING_LIST(STRING_NAME)
#undef STRING_NAME
+#define SYMBOL_NAME(name) NAME_ENTRY(name)
+ PRIVATE_SYMBOL_LIST(SYMBOL_NAME)
+#undef SYMBOL_NAME
#undef NAME_ENTRY
CHECK(!strong_gc_subroot_names_.is_empty());
}
: isolate_(snapshot->profiler()->heap_object_map()->heap()->isolate()),
snapshot_(snapshot),
names_(snapshot_->profiler()->names()),
- progress_(progress),
embedder_queried_(false),
objects_by_info_(RetainedInfosMatch),
native_groups_(StringsMatch),
kWeak = v8::HeapGraphEdge::kWeak
};
- HeapGraphEdge() { }
HeapGraphEdge(Type type, const char* name, int from, int to);
HeapGraphEdge(Type type, int index, int from, int to);
void ReplaceToIndexWithEntry(HeapSnapshot* snapshot);
- Type type() const { return static_cast<Type>(type_); }
+ Type type() const { return TypeField::decode(bit_field_); }
int index() const {
- DCHECK(type_ == kElement || type_ == kHidden);
+ DCHECK(type() == kElement || type() == kHidden);
return index_;
}
const char* name() const {
- DCHECK(type_ == kContextVariable
- || type_ == kProperty
- || type_ == kInternal
- || type_ == kShortcut
- || type_ == kWeak);
+ DCHECK(type() == kContextVariable || type() == kProperty ||
+ type() == kInternal || type() == kShortcut || type() == kWeak);
return name_;
}
INLINE(HeapEntry* from() const);
private:
INLINE(HeapSnapshot* snapshot() const);
+ int from_index() const { return FromIndexField::decode(bit_field_); }
- unsigned type_ : 3;
- int from_index_ : 29;
+ class TypeField : public BitField<Type, 0, 3> {};
+ class FromIndexField : public BitField<int, 3, 29> {};
+ uint32_t bit_field_;
union {
// During entries population |to_index_| is used for storing the index,
// afterwards it is replaced with a pointer to the entry.
void FillChildren();
void Print(int max_depth);
- void PrintEntriesSize();
private:
HeapEntry* AddRootEntry();
v8::HeapProfiler::ObjectNameResolver* resolver);
virtual ~V8HeapExplorer();
virtual HeapEntry* AllocateEntry(HeapThing ptr);
- void AddRootEntries(SnapshotFiller* filler);
int EstimateObjectsCount(HeapIterator* iterator);
bool IterateAndExtractReferences(SnapshotFiller* filler);
void TagGlobalObjects();
NativeObjectsExplorer(HeapSnapshot* snapshot,
SnapshottingProgressReportingInterface* progress);
virtual ~NativeObjectsExplorer();
- void AddRootEntries(SnapshotFiller* filler);
int EstimateObjectsCount();
bool IterateAndExtractReferences(SnapshotFiller* filler);
Isolate* isolate_;
HeapSnapshot* snapshot_;
StringsStorage* names_;
- SnapshottingProgressReportingInterface* progress_;
bool embedder_queried_;
HeapObjectsSet in_groups_;
// RetainedObjectInfo* -> List<HeapObject*>*
size_t GCIdleTimeHandler::EstimateMarkCompactTime(
size_t size_of_objects, size_t mark_compact_speed_in_bytes_per_ms) {
+ // TODO(hpayer): Be more precise about the type of mark-compact event. It
+ // makes a huge difference if it is incremental or non-incremental and if
+ // compaction is happening.
if (mark_compact_speed_in_bytes_per_ms == 0) {
mark_compact_speed_in_bytes_per_ms = kInitialConservativeMarkCompactSpeed;
}
}
-size_t GCIdleTimeHandler::EstimateScavengeTime(
- size_t new_space_size, size_t scavenge_speed_in_bytes_per_ms) {
+bool GCIdleTimeHandler::ShouldDoScavenge(
+ size_t idle_time_in_ms, size_t new_space_size, size_t used_new_space_size,
+ size_t scavenge_speed_in_bytes_per_ms,
+ size_t new_space_allocation_throughput_in_bytes_per_ms) {
+ size_t new_space_allocation_limit =
+ kMaxFrameRenderingIdleTime * scavenge_speed_in_bytes_per_ms;
+
+ // If the limit is larger than the new space size, then scavenging used to be
+ // really fast. We can take advantage of the whole new space.
+ if (new_space_allocation_limit > new_space_size) {
+ new_space_allocation_limit = new_space_size;
+ }
+
+ // We do not know the allocation throughput before the first Scavenge.
+ // TODO(hpayer): Estimate allocation throughput before the first Scavenge.
+ if (new_space_allocation_throughput_in_bytes_per_ms == 0) {
+ new_space_allocation_limit =
+ static_cast<size_t>(new_space_size * kConservativeTimeRatio);
+ } else {
+ // We have to trigger scavenge before we reach the end of new space.
+ new_space_allocation_limit -=
+ new_space_allocation_throughput_in_bytes_per_ms *
+ kMaxFrameRenderingIdleTime;
+ }
+
if (scavenge_speed_in_bytes_per_ms == 0) {
scavenge_speed_in_bytes_per_ms = kInitialConservativeScavengeSpeed;
}
- return new_space_size / scavenge_speed_in_bytes_per_ms;
-}
-
-bool GCIdleTimeHandler::ScavangeMayHappenSoon(
- size_t available_new_space_memory,
- size_t new_space_allocation_throughput_in_bytes_per_ms) {
- if (available_new_space_memory <=
- new_space_allocation_throughput_in_bytes_per_ms *
- kMaxFrameRenderingIdleTime) {
- return true;
+ if (new_space_allocation_limit <= used_new_space_size) {
+ if (used_new_space_size / scavenge_speed_in_bytes_per_ms <=
+ idle_time_in_ms) {
+ return true;
+ }
}
return false;
}
+bool GCIdleTimeHandler::ShouldDoMarkCompact(
+ size_t idle_time_in_ms, size_t size_of_objects,
+ size_t mark_compact_speed_in_bytes_per_ms) {
+ return idle_time_in_ms >=
+ EstimateMarkCompactTime(size_of_objects,
+ mark_compact_speed_in_bytes_per_ms);
+}
+
+
// The following logic is implemented by the controller:
-// (1) If the new space is almost full and we can effort a Scavenge, then a
-// Scavenge is performed.
-// (2) If there is currently no MarkCompact idle round going on, we start a
+// (1) If we don't have any idle time, do nothing, unless a context was
+// disposed, incremental marking is stopped, and the heap is small. Then do
+// a full GC.
+// (2) If the new space is almost full and we can affort a Scavenge or if the
+// next Scavenge will very likely take long, then a Scavenge is performed.
+// (3) If there is currently no MarkCompact idle round going on, we start a
// new idle round if enough garbage was created or we received a context
// disposal event. Otherwise we do not perform garbage collection to keep
// system utilization low.
-// (3) If incremental marking is done, we perform a full garbage collection
+// (4) If incremental marking is done, we perform a full garbage collection
// if context was disposed or if we are allowed to still do full garbage
// collections during this idle round or if we are not allowed to start
// incremental marking. Otherwise we do not perform garbage collection to
// keep system utilization low.
-// (4) If sweeping is in progress and we received a large enough idle time
+// (5) If sweeping is in progress and we received a large enough idle time
// request, we finalize sweeping here.
-// (5) If incremental marking is in progress, we perform a marking step. Note,
+// (6) If incremental marking is in progress, we perform a marking step. Note,
// that this currently may trigger a full garbage collection.
GCIdleTimeAction GCIdleTimeHandler::Compute(size_t idle_time_in_ms,
HeapState heap_state) {
- if (idle_time_in_ms <= kMaxFrameRenderingIdleTime &&
- ScavangeMayHappenSoon(
- heap_state.available_new_space_memory,
- heap_state.new_space_allocation_throughput_in_bytes_per_ms) &&
- idle_time_in_ms >=
- EstimateScavengeTime(heap_state.new_space_capacity,
- heap_state.scavenge_speed_in_bytes_per_ms)) {
+ if (idle_time_in_ms == 0) {
+ if (heap_state.incremental_marking_stopped) {
+ if (heap_state.size_of_objects < kSmallHeapSize &&
+ heap_state.contexts_disposed > 0) {
+ return GCIdleTimeAction::FullGC();
+ }
+ }
+ return GCIdleTimeAction::Nothing();
+ }
+
+ if (ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size,
+ heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms)) {
return GCIdleTimeAction::Scavenge();
}
+
if (IsMarkCompactIdleRoundFinished()) {
if (EnoughGarbageSinceLastIdleRound() || heap_state.contexts_disposed > 0) {
StartIdleRound();
}
}
- if (idle_time_in_ms == 0) {
- return GCIdleTimeAction::Nothing();
- }
-
if (heap_state.incremental_marking_stopped) {
- size_t estimated_time_in_ms =
- EstimateMarkCompactTime(heap_state.size_of_objects,
- heap_state.mark_compact_speed_in_bytes_per_ms);
- if (idle_time_in_ms >= estimated_time_in_ms ||
+ // TODO(jochen): Remove context disposal dependant logic.
+ if (ShouldDoMarkCompact(idle_time_in_ms, heap_state.size_of_objects,
+ heap_state.mark_compact_speed_in_bytes_per_ms) ||
(heap_state.size_of_objects < kSmallHeapSize &&
heap_state.contexts_disposed > 0)) {
// If there are no more than two GCs left in this idle round and we are
// That is the maximum idle time we will have during frame rendering.
static const size_t kMaxFrameRenderingIdleTime = 16;
- // If less than that much memory is left in the new space, we consider it
- // as almost full and force a new space collection earlier in the idle time.
- static const size_t kNewSpaceAlmostFullTreshold = 100 * KB;
-
// If we haven't recorded any scavenger events yet, we use a conservative
// lower bound for the scavenger speed.
static const size_t kInitialConservativeScavengeSpeed = 100 * KB;
size_t mark_compact_speed_in_bytes_per_ms;
size_t incremental_marking_speed_in_bytes_per_ms;
size_t scavenge_speed_in_bytes_per_ms;
- size_t available_new_space_memory;
+ size_t used_new_space_size;
size_t new_space_capacity;
size_t new_space_allocation_throughput_in_bytes_per_ms;
};
static size_t EstimateMarkCompactTime(
size_t size_of_objects, size_t mark_compact_speed_in_bytes_per_ms);
- static size_t EstimateScavengeTime(size_t new_space_size,
- size_t scavenger_speed_in_bytes_per_ms);
+ static bool ShouldDoMarkCompact(size_t idle_time_in_ms,
+ size_t size_of_objects,
+ size_t mark_compact_speed_in_bytes_per_ms);
- static bool ScavangeMayHappenSoon(
- size_t available_new_space_memory,
+ static bool ShouldDoScavenge(
+ size_t idle_time_in_ms, size_t new_space_size, size_t used_new_space_size,
+ size_t scavenger_speed_in_bytes_per_ms,
size_t new_space_allocation_throughput_in_bytes_per_ms);
private:
case PROPERTY_CELL_SPACE:
case LO_SPACE:
return false;
- case INVALID_SPACE:
- break;
}
UNREACHABLE();
return false;
void Heap::ClearInstanceofCache() {
- set_instanceof_cache_function(the_hole_value());
+ set_instanceof_cache_function(Smi::FromInt(0));
}
void Heap::CompletelyClearInstanceofCache() {
- set_instanceof_cache_map(the_hole_value());
- set_instanceof_cache_function(the_hole_value());
+ set_instanceof_cache_map(Smi::FromInt(0));
+ set_instanceof_cache_function(Smi::FromInt(0));
}
#include "src/natives.h"
#include "src/runtime-profiler.h"
#include "src/scopeinfo.h"
+#include "src/serialize.h"
#include "src/snapshot.h"
#include "src/utils.h"
#include "src/v8threads.h"
reserved_semispace_size_(8 * (kPointerSize / 4) * MB),
max_semi_space_size_(8 * (kPointerSize / 4) * MB),
initial_semispace_size_(Page::kPageSize),
+ target_semispace_size_(Page::kPageSize),
max_old_generation_size_(700ul * (kPointerSize / 4) * MB),
max_executable_size_(256ul * (kPointerSize / 4) * MB),
// Variables set based on semispace_size_ and old_generation_size_ in
configured_(false),
external_string_table_(this),
chunks_queued_for_free_(NULL),
- gc_callbacks_depth_(0) {
+ gc_callbacks_depth_(0),
+ deserialization_complete_(false) {
// Allow build-time customization of the max semispace size. Building
// V8 with snapshots and a non-default max semispace size is much
// easier if you can define it as part of the build environment.
set_array_buffers_list(Smi::FromInt(0));
set_allocation_sites_list(Smi::FromInt(0));
set_encountered_weak_collections(Smi::FromInt(0));
+ set_encountered_weak_cells(Smi::FromInt(0));
// Put a dummy entry in the remembered pages so we can find the list the
// minidump even if there are no real unmapped pages.
RememberUnmappedPage(NULL, false);
}
-void Heap::ReserveSpace(int* sizes, Address* locations_out) {
+bool Heap::ReserveSpace(Reservation* reservations) {
bool gc_performed = true;
int counter = 0;
static const int kThreshold = 20;
while (gc_performed && counter++ < kThreshold) {
gc_performed = false;
for (int space = NEW_SPACE; space < Serializer::kNumberOfSpaces; space++) {
- if (sizes[space] == 0) continue;
+ Reservation* reservation = &reservations[space];
+ DCHECK_LE(1, reservation->length());
+ if (reservation->at(0).size == 0) continue;
bool perform_gc = false;
if (space == LO_SPACE) {
- perform_gc = !lo_space()->CanAllocateSize(sizes[space]);
+ DCHECK_EQ(1, reservation->length());
+ perform_gc = !lo_space()->CanAllocateSize(reservation->at(0).size);
} else {
- AllocationResult allocation;
- if (space == NEW_SPACE) {
- allocation = new_space()->AllocateRaw(sizes[space]);
- } else {
- allocation = paged_space(space)->AllocateRaw(sizes[space]);
- }
- FreeListNode* node;
- if (allocation.To(&node)) {
- // Mark with a free list node, in case we have a GC before
- // deserializing.
- node->set_size(this, sizes[space]);
- DCHECK(space < Serializer::kNumberOfPreallocatedSpaces);
- locations_out[space] = node->address();
- } else {
- perform_gc = true;
+ for (auto& chunk : *reservation) {
+ AllocationResult allocation;
+ int size = chunk.size;
+ DCHECK_LE(size, MemoryAllocator::PageAreaSize(
+ static_cast<AllocationSpace>(space)));
+ if (space == NEW_SPACE) {
+ allocation = new_space()->AllocateRaw(size);
+ } else {
+ allocation = paged_space(space)->AllocateRaw(size);
+ }
+ FreeListNode* node;
+ if (allocation.To(&node)) {
+ // Mark with a free list node, in case we have a GC before
+ // deserializing.
+ node->set_size(this, size);
+ DCHECK(space < Serializer::kNumberOfPreallocatedSpaces);
+ chunk.start = node->address();
+ chunk.end = node->address() + size;
+ } else {
+ perform_gc = true;
+ break;
+ }
}
}
if (perform_gc) {
}
}
- if (gc_performed) {
- // Failed to reserve the space after several attempts.
- V8::FatalProcessOutOfMemory("Heap::ReserveSpace");
- }
+ return !gc_performed;
}
while (head_start != head_end) {
int size = static_cast<int>(*(head_start++));
HeapObject* obj = reinterpret_cast<HeapObject*>(*(head_start++));
+ // New space allocation in SemiSpaceCopyObject marked the region
+ // overlapping with promotion queue as uninitialized.
+ MSAN_MEMORY_IS_INITIALIZED(&size, sizeof(size));
+ MSAN_MEMORY_IS_INITIALIZED(&obj, sizeof(obj));
emergency_stack_->Add(Entry(obj, size));
}
rear_ = head_end;
// Copy objects reachable from the encountered weak collections list.
scavenge_visitor.VisitPointer(&encountered_weak_collections_);
+ // Copy objects reachable from the encountered weak cells.
+ scavenge_visitor.VisitPointer(&encountered_weak_cells_);
// Copy objects reachable from the code flushing candidates list.
MarkCompactCollector* collector = mark_compact_collector();
LOG(isolate_, ResourceEvent("scavenge", "end"));
gc_state_ = NOT_IN_GC;
+
+ gc_idle_time_handler_.NotifyScavenge();
}
// Order is important: slot might be inside of the target if target
// was allocated over a dead object and slot comes from the store
// buffer.
- *slot = target;
+
+ // Unfortunately, the allocation can also write over the slot if the slot
+ // was in free space and the allocation wrote free list data (such as the
+ // free list map or entry size) over the slot. We guard against this by
+ // checking that the slot still points to the object being moved. This
+ // should be sufficient because neither the free list map nor the free
+ // list entry size should look like a new space pointer (the former is an
+ // old space pointer, the latter is word-aligned).
+ if (*slot == object) {
+ *slot = target;
+ }
MigrateObject(heap, object, target, object_size);
if (object_contents == POINTER_OBJECT) {
roots_[entry.index] = map;
}
+ { // Create a separate external one byte string map for native sources.
+ AllocationResult allocation = AllocateMap(EXTERNAL_ONE_BYTE_STRING_TYPE,
+ ExternalOneByteString::kSize);
+ if (!allocation.To(&obj)) return false;
+ set_native_source_string_map(Map::cast(obj));
+ }
+
ALLOCATE_VARSIZE_MAP(STRING_TYPE, undetectable_string)
undetectable_string_map()->set_is_undetectable();
ALLOCATE_MAP(CELL_TYPE, Cell::kSize, cell)
ALLOCATE_MAP(PROPERTY_CELL_TYPE, PropertyCell::kSize, global_property_cell)
+ ALLOCATE_MAP(WEAK_CELL_TYPE, WeakCell::kSize, weak_cell)
ALLOCATE_MAP(FILLER_TYPE, kPointerSize, one_pointer_filler)
ALLOCATE_MAP(FILLER_TYPE, 2 * kPointerSize, two_pointer_filler)
}
+AllocationResult Heap::AllocateWeakCell(HeapObject* value) {
+ int size = WeakCell::kSize;
+ STATIC_ASSERT(WeakCell::kSize <= Page::kMaxRegularHeapObjectSize);
+ HeapObject* result;
+ {
+ AllocationResult allocation =
+ AllocateRaw(size, OLD_POINTER_SPACE, OLD_POINTER_SPACE);
+ if (!allocation.To(&result)) return allocation;
+ }
+ result->set_map_no_write_barrier(weak_cell_map());
+ WeakCell::cast(result)->initialize(value);
+ WeakCell::cast(result)->set_next(undefined_value(), SKIP_WRITE_BARRIER);
+ return result;
+}
+
+
void Heap::CreateApiObjects() {
HandleScope scope(isolate());
Factory* factory = isolate()->factory();
set_instanceof_cache_map(Smi::FromInt(0));
set_instanceof_cache_answer(Smi::FromInt(0));
+ {
+ HandleScope scope(isolate());
+#define SYMBOL_INIT(name) \
+ Handle<Symbol> name = factory->NewPrivateOwnSymbol(); \
+ roots_[k##name##RootIndex] = *name;
+ PRIVATE_SYMBOL_LIST(SYMBOL_INIT)
+#undef SYMBOL_INIT
+ }
+
CreateFixedStubs();
// Allocate the dictionary of intrinsic function names.
set_undefined_cell(*factory->NewCell(factory->undefined_value()));
// The symbol registry is initialized lazily.
- set_symbol_registry(undefined_value());
+ set_symbol_registry(Smi::FromInt(0));
// Allocate object to hold object observation state.
set_observation_state(*factory->NewJSObjectFromMap(
// Number of queued microtasks stored in Isolate::pending_microtask_count().
set_microtask_queue(empty_fixed_array());
- set_detailed_stack_trace_symbol(*factory->NewPrivateOwnSymbol());
- set_elements_transition_symbol(*factory->NewPrivateOwnSymbol());
- set_frozen_symbol(*factory->NewPrivateOwnSymbol());
- set_megamorphic_symbol(*factory->NewPrivateOwnSymbol());
- set_premonomorphic_symbol(*factory->NewPrivateOwnSymbol());
- set_generic_symbol(*factory->NewPrivateOwnSymbol());
- set_nonexistent_symbol(*factory->NewPrivateOwnSymbol());
- set_normal_ic_symbol(*factory->NewPrivateOwnSymbol());
- set_observed_symbol(*factory->NewPrivateOwnSymbol());
- set_stack_trace_symbol(*factory->NewPrivateOwnSymbol());
- set_uninitialized_symbol(*factory->NewPrivateOwnSymbol());
- set_home_object_symbol(*factory->NewPrivateOwnSymbol());
-
Handle<SeededNumberDictionary> slow_element_dictionary =
SeededNumberDictionary::New(isolate(), 0, TENURED);
slow_element_dictionary->set_requires_slow_elements();
AllocationResult Heap::CopyJSObject(JSObject* source, AllocationSite* site) {
- // Never used to copy functions. If functions need to be copied we
- // have to be careful to clear the literals array.
- SLOW_DCHECK(!source->IsJSFunction());
-
// Make the clone.
Map* map = source->map();
+
+ // We can only clone normal objects or arrays. Copying anything else
+ // will break invariants.
+ CHECK(map->instance_type() == JS_OBJECT_TYPE ||
+ map->instance_type() == JS_ARRAY_TYPE);
+
int object_size = map->instance_size();
HeapObject* clone;
}
-void Heap::AdvanceIdleIncrementalMarking(intptr_t step_size) {
- incremental_marking()->Step(step_size,
- IncrementalMarking::NO_GC_VIA_STACK_GUARD, true);
+void Heap::IdleMarkCompact(const char* message) {
+ bool uncommit = false;
+ if (gc_count_at_last_idle_gc_ == gc_count_) {
+ // No GC since the last full GC, the mutator is probably not active.
+ isolate_->compilation_cache()->Clear();
+ uncommit = true;
+ }
+ CollectAllGarbage(kReduceMemoryFootprintMask, message);
+ gc_idle_time_handler_.NotifyIdleMarkCompact();
+ gc_count_at_last_idle_gc_ = gc_count_;
+ if (uncommit) {
+ new_space_.Shrink();
+ UncommitFromSpace();
+ }
+}
- if (incremental_marking()->IsComplete()) {
- bool uncommit = false;
- if (gc_count_at_last_idle_gc_ == gc_count_) {
- // No GC since the last full GC, the mutator is probably not active.
- isolate_->compilation_cache()->Clear();
- uncommit = true;
- }
- CollectAllGarbage(kReduceMemoryFootprintMask,
- "idle notification: finalize incremental");
- gc_idle_time_handler_.NotifyIdleMarkCompact();
- gc_count_at_last_idle_gc_ = gc_count_;
- if (uncommit) {
- new_space_.Shrink();
- UncommitFromSpace();
- }
+
+void Heap::TryFinalizeIdleIncrementalMarking(
+ size_t idle_time_in_ms, size_t size_of_objects,
+ size_t mark_compact_speed_in_bytes_per_ms) {
+ if (incremental_marking()->IsComplete() ||
+ (mark_compact_collector()->IsMarkingDequeEmpty() &&
+ gc_idle_time_handler_.ShouldDoMarkCompact(
+ idle_time_in_ms, size_of_objects,
+ mark_compact_speed_in_bytes_per_ms))) {
+ IdleMarkCompact("idle notification: finalize incremental");
}
}
tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
heap_state.scavenge_speed_in_bytes_per_ms =
static_cast<size_t>(tracer()->ScavengeSpeedInBytesPerMillisecond());
- heap_state.available_new_space_memory = new_space_.Available();
+ heap_state.used_new_space_size = new_space_.Size();
heap_state.new_space_capacity = new_space_.Capacity();
heap_state.new_space_allocation_throughput_in_bytes_per_ms =
static_cast<size_t>(
gc_idle_time_handler_.Compute(idle_time_in_ms, heap_state);
bool result = false;
+ int actual_time_in_ms = 0;
switch (action.type) {
case DONE:
result = true;
break;
- case DO_INCREMENTAL_MARKING:
+ case DO_INCREMENTAL_MARKING: {
if (incremental_marking()->IsStopped()) {
incremental_marking()->Start();
}
- AdvanceIdleIncrementalMarking(action.parameter);
+ incremental_marking()->Step(action.parameter,
+ IncrementalMarking::NO_GC_VIA_STACK_GUARD,
+ IncrementalMarking::FORCE_MARKING,
+ IncrementalMarking::DO_NOT_FORCE_COMPLETION);
+ actual_time_in_ms = static_cast<int>(timer.Elapsed().InMilliseconds());
+ int remaining_idle_time_in_ms = idle_time_in_ms - actual_time_in_ms;
+ if (remaining_idle_time_in_ms > 0) {
+ TryFinalizeIdleIncrementalMarking(
+ remaining_idle_time_in_ms, heap_state.size_of_objects,
+ heap_state.mark_compact_speed_in_bytes_per_ms);
+ }
break;
+ }
case DO_FULL_GC: {
HistogramTimerScope scope(isolate_->counters()->gc_context());
- const char* message = contexts_disposed_
- ? "idle notification: contexts disposed"
- : "idle notification: finalize idle round";
- CollectAllGarbage(kReduceMemoryFootprintMask, message);
- gc_idle_time_handler_.NotifyIdleMarkCompact();
+ if (contexts_disposed_) {
+ CollectAllGarbage(kReduceMemoryFootprintMask,
+ "idle notification: contexts disposed");
+ gc_idle_time_handler_.NotifyIdleMarkCompact();
+ gc_count_at_last_idle_gc_ = gc_count_;
+ } else {
+ IdleMarkCompact("idle notification: finalize idle round");
+ }
break;
}
case DO_SCAVENGE:
break;
}
- int actual_time_ms = static_cast<int>(timer.Elapsed().InMilliseconds());
- if (actual_time_ms <= idle_time_in_ms) {
+ actual_time_in_ms = static_cast<int>(timer.Elapsed().InMilliseconds());
+ if (actual_time_in_ms <= idle_time_in_ms) {
if (action.type != DONE && action.type != DO_NOTHING) {
isolate()->counters()->gc_idle_time_limit_undershot()->AddSample(
- idle_time_in_ms - actual_time_ms);
+ idle_time_in_ms - actual_time_in_ms);
}
} else {
isolate()->counters()->gc_idle_time_limit_overshot()->AddSample(
- actual_time_ms - idle_time_in_ms);
+ actual_time_in_ms - idle_time_in_ms);
}
if (FLAG_trace_idle_notification) {
PrintF("Idle notification: requested idle time %d ms, actual time %d ms [",
- idle_time_in_ms, actual_time_ms);
+ idle_time_in_ms, actual_time_in_ms);
action.Print();
PrintF("]\n");
}
return property_cell_space_->Contains(addr);
case LO_SPACE:
return lo_space_->SlowContains(addr);
- case INVALID_SPACE:
- break;
}
UNREACHABLE();
return false;
}
+bool Heap::RootIsImmortalImmovable(int root_index) {
+ switch (root_index) {
+#define CASE(name) \
+ case Heap::k##name##RootIndex: \
+ return true;
+ IMMORTAL_IMMOVABLE_ROOT_LIST(CASE);
+#undef CASE
+ default:
+ return false;
+ }
+}
+
+
#ifdef VERIFY_HEAP
void Heap::Verify() {
CHECK(HasBeenSetUp());
initial_semispace_size_ = max_semi_space_size_;
if (FLAG_trace_gc) {
PrintPID(
- "Min semi-space size cannot be more than the maximum"
+ "Min semi-space size cannot be more than the maximum "
"semi-space size of %d MB\n",
- max_semi_space_size_);
+ max_semi_space_size_ / MB);
}
} else {
initial_semispace_size_ = initial_semispace_size;
initial_semispace_size_ = Min(initial_semispace_size_, max_semi_space_size_);
+ if (FLAG_target_semi_space_size > 0) {
+ int target_semispace_size = FLAG_target_semi_space_size * MB;
+ if (target_semispace_size < initial_semispace_size_) {
+ target_semispace_size_ = initial_semispace_size_;
+ if (FLAG_trace_gc) {
+ PrintPID(
+ "Target semi-space size cannot be less than the minimum "
+ "semi-space size of %d MB\n",
+ initial_semispace_size_ / MB);
+ }
+ } else if (target_semispace_size > max_semi_space_size_) {
+ target_semispace_size_ = max_semi_space_size_;
+ if (FLAG_trace_gc) {
+ PrintPID(
+ "Target semi-space size cannot be less than the maximum "
+ "semi-space size of %d MB\n",
+ max_semi_space_size_ / MB);
+ }
+ } else {
+ target_semispace_size_ = target_semispace_size;
+ }
+ }
+
+ target_semispace_size_ = Max(initial_semispace_size_, target_semispace_size_);
+
// The old generation is paged and needs at least one page for each space.
int paged_space_count = LAST_PAGED_SPACE - FIRST_PAGED_SPACE + 1;
max_old_generation_size_ =
}
+void Heap::NotifyDeserializationComplete() { deserialization_complete_ = true; }
+
+
void Heap::TearDown() {
#ifdef VERIFY_HEAP
if (FLAG_verify_heap) {
PrintF("total_gc_time=%.1f ", total_gc_time_ms_);
PrintF("min_in_mutator=%.1f ", get_min_in_mutator());
PrintF("max_alive_after_gc=%" V8_PTR_PREFIX "d ", get_max_alive_after_gc());
- PrintF("total_marking_time=%.1f ", tracer_.cumulative_sweeping_duration());
+ PrintF("total_marking_time=%.1f ", tracer_.cumulative_marking_duration());
PrintF("total_sweeping_time=%.1f ", tracer_.cumulative_sweeping_duration());
PrintF("\n\n");
}
+++ /dev/null
-# 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.
-
-{
- 'variables': {
- 'v8_code': 1,
- },
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
- 'targets': [
- {
- 'target_name': 'heap-unittests',
- 'type': 'executable',
- 'dependencies': [
- '../../testing/gtest.gyp:gtest',
- '../../testing/gtest.gyp:gtest_main',
- '../../tools/gyp/v8.gyp:v8_libplatform',
- ],
- 'include_dirs': [
- '../..',
- ],
- 'sources': [ ### gcmole(all) ###
- 'gc-idle-time-handler-unittest.cc',
- ],
- 'conditions': [
- ['component=="shared_library"', {
- # heap-unittests can't be built against a shared library, so we
- # need to depend on the underlying static target in that case.
- 'conditions': [
- ['v8_use_snapshot=="true"', {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8_snapshot'],
- },
- {
- 'dependencies': [
- '../../tools/gyp/v8.gyp:v8_nosnapshot',
- ],
- }],
- ],
- }, {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8'],
- }],
- ['os_posix == 1', {
- # TODO(svenpanne): This is a temporary work-around to fix the warnings
- # that show up because we use -std=gnu++0x instead of -std=c++11.
- 'cflags!': [
- '-pedantic',
- ],
- }],
- ],
- },
- ],
-}
V(Map, fixed_cow_array_map, FixedCOWArrayMap) \
V(Map, fixed_double_array_map, FixedDoubleArrayMap) \
V(Map, constant_pool_array_map, ConstantPoolArrayMap) \
+ V(Map, weak_cell_map, WeakCellMap) \
V(Oddball, no_interceptor_result_sentinel, NoInterceptorResultSentinel) \
V(Map, hash_table_map, HashTableMap) \
V(Map, ordered_hash_table_map, OrderedHashTableMap) \
V(Map, external_string_with_one_byte_data_map, \
ExternalStringWithOneByteDataMap) \
V(Map, external_one_byte_string_map, ExternalOneByteStringMap) \
+ V(Map, native_source_string_map, NativeSourceStringMap) \
V(Map, short_external_string_map, ShortExternalStringMap) \
V(Map, short_external_string_with_one_byte_data_map, \
ShortExternalStringWithOneByteDataMap) \
V(JSObject, observation_state, ObservationState) \
V(Map, external_map, ExternalMap) \
V(Object, symbol_registry, SymbolRegistry) \
- V(Symbol, frozen_symbol, FrozenSymbol) \
- V(Symbol, nonexistent_symbol, NonExistentSymbol) \
- V(Symbol, elements_transition_symbol, ElementsTransitionSymbol) \
V(SeededNumberDictionary, empty_slow_element_dictionary, \
EmptySlowElementDictionary) \
- V(Symbol, observed_symbol, ObservedSymbol) \
- V(Symbol, uninitialized_symbol, UninitializedSymbol) \
- V(Symbol, megamorphic_symbol, MegamorphicSymbol) \
- V(Symbol, premonomorphic_symbol, PremonomorphicSymbol) \
- V(Symbol, generic_symbol, GenericSymbol) \
- V(Symbol, stack_trace_symbol, StackTraceSymbol) \
- V(Symbol, detailed_stack_trace_symbol, DetailedStackTraceSymbol) \
- V(Symbol, normal_ic_symbol, NormalICSymbol) \
- V(Symbol, home_object_symbol, HomeObjectSymbol) \
V(FixedArray, materialized_objects, MaterializedObjects) \
V(FixedArray, allocation_sites_scratchpad, AllocationSitesScratchpad) \
V(FixedArray, microtask_queue, MicrotaskQueue)
SMI_ROOT_LIST(V) \
V(StringTable, string_table, StringTable)
+#define INTERNALIZED_STRING_LIST(V) \
+ V(Object_string, "Object") \
+ V(proto_string, "__proto__") \
+ V(arguments_string, "arguments") \
+ V(Arguments_string, "Arguments") \
+ V(caller_string, "caller") \
+ V(boolean_string, "boolean") \
+ V(Boolean_string, "Boolean") \
+ V(callee_string, "callee") \
+ V(constructor_string, "constructor") \
+ V(dot_result_string, ".result") \
+ V(dot_for_string, ".for.") \
+ V(eval_string, "eval") \
+ V(empty_string, "") \
+ V(function_string, "function") \
+ V(Function_string, "Function") \
+ V(length_string, "length") \
+ V(name_string, "name") \
+ V(null_string, "null") \
+ V(number_string, "number") \
+ V(Number_string, "Number") \
+ V(nan_string, "NaN") \
+ V(source_string, "source") \
+ V(source_url_string, "source_url") \
+ V(source_mapping_url_string, "source_mapping_url") \
+ V(global_string, "global") \
+ V(ignore_case_string, "ignoreCase") \
+ V(multiline_string, "multiline") \
+ V(sticky_string, "sticky") \
+ V(harmony_regexps_string, "harmony_regexps") \
+ V(input_string, "input") \
+ V(index_string, "index") \
+ V(last_index_string, "lastIndex") \
+ V(object_string, "object") \
+ V(prototype_string, "prototype") \
+ V(string_string, "string") \
+ V(String_string, "String") \
+ V(symbol_string, "symbol") \
+ V(Symbol_string, "Symbol") \
+ V(Map_string, "Map") \
+ V(Set_string, "Set") \
+ V(WeakMap_string, "WeakMap") \
+ V(WeakSet_string, "WeakSet") \
+ V(for_string, "for") \
+ V(for_api_string, "for_api") \
+ V(for_intern_string, "for_intern") \
+ V(private_api_string, "private_api") \
+ V(private_intern_string, "private_intern") \
+ V(Date_string, "Date") \
+ V(char_at_string, "CharAt") \
+ V(undefined_string, "undefined") \
+ V(value_of_string, "valueOf") \
+ V(stack_string, "stack") \
+ V(toJSON_string, "toJSON") \
+ V(KeyedLoadMonomorphic_string, "KeyedLoadMonomorphic") \
+ V(KeyedStoreMonomorphic_string, "KeyedStoreMonomorphic") \
+ V(stack_overflow_string, "kStackOverflowBoilerplate") \
+ V(illegal_access_string, "illegal access") \
+ V(cell_value_string, "%cell_value") \
+ V(illegal_argument_string, "illegal argument") \
+ V(identity_hash_string, "v8::IdentityHash") \
+ V(closure_string, "(closure)") \
+ V(dot_string, ".") \
+ V(compare_ic_string, "==") \
+ V(strict_compare_ic_string, "===") \
+ V(infinity_string, "Infinity") \
+ V(minus_infinity_string, "-Infinity") \
+ V(query_colon_string, "(?:)") \
+ V(Generator_string, "Generator") \
+ V(throw_string, "throw") \
+ V(done_string, "done") \
+ V(value_string, "value") \
+ V(next_string, "next") \
+ V(byte_length_string, "byteLength") \
+ V(byte_offset_string, "byteOffset") \
+ V(minus_zero_string, "-0") \
+ V(Array_string, "Array") \
+ V(Error_string, "Error") \
+ V(RegExp_string, "RegExp")
+
+#define PRIVATE_SYMBOL_LIST(V) \
+ V(frozen_symbol) \
+ V(nonexistent_symbol) \
+ V(elements_transition_symbol) \
+ V(observed_symbol) \
+ V(uninitialized_symbol) \
+ V(megamorphic_symbol) \
+ V(premonomorphic_symbol) \
+ V(generic_symbol) \
+ V(stack_trace_symbol) \
+ V(detailed_stack_trace_symbol) \
+ V(normal_ic_symbol) \
+ V(home_object_symbol) \
+ V(intl_initialized_marker_symbol) \
+ V(intl_impl_object_symbol) \
+ V(promise_debug_marker_symbol) \
+ V(promise_has_handler_symbol) \
+ V(class_script_symbol) \
+ V(class_start_position_symbol) \
+ V(class_end_position_symbol)
+
// Heap roots that are known to be immortal immovable, for which we can safely
-// skip write barriers.
+// skip write barriers. This list is not complete and has omissions.
#define IMMORTAL_IMMOVABLE_ROOT_LIST(V) \
- V(byte_array_map) \
- V(free_space_map) \
- V(one_pointer_filler_map) \
- V(two_pointer_filler_map) \
- V(undefined_value) \
- V(the_hole_value) \
- V(null_value) \
- V(true_value) \
- V(false_value) \
- V(uninitialized_value) \
- V(cell_map) \
- V(global_property_cell_map) \
- V(shared_function_info_map) \
- V(meta_map) \
- V(heap_number_map) \
- V(mutable_heap_number_map) \
- V(native_context_map) \
- V(fixed_array_map) \
- V(code_map) \
- V(scope_info_map) \
- V(fixed_cow_array_map) \
- V(fixed_double_array_map) \
- V(constant_pool_array_map) \
- V(no_interceptor_result_sentinel) \
- V(hash_table_map) \
- V(ordered_hash_table_map) \
- V(empty_fixed_array) \
- V(empty_byte_array) \
- V(empty_descriptor_array) \
- V(empty_constant_pool_array) \
- V(arguments_marker) \
- V(symbol_map) \
- V(sloppy_arguments_elements_map) \
- V(function_context_map) \
- V(catch_context_map) \
- V(with_context_map) \
- V(block_context_map) \
- V(module_context_map) \
- V(global_context_map) \
- V(undefined_map) \
- V(the_hole_map) \
- V(null_map) \
- V(boolean_map) \
- V(uninitialized_map) \
- V(message_object_map) \
- V(foreign_map) \
- V(neander_map)
-
-#define INTERNALIZED_STRING_LIST(V) \
- V(Object_string, "Object") \
- V(proto_string, "__proto__") \
- V(arguments_string, "arguments") \
- V(Arguments_string, "Arguments") \
- V(caller_string, "caller") \
- V(boolean_string, "boolean") \
- V(Boolean_string, "Boolean") \
- V(callee_string, "callee") \
- V(constructor_string, "constructor") \
- V(dot_result_string, ".result") \
- V(dot_for_string, ".for.") \
- V(eval_string, "eval") \
- V(empty_string, "") \
- V(function_string, "function") \
- V(Function_string, "Function") \
- V(length_string, "length") \
- V(name_string, "name") \
- V(null_string, "null") \
- V(number_string, "number") \
- V(Number_string, "Number") \
- V(nan_string, "NaN") \
- V(source_string, "source") \
- V(source_url_string, "source_url") \
- V(source_mapping_url_string, "source_mapping_url") \
- V(global_string, "global") \
- V(ignore_case_string, "ignoreCase") \
- V(multiline_string, "multiline") \
- V(sticky_string, "sticky") \
- V(harmony_regexps_string, "harmony_regexps") \
- V(input_string, "input") \
- V(index_string, "index") \
- V(last_index_string, "lastIndex") \
- V(object_string, "object") \
- V(prototype_string, "prototype") \
- V(string_string, "string") \
- V(String_string, "String") \
- V(symbol_string, "symbol") \
- V(Symbol_string, "Symbol") \
- V(Map_string, "Map") \
- V(Set_string, "Set") \
- V(WeakMap_string, "WeakMap") \
- V(WeakSet_string, "WeakSet") \
- V(for_string, "for") \
- V(for_api_string, "for_api") \
- V(for_intern_string, "for_intern") \
- V(private_api_string, "private_api") \
- V(private_intern_string, "private_intern") \
- V(Date_string, "Date") \
- V(char_at_string, "CharAt") \
- V(undefined_string, "undefined") \
- V(value_of_string, "valueOf") \
- V(stack_string, "stack") \
- V(toJSON_string, "toJSON") \
- V(KeyedLoadMonomorphic_string, "KeyedLoadMonomorphic") \
- V(KeyedStoreMonomorphic_string, "KeyedStoreMonomorphic") \
- V(stack_overflow_string, "kStackOverflowBoilerplate") \
- V(illegal_access_string, "illegal access") \
- V(cell_value_string, "%cell_value") \
- V(illegal_argument_string, "illegal argument") \
- V(identity_hash_string, "v8::IdentityHash") \
- V(closure_string, "(closure)") \
- V(dot_string, ".") \
- V(compare_ic_string, "==") \
- V(strict_compare_ic_string, "===") \
- V(infinity_string, "Infinity") \
- V(minus_infinity_string, "-Infinity") \
- V(query_colon_string, "(?:)") \
- V(Generator_string, "Generator") \
- V(throw_string, "throw") \
- V(done_string, "done") \
- V(value_string, "value") \
- V(next_string, "next") \
- V(byte_length_string, "byteLength") \
- V(byte_offset_string, "byteOffset") \
- V(intl_initialized_marker_string, "v8::intl_initialized_marker") \
- V(intl_impl_object_string, "v8::intl_object")
+ V(ByteArrayMap) \
+ V(FreeSpaceMap) \
+ V(OnePointerFillerMap) \
+ V(TwoPointerFillerMap) \
+ V(UndefinedValue) \
+ V(TheHoleValue) \
+ V(NullValue) \
+ V(TrueValue) \
+ V(FalseValue) \
+ V(UninitializedValue) \
+ V(CellMap) \
+ V(GlobalPropertyCellMap) \
+ V(SharedFunctionInfoMap) \
+ V(MetaMap) \
+ V(HeapNumberMap) \
+ V(MutableHeapNumberMap) \
+ V(NativeContextMap) \
+ V(FixedArrayMap) \
+ V(CodeMap) \
+ V(ScopeInfoMap) \
+ V(FixedCOWArrayMap) \
+ V(FixedDoubleArrayMap) \
+ V(ConstantPoolArrayMap) \
+ V(WeakCellMap) \
+ V(NoInterceptorResultSentinel) \
+ V(HashTableMap) \
+ V(OrderedHashTableMap) \
+ V(EmptyFixedArray) \
+ V(EmptyByteArray) \
+ V(EmptyDescriptorArray) \
+ V(EmptyConstantPoolArray) \
+ V(ArgumentsMarker) \
+ V(SymbolMap) \
+ V(SloppyArgumentsElementsMap) \
+ V(FunctionContextMap) \
+ V(CatchContextMap) \
+ V(WithContextMap) \
+ V(BlockContextMap) \
+ V(ModuleContextMap) \
+ V(GlobalContextMap) \
+ V(UndefinedMap) \
+ V(TheHoleMap) \
+ V(NullMap) \
+ V(BooleanMap) \
+ V(UninitializedMap) \
+ V(ArgumentsMarkerMap) \
+ V(JSMessageObjectMap) \
+ V(ForeignMap) \
+ V(NeanderMap) \
+ PRIVATE_SYMBOL_LIST(V)
// Forward declarations.
class HeapStats;
// jslimit_/real_jslimit_ variable in the StackGuard.
void SetStackLimits();
+ // Notifies the heap that is ok to start marking or other activities that
+ // should not happen during deserialization.
+ void NotifyDeserializationComplete();
+
// Returns whether SetUp has been called.
bool HasBeenSetUp();
int MaxSemiSpaceSize() { return max_semi_space_size_; }
int ReservedSemiSpaceSize() { return reserved_semispace_size_; }
int InitialSemiSpaceSize() { return initial_semispace_size_; }
+ int TargetSemiSpaceSize() { return target_semispace_size_; }
intptr_t MaxOldGenerationSize() { return max_old_generation_size_; }
intptr_t MaxExecutableSize() { return max_executable_size_; }
INTERNALIZED_STRING_LIST(STRING_ACCESSOR)
#undef STRING_ACCESSOR
+#define SYMBOL_ACCESSOR(name) \
+ Symbol* name() { return Symbol::cast(roots_[k##name##RootIndex]); }
+ PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR)
+#undef SYMBOL_ACCESSOR
+
// The hidden_string is special because it is the empty string, but does
// not match the empty string.
String* hidden_string() { return hidden_string_; }
return encountered_weak_collections_;
}
+ void set_encountered_weak_cells(Object* weak_cell) {
+ encountered_weak_cells_ = weak_cell;
+ }
+ Object* encountered_weak_cells() const { return encountered_weak_cells_; }
+
// Number of mark-sweeps.
unsigned int ms_count() { return ms_count_; }
return reinterpret_cast<Address*>(&roots_[kStoreBufferTopRootIndex]);
}
+ static bool RootIsImmortalImmovable(int root_index);
+
#ifdef VERIFY_HEAP
// Verify the heap is in its normal state before or after a GC.
void Verify();
// Support for partial snapshots. After calling this we have a linear
// space to write objects in each space.
- void ReserveSpace(int* sizes, Address* addresses);
+ struct Chunk {
+ uint32_t size;
+ Address start;
+ Address end;
+ };
+
+ typedef List<Chunk> Reservation;
+
+ // Returns false if not able to reserve.
+ bool ReserveSpace(Reservation* reservations);
//
// Support for the API.
INTERNALIZED_STRING_LIST(STRING_INDEX_DECLARATION)
#undef STRING_DECLARATION
+#define SYMBOL_INDEX_DECLARATION(name) k##name##RootIndex,
+ PRIVATE_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION)
+#undef SYMBOL_INDEX_DECLARATION
+
// Utility type maps
#define DECLARE_STRUCT_MAP(NAME, Name, name) k##Name##MapRootIndex,
STRUCT_LIST(DECLARE_STRUCT_MAP)
kSmiRootsStart = kStringTableRootIndex + 1
};
+ Object* root(RootListIndex index) { return roots_[index]; }
+
STATIC_ASSERT(kUndefinedValueRootIndex ==
Internals::kUndefinedValueRootIndex);
STATIC_ASSERT(kNullValueRootIndex == Internals::kNullValueRootIndex);
inline void OnMoveEvent(HeapObject* target, HeapObject* source,
int size_in_bytes);
+ bool deserialization_complete() const { return deserialization_complete_; }
+
protected:
// Methods made available to tests.
int reserved_semispace_size_;
int max_semi_space_size_;
int initial_semispace_size_;
+ int target_semispace_size_;
intptr_t max_old_generation_size_;
intptr_t max_executable_size_;
intptr_t maximum_committed_;
// contains Smi(0) while marking is not active.
Object* encountered_weak_collections_;
+ Object* encountered_weak_cells_;
+
StoreBufferRebuilder store_buffer_rebuilder_;
struct StringTypeTable {
// Allocate a tenured JS global property cell initialized with the hole.
MUST_USE_RESULT AllocationResult AllocatePropertyCell();
+ MUST_USE_RESULT AllocationResult AllocateWeakCell(HeapObject* value);
+
// Allocates a new utility object in the old generation.
MUST_USE_RESULT AllocationResult AllocateStruct(InstanceType type);
void SelectScavengingVisitorsTable();
- void AdvanceIdleIncrementalMarking(intptr_t step_size);
+ void IdleMarkCompact(const char* message);
+
+ void TryFinalizeIdleIncrementalMarking(
+ size_t idle_time_in_ms, size_t size_of_objects,
+ size_t mark_compact_speed_in_bytes_per_ms);
bool WorthActivatingIncrementalMarking();
int gc_callbacks_depth_;
+ bool deserialization_complete_;
+
friend class AlwaysAllocateScope;
friend class Deserializer;
friend class Factory;
should_hurry_(false),
marking_speed_(0),
allocated_(0),
+ idle_marking_delay_counter_(0),
no_marking_scope_depth_(0),
unscanned_bytes_of_large_object_(0) {}
// 3) when we are currently not serializing or deserializing the heap.
return FLAG_incremental_marking && FLAG_incremental_marking_steps &&
heap_->gc_state() == Heap::NOT_IN_GC &&
+ heap_->deserialization_complete() &&
!heap_->isolate()->serializer_enabled() &&
- heap_->isolate()->IsInitialized() &&
heap_->PromotedSpaceSizeOfObjects() > kActivationThreshold;
}
DCHECK(state_ == STOPPED);
DCHECK(heap_->gc_state() == Heap::NOT_IN_GC);
DCHECK(!heap_->isolate()->serializer_enabled());
- DCHECK(heap_->isolate()->IsInitialized());
ResetStepCounters();
}
-void IncrementalMarking::Step(intptr_t allocated_bytes, CompletionAction action,
- bool force_marking) {
+intptr_t IncrementalMarking::Step(intptr_t allocated_bytes,
+ CompletionAction action,
+ ForceMarkingAction marking,
+ ForceCompletionAction completion) {
if (heap_->gc_state() != Heap::NOT_IN_GC || !FLAG_incremental_marking ||
!FLAG_incremental_marking_steps ||
(state_ != SWEEPING && state_ != MARKING)) {
- return;
+ return 0;
}
allocated_ += allocated_bytes;
- if (!force_marking && allocated_ < kAllocatedThreshold &&
+ if (marking == DO_NOT_FORCE_MARKING && allocated_ < kAllocatedThreshold &&
write_barriers_invoked_since_last_step_ <
kWriteBarriersInvokedThreshold) {
- return;
+ return 0;
}
- if (state_ == MARKING && no_marking_scope_depth_ > 0) return;
+ if (state_ == MARKING && no_marking_scope_depth_ > 0) return 0;
+ intptr_t bytes_processed = 0;
{
HistogramTimerScope incremental_marking_scope(
heap_->isolate()->counters()->gc_incremental_marking());
write_barriers_invoked_since_last_step_ = 0;
bytes_scanned_ += bytes_to_process;
- intptr_t bytes_processed = 0;
if (state_ == SWEEPING) {
if (heap_->mark_compact_collector()->sweeping_in_progress() &&
}
} else if (state_ == MARKING) {
bytes_processed = ProcessMarkingDeque(bytes_to_process);
- if (marking_deque_.IsEmpty()) MarkingComplete(action);
+ if (marking_deque_.IsEmpty()) {
+ if (completion == FORCE_COMPLETION ||
+ IsIdleMarkingDelayCounterLimitReached()) {
+ MarkingComplete(action);
+ } else {
+ IncrementIdleMarkingDelayCounter();
+ }
+ }
}
steps_count_++;
// process the marking deque.
heap_->tracer()->AddIncrementalMarkingStep(duration, bytes_processed);
}
+ return bytes_processed;
}
int64_t IncrementalMarking::SpaceLeftInOldSpace() {
return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
}
+
+
+bool IncrementalMarking::IsIdleMarkingDelayCounterLimitReached() {
+ return idle_marking_delay_counter_ > kMaxIdleMarkingDelayCounter;
+}
+
+
+void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
+ idle_marking_delay_counter_++;
+}
+
+
+void IncrementalMarking::ClearIdleMarkingDelayCounter() {
+ idle_marking_delay_counter_ = 0;
+}
}
} // namespace v8::internal
enum CompletionAction { GC_VIA_STACK_GUARD, NO_GC_VIA_STACK_GUARD };
+ enum ForceMarkingAction { FORCE_MARKING, DO_NOT_FORCE_MARKING };
+
+ enum ForceCompletionAction { FORCE_COMPLETION, DO_NOT_FORCE_COMPLETION };
+
explicit IncrementalMarking(Heap* heap);
static void Initialize();
static const intptr_t kMarkingSpeedAccelleration = 2;
static const intptr_t kMaxMarkingSpeed = 1000;
+ // This is the upper bound for how many times we allow finalization of
+ // incremental marking to be postponed.
+ static const size_t kMaxIdleMarkingDelayCounter = 3;
+
void OldSpaceStep(intptr_t allocated);
- void Step(intptr_t allocated, CompletionAction action,
- bool force_marking = false);
+ intptr_t Step(intptr_t allocated, CompletionAction action,
+ ForceMarkingAction marking = DO_NOT_FORCE_MARKING,
+ ForceCompletionAction completion = FORCE_COMPLETION);
inline void RestartIfNotMarking() {
if (state_ == COMPLETE) {
unscanned_bytes_of_large_object_ = unscanned_bytes;
}
+ void ClearIdleMarkingDelayCounter();
+
+ bool IsIdleMarkingDelayCounterLimitReached();
+
private:
int64_t SpaceLeftInOldSpace();
INLINE(void VisitObject(Map* map, HeapObject* obj, int size));
+ void IncrementIdleMarkingDelayCounter();
+
Heap* heap_;
State state_;
intptr_t bytes_scanned_;
intptr_t allocated_;
intptr_t write_barriers_invoked_since_last_step_;
+ size_t idle_marking_delay_counter_;
int no_marking_scope_depth_;
#include "src/heap/objects-visiting.h"
#include "src/heap/objects-visiting-inl.h"
#include "src/heap/spaces-inl.h"
-#include "src/heap/sweeper-thread.h"
#include "src/heap-profiler.h"
#include "src/ic/ic.h"
#include "src/ic/stub-cache.h"
#endif // VERIFY_HEAP
-#ifdef DEBUG
-class VerifyNativeContextSeparationVisitor : public ObjectVisitor {
- public:
- VerifyNativeContextSeparationVisitor() : current_native_context_(NULL) {}
-
- void VisitPointers(Object** start, Object** end) {
- for (Object** current = start; current < end; current++) {
- if ((*current)->IsHeapObject()) {
- HeapObject* object = HeapObject::cast(*current);
- if (object->IsString()) continue;
- switch (object->map()->instance_type()) {
- case JS_FUNCTION_TYPE:
- CheckContext(JSFunction::cast(object)->context());
- break;
- case JS_GLOBAL_PROXY_TYPE:
- CheckContext(JSGlobalProxy::cast(object)->native_context());
- break;
- case JS_GLOBAL_OBJECT_TYPE:
- case JS_BUILTINS_OBJECT_TYPE:
- CheckContext(GlobalObject::cast(object)->native_context());
- break;
- case JS_ARRAY_TYPE:
- case JS_DATE_TYPE:
- case JS_OBJECT_TYPE:
- case JS_REGEXP_TYPE:
- VisitPointer(HeapObject::RawField(object, JSObject::kMapOffset));
- break;
- case MAP_TYPE:
- VisitPointer(HeapObject::RawField(object, Map::kPrototypeOffset));
- VisitPointer(HeapObject::RawField(object, Map::kConstructorOffset));
- break;
- case FIXED_ARRAY_TYPE:
- if (object->IsContext()) {
- CheckContext(object);
- } else {
- FixedArray* array = FixedArray::cast(object);
- int length = array->length();
- // Set array length to zero to prevent cycles while iterating
- // over array bodies, this is easier than intrusive marking.
- array->set_length(0);
- array->IterateBody(FIXED_ARRAY_TYPE, FixedArray::SizeFor(length),
- this);
- array->set_length(length);
- }
- break;
- case CELL_TYPE:
- case JS_PROXY_TYPE:
- case JS_VALUE_TYPE:
- case TYPE_FEEDBACK_INFO_TYPE:
- object->Iterate(this);
- break;
- case DECLARED_ACCESSOR_INFO_TYPE:
- case EXECUTABLE_ACCESSOR_INFO_TYPE:
- case BYTE_ARRAY_TYPE:
- case CALL_HANDLER_INFO_TYPE:
- case CODE_TYPE:
- case FIXED_DOUBLE_ARRAY_TYPE:
- case HEAP_NUMBER_TYPE:
- case MUTABLE_HEAP_NUMBER_TYPE:
- case INTERCEPTOR_INFO_TYPE:
- case ODDBALL_TYPE:
- case SCRIPT_TYPE:
- case SHARED_FUNCTION_INFO_TYPE:
- break;
- default:
- UNREACHABLE();
- }
- }
- }
- }
-
- private:
- void CheckContext(Object* context) {
- if (!context->IsContext()) return;
- Context* native_context = Context::cast(context)->native_context();
- if (current_native_context_ == NULL) {
- current_native_context_ = native_context;
- } else {
- CHECK_EQ(current_native_context_, native_context);
- }
- }
-
- Context* current_native_context_;
-};
-
-
-static void VerifyNativeContextSeparation(Heap* heap) {
- HeapObjectIterator it(heap->code_space());
-
- for (Object* object = it.Next(); object != NULL; object = it.Next()) {
- VerifyNativeContextSeparationVisitor visitor;
- Code::cast(object)->CodeIterateBody(&visitor);
- }
-}
-#endif
-
-
void MarkCompactCollector::SetUp() {
free_list_old_data_space_.Reset(new FreeList(heap_->old_data_space()));
free_list_old_pointer_space_.Reset(new FreeList(heap_->old_pointer_space()));
if (FLAG_collect_maps) ClearNonLiveReferences();
+ ProcessAndClearWeakCells();
+
ClearWeakCollections();
+ heap_->set_encountered_weak_cells(Smi::FromInt(0));
+
#ifdef VERIFY_HEAP
if (FLAG_verify_heap) {
VerifyMarking(heap_);
SweepSpaces();
-#ifdef DEBUG
- if (FLAG_verify_native_context_separation) {
- VerifyNativeContextSeparation(heap_);
- }
-#endif
-
#ifdef VERIFY_HEAP
if (heap()->weak_embedded_objects_verification_enabled()) {
VerifyWeakEmbeddedObjectsInCode();
void MarkCompactCollector::StartSweeperThreads() {
DCHECK(free_list_old_pointer_space_.get()->IsEmpty());
DCHECK(free_list_old_data_space_.get()->IsEmpty());
- sweeping_in_progress_ = true;
- for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
- isolate()->sweeper_threads()[i]->StartSweeping();
- }
- if (FLAG_job_based_sweeping) {
- V8::GetCurrentPlatform()->CallOnBackgroundThread(
- new SweeperTask(heap(), heap()->old_data_space()),
- v8::Platform::kShortRunningTask);
- V8::GetCurrentPlatform()->CallOnBackgroundThread(
- new SweeperTask(heap(), heap()->old_pointer_space()),
- v8::Platform::kShortRunningTask);
- }
+ V8::GetCurrentPlatform()->CallOnBackgroundThread(
+ new SweeperTask(heap(), heap()->old_data_space()),
+ v8::Platform::kShortRunningTask);
+ V8::GetCurrentPlatform()->CallOnBackgroundThread(
+ new SweeperTask(heap(), heap()->old_pointer_space()),
+ v8::Platform::kShortRunningTask);
}
void MarkCompactCollector::EnsureSweepingCompleted() {
DCHECK(sweeping_in_progress_ == true);
- // If sweeping is not completed, we try to complete it here. If we do not
- // have sweeper threads we have to complete since we do not have a good
- // indicator for a swept space in that case.
- if (!AreSweeperThreadsActivated() || !IsSweepingCompleted()) {
+ // If sweeping is not completed or not running at all, we try to complete it
+ // here.
+ if (FLAG_predictable || !IsSweepingCompleted()) {
SweepInParallel(heap()->paged_space(OLD_DATA_SPACE), 0);
SweepInParallel(heap()->paged_space(OLD_POINTER_SPACE), 0);
}
-
- for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
- isolate()->sweeper_threads()[i]->WaitForSweeperThread();
- }
- if (FLAG_job_based_sweeping) {
- // Wait twice for both jobs.
+ // Wait twice for both jobs.
+ if (!FLAG_predictable) {
pending_sweeper_jobs_semaphore_.Wait();
pending_sweeper_jobs_semaphore_.Wait();
}
bool MarkCompactCollector::IsSweepingCompleted() {
- for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
- if (!isolate()->sweeper_threads()[i]->SweepingCompleted()) {
- return false;
- }
- }
-
- if (FLAG_job_based_sweeping) {
- if (!pending_sweeper_jobs_semaphore_.WaitFor(
- base::TimeDelta::FromSeconds(0))) {
- return false;
- }
- pending_sweeper_jobs_semaphore_.Signal();
+ if (!pending_sweeper_jobs_semaphore_.WaitFor(
+ base::TimeDelta::FromSeconds(0))) {
+ return false;
}
-
+ pending_sweeper_jobs_semaphore_.Signal();
return true;
}
}
-bool MarkCompactCollector::AreSweeperThreadsActivated() {
- return isolate()->sweeper_threads() != NULL || FLAG_job_based_sweeping;
-}
-
-
void Marking::TransferMark(Address old_start, Address new_start) {
// This is only used when resizing an object.
DCHECK(MemoryChunk::FromAddress(old_start) ==
heap()->incremental_marking()->Abort();
ClearMarkbits();
AbortWeakCollections();
+ AbortWeakCells();
AbortCompaction();
was_marked_incrementally_ = false;
}
Deoptimizer::DeoptimizeMarkedCode(isolate());
have_code_to_deoptimize_ = false;
}
+
+ heap_->incremental_marking()->ClearIdleMarkingDelayCounter();
}
}
+bool MarkCompactCollector::IsMarkingDequeEmpty() {
+ return marking_deque_.IsEmpty();
+}
+
+
void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {
// Mark the heap roots including global variables, stack variables,
// etc., and all objects reachable from them.
// Note that we never eliminate a transition array, though we might right-trim
// such that number_of_transitions() == 0. If this assumption changes,
- // TransitionArray::CopyInsert() will need to deal with the case that a
- // transition array disappeared during GC.
- int trim = t->number_of_transitions() - transition_index;
+ // TransitionArray::Insert() will need to deal with the case that a transition
+ // array disappeared during GC.
+ int trim = t->number_of_transitions_storage() - transition_index;
if (trim > 0) {
heap_->RightTrimFixedArray<Heap::FROM_GC>(
t, t->IsSimpleTransition() ? trim
: trim * TransitionArray::kTransitionSize);
+ t->SetNumberOfTransitions(transition_index);
}
DCHECK(map->HasTransitionArray());
}
}
+void MarkCompactCollector::ProcessAndClearWeakCells() {
+ HeapObject* undefined = heap()->undefined_value();
+ Object* weak_cell_obj = heap()->encountered_weak_cells();
+ while (weak_cell_obj != Smi::FromInt(0)) {
+ WeakCell* weak_cell = reinterpret_cast<WeakCell*>(weak_cell_obj);
+ // We do not insert cleared weak cells into the list, so the value
+ // cannot be a Smi here.
+ HeapObject* value = HeapObject::cast(weak_cell->value());
+ if (!MarkCompactCollector::IsMarked(value)) {
+ weak_cell->clear();
+ } else {
+ Object** slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
+ heap()->mark_compact_collector()->RecordSlot(slot, slot, value);
+ }
+ weak_cell_obj = weak_cell->next();
+ weak_cell->set_next(undefined, SKIP_WRITE_BARRIER);
+ }
+ heap()->set_encountered_weak_cells(Smi::FromInt(0));
+}
+
+
+void MarkCompactCollector::AbortWeakCells() {
+ Object* undefined = heap()->undefined_value();
+ Object* weak_cell_obj = heap()->encountered_weak_cells();
+ while (weak_cell_obj != Smi::FromInt(0)) {
+ WeakCell* weak_cell = reinterpret_cast<WeakCell*>(weak_cell_obj);
+ weak_cell_obj = weak_cell->next();
+ weak_cell->set_next(undefined, SKIP_WRITE_BARRIER);
+ }
+ heap()->set_encountered_weak_cells(Smi::FromInt(0));
+}
+
+
void MarkCompactCollector::RecordMigratedSlot(Object* value, Address slot) {
if (heap_->InNewSpace(value)) {
heap_->store_buffer()->Mark(slot);
}
-// We scavange new space simultaneously with sweeping. This is done in two
+// We scavenge new space simultaneously with sweeping. This is done in two
// passes.
//
// The first pass migrates all alive objects from one semispace to another or
switch (sweeper) {
case CONCURRENT_SWEEPING:
- case PARALLEL_SWEEPING:
if (!parallel_sweeping_active) {
if (FLAG_gc_verbose) {
PrintF("Sweeping 0x%" V8PRIxPTR ".\n",
}
-static bool ShouldStartSweeperThreads(MarkCompactCollector::SweeperType type) {
- return type == MarkCompactCollector::PARALLEL_SWEEPING ||
- type == MarkCompactCollector::CONCURRENT_SWEEPING;
-}
-
-
-static bool ShouldWaitForSweeperThreads(
- MarkCompactCollector::SweeperType type) {
- return type == MarkCompactCollector::PARALLEL_SWEEPING;
-}
-
-
void MarkCompactCollector::SweepSpaces() {
GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_SWEEP);
double start_time = 0.0;
#ifdef DEBUG
state_ = SWEEP_SPACES;
#endif
- SweeperType how_to_sweep = CONCURRENT_SWEEPING;
- if (FLAG_parallel_sweeping) how_to_sweep = PARALLEL_SWEEPING;
- if (FLAG_concurrent_sweeping) how_to_sweep = CONCURRENT_SWEEPING;
-
MoveEvacuationCandidatesToEndOfPagesList();
// Noncompacting collections simply sweep the spaces to clear the mark
GCTracer::Scope::MC_SWEEP_OLDSPACE);
{
SequentialSweepingScope scope(this);
- SweepSpace(heap()->old_pointer_space(), how_to_sweep);
- SweepSpace(heap()->old_data_space(), how_to_sweep);
+ SweepSpace(heap()->old_pointer_space(), CONCURRENT_SWEEPING);
+ SweepSpace(heap()->old_data_space(), CONCURRENT_SWEEPING);
}
-
- if (ShouldStartSweeperThreads(how_to_sweep)) {
+ sweeping_in_progress_ = true;
+ if (!FLAG_predictable) {
StartSweeperThreads();
}
-
- if (ShouldWaitForSweeperThreads(how_to_sweep)) {
- EnsureSweepingCompleted();
- }
}
RemoveDeadInvalidatedCode();
void EnableCodeFlushing(bool enable);
enum SweeperType {
- PARALLEL_SWEEPING,
CONCURRENT_SWEEPING,
SEQUENTIAL_SWEEPING
};
void RefillFreeList(PagedSpace* space);
- bool AreSweeperThreadsActivated();
-
// Checks if sweeping is in progress right now on any space.
bool sweeping_in_progress() { return sweeping_in_progress_; }
// to artificially keep AllocationSites alive for a time.
void MarkAllocationSite(AllocationSite* site);
+ bool IsMarkingDequeEmpty();
+
private:
class SweeperTask;
// collections when incremental marking is aborted.
void AbortWeakCollections();
+
+ void ProcessAndClearWeakCells();
+ void AbortWeakCells();
+
// -----------------------------------------------------------------------
// Phase 2: Sweeping to clear mark bits and free non-live objects for
// a non-compacting collection.
table_.Register(kVisitPropertyCell, &VisitPropertyCell);
+ table_.Register(kVisitWeakCell, &VisitWeakCell);
+
table_.template RegisterSpecializations<DataObjectVisitor, kVisitDataObject,
kVisitDataObjectGeneric>();
// when they might be keeping a Context alive, or when the heap is about
// to be serialized.
if (FLAG_cleanup_code_caches_at_gc && target->is_inline_cache_stub() &&
+ !target->is_call_stub() &&
(target->ic_state() == MEGAMORPHIC || target->ic_state() == GENERIC ||
target->ic_state() == POLYMORPHIC ||
(heap->flush_monomorphic_ics() && !target->is_weak_stub()) ||
template <typename StaticVisitor>
+void StaticMarkingVisitor<StaticVisitor>::VisitWeakCell(Map* map,
+ HeapObject* object) {
+ Heap* heap = map->GetHeap();
+ WeakCell* weak_cell = reinterpret_cast<WeakCell*>(object);
+ Object* undefined = heap->undefined_value();
+ // Enqueue weak cell in linked list of encountered weak collections.
+ // We can ignore weak cells with cleared values because they will always
+ // contain smi zero.
+ if (weak_cell->next() == undefined && !weak_cell->cleared()) {
+ weak_cell->set_next(heap->encountered_weak_cells());
+ heap->set_encountered_weak_cells(weak_cell);
+ }
+}
+
+
+template <typename StaticVisitor>
void StaticMarkingVisitor<StaticVisitor>::VisitAllocationSite(
Map* map, HeapObject* object) {
Heap* heap = map->GetHeap();
case PROPERTY_CELL_TYPE:
return kVisitPropertyCell;
+ case WEAK_CELL_TYPE:
+ return kVisitWeakCell;
+
case JS_SET_TYPE:
return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
JSSet::kSize);
V(Map) \
V(Cell) \
V(PropertyCell) \
+ V(WeakCell) \
V(SharedFunctionInfo) \
V(JSFunction) \
V(JSWeakCollection) \
}
INLINE(static void VisitPropertyCell(Map* map, HeapObject* object));
+ INLINE(static void VisitWeakCell(Map* map, HeapObject* object));
INLINE(static void VisitCodeEntry(Heap* heap, Address entry_address));
INLINE(static void VisitEmbeddedPointer(Heap* heap, RelocInfo* rinfo));
INLINE(static void VisitCell(Heap* heap, RelocInfo* rinfo));
}
}
+ if (requested <= kMinimumCodeRangeSize) {
+ requested = kMinimumCodeRangeSize;
+ }
+
DCHECK(!kRequiresCodeRange || requested <= kMaximalCodeRangeSize);
code_range_ = new base::VirtualMemory(requested);
CHECK(code_range_ != NULL);
// We are sure that we have mapped a block of requested addresses.
DCHECK(code_range_->size() == requested);
- LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
Address base = reinterpret_cast<Address>(code_range_->address());
- Address aligned_base =
- RoundUp(reinterpret_cast<Address>(code_range_->address()),
- MemoryChunk::kAlignment);
+
+ // On some platforms, specifically Win64, we need to reserve some pages at
+ // the beginning of an executable space.
+ if (kReservedCodeRangePages) {
+ if (!code_range_->Commit(
+ base, kReservedCodeRangePages * base::OS::CommitPageSize(), true)) {
+ delete code_range_;
+ code_range_ = NULL;
+ return false;
+ }
+ base += kReservedCodeRangePages * base::OS::CommitPageSize();
+ }
+ Address aligned_base = RoundUp(base, MemoryChunk::kAlignment);
size_t size = code_range_->size() - (aligned_base - base);
allocation_list_.Add(FreeBlock(aligned_base, size));
current_allocation_block_index_ = 0;
+
+ LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
return true;
}
// -----------------------------------------------------------------------------
// PagedSpace implementation
-PagedSpace::PagedSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id,
+PagedSpace::PagedSpace(Heap* heap, intptr_t max_capacity, AllocationSpace space,
Executability executable)
- : Space(heap, id, executable),
+ : Space(heap, space, executable),
free_list_(this),
unswept_free_bytes_(0),
end_of_unswept_pages_(NULL),
emergency_memory_(NULL) {
- if (id == CODE_SPACE) {
- area_size_ = heap->isolate()->memory_allocator()->CodePageAreaSize();
- } else {
- area_size_ = Page::kPageSize - Page::kObjectStartOffset;
- }
+ area_size_ = MemoryAllocator::PageAreaSize(space);
max_capacity_ =
(RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize) * AreaSize();
accounting_stats_.Clear();
int size = 0;
switch (identity()) {
case OLD_POINTER_SPACE:
- size = (112 + constant_pool_delta) * kPointerSize * KB;
+ size = (128 + constant_pool_delta) * kPointerSize * KB;
break;
case OLD_DATA_SPACE:
size = 192 * KB;
// this chunk must be a power of two and it must be aligned to its size.
int initial_semispace_capacity = heap()->InitialSemiSpaceSize();
+ int target_semispace_capacity = heap()->TargetSemiSpaceSize();
+
size_t size = 2 * reserved_semispace_capacity;
Address base = heap()->isolate()->memory_allocator()->ReserveAlignedMemory(
size, size, &reservation_);
DCHECK(IsAddressAligned(chunk_base_, 2 * reserved_semispace_capacity, 0));
to_space_.SetUp(chunk_base_, initial_semispace_capacity,
- maximum_semispace_capacity);
+ target_semispace_capacity, maximum_semispace_capacity);
from_space_.SetUp(chunk_base_ + reserved_semispace_capacity,
- initial_semispace_capacity, maximum_semispace_capacity);
+ initial_semispace_capacity, target_semispace_capacity,
+ maximum_semispace_capacity);
if (!to_space_.Commit()) {
return false;
}
if (!to_space_.ShrinkTo(from_space_.TotalCapacity())) {
// We are in an inconsistent state because we could not
// commit/uncommit memory from new space.
- V8::FatalProcessOutOfMemory("Failed to grow new space.");
+ CHECK(false);
}
}
}
}
+bool NewSpace::GrowOnePage() {
+ if (TotalCapacity() == MaximumCapacity()) return false;
+ int new_capacity = static_cast<int>(TotalCapacity()) + Page::kPageSize;
+ if (to_space_.GrowTo(new_capacity)) {
+ // Only grow from space if we managed to grow to-space and the from space
+ // is actually committed.
+ if (from_space_.is_committed()) {
+ if (!from_space_.GrowTo(new_capacity)) {
+ // If we managed to grow to-space but couldn't grow from-space,
+ // attempt to shrink to-space.
+ if (!to_space_.ShrinkTo(from_space_.TotalCapacity())) {
+ // We are in an inconsistent state because we could not
+ // commit/uncommit memory from new space.
+ CHECK(false);
+ }
+ return false;
+ }
+ } else {
+ if (!from_space_.SetTotalCapacity(new_capacity)) {
+ // Can't really happen, but better safe than sorry.
+ CHECK(false);
+ }
+ }
+ DCHECK_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
+ return true;
+ }
+ return false;
+}
+
+
void NewSpace::Shrink() {
int new_capacity = Max(InitialTotalCapacity(), 2 * SizeAsInt());
int rounded_new_capacity = RoundUp(new_capacity, Page::kPageSize);
if (!to_space_.GrowTo(from_space_.TotalCapacity())) {
// We are in an inconsistent state because we could not
// commit/uncommit memory from new space.
- V8::FatalProcessOutOfMemory("Failed to shrink new space.");
+ CHECK(false);
}
}
}
return false;
}
if (!to_space_.AdvancePage()) {
- // Failed to get a new page in to-space.
- return false;
+ // Check if we reached the target capacity yet. If not, try to commit a page
+ // and continue.
+ if ((to_space_.TotalCapacity() < to_space_.TargetCapacity()) &&
+ GrowOnePage()) {
+ if (!to_space_.AdvancePage()) {
+ // It doesn't make sense that we managed to commit a page, but can't use
+ // it.
+ CHECK(false);
+ }
+ } else {
+ // Failed to get a new page in to-space.
+ return false;
+ }
}
// Clear remainder of current page.
// -----------------------------------------------------------------------------
// SemiSpace implementation
-void SemiSpace::SetUp(Address start, int initial_capacity,
+void SemiSpace::SetUp(Address start, int initial_capacity, int target_capacity,
int maximum_capacity) {
// Creates a space in the young generation. The constructor does not
// allocate memory from the OS. A SemiSpace is given a contiguous chunk of
// space is used as the marking stack. It requires contiguous memory
// addresses.
DCHECK(maximum_capacity >= Page::kPageSize);
+ DCHECK(initial_capacity <= target_capacity);
+ DCHECK(target_capacity <= maximum_capacity);
initial_total_capacity_ = RoundDown(initial_capacity, Page::kPageSize);
total_capacity_ = initial_capacity;
+ target_capacity_ = RoundDown(target_capacity, Page::kPageSize);
maximum_total_capacity_ = RoundDown(maximum_capacity, Page::kPageSize);
maximum_committed_ = 0;
committed_ = false;
}
+bool SemiSpace::SetTotalCapacity(int new_capacity) {
+ CHECK(!is_committed());
+ if (new_capacity >= initial_total_capacity_ &&
+ new_capacity <= maximum_total_capacity_) {
+ total_capacity_ = new_capacity;
+ return true;
+ }
+ return false;
+}
+
+
void SemiSpace::FlipPages(intptr_t flags, intptr_t mask) {
anchor_.set_owner(this);
// Fixup back-pointers to anchor. Address of anchor changes
intptr_t PagedSpace::SizeOfObjects() {
- DCHECK(heap()->mark_compact_collector()->sweeping_in_progress() ||
+ DCHECK(FLAG_predictable ||
+ heap()->mark_compact_collector()->sweeping_in_progress() ||
(unswept_free_bytes_ == 0));
return Size() - unswept_free_bytes_ - (limit() - top());
}
return CodePageAreaEndOffset() - CodePageAreaStartOffset();
}
+ static int PageAreaSize(AllocationSpace space) {
+ DCHECK_NE(LO_SPACE, space);
+ return (space == CODE_SPACE) ? CodePageAreaSize()
+ : Page::kMaxRegularHeapObjectSize;
+ }
+
MUST_USE_RESULT bool CommitExecutableMemory(base::VirtualMemory* vm,
Address start, size_t commit_size,
size_t reserved_size);
public:
// Implicit constructor from Object*.
AllocationResult(Object* object) // NOLINT
- : object_(object),
- retry_space_(INVALID_SPACE) {}
+ : object_(object) {
+ // AllocationResults can't return Smis, which are used to represent
+ // failure and the space to retry in.
+ CHECK(!object->IsSmi());
+ }
- AllocationResult() : object_(NULL), retry_space_(INVALID_SPACE) {}
+ AllocationResult() : object_(Smi::FromInt(NEW_SPACE)) {}
static inline AllocationResult Retry(AllocationSpace space = NEW_SPACE) {
return AllocationResult(space);
}
- inline bool IsRetry() { return retry_space_ != INVALID_SPACE; }
+ inline bool IsRetry() { return object_->IsSmi(); }
template <typename T>
bool To(T** obj) {
AllocationSpace RetrySpace() {
DCHECK(IsRetry());
- return retry_space_;
+ return static_cast<AllocationSpace>(Smi::cast(object_)->value());
}
private:
explicit AllocationResult(AllocationSpace space)
- : object_(NULL), retry_space_(space) {}
+ : object_(Smi::FromInt(static_cast<int>(space))) {}
Object* object_;
- AllocationSpace retry_space_;
};
+STATIC_ASSERT(sizeof(AllocationResult) == kPointerSize);
+
+
class PagedSpace : public Space {
public:
// Creates a space with a maximum capacity, and an id.
current_page_(NULL) {}
// Sets up the semispace using the given chunk.
- void SetUp(Address start, int initial_capacity, int maximum_capacity);
+ void SetUp(Address start, int initial_capacity, int target_capacity,
+ int maximum_capacity);
// Tear down the space. Heap memory was not allocated by the space, so it
// is not deallocated here.
// semispace and less than the current capacity.
bool ShrinkTo(int new_capacity);
+ // Sets the total capacity. Only possible when the space is not committed.
+ bool SetTotalCapacity(int new_capacity);
+
// Returns the start address of the first page of the space.
Address space_start() {
DCHECK(anchor_.next_page() != &anchor_);
// Returns the current total capacity of the semispace.
int TotalCapacity() { return total_capacity_; }
+ // Returns the target for total capacity of the semispace.
+ int TargetCapacity() { return target_capacity_; }
+
// Returns the maximum total capacity of the semispace.
int MaximumTotalCapacity() { return maximum_total_capacity_; }
// The current and maximum total capacity of the space.
int total_capacity_;
+ int target_capacity_;
int maximum_total_capacity_;
int initial_total_capacity_;
// their maximum capacity.
void Grow();
+ // Grow the capacity of the semispaces by one page.
+ bool GrowOnePage();
+
// Shrink the capacity of the semispaces.
void Shrink();
+++ /dev/null
-// Copyright 2012 the V8 project 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/sweeper-thread.h"
-
-#include "src/v8.h"
-
-#include "src/isolate.h"
-#include "src/v8threads.h"
-
-namespace v8 {
-namespace internal {
-
-static const int kSweeperThreadStackSize = 64 * KB;
-
-SweeperThread::SweeperThread(Isolate* isolate)
- : Thread(Thread::Options("v8:SweeperThread", kSweeperThreadStackSize)),
- isolate_(isolate),
- heap_(isolate->heap()),
- collector_(heap_->mark_compact_collector()),
- start_sweeping_semaphore_(0),
- end_sweeping_semaphore_(0),
- stop_semaphore_(0) {
- DCHECK(!FLAG_job_based_sweeping);
- base::NoBarrier_Store(&stop_thread_, static_cast<base::AtomicWord>(false));
-}
-
-
-void SweeperThread::Run() {
- Isolate::SetIsolateThreadLocals(isolate_, NULL);
- DisallowHeapAllocation no_allocation;
- DisallowHandleAllocation no_handles;
- DisallowHandleDereference no_deref;
-
- while (true) {
- start_sweeping_semaphore_.Wait();
-
- if (base::Acquire_Load(&stop_thread_)) {
- stop_semaphore_.Signal();
- return;
- }
-
- collector_->SweepInParallel(heap_->old_data_space(), 0);
- collector_->SweepInParallel(heap_->old_pointer_space(), 0);
- end_sweeping_semaphore_.Signal();
- }
-}
-
-
-void SweeperThread::Stop() {
- base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(true));
- start_sweeping_semaphore_.Signal();
- stop_semaphore_.Wait();
- Join();
-}
-
-
-void SweeperThread::StartSweeping() { start_sweeping_semaphore_.Signal(); }
-
-
-void SweeperThread::WaitForSweeperThread() { end_sweeping_semaphore_.Wait(); }
-
-
-bool SweeperThread::SweepingCompleted() {
- bool value = end_sweeping_semaphore_.WaitFor(base::TimeDelta::FromSeconds(0));
- if (value) {
- end_sweeping_semaphore_.Signal();
- }
- return value;
-}
-
-
-int SweeperThread::NumberOfThreads(int max_available) {
- if (!FLAG_concurrent_sweeping && !FLAG_parallel_sweeping) return 0;
- if (FLAG_sweeper_threads > 0) return FLAG_sweeper_threads;
- if (FLAG_concurrent_sweeping) return max_available - 1;
- DCHECK(FLAG_parallel_sweeping);
- return max_available;
-}
-}
-} // namespace v8::internal
+++ /dev/null
-// Copyright 2012 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_HEAP_SWEEPER_THREAD_H_
-#define V8_HEAP_SWEEPER_THREAD_H_
-
-#include "src/base/atomicops.h"
-#include "src/base/platform/platform.h"
-#include "src/flags.h"
-#include "src/utils.h"
-
-#include "src/heap/spaces.h"
-
-#include "src/heap/heap.h"
-
-namespace v8 {
-namespace internal {
-
-class SweeperThread : public base::Thread {
- public:
- explicit SweeperThread(Isolate* isolate);
- ~SweeperThread() {}
-
- void Run();
- void Stop();
- void StartSweeping();
- void WaitForSweeperThread();
- bool SweepingCompleted();
-
- static int NumberOfThreads(int max_available);
-
- private:
- Isolate* isolate_;
- Heap* heap_;
- MarkCompactCollector* collector_;
- base::Semaphore start_sweeping_semaphore_;
- base::Semaphore end_sweeping_semaphore_;
- base::Semaphore stop_semaphore_;
- volatile base::AtomicWord stop_thread_;
-};
-}
-} // namespace v8::internal
-
-#endif // V8_HEAP_SWEEPER_THREAD_H_
// constant limit we will use that instead of the induction limit.
bool has_upper_constant_limit = true;
int32_t upper_constant_limit =
- check != NULL && check->HasUpperLimit() ? check->upper_limit() : 0;
+ check->HasUpperLimit() ? check->upper_limit() : 0;
for (InductionVariableData::InductionVariableCheck* current_check = check;
current_check != NULL;
current_check = current_check->next()) {
has_upper_constant_limit =
- has_upper_constant_limit &&
- check->HasUpperLimit() &&
- check->upper_limit() == upper_constant_limit;
+ has_upper_constant_limit && current_check->HasUpperLimit() &&
+ current_check->upper_limit() == upper_constant_limit;
counters()->bounds_checks_eliminated()->Increment();
current_check->check()->set_skip_check();
}
} else {
os << "root ";
}
- os << " -> " << *instr << "]" << endl;
+ os << " -> " << *instr << "]" << std::endl;
}
}
-OStream& operator<<(OStream& os, const TrackedEffects& te) {
+std::ostream& operator<<(std::ostream& os, const TrackedEffects& te) {
SideEffectsTracker* t = te.tracker;
const char* separator = "";
os << "[";
if (FLAG_trace_gvn) {
OFStream os(stdout);
os << "Tracking global var [" << *cell.handle() << "] "
- << "(mapped to index " << num_global_vars_ << ")" << endl;
+ << "(mapped to index " << num_global_vars_ << ")" << std::endl;
}
*index = num_global_vars_;
global_vars_[num_global_vars_++] = cell;
if (FLAG_trace_gvn) {
OFStream os(stdout);
os << "Tracking inobject field access " << access << " (mapped to index "
- << num_inobject_fields_ << ")" << endl;
+ << num_inobject_fields_ << ")" << std::endl;
}
*index = num_inobject_fields_;
inobject_fields_[num_inobject_fields_++] = access;
if (FLAG_trace_gvn) {
OFStream os(stdout);
os << "Try loop invariant motion for " << *block << " changes "
- << Print(side_effects) << endl;
+ << Print(side_effects) << std::endl;
}
HBasicBlock* last = block->loop_information()->GetLastBackEdge();
for (int j = block->block_id(); j <= last->block_id(); ++j) {
if (FLAG_trace_gvn) {
OFStream os(stdout);
os << "Loop invariant code motion for " << *block << " depends on "
- << Print(loop_kills) << endl;
+ << Print(loop_kills) << std::endl;
}
HInstruction* instr = block->first();
while (instr != NULL) {
os << "Checking instruction i" << instr->id() << " ("
<< instr->Mnemonic() << ") changes " << Print(changes)
<< ", depends on " << Print(depends_on) << ". Loop changes "
- << Print(loop_kills) << endl;
+ << Print(loop_kills) << std::endl;
}
bool can_hoist = !depends_on.ContainsAnyOf(loop_kills);
if (can_hoist && !graph()->use_optimistic_licm()) {
if (FLAG_trace_gvn) {
OFStream os(stdout);
os << "Instruction i" << instr->id() << " changes " << Print(changes)
- << endl;
+ << std::endl;
}
}
if (instr->CheckFlag(HValue::kUseGVN) &&
#ifndef V8_HYDROGEN_GVN_H_
#define V8_HYDROGEN_GVN_H_
+#include <iosfwd>
+
#include "src/compiler.h"
#include "src/hydrogen.h"
#include "src/hydrogen-instructions.h"
namespace v8 {
namespace internal {
-class OStream;
-
// This class extends GVNFlagSet with additional "special" dynamic side effects,
// which can be used to represent side effects that cannot be expressed using
// the GVNFlags of an HInstruction. These special side effects are tracked by a
SideEffects ComputeDependsOn(HInstruction* instr);
private:
- friend OStream& operator<<(OStream& os, const TrackedEffects& f);
+ friend std::ostream& operator<<(std::ostream& os, const TrackedEffects& f);
bool ComputeGlobalVar(Unique<Cell> cell, int* index);
bool ComputeInobjectField(HObjectAccess access, int* index);
};
-OStream& operator<<(OStream& os, const TrackedEffects& f);
+std::ostream& operator<<(std::ostream& os, const TrackedEffects& f);
// Perform common subexpression elimination and loop-invariant code motion.
}
-OStream& operator<<(OStream& os, const HValue& v) { return v.PrintTo(os); }
+std::ostream& operator<<(std::ostream& os, const HValue& v) {
+ return v.PrintTo(os);
+}
-OStream& operator<<(OStream& os, const TypeOf& t) {
+std::ostream& operator<<(std::ostream& os, const TypeOf& t) {
if (t.value->representation().IsTagged() &&
!t.value->type().Equals(HType::Tagged()))
return os;
}
-OStream& operator<<(OStream& os, const ChangesOf& c) {
+std::ostream& operator<<(std::ostream& os, const ChangesOf& c) {
GVNFlagSet changes_flags = c.value->ChangesFlags();
if (changes_flags.IsEmpty()) return os;
os << " changes[";
}
-OStream& operator<<(OStream& os, const HSourcePosition& p) {
+std::ostream& operator<<(std::ostream& os, const HSourcePosition& p) {
if (p.IsUnknown()) {
return os << "<?>";
} else if (FLAG_hydrogen_track_positions) {
}
-OStream& HInstruction::PrintTo(OStream& os) const { // NOLINT
+std::ostream& HInstruction::PrintTo(std::ostream& os) const { // NOLINT
os << Mnemonic() << " ";
PrintDataTo(os) << ChangesOf(this) << TypeOf(this);
if (CheckFlag(HValue::kHasNoObservableSideEffects)) os << " [noOSE]";
}
-OStream& HInstruction::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HInstruction::PrintDataTo(std::ostream& os) const { // NOLINT
for (int i = 0; i < OperandCount(); ++i) {
if (i > 0) os << " ";
os << NameOf(OperandAt(i));
}
-OStream& operator<<(OStream& os, const NameOf& v) {
+std::ostream& operator<<(std::ostream& os, const NameOf& v) {
return os << v.value->representation().Mnemonic() << v.value->id();
}
-OStream& HDummyUse::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HDummyUse::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value());
}
-OStream& HEnvironmentMarker::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HEnvironmentMarker::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << (kind() == BIND ? "bind" : "lookup") << " var[" << index()
<< "]";
}
-OStream& HUnaryCall::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HUnaryCall::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value()) << " #" << argument_count();
}
-OStream& HCallJSFunction::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCallJSFunction::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(function()) << " #" << argument_count();
}
}
-OStream& HBinaryCall::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HBinaryCall::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(first()) << " " << NameOf(second()) << " #"
<< argument_count();
}
}
-OStream& HBoundsCheck::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HBoundsCheck::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(index()) << " " << NameOf(length());
if (base() != NULL && (offset() != 0 || scale() != 0)) {
os << " base: ((";
}
-OStream& HBoundsCheckBaseIndexInformation::PrintDataTo(
- OStream& os) const { // NOLINT
+std::ostream& HBoundsCheckBaseIndexInformation::PrintDataTo(
+ std::ostream& os) const { // NOLINT
// TODO(svenpanne) This 2nd base_index() looks wrong...
return os << "base: " << NameOf(base_index())
<< ", check: " << NameOf(base_index());
}
-OStream& HCallWithDescriptor::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCallWithDescriptor::PrintDataTo(
+ std::ostream& os) const { // NOLINT
for (int i = 0; i < OperandCount(); i++) {
os << NameOf(OperandAt(i)) << " ";
}
}
-OStream& HCallNewArray::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCallNewArray::PrintDataTo(std::ostream& os) const { // NOLINT
os << ElementsKindToString(elements_kind()) << " ";
return HBinaryCall::PrintDataTo(os);
}
-OStream& HCallRuntime::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCallRuntime::PrintDataTo(std::ostream& os) const { // NOLINT
os << name()->ToCString().get() << " ";
if (save_doubles() == kSaveFPRegs) os << "[save doubles] ";
return os << "#" << argument_count();
}
-OStream& HClassOfTestAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HClassOfTestAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << "class_of_test(" << NameOf(value()) << ", \""
<< class_name()->ToCString().get() << "\")";
}
-OStream& HWrapReceiver::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HWrapReceiver::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(receiver()) << " " << NameOf(function());
}
-OStream& HAccessArgumentsAt::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HAccessArgumentsAt::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(arguments()) << "[" << NameOf(index()) << "], length "
<< NameOf(length());
}
-OStream& HAllocateBlockContext::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HAllocateBlockContext::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(context()) << " " << NameOf(function());
}
-OStream& HControlInstruction::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HControlInstruction::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << " goto (";
bool first_block = true;
for (HSuccessorIterator it(this); !it.Done(); it.Advance()) {
}
-OStream& HUnaryControlInstruction::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HUnaryControlInstruction::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(value());
return HControlInstruction::PrintDataTo(os);
}
-OStream& HReturn::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HReturn::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value()) << " (pop " << NameOf(parameter_count())
<< " values)";
}
}
-OStream& HBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HBranch::PrintDataTo(std::ostream& os) const { // NOLINT
return HUnaryControlInstruction::PrintDataTo(os) << " "
<< expected_input_types();
}
-OStream& HCompareMap::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCompareMap::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(value()) << " (" << *map().handle() << ")";
HControlInstruction::PrintDataTo(os);
if (known_successor_index() == 0) {
}
-OStream& HUnaryMathOperation::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HUnaryMathOperation::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << OpName() << " " << NameOf(value());
}
-OStream& HUnaryOperation::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HUnaryOperation::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value());
}
-OStream& HHasInstanceTypeAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HHasInstanceTypeAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(value());
switch (from_) {
case FIRST_JS_RECEIVER_TYPE:
}
-OStream& HTypeofIsAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HTypeofIsAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(value()) << " == " << type_literal()->ToCString().get();
return HControlInstruction::PrintDataTo(os);
}
}
-OStream& HCheckMapValue::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCheckMapValue::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value()) << " " << NameOf(map());
}
}
-OStream& HForInPrepareMap::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HForInPrepareMap::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(enumerable());
}
-OStream& HForInCacheArray::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HForInCacheArray::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(enumerable()) << " " << NameOf(map()) << "[" << idx_
<< "]";
}
-OStream& HLoadFieldByIndex::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadFieldByIndex::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(object()) << " " << NameOf(index());
}
}
-OStream& HTypeof::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HTypeof::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value());
}
}
-OStream& HForceRepresentation::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HForceRepresentation::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << representation().Mnemonic() << " " << NameOf(value());
}
-OStream& HChange::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HChange::PrintDataTo(std::ostream& os) const { // NOLINT
HUnaryOperation::PrintDataTo(os);
os << " " << from().Mnemonic() << " to " << to().Mnemonic();
}
-OStream& HCheckMaps::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCheckMaps::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(value()) << " [" << *maps()->at(0).handle();
for (int i = 1; i < maps()->size(); ++i) {
os << "," << *maps()->at(i).handle();
}
-OStream& HCheckValue::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCheckValue::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value()) << " " << Brief(*object().handle());
}
}
-OStream& HCheckInstanceType::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCheckInstanceType::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << GetCheckName() << " ";
return HUnaryOperation::PrintDataTo(os);
}
-OStream& HCallStub::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCallStub::PrintDataTo(std::ostream& os) const { // NOLINT
os << CodeStub::MajorName(major_key_, false) << " ";
return HUnaryCall::PrintDataTo(os);
}
-OStream& HTailCallThroughMegamorphicCache::PrintDataTo(
- OStream& os) const { // NOLINT
+std::ostream& HTailCallThroughMegamorphicCache::PrintDataTo(
+ std::ostream& os) const { // NOLINT
for (int i = 0; i < OperandCount(); i++) {
os << NameOf(OperandAt(i)) << " ";
}
}
-OStream& HUnknownOSRValue::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HUnknownOSRValue::PrintDataTo(std::ostream& os) const { // NOLINT
const char* type = "expression";
if (environment_->is_local_index(index_)) type = "local";
if (environment_->is_special_index(index_)) type = "special";
}
-OStream& HInstanceOf::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HInstanceOf::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(left()) << " " << NameOf(right()) << " "
<< NameOf(context());
}
Range* HConstant::InferRange(Zone* zone) {
- if (has_int32_value_) {
+ if (HasInteger32Value()) {
Range* result = new(zone) Range(int32_value_, int32_value_);
result->set_can_be_minus_zero(false);
return result;
*/
int32_t InductionVariableData::ComputeIncrement(HPhi* phi,
HValue* phi_operand) {
- if (!phi_operand->representation().IsInteger32()) return 0;
+ if (!phi_operand->representation().IsSmiOrInteger32()) return 0;
if (phi_operand->IsAdd()) {
HAdd* operation = HAdd::cast(phi_operand);
}
-OStream& HPhi::PrintTo(OStream& os) const { // NOLINT
+std::ostream& HPhi::PrintTo(std::ostream& os) const { // NOLINT
os << "[";
for (int i = 0; i < OperandCount(); ++i) {
os << " " << NameOf(OperandAt(i)) << " ";
}
-OStream& HSimulate::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HSimulate::PrintDataTo(std::ostream& os) const { // NOLINT
os << "id=" << ast_id().ToInt();
if (pop_count_ > 0) os << " pop " << pop_count_;
if (values_.length() > 0) {
void HSimulate::ReplayEnvironment(HEnvironment* env) {
- if (done_with_replay_) return;
+ if (is_done_with_replay()) return;
DCHECK(env != NULL);
env->set_ast_id(ast_id());
env->Drop(pop_count());
env->Push(value);
}
}
- done_with_replay_ = true;
+ set_done_with_replay();
}
}
-OStream& HCapturedObject::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCapturedObject::PrintDataTo(std::ostream& os) const { // NOLINT
os << "#" << capture_id() << " ";
return HDematerializedObject::PrintDataTo(os);
}
}
-OStream& HEnterInlined::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HEnterInlined::PrintDataTo(std::ostream& os) const { // NOLINT
return os << function()->debug_name()->ToCString().get()
<< ", id=" << function()->id().ToInt();
}
HConstant::HConstant(Handle<Object> object, Representation r)
- : HTemplateInstruction<0>(HType::FromValue(object)),
- object_(Unique<Object>::CreateUninitialized(object)),
- object_map_(Handle<Map>::null()),
- has_stable_map_value_(false),
- has_smi_value_(false),
- has_int32_value_(false),
- has_double_value_(false),
- has_external_reference_value_(false),
- is_not_in_new_space_(true),
- boolean_value_(object->BooleanValue()),
- is_undetectable_(false),
- instance_type_(kUnknownInstanceType) {
+ : HTemplateInstruction<0>(HType::FromValue(object)),
+ object_(Unique<Object>::CreateUninitialized(object)),
+ object_map_(Handle<Map>::null()),
+ bit_field_(HasStableMapValueField::encode(false) |
+ HasSmiValueField::encode(false) |
+ HasInt32ValueField::encode(false) |
+ HasDoubleValueField::encode(false) |
+ HasExternalReferenceValueField::encode(false) |
+ IsNotInNewSpaceField::encode(true) |
+ BooleanValueField::encode(object->BooleanValue()) |
+ IsUndetectableField::encode(false) |
+ InstanceTypeField::encode(kUnknownInstanceType)) {
if (object->IsHeapObject()) {
Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
Isolate* isolate = heap_object->GetIsolate();
Handle<Map> map(heap_object->map(), isolate);
- is_not_in_new_space_ = !isolate->heap()->InNewSpace(*object);
- instance_type_ = map->instance_type();
- is_undetectable_ = map->is_undetectable();
+ bit_field_ = IsNotInNewSpaceField::update(
+ bit_field_, !isolate->heap()->InNewSpace(*object));
+ bit_field_ = InstanceTypeField::update(bit_field_, map->instance_type());
+ bit_field_ =
+ IsUndetectableField::update(bit_field_, map->is_undetectable());
if (map->is_stable()) object_map_ = Unique<Map>::CreateImmovable(map);
- has_stable_map_value_ = (instance_type_ == MAP_TYPE &&
- Handle<Map>::cast(heap_object)->is_stable());
+ bit_field_ = HasStableMapValueField::update(
+ bit_field_,
+ HasMapValue() && Handle<Map>::cast(heap_object)->is_stable());
}
if (object->IsNumber()) {
double n = object->Number();
- has_int32_value_ = IsInteger32(n);
+ bool has_int32_value = IsInteger32(n);
+ bit_field_ = HasInt32ValueField::update(bit_field_, has_int32_value);
int32_value_ = DoubleToInt32(n);
- has_smi_value_ = has_int32_value_ && Smi::IsValid(int32_value_);
+ bit_field_ = HasSmiValueField::update(
+ bit_field_, has_int32_value && Smi::IsValid(int32_value_));
double_value_ = n;
- has_double_value_ = true;
+ bit_field_ = HasDoubleValueField::update(bit_field_, true);
// TODO(titzer): if this heap number is new space, tenure a new one.
}
}
-HConstant::HConstant(Unique<Object> object,
- Unique<Map> object_map,
- bool has_stable_map_value,
- Representation r,
- HType type,
- bool is_not_in_new_space,
- bool boolean_value,
- bool is_undetectable,
- InstanceType instance_type)
- : HTemplateInstruction<0>(type),
- object_(object),
- object_map_(object_map),
- has_stable_map_value_(has_stable_map_value),
- has_smi_value_(false),
- has_int32_value_(false),
- has_double_value_(false),
- has_external_reference_value_(false),
- is_not_in_new_space_(is_not_in_new_space),
- boolean_value_(boolean_value),
- is_undetectable_(is_undetectable),
- instance_type_(instance_type) {
+HConstant::HConstant(Unique<Object> object, Unique<Map> object_map,
+ bool has_stable_map_value, Representation r, HType type,
+ bool is_not_in_new_space, bool boolean_value,
+ bool is_undetectable, InstanceType instance_type)
+ : HTemplateInstruction<0>(type),
+ object_(object),
+ object_map_(object_map),
+ bit_field_(HasStableMapValueField::encode(has_stable_map_value) |
+ HasSmiValueField::encode(false) |
+ HasInt32ValueField::encode(false) |
+ HasDoubleValueField::encode(false) |
+ HasExternalReferenceValueField::encode(false) |
+ IsNotInNewSpaceField::encode(is_not_in_new_space) |
+ BooleanValueField::encode(boolean_value) |
+ IsUndetectableField::encode(is_undetectable) |
+ InstanceTypeField::encode(instance_type)) {
DCHECK(!object.handle().is_null());
DCHECK(!type.IsTaggedNumber() || type.IsNone());
Initialize(r);
}
-HConstant::HConstant(int32_t integer_value,
- Representation r,
- bool is_not_in_new_space,
- Unique<Object> object)
- : object_(object),
- object_map_(Handle<Map>::null()),
- has_stable_map_value_(false),
- has_smi_value_(Smi::IsValid(integer_value)),
- has_int32_value_(true),
- has_double_value_(true),
- has_external_reference_value_(false),
- is_not_in_new_space_(is_not_in_new_space),
- boolean_value_(integer_value != 0),
- is_undetectable_(false),
- int32_value_(integer_value),
- double_value_(FastI2D(integer_value)),
- instance_type_(kUnknownInstanceType) {
+HConstant::HConstant(int32_t integer_value, Representation r,
+ bool is_not_in_new_space, Unique<Object> object)
+ : object_(object),
+ object_map_(Handle<Map>::null()),
+ bit_field_(HasStableMapValueField::encode(false) |
+ HasSmiValueField::encode(Smi::IsValid(integer_value)) |
+ HasInt32ValueField::encode(true) |
+ HasDoubleValueField::encode(true) |
+ HasExternalReferenceValueField::encode(false) |
+ IsNotInNewSpaceField::encode(is_not_in_new_space) |
+ BooleanValueField::encode(integer_value != 0) |
+ IsUndetectableField::encode(false) |
+ InstanceTypeField::encode(kUnknownInstanceType)),
+ int32_value_(integer_value),
+ double_value_(FastI2D(integer_value)) {
// It's possible to create a constant with a value in Smi-range but stored
// in a (pre-existing) HeapNumber. See crbug.com/349878.
bool could_be_heapobject = r.IsTagged() && !object.handle().is_null();
- bool is_smi = has_smi_value_ && !could_be_heapobject;
+ bool is_smi = HasSmiValue() && !could_be_heapobject;
set_type(is_smi ? HType::Smi() : HType::TaggedNumber());
Initialize(r);
}
-HConstant::HConstant(double double_value,
- Representation r,
- bool is_not_in_new_space,
- Unique<Object> object)
- : object_(object),
- object_map_(Handle<Map>::null()),
- has_stable_map_value_(false),
- has_int32_value_(IsInteger32(double_value)),
- has_double_value_(true),
- has_external_reference_value_(false),
- is_not_in_new_space_(is_not_in_new_space),
- boolean_value_(double_value != 0 && !std::isnan(double_value)),
- is_undetectable_(false),
- int32_value_(DoubleToInt32(double_value)),
- double_value_(double_value),
- instance_type_(kUnknownInstanceType) {
- has_smi_value_ = has_int32_value_ && Smi::IsValid(int32_value_);
+HConstant::HConstant(double double_value, Representation r,
+ bool is_not_in_new_space, Unique<Object> object)
+ : object_(object),
+ object_map_(Handle<Map>::null()),
+ bit_field_(HasStableMapValueField::encode(false) |
+ HasInt32ValueField::encode(IsInteger32(double_value)) |
+ HasDoubleValueField::encode(true) |
+ HasExternalReferenceValueField::encode(false) |
+ IsNotInNewSpaceField::encode(is_not_in_new_space) |
+ BooleanValueField::encode(double_value != 0 &&
+ !std::isnan(double_value)) |
+ IsUndetectableField::encode(false) |
+ InstanceTypeField::encode(kUnknownInstanceType)),
+ int32_value_(DoubleToInt32(double_value)),
+ double_value_(double_value) {
+ bit_field_ = HasSmiValueField::update(
+ bit_field_, HasInteger32Value() && Smi::IsValid(int32_value_));
// It's possible to create a constant with a value in Smi-range but stored
// in a (pre-existing) HeapNumber. See crbug.com/349878.
bool could_be_heapobject = r.IsTagged() && !object.handle().is_null();
- bool is_smi = has_smi_value_ && !could_be_heapobject;
+ bool is_smi = HasSmiValue() && !could_be_heapobject;
set_type(is_smi ? HType::Smi() : HType::TaggedNumber());
Initialize(r);
}
HConstant::HConstant(ExternalReference reference)
- : HTemplateInstruction<0>(HType::Any()),
- object_(Unique<Object>(Handle<Object>::null())),
- object_map_(Handle<Map>::null()),
- has_stable_map_value_(false),
- has_smi_value_(false),
- has_int32_value_(false),
- has_double_value_(false),
- has_external_reference_value_(true),
- is_not_in_new_space_(true),
- boolean_value_(true),
- is_undetectable_(false),
- external_reference_value_(reference),
- instance_type_(kUnknownInstanceType) {
+ : HTemplateInstruction<0>(HType::Any()),
+ object_(Unique<Object>(Handle<Object>::null())),
+ object_map_(Handle<Map>::null()),
+ bit_field_(
+ HasStableMapValueField::encode(false) |
+ HasSmiValueField::encode(false) | HasInt32ValueField::encode(false) |
+ HasDoubleValueField::encode(false) |
+ HasExternalReferenceValueField::encode(true) |
+ IsNotInNewSpaceField::encode(true) | BooleanValueField::encode(true) |
+ IsUndetectableField::encode(false) |
+ InstanceTypeField::encode(kUnknownInstanceType)),
+ external_reference_value_(reference) {
Initialize(Representation::External());
}
void HConstant::Initialize(Representation r) {
if (r.IsNone()) {
- if (has_smi_value_ && SmiValuesAre31Bits()) {
+ if (HasSmiValue() && SmiValuesAre31Bits()) {
r = Representation::Smi();
- } else if (has_int32_value_) {
+ } else if (HasInteger32Value()) {
r = Representation::Integer32();
- } else if (has_double_value_) {
+ } else if (HasDoubleValue()) {
r = Representation::Double();
- } else if (has_external_reference_value_) {
+ } else if (HasExternalReferenceValue()) {
r = Representation::External();
} else {
Handle<Object> object = object_.handle();
bool HConstant::ImmortalImmovable() const {
- if (has_int32_value_) {
+ if (HasInteger32Value()) {
return false;
}
- if (has_double_value_) {
+ if (HasDoubleValue()) {
if (IsSpecialDouble()) {
return true;
}
return false;
}
- if (has_external_reference_value_) {
+ if (HasExternalReferenceValue()) {
return false;
}
DCHECK(!object_.IsKnownGlobal(heap->nan_value()));
return
#define IMMORTAL_IMMOVABLE_ROOT(name) \
- object_.IsKnownGlobal(heap->name()) ||
+ object_.IsKnownGlobal(heap->root(Heap::k##name##RootIndex)) ||
IMMORTAL_IMMOVABLE_ROOT_LIST(IMMORTAL_IMMOVABLE_ROOT)
#undef IMMORTAL_IMMOVABLE_ROOT
#define INTERNALIZED_STRING(name, value) \
HConstant* HConstant::CopyToRepresentation(Representation r, Zone* zone) const {
- if (r.IsSmi() && !has_smi_value_) return NULL;
- if (r.IsInteger32() && !has_int32_value_) return NULL;
- if (r.IsDouble() && !has_double_value_) return NULL;
- if (r.IsExternal() && !has_external_reference_value_) return NULL;
- if (has_int32_value_) {
- return new(zone) HConstant(int32_value_, r, is_not_in_new_space_, object_);
+ if (r.IsSmi() && !HasSmiValue()) return NULL;
+ if (r.IsInteger32() && !HasInteger32Value()) return NULL;
+ if (r.IsDouble() && !HasDoubleValue()) return NULL;
+ if (r.IsExternal() && !HasExternalReferenceValue()) return NULL;
+ if (HasInteger32Value()) {
+ return new (zone) HConstant(int32_value_, r, NotInNewSpace(), object_);
}
- if (has_double_value_) {
- return new(zone) HConstant(double_value_, r, is_not_in_new_space_, object_);
+ if (HasDoubleValue()) {
+ return new (zone) HConstant(double_value_, r, NotInNewSpace(), object_);
}
- if (has_external_reference_value_) {
+ if (HasExternalReferenceValue()) {
return new(zone) HConstant(external_reference_value_);
}
DCHECK(!object_.handle().is_null());
- return new(zone) HConstant(object_,
- object_map_,
- has_stable_map_value_,
- r,
- type_,
- is_not_in_new_space_,
- boolean_value_,
- is_undetectable_,
- instance_type_);
+ return new (zone) HConstant(object_, object_map_, HasStableMapValue(), r,
+ type_, NotInNewSpace(), BooleanValue(),
+ IsUndetectable(), GetInstanceType());
}
Maybe<HConstant*> HConstant::CopyToTruncatedInt32(Zone* zone) {
HConstant* res = NULL;
- if (has_int32_value_) {
- res = new(zone) HConstant(int32_value_,
- Representation::Integer32(),
- is_not_in_new_space_,
- object_);
- } else if (has_double_value_) {
- res = new(zone) HConstant(DoubleToInt32(double_value_),
- Representation::Integer32(),
- is_not_in_new_space_,
- object_);
+ if (HasInteger32Value()) {
+ res = new (zone) HConstant(int32_value_, Representation::Integer32(),
+ NotInNewSpace(), object_);
+ } else if (HasDoubleValue()) {
+ res = new (zone)
+ HConstant(DoubleToInt32(double_value_), Representation::Integer32(),
+ NotInNewSpace(), object_);
}
return Maybe<HConstant*>(res != NULL, res);
}
}
-OStream& HConstant::PrintDataTo(OStream& os) const { // NOLINT
- if (has_int32_value_) {
+std::ostream& HConstant::PrintDataTo(std::ostream& os) const { // NOLINT
+ if (HasInteger32Value()) {
os << int32_value_ << " ";
- } else if (has_double_value_) {
+ } else if (HasDoubleValue()) {
os << double_value_ << " ";
- } else if (has_external_reference_value_) {
+ } else if (HasExternalReferenceValue()) {
os << reinterpret_cast<void*>(external_reference_value_.address()) << " ";
} else {
// The handle() method is silently and lazily mutating the object.
if (HasStableMapValue()) os << "[stable-map] ";
if (HasObjectMap()) os << "[map " << *ObjectMap().handle() << "] ";
}
- if (!is_not_in_new_space_) os << "[new space] ";
+ if (!NotInNewSpace()) os << "[new space] ";
return os;
}
-OStream& HBinaryOperation::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HBinaryOperation::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(left()) << " " << NameOf(right());
if (CheckFlag(kCanOverflow)) os << " !";
if (CheckFlag(kBailoutOnMinusZero)) os << " -0?";
}
-OStream& HCompareGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCompareGeneric::PrintDataTo(std::ostream& os) const { // NOLINT
os << Token::Name(token()) << " ";
return HBinaryOperation::PrintDataTo(os);
}
-OStream& HStringCompareAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStringCompareAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << Token::Name(token()) << " ";
return HControlInstruction::PrintDataTo(os);
}
-OStream& HCompareNumericAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCompareNumericAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << Token::Name(token()) << " " << NameOf(left()) << " " << NameOf(right());
return HControlInstruction::PrintDataTo(os);
}
-OStream& HCompareObjectEqAndBranch::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HCompareObjectEqAndBranch::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(left()) << " " << NameOf(right());
return HControlInstruction::PrintDataTo(os);
}
}
-OStream& HGoto::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HGoto::PrintDataTo(std::ostream& os) const { // NOLINT
return os << *SuccessorAt(0);
}
}
-OStream& HParameter::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HParameter::PrintDataTo(std::ostream& os) const { // NOLINT
return os << index();
}
-OStream& HLoadNamedField::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadNamedField::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(object()) << access_;
if (maps() != NULL) {
}
-OStream& HLoadNamedGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadNamedGeneric::PrintDataTo(
+ std::ostream& os) const { // NOLINT
Handle<String> n = Handle<String>::cast(name());
return os << NameOf(object()) << "." << n->ToCString().get();
}
-OStream& HLoadKeyed::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadKeyed::PrintDataTo(std::ostream& os) const { // NOLINT
if (!is_external()) {
os << NameOf(elements());
} else {
}
-OStream& HLoadKeyedGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadKeyedGeneric::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(object()) << "[" << NameOf(key()) << "]";
}
}
-OStream& HStoreNamedGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreNamedGeneric::PrintDataTo(
+ std::ostream& os) const { // NOLINT
Handle<String> n = Handle<String>::cast(name());
return os << NameOf(object()) << "." << n->ToCString().get() << " = "
<< NameOf(value());
}
-OStream& HStoreNamedField::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreNamedField::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(object()) << access_ << " = " << NameOf(value());
if (NeedsWriteBarrier()) os << " (write-barrier)";
if (has_transition()) os << " (transition map " << *transition_map() << ")";
}
-OStream& HStoreKeyed::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreKeyed::PrintDataTo(std::ostream& os) const { // NOLINT
if (!is_external()) {
os << NameOf(elements());
} else {
}
-OStream& HStoreKeyedGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreKeyedGeneric::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(object()) << "[" << NameOf(key())
<< "] = " << NameOf(value());
}
-OStream& HTransitionElementsKind::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HTransitionElementsKind::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(object());
ElementsKind from_kind = original_map().handle()->elements_kind();
ElementsKind to_kind = transitioned_map().handle()->elements_kind();
}
-OStream& HLoadGlobalCell::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadGlobalCell::PrintDataTo(std::ostream& os) const { // NOLINT
os << "[" << *cell().handle() << "]";
if (details_.IsConfigurable()) os << " (configurable)";
if (details_.IsReadOnly()) os << " (read-only)";
}
-OStream& HLoadGlobalGeneric::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadGlobalGeneric::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << name()->ToCString().get() << " ";
}
-OStream& HInnerAllocatedObject::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HInnerAllocatedObject::PrintDataTo(
+ std::ostream& os) const { // NOLINT
os << NameOf(base_object()) << " offset ";
return offset()->PrintTo(os);
}
-OStream& HStoreGlobalCell::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreGlobalCell::PrintDataTo(std::ostream& os) const { // NOLINT
os << "[" << *cell().handle() << "] = " << NameOf(value());
if (details_.IsConfigurable()) os << " (configurable)";
if (details_.IsReadOnly()) os << " (read-only)";
}
-OStream& HLoadContextSlot::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HLoadContextSlot::PrintDataTo(std::ostream& os) const { // NOLINT
return os << NameOf(value()) << "[" << slot_index() << "]";
}
-OStream& HStoreContextSlot::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStoreContextSlot::PrintDataTo(
+ std::ostream& os) const { // NOLINT
return os << NameOf(context()) << "[" << slot_index()
<< "] = " << NameOf(value());
}
}
-OStream& HAllocate::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HAllocate::PrintDataTo(std::ostream& os) const { // NOLINT
os << NameOf(size()) << " (";
if (IsNewSpaceAllocation()) os << "N";
if (IsOldPointerSpaceAllocation()) os << "P";
}
-OStream& HStringAdd::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HStringAdd::PrintDataTo(std::ostream& os) const { // NOLINT
if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_BOTH) {
os << "_CheckBoth";
} else if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_LEFT) {
#undef H_CONSTANT_DOUBLE
-OStream& HBitwise::PrintDataTo(OStream& os) const { // NOLINT
+std::ostream& HBitwise::PrintDataTo(std::ostream& os) const { // NOLINT
os << Token::Name(op_) << " ";
return HBitwiseBinaryOperation::PrintDataTo(os);
}
}
-OStream& operator<<(OStream& os, const HObjectAccess& access) {
+std::ostream& operator<<(std::ostream& os, const HObjectAccess& access) {
os << ".";
switch (access.portion()) {
#ifndef V8_HYDROGEN_INSTRUCTIONS_H_
#define V8_HYDROGEN_INSTRUCTIONS_H_
+#include <iosfwd>
+
#include "src/v8.h"
#include "src/allocation.h"
#include "src/base/bits.h"
+#include "src/bit-vector.h"
#include "src/code-stubs.h"
#include "src/conversions.h"
-#include "src/data-flow.h"
#include "src/deoptimizer.h"
-#include "src/feedback-slots.h"
#include "src/hydrogen-types.h"
#include "src/small-pointer-list.h"
#include "src/unique.h"
class HValue;
class LInstruction;
class LChunkBuilder;
-class OStream;
#define HYDROGEN_ABSTRACT_INSTRUCTION_LIST(V) \
V(ArithmeticBinaryOperation) \
};
-OStream& operator<<(OStream& os, const HSourcePosition& p);
+std::ostream& operator<<(std::ostream& os, const HSourcePosition& p);
class HValue : public ZoneObject {
virtual void FinalizeUniqueness() { }
// Printing support.
- virtual OStream& PrintTo(OStream& os) const = 0; // NOLINT
+ virtual std::ostream& PrintTo(std::ostream& os) const = 0; // NOLINT
const char* Mnemonic() const;
result.Remove(kOsrEntries);
return result;
}
- friend OStream& operator<<(OStream& os, const ChangesOf& v);
+ friend std::ostream& operator<<(std::ostream& os, const ChangesOf& v);
// A flag mask of all side effects that can make observable changes in
// an executing program (i.e. are not safe to repeat, move or remove);
};
-OStream& operator<<(OStream& os, const HValue& v);
-OStream& operator<<(OStream& os, const NameOf& v);
-OStream& operator<<(OStream& os, const TypeOf& v);
-OStream& operator<<(OStream& os, const ChangesOf& v);
+std::ostream& operator<<(std::ostream& os, const HValue& v);
+std::ostream& operator<<(std::ostream& os, const NameOf& v);
+std::ostream& operator<<(std::ostream& os, const TypeOf& v);
+std::ostream& operator<<(std::ostream& os, const ChangesOf& v);
#define DECLARE_INSTRUCTION_FACTORY_P0(I) \
HInstruction* next() const { return next_; }
HInstruction* previous() const { return previous_; }
- virtual OStream& PrintTo(OStream& os) const OVERRIDE; // NOLINT
- virtual OStream& PrintDataTo(OStream& os) const; // NOLINT
+ virtual std::ostream& PrintTo(std::ostream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const; // NOLINT
bool IsLinked() const { return block() != NULL; }
void Unlink();
virtual int SuccessorCount() const = 0;
virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual bool KnownSuccessorBlock(HBasicBlock** block) {
*block = NULL;
return Representation::None();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(DummyUse);
};
return Representation::None();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Goto)
};
SetSuccessorAt(1, false_target);
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* value() const { return OperandAt(0); }
};
virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
ToBooleanStub::Types expected_input_types() const {
return expected_input_types_;
return false;
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
static const int kNoKnownSuccessorIndex = -1;
- int known_successor_index() const { return known_successor_index_; }
- void set_known_successor_index(int known_successor_index) {
- known_successor_index_ = known_successor_index;
+ int known_successor_index() const {
+ return KnownSuccessorIndexField::decode(bit_field_) -
+ kInternalKnownSuccessorOffset;
+ }
+ void set_known_successor_index(int index) {
+ DCHECK(index >= 0 - kInternalKnownSuccessorOffset);
+ bit_field_ = KnownSuccessorIndexField::update(
+ bit_field_, index + kInternalKnownSuccessorOffset);
}
Unique<Map> map() const { return map_; }
- bool map_is_stable() const { return map_is_stable_; }
+ bool map_is_stable() const { return MapIsStableField::decode(bit_field_); }
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
DECLARE_CONCRETE_INSTRUCTION(CompareMap)
protected:
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
- HCompareMap(HValue* value,
- Handle<Map> map,
- HBasicBlock* true_target = NULL,
+ HCompareMap(HValue* value, Handle<Map> map, HBasicBlock* true_target = NULL,
HBasicBlock* false_target = NULL)
: HUnaryControlInstruction(value, true_target, false_target),
- known_successor_index_(kNoKnownSuccessorIndex),
- map_is_stable_(map->is_stable()),
+ bit_field_(KnownSuccessorIndexField::encode(
+ kNoKnownSuccessorIndex + kInternalKnownSuccessorOffset) |
+ MapIsStableField::encode(map->is_stable())),
map_(Unique<Map>::CreateImmovable(map)) {
set_representation(Representation::Tagged());
}
- int known_successor_index_ : 31;
- bool map_is_stable_ : 1;
+ // BitFields can only store unsigned values, so use an offset.
+ // Adding kInternalKnownSuccessorOffset must yield an unsigned value.
+ static const int kInternalKnownSuccessorOffset = 1;
+ STATIC_ASSERT(kNoKnownSuccessorIndex + kInternalKnownSuccessorOffset >= 0);
+
+ class KnownSuccessorIndexField : public BitField<int, 0, 31> {};
+ class MapIsStableField : public BitField<bool, 31, 1> {};
+
+ uint32_t bit_field_;
Unique<Map> map_;
};
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* value() const { return OperandAt(0); }
HValue* context() const { return OperandAt(1); }
}
HValue* value() const { return OperandAt(0); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
};
return representation(); // Same as the output representation.
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation)
virtual Range* InferRange(Zone* zone) OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Change)
class HSimulate FINAL : public HInstruction {
public:
- HSimulate(BailoutId ast_id,
- int pop_count,
- Zone* zone,
+ HSimulate(BailoutId ast_id, int pop_count, Zone* zone,
RemovableSimulate removable)
: ast_id_(ast_id),
pop_count_(pop_count),
values_(2, zone),
assigned_indexes_(2, zone),
zone_(zone),
- removable_(removable),
- done_with_replay_(false) {}
+ bit_field_(RemovableField::encode(removable) |
+ DoneWithReplayField::encode(false)) {}
~HSimulate() {}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
bool HasAstId() const { return !ast_id_.IsNone(); }
BailoutId ast_id() const { return ast_id_; }
}
void MergeWith(ZoneList<HSimulate*>* list);
- bool is_candidate_for_removal() { return removable_ == REMOVABLE_SIMULATE; }
+ bool is_candidate_for_removal() {
+ return RemovableField::decode(bit_field_) == REMOVABLE_SIMULATE;
+ }
// Replay effects of this instruction on the given environment.
void ReplayEnvironment(HEnvironment* env);
}
return false;
}
+ bool is_done_with_replay() const {
+ return DoneWithReplayField::decode(bit_field_);
+ }
+ void set_done_with_replay() {
+ bit_field_ = DoneWithReplayField::update(bit_field_, true);
+ }
+
+ class RemovableField : public BitField<RemovableSimulate, 0, 1> {};
+ class DoneWithReplayField : public BitField<bool, 1, 1> {};
+
BailoutId ast_id_;
int pop_count_;
ZoneList<HValue*> values_;
ZoneList<int> assigned_indexes_;
Zone* zone_;
- RemovableSimulate removable_ : 2;
- bool done_with_replay_ : 1;
+ uint32_t bit_field_;
#ifdef DEBUG
Handle<JSFunction> closure_;
return Representation::None();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
#ifdef DEBUG
void set_closure(Handle<JSFunction> closure) {
void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone);
ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
Handle<JSFunction> closure() const { return closure_; }
HConstant* closure_context() const { return closure_context_; }
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* value() const { return OperandAt(0); }
};
SetOperandAt(1, second);
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(
int index) FINAL OVERRIDE {
HValue* function() const { return OperandAt(0); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(
int index) FINAL OVERRIDE {
return OperandAt(0);
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
private:
// The argument count includes the receiver.
HValue* context() { return first(); }
HValue* constructor() { return second(); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
ElementsKind elements_kind() const { return elements_kind_; }
const Runtime::Function*,
int);
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* context() { return OperandAt(0); }
const Runtime::Function* function() const { return c_function_; }
HValue* context() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
if (index == 0) {
// TODO(bmeurer): We'll need kDependsOnRoots once we add the
// corresponding HStoreRoot instruction.
SetDependsOnFlag(kCalls);
+ set_representation(Representation::Tagged());
}
virtual bool IsDeletable() const OVERRIDE { return true; }
return new(zone) HCheckMaps(value, maps, typecheck);
}
- bool IsStabilityCheck() const { return is_stability_check_; }
+ bool IsStabilityCheck() const {
+ return IsStabilityCheckField::decode(bit_field_);
+ }
void MarkAsStabilityCheck() {
- maps_are_stable_ = true;
- has_migration_target_ = false;
- is_stability_check_ = true;
+ bit_field_ = MapsAreStableField::encode(true) |
+ HasMigrationTargetField::encode(false) |
+ IsStabilityCheckField::encode(true);
ClearChangesFlag(kNewSpacePromotion);
ClearDependsOnFlag(kElementsKind);
ClearDependsOnFlag(kMaps);
return HType::HeapObject();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* value() const { return OperandAt(0); }
HValue* typecheck() const { return OperandAt(1); }
const UniqueSet<Map>* maps() const { return maps_; }
void set_maps(const UniqueSet<Map>* maps) { maps_ = maps; }
- bool maps_are_stable() const { return maps_are_stable_; }
+ bool maps_are_stable() const {
+ return MapsAreStableField::decode(bit_field_);
+ }
- bool HasMigrationTarget() const { return has_migration_target_; }
+ bool HasMigrationTarget() const {
+ return HasMigrationTargetField::decode(bit_field_);
+ }
virtual HValue* Canonicalize() OVERRIDE;
return this->maps()->Equals(HCheckMaps::cast(other)->maps());
}
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
HCheckMaps(HValue* value, const UniqueSet<Map>* maps, bool maps_are_stable)
- : HTemplateInstruction<2>(HType::HeapObject()), maps_(maps),
- has_migration_target_(false), is_stability_check_(false),
- maps_are_stable_(maps_are_stable) {
+ : HTemplateInstruction<2>(HType::HeapObject()),
+ maps_(maps),
+ bit_field_(HasMigrationTargetField::encode(false) |
+ IsStabilityCheckField::encode(false) |
+ MapsAreStableField::encode(maps_are_stable)) {
DCHECK_NE(0, maps->size());
SetOperandAt(0, value);
// Use the object value for the dependency.
}
HCheckMaps(HValue* value, const UniqueSet<Map>* maps, HValue* typecheck)
- : HTemplateInstruction<2>(HType::HeapObject()), maps_(maps),
- has_migration_target_(false), is_stability_check_(false),
- maps_are_stable_(true) {
+ : HTemplateInstruction<2>(HType::HeapObject()),
+ maps_(maps),
+ bit_field_(HasMigrationTargetField::encode(false) |
+ IsStabilityCheckField::encode(false) |
+ MapsAreStableField::encode(true)) {
DCHECK_NE(0, maps->size());
SetOperandAt(0, value);
// Use the object value for the dependency if NULL is passed.
SetDependsOnFlag(kElementsKind);
for (int i = 0; i < maps->size(); ++i) {
Handle<Map> map = maps->at(i).handle();
- if (map->is_migration_target()) has_migration_target_ = true;
- if (!map->is_stable()) maps_are_stable_ = false;
+ if (map->is_migration_target()) {
+ bit_field_ = HasMigrationTargetField::update(bit_field_, true);
+ }
+ if (!map->is_stable()) {
+ bit_field_ = MapsAreStableField::update(bit_field_, false);
+ }
}
- if (has_migration_target_) SetChangesFlag(kNewSpacePromotion);
+ if (HasMigrationTarget()) SetChangesFlag(kNewSpacePromotion);
}
+ class HasMigrationTargetField : public BitField<bool, 0, 1> {};
+ class IsStabilityCheckField : public BitField<bool, 1, 1> {};
+ class MapsAreStableField : public BitField<bool, 2, 1> {};
+
const UniqueSet<Map>* maps_;
- bool has_migration_target_ : 1;
- bool is_stability_check_ : 1;
- bool maps_are_stable_ : 1;
+ uint32_t bit_field_;
};
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual HValue* Canonicalize() OVERRIDE;
DECLARE_INSTRUCTION_FACTORY_P2(HCheckInstanceType, HValue*, Check);
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
return check_ == b->check_;
}
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
const char* GetCheckName() const;
induction_variable_data_ = InductionVariableData::ExaminePhi(this);
}
- virtual OStream& PrintTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintTo(std::ostream& os) const OVERRIDE; // NOLINT
#ifdef DEBUG
virtual void Verify() OVERRIDE;
// Replay effects of this instruction on the given environment.
void ReplayEnvironment(HEnvironment* env);
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CapturedObject)
isolate->factory()->NewNumber(double_value_, TENURED));
}
AllowDeferredHandleDereference smi_check;
- DCHECK(has_int32_value_ || !object_.handle()->IsSmi());
+ DCHECK(HasInteger32Value() || !object_.handle()->IsSmi());
return object_.handle();
}
bool IsSpecialDouble() const {
- return has_double_value_ &&
+ return HasDoubleValue() &&
(bit_cast<int64_t>(double_value_) == bit_cast<int64_t>(-0.0) ||
FixedDoubleArray::is_the_hole_nan(double_value_) ||
std::isnan(double_value_));
}
bool NotInNewSpace() const {
- return is_not_in_new_space_;
+ return IsNotInNewSpaceField::decode(bit_field_);
}
bool ImmortalImmovable() const;
bool IsCell() const {
- return instance_type_ == CELL_TYPE || instance_type_ == PROPERTY_CELL_TYPE;
- }
-
- bool IsMap() const {
- return instance_type_ == MAP_TYPE;
+ InstanceType instance_type = GetInstanceType();
+ return instance_type == CELL_TYPE || instance_type == PROPERTY_CELL_TYPE;
}
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
}
virtual bool EmitAtUses() OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HConstant* CopyToRepresentation(Representation r, Zone* zone) const;
Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone);
Maybe<HConstant*> CopyToTruncatedNumber(Zone* zone);
- bool HasInteger32Value() const { return has_int32_value_; }
+ bool HasInteger32Value() const {
+ return HasInt32ValueField::decode(bit_field_);
+ }
int32_t Integer32Value() const {
DCHECK(HasInteger32Value());
return int32_value_;
}
- bool HasSmiValue() const { return has_smi_value_; }
- bool HasDoubleValue() const { return has_double_value_; }
+ bool HasSmiValue() const { return HasSmiValueField::decode(bit_field_); }
+ bool HasDoubleValue() const {
+ return HasDoubleValueField::decode(bit_field_);
+ }
double DoubleValue() const {
DCHECK(HasDoubleValue());
return double_value_;
return object_.IsInitialized() &&
object_.IsKnownGlobal(isolate()->heap()->the_hole_value());
}
- bool HasNumberValue() const { return has_double_value_; }
+ bool HasNumberValue() const { return HasDoubleValue(); }
int32_t NumberValueAsInteger32() const {
DCHECK(HasNumberValue());
// Irrespective of whether a numeric HConstant can be safely
return int32_value_;
}
bool HasStringValue() const {
- if (has_double_value_ || has_int32_value_) return false;
+ if (HasNumberValue()) return false;
DCHECK(!object_.handle().is_null());
- return instance_type_ < FIRST_NONSTRING_TYPE;
+ return GetInstanceType() < FIRST_NONSTRING_TYPE;
}
Handle<String> StringValue() const {
DCHECK(HasStringValue());
return Handle<String>::cast(object_.handle());
}
bool HasInternalizedStringValue() const {
- return HasStringValue() && StringShape(instance_type_).IsInternalized();
+ return HasStringValue() && StringShape(GetInstanceType()).IsInternalized();
}
bool HasExternalReferenceValue() const {
- return has_external_reference_value_;
+ return HasExternalReferenceValueField::decode(bit_field_);
}
ExternalReference ExternalReferenceValue() const {
return external_reference_value_;
}
bool HasBooleanValue() const { return type_.IsBoolean(); }
- bool BooleanValue() const { return boolean_value_; }
- bool IsUndetectable() const { return is_undetectable_; }
- InstanceType GetInstanceType() const { return instance_type_; }
+ bool BooleanValue() const { return BooleanValueField::decode(bit_field_); }
+ bool IsUndetectable() const {
+ return IsUndetectableField::decode(bit_field_);
+ }
+ InstanceType GetInstanceType() const {
+ return InstanceTypeField::decode(bit_field_);
+ }
- bool HasMapValue() const { return instance_type_ == MAP_TYPE; }
+ bool HasMapValue() const { return GetInstanceType() == MAP_TYPE; }
Unique<Map> MapValue() const {
DCHECK(HasMapValue());
return Unique<Map>::cast(GetUnique());
}
bool HasStableMapValue() const {
- DCHECK(HasMapValue() || !has_stable_map_value_);
- return has_stable_map_value_;
+ DCHECK(HasMapValue() || !HasStableMapValueField::decode(bit_field_));
+ return HasStableMapValueField::decode(bit_field_);
}
bool HasObjectMap() const { return !object_map_.IsNull(); }
}
virtual intptr_t Hashcode() OVERRIDE {
- if (has_int32_value_) {
+ if (HasInteger32Value()) {
return static_cast<intptr_t>(int32_value_);
- } else if (has_double_value_) {
+ } else if (HasDoubleValue()) {
return static_cast<intptr_t>(bit_cast<int64_t>(double_value_));
- } else if (has_external_reference_value_) {
+ } else if (HasExternalReferenceValue()) {
return reinterpret_cast<intptr_t>(external_reference_value_.address());
} else {
DCHECK(!object_.handle().is_null());
}
virtual void FinalizeUniqueness() OVERRIDE {
- if (!has_double_value_ && !has_external_reference_value_) {
+ if (!HasDoubleValue() && !HasExternalReferenceValue()) {
DCHECK(!object_.handle().is_null());
object_ = Unique<Object>(object_.handle());
}
virtual bool DataEquals(HValue* other) OVERRIDE {
HConstant* other_constant = HConstant::cast(other);
- if (has_int32_value_) {
- return other_constant->has_int32_value_ &&
- int32_value_ == other_constant->int32_value_;
- } else if (has_double_value_) {
- return other_constant->has_double_value_ &&
+ if (HasInteger32Value()) {
+ return other_constant->HasInteger32Value() &&
+ int32_value_ == other_constant->int32_value_;
+ } else if (HasDoubleValue()) {
+ return other_constant->HasDoubleValue() &&
bit_cast<int64_t>(double_value_) ==
bit_cast<int64_t>(other_constant->double_value_);
- } else if (has_external_reference_value_) {
- return other_constant->has_external_reference_value_ &&
- external_reference_value_ ==
- other_constant->external_reference_value_;
+ } else if (HasExternalReferenceValue()) {
+ return other_constant->HasExternalReferenceValue() &&
+ external_reference_value_ ==
+ other_constant->external_reference_value_;
} else {
- if (other_constant->has_int32_value_ ||
- other_constant->has_double_value_ ||
- other_constant->has_external_reference_value_) {
+ if (other_constant->HasInteger32Value() ||
+ other_constant->HasDoubleValue() ||
+ other_constant->HasExternalReferenceValue()) {
return false;
}
DCHECK(!object_.handle().is_null());
virtual bool IsDeletable() const OVERRIDE { return true; }
+ // If object_ is a map, this indicates whether the map is stable.
+ class HasStableMapValueField : public BitField<bool, 0, 1> {};
+
+ // We store the HConstant in the most specific form safely possible.
+ // These flags tell us if the respective member fields hold valid, safe
+ // representations of the constant. More specific flags imply more general
+ // flags, but not the converse (i.e. smi => int32 => double).
+ class HasSmiValueField : public BitField<bool, 1, 1> {};
+ class HasInt32ValueField : public BitField<bool, 2, 1> {};
+ class HasDoubleValueField : public BitField<bool, 3, 1> {};
+
+ class HasExternalReferenceValueField : public BitField<bool, 4, 1> {};
+ class IsNotInNewSpaceField : public BitField<bool, 5, 1> {};
+ class BooleanValueField : public BitField<bool, 6, 1> {};
+ class IsUndetectableField : public BitField<bool, 7, 1> {};
+
+ static const InstanceType kUnknownInstanceType = FILLER_TYPE;
+ class InstanceTypeField : public BitField<InstanceType, 8, 8> {};
+
// If this is a numerical constant, object_ either points to the
// HeapObject the constant originated from or is null. If the
// constant is non-numeric, object_ always points to a valid
// If object_ is a heap object, this points to the stable map of the object.
Unique<Map> object_map_;
- // If object_ is a map, this indicates whether the map is stable.
- bool has_stable_map_value_ : 1;
+ uint32_t bit_field_;
- // We store the HConstant in the most specific form safely possible.
- // The two flags, has_int32_value_ and has_double_value_ tell us if
- // int32_value_ and double_value_ hold valid, safe representations
- // of the constant. has_int32_value_ implies has_double_value_ but
- // not the converse.
- bool has_smi_value_ : 1;
- bool has_int32_value_ : 1;
- bool has_double_value_ : 1;
- bool has_external_reference_value_ : 1;
- bool is_not_in_new_space_ : 1;
- bool boolean_value_ : 1;
- bool is_undetectable_: 1;
int32_t int32_value_;
double double_value_;
ExternalReference external_reference_value_;
-
- static const InstanceType kUnknownInstanceType = FILLER_TYPE;
- InstanceType instance_type_;
};
virtual bool IsCommutative() const { return false; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
if (index == 0) return Representation::Tagged();
virtual HValue* Canonicalize() OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
bool known_function() const { return known_function_; }
DECLARE_CONCRETE_INSTRUCTION(WrapReceiver)
public:
DECLARE_INSTRUCTION_FACTORY_P3(HAccessArgumentsAt, HValue*, HValue*, HValue*);
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
// The arguments elements is considered tagged.
return representation();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual void InferRepresentation(
HInferRepresentationPhase* h_infer) OVERRIDE;
return representation();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
virtual bool IsPurelyInformativeDefinition() OVERRIDE { return true; }
return r;
}
- virtual void initialize_output_representation(Representation observed) {
+ virtual void initialize_output_representation(
+ Representation observed) OVERRIDE {
if (observed.IsDouble()) observed = Representation::Integer32();
HBinaryOperation::initialize_output_representation(observed);
}
}
Token::Value token() const { return token_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
void SetOperandPositions(Zone* zone,
HSourcePosition left_pos,
HValue* left() const { return OperandAt(0); }
HValue* right() const { return OperandAt(1); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch)
protected:
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
- HIsStringAndBranch(HValue* value,
- HBasicBlock* true_target = NULL,
+ HIsStringAndBranch(HValue* value, HBasicBlock* true_target = NULL,
HBasicBlock* false_target = NULL)
- : HUnaryControlInstruction(value, true_target, false_target),
- known_successor_index_(kNoKnownSuccessorIndex) { }
+ : HUnaryControlInstruction(value, true_target, false_target),
+ known_successor_index_(kNoKnownSuccessorIndex) {
+ set_representation(Representation::Tagged());
+ }
int known_successor_index_;
};
protected:
virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
HIsSmiAndBranch(HValue* value,
HValue* right() { return OperandAt(2); }
Token::Value token() const { return token_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
InstanceType from() { return from_; }
InstanceType to() { return to_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
Handle<String> class_name() const { return class_name_; }
DECLARE_INSTRUCTION_FACTORY_P2(HTypeofIsAndBranch, HValue*, Handle<String>);
Handle<String> type_literal() const { return type_literal_.handle(); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
virtual HValue* Canonicalize() OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Bitwise)
unsigned index() const { return index_; }
ParameterKind kind() const { return kind_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::None();
}
+ virtual Representation KnownOptimalRepresentation() OVERRIDE {
+ // If a parameter is an input to a phi, that phi should not
+ // choose any more optimistic representation than Tagged.
+ return Representation::Tagged();
+ }
+
DECLARE_CONCRETE_INSTRUCTION(Parameter)
private:
HValue* context() { return value(); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CallStub)
HValue* name() const { return OperandAt(2); }
Code::Flags flags() const { return flags_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache)
public:
DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int);
- virtual OStream& PrintDataTo(OStream& os) const; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::None();
Unique<Cell> cell() const { return cell_; }
bool RequiresHoleCheck() const;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual intptr_t Hashcode() OVERRIDE {
return cell_.Hashcode();
HValue* global_object() { return OperandAt(1); }
Handle<String> name() const { return name_; }
bool for_typeof() const { return for_typeof_; }
- int slot() const {
- DCHECK(FLAG_vector_ics &&
- slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot);
+ FeedbackVectorICSlot slot() const {
+ DCHECK(FLAG_vector_ics && !slot_.IsInvalid());
return slot_;
}
- Handle<FixedArray> feedback_vector() const { return feedback_vector_; }
- void SetVectorAndSlot(Handle<FixedArray> vector, int slot) {
+ Handle<TypeFeedbackVector> feedback_vector() const {
+ return feedback_vector_;
+ }
+ void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
+ FeedbackVectorICSlot slot) {
DCHECK(FLAG_vector_ics);
feedback_vector_ = vector;
slot_ = slot;
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
private:
HLoadGlobalGeneric(HValue* context, HValue* global_object,
Handle<String> name, bool for_typeof)
- : name_(name), for_typeof_(for_typeof),
- slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) {
+ : name_(name),
+ for_typeof_(for_typeof),
+ slot_(FeedbackVectorICSlot::Invalid()) {
SetOperandAt(0, context);
SetOperandAt(1, global_object);
set_representation(Representation::Tagged());
Handle<String> name_;
bool for_typeof_;
- Handle<FixedArray> feedback_vector_;
- int slot_;
+ Handle<TypeFeedbackVector> feedback_vector_;
+ FeedbackVectorICSlot slot_;
};
virtual bool HandleSideEffectDominator(GVNFlag side_effect,
HValue* dominator) OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Allocate)
return new(zone) HStoreCodeEntry(function, code);
}
- virtual Representation RequiredInputRepresentation(int index) {
+ virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
return index == 0 ? Representation::Tagged() : Representation::Integer32();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject)
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell)
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot)
friend class HLoadNamedField;
friend class HStoreNamedField;
friend class SideEffectsTracker;
- friend OStream& operator<<(OStream& os, const HObjectAccess& access);
+ friend std::ostream& operator<<(std::ostream& os,
+ const HObjectAccess& access);
inline Portion portion() const {
return PortionField::decode(value_);
};
-OStream& operator<<(OStream& os, const HObjectAccess& access);
+std::ostream& operator<<(std::ostream& os, const HObjectAccess& access);
class HLoadNamedField FINAL : public HTemplateInstruction<2> {
return !access().IsInobject() || access().offset() >= size;
}
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
- if (index == 0 && access().IsExternalMemory()) {
+ if (index == 0) {
// object must be external in case of external memory access
- return Representation::External();
+ return access().IsExternalMemory() ? Representation::External()
+ : Representation::Tagged();
}
- return Representation::Tagged();
+ DCHECK(index == 1);
+ return Representation::None();
}
virtual Range* InferRange(Zone* zone) OVERRIDE;
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
bool CanBeReplacedWith(HValue* other) const {
if (!CheckFlag(HValue::kCantBeReplaced)) return false;
HValue* object() const { return OperandAt(1); }
Handle<Object> name() const { return name_; }
- int slot() const {
- DCHECK(FLAG_vector_ics &&
- slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot);
+ FeedbackVectorICSlot slot() const {
+ DCHECK(FLAG_vector_ics && !slot_.IsInvalid());
return slot_;
}
- Handle<FixedArray> feedback_vector() const { return feedback_vector_; }
- void SetVectorAndSlot(Handle<FixedArray> vector, int slot) {
+ Handle<TypeFeedbackVector> feedback_vector() const {
+ return feedback_vector_;
+ }
+ void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
+ FeedbackVectorICSlot slot) {
DCHECK(FLAG_vector_ics);
feedback_vector_ = vector;
slot_ = slot;
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
private:
HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name)
- : name_(name),
- slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) {
+ : name_(name), slot_(FeedbackVectorICSlot::Invalid()) {
SetOperandAt(0, context);
SetOperandAt(1, object);
set_representation(Representation::Tagged());
}
Handle<Object> name_;
- Handle<FixedArray> feedback_vector_;
- int slot_;
+ Handle<TypeFeedbackVector> feedback_vector_;
+ FeedbackVectorICSlot slot_;
};
}
bool HasDependency() const { return OperandAt(0) != OperandAt(2); }
uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); }
- bool TryIncreaseBaseOffset(uint32_t increase_by_value);
- HValue* GetKey() { return key(); }
- void SetKey(HValue* key) { SetOperandAt(1, key); }
- bool IsDehoisted() const { return IsDehoistedField::decode(bit_field_); }
- void SetDehoisted(bool is_dehoisted) {
+ bool TryIncreaseBaseOffset(uint32_t increase_by_value) OVERRIDE;
+ HValue* GetKey() OVERRIDE { return key(); }
+ void SetKey(HValue* key) OVERRIDE { SetOperandAt(1, key); }
+ bool IsDehoisted() const OVERRIDE {
+ return IsDehoistedField::decode(bit_field_);
+ }
+ void SetDehoisted(bool is_dehoisted) OVERRIDE {
bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
}
virtual ElementsKind elements_kind() const OVERRIDE {
return RequiredInputRepresentation(index);
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
bool UsesMustHandleHole() const;
bool AllUsesCanTreatHoleAsNaN() const;
kStartIsDehoisted = kStartBaseOffset + kBitsForBaseOffset
};
- STATIC_ASSERT((kBitsForElementsKind + kBitsForBaseOffset +
- kBitsForIsDehoisted) <= sizeof(uint32_t)*8);
+ STATIC_ASSERT((kBitsForElementsKind + kBitsForHoleMode + kBitsForBaseOffset +
+ kBitsForIsDehoisted) <= sizeof(uint32_t) * 8);
STATIC_ASSERT(kElementsKindCount <= (1 << kBitsForElementsKind));
class ElementsKindField:
public BitField<ElementsKind, kStartElementsKind, kBitsForElementsKind>
HValue* object() const { return OperandAt(0); }
HValue* key() const { return OperandAt(1); }
HValue* context() const { return OperandAt(2); }
- int slot() const {
- DCHECK(FLAG_vector_ics &&
- slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot);
+ FeedbackVectorICSlot slot() const {
+ DCHECK(FLAG_vector_ics && !slot_.IsInvalid());
return slot_;
}
- Handle<FixedArray> feedback_vector() const { return feedback_vector_; }
- void SetVectorAndSlot(Handle<FixedArray> vector, int slot) {
+ Handle<TypeFeedbackVector> feedback_vector() const {
+ return feedback_vector_;
+ }
+ void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
+ FeedbackVectorICSlot slot) {
DCHECK(FLAG_vector_ics);
feedback_vector_ = vector;
slot_ = slot;
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
// tagged[tagged]
private:
HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key)
- : slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) {
+ : slot_(FeedbackVectorICSlot::Invalid()) {
set_representation(Representation::Tagged());
SetOperandAt(0, obj);
SetOperandAt(1, key);
SetAllSideEffects();
}
- Handle<FixedArray> feedback_vector_;
- int slot_;
+ Handle<TypeFeedbackVector> feedback_vector_;
+ FeedbackVectorICSlot slot_;
};
} else if (field_representation().IsDouble()) {
return field_representation();
} else if (field_representation().IsSmi()) {
- if (SmiValuesAre32Bits() && store_mode_ == STORE_TO_INITIALIZED_ENTRY) {
+ if (SmiValuesAre32Bits() &&
+ store_mode() == STORE_TO_INITIALIZED_ENTRY) {
return Representation::Integer32();
}
return field_representation();
dominator_ = dominator;
return false;
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
HValue* object() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
HObjectAccess access() const { return access_; }
HValue* dominator() const { return dominator_; }
- bool has_transition() const { return has_transition_; }
- StoreFieldOrKeyedMode store_mode() const { return store_mode_; }
+ bool has_transition() const { return HasTransitionField::decode(bit_field_); }
+ StoreFieldOrKeyedMode store_mode() const {
+ return StoreModeField::decode(bit_field_);
+ }
Handle<Map> transition_map() const {
if (has_transition()) {
void SetTransition(HConstant* transition) {
DCHECK(!has_transition()); // Only set once.
SetOperandAt(2, transition);
- has_transition_ = true;
+ bit_field_ = HasTransitionField::update(bit_field_, true);
SetChangesFlag(kMaps);
}
}
private:
- HStoreNamedField(HValue* obj,
- HObjectAccess access,
- HValue* val,
+ HStoreNamedField(HValue* obj, HObjectAccess access, HValue* val,
StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE)
: access_(access),
dominator_(NULL),
- has_transition_(false),
- store_mode_(store_mode) {
+ bit_field_(HasTransitionField::encode(false) |
+ StoreModeField::encode(store_mode)) {
// Stores to a non existing in-object property are allowed only to the
// newly allocated objects (via HAllocate or HInnerAllocatedObject).
DCHECK(!access.IsInobject() || access.existing_inobject_property() ||
access.SetGVNFlags(this, STORE);
}
+ class HasTransitionField : public BitField<bool, 0, 1> {};
+ class StoreModeField : public BitField<StoreFieldOrKeyedMode, 1, 1> {};
+
HObjectAccess access_;
HValue* dominator_;
- bool has_transition_ : 1;
- StoreFieldOrKeyedMode store_mode_ : 1;
+ uint32_t bit_field_;
};
Handle<String> name() const { return name_; }
StrictMode strict_mode() const { return strict_mode_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
DCHECK_EQ(index, 2);
- return RequiredValueRepresentation(elements_kind_, store_mode_);
+ return RequiredValueRepresentation(elements_kind(), store_mode());
}
static Representation RequiredValueRepresentation(
if (IsUninitialized()) {
return Representation::None();
}
- Representation r = RequiredValueRepresentation(elements_kind_, store_mode_);
+ Representation r =
+ RequiredValueRepresentation(elements_kind(), store_mode());
// For fast object elements kinds, don't assume anything.
if (r.IsTagged()) return Representation::None();
return r;
HValue* elements() const { return OperandAt(0); }
HValue* key() const { return OperandAt(1); }
HValue* value() const { return OperandAt(2); }
- bool value_is_smi() const {
- return IsFastSmiElementsKind(elements_kind_);
+ bool value_is_smi() const { return IsFastSmiElementsKind(elements_kind()); }
+ StoreFieldOrKeyedMode store_mode() const {
+ return StoreModeField::decode(bit_field_);
+ }
+ ElementsKind elements_kind() const OVERRIDE {
+ return ElementsKindField::decode(bit_field_);
}
- StoreFieldOrKeyedMode store_mode() const { return store_mode_; }
- ElementsKind elements_kind() const { return elements_kind_; }
uint32_t base_offset() const { return base_offset_; }
- bool TryIncreaseBaseOffset(uint32_t increase_by_value);
- HValue* GetKey() { return key(); }
- void SetKey(HValue* key) { SetOperandAt(1, key); }
- bool IsDehoisted() const { return is_dehoisted_; }
- void SetDehoisted(bool is_dehoisted) { is_dehoisted_ = is_dehoisted; }
- bool IsUninitialized() { return is_uninitialized_; }
+ bool TryIncreaseBaseOffset(uint32_t increase_by_value) OVERRIDE;
+ HValue* GetKey() OVERRIDE { return key(); }
+ void SetKey(HValue* key) OVERRIDE { SetOperandAt(1, key); }
+ bool IsDehoisted() const OVERRIDE {
+ return IsDehoistedField::decode(bit_field_);
+ }
+ void SetDehoisted(bool is_dehoisted) OVERRIDE {
+ bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
+ }
+ bool IsUninitialized() { return IsUninitializedField::decode(bit_field_); }
void SetUninitialized(bool is_uninitialized) {
- is_uninitialized_ = is_uninitialized;
+ bit_field_ = IsUninitializedField::update(bit_field_, is_uninitialized);
}
bool IsConstantHoleStore() {
bool NeedsCanonicalization();
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed)
private:
- HStoreKeyed(HValue* obj, HValue* key, HValue* val,
- ElementsKind elements_kind,
+ HStoreKeyed(HValue* obj, HValue* key, HValue* val, ElementsKind elements_kind,
StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE,
int offset = kDefaultKeyedHeaderOffsetSentinel)
- : elements_kind_(elements_kind),
- base_offset_(offset == kDefaultKeyedHeaderOffsetSentinel
- ? GetDefaultHeaderSizeForElementsKind(elements_kind)
- : offset),
- is_dehoisted_(false),
- is_uninitialized_(false),
- store_mode_(store_mode),
- dominator_(NULL) {
+ : base_offset_(offset == kDefaultKeyedHeaderOffsetSentinel
+ ? GetDefaultHeaderSizeForElementsKind(elements_kind)
+ : offset),
+ bit_field_(IsDehoistedField::encode(false) |
+ IsUninitializedField::encode(false) |
+ StoreModeField::encode(store_mode) |
+ ElementsKindField::encode(elements_kind)),
+ dominator_(NULL) {
SetOperandAt(0, obj);
SetOperandAt(1, key);
SetOperandAt(2, val);
}
}
- ElementsKind elements_kind_;
+ class IsDehoistedField : public BitField<bool, 0, 1> {};
+ class IsUninitializedField : public BitField<bool, 1, 1> {};
+ class StoreModeField : public BitField<StoreFieldOrKeyedMode, 2, 1> {};
+ class ElementsKindField : public BitField<ElementsKind, 3, 5> {};
+
uint32_t base_offset_;
- bool is_dehoisted_ : 1;
- bool is_uninitialized_ : 1;
- StoreFieldOrKeyedMode store_mode_: 1;
+ uint32_t bit_field_;
HValue* dominator_;
};
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric)
ElementsKind from_kind() const { return from_kind_; }
ElementsKind to_kind() const { return to_kind_; }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
transitioned_map_ == instr->transitioned_map_;
}
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
private:
HTransitionElementsKind(HValue* context,
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StringAdd)
HValue*,
HValue*);
- virtual Representation RequiredInputRepresentation(int index) {
+ virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
// The index is supposed to be Integer32.
return index == 2
? Representation::Integer32()
DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral)
Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
- bool pretenure() const { return pretenure_; }
- bool has_no_literals() const { return has_no_literals_; }
- bool is_arrow() const { return IsArrowFunction(kind_); }
- bool is_generator() const { return IsGeneratorFunction(kind_); }
- bool is_concise_method() const { return IsConciseMethod(kind_); }
- FunctionKind kind() const { return kind_; }
- StrictMode strict_mode() const { return strict_mode_; }
+ bool pretenure() const { return PretenureField::decode(bit_field_); }
+ bool has_no_literals() const {
+ return HasNoLiteralsField::decode(bit_field_);
+ }
+ bool is_arrow() const { return IsArrowFunction(kind()); }
+ bool is_generator() const { return IsGeneratorFunction(kind()); }
+ bool is_concise_method() const { return IsConciseMethod(kind()); }
+ FunctionKind kind() const { return FunctionKindField::decode(bit_field_); }
+ StrictMode strict_mode() const { return StrictModeField::decode(bit_field_); }
private:
HFunctionLiteral(HValue* context, Handle<SharedFunctionInfo> shared,
bool pretenure)
: HTemplateInstruction<1>(HType::JSObject()),
shared_info_(shared),
- kind_(shared->kind()),
- pretenure_(pretenure),
- has_no_literals_(shared->num_literals() == 0),
- strict_mode_(shared->strict_mode()) {
+ bit_field_(FunctionKindField::encode(shared->kind()) |
+ PretenureField::encode(pretenure) |
+ HasNoLiteralsField::encode(shared->num_literals() == 0) |
+ StrictModeField::encode(shared->strict_mode())) {
SetOperandAt(0, context);
set_representation(Representation::Tagged());
SetChangesFlag(kNewSpacePromotion);
virtual bool IsDeletable() const OVERRIDE { return true; }
+ class FunctionKindField : public BitField<FunctionKind, 0, 3> {};
+ class PretenureField : public BitField<bool, 3, 1> {};
+ class HasNoLiteralsField : public BitField<bool, 4, 1> {};
+ class StrictModeField : public BitField<StrictMode, 5, 1> {};
+
Handle<SharedFunctionInfo> shared_info_;
- FunctionKind kind_;
- bool pretenure_ : 1;
- bool has_no_literals_ : 1;
- StrictMode strict_mode_;
+ uint32_t bit_field_;
};
HValue* context() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual HType CalculateInferredType() OVERRIDE {
if (value()->type().IsHeapObject()) return value()->type();
DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
protected:
- virtual int RedefinedOperandIndex() { return 0; }
+ virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
virtual bool DataEquals(HValue* other) OVERRIDE {
return true;
HValue* context() const { return OperandAt(0); }
HValue* enumerable() const { return OperandAt(1); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual HType CalculateInferredType() OVERRIDE {
return HType::Tagged();
index_cache_ = index_cache;
}
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual HType CalculateInferredType() OVERRIDE {
return HType::Tagged();
HValue* object() const { return OperandAt(0); }
HValue* index() const { return OperandAt(1); }
- virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
virtual HType CalculateInferredType() OVERRIDE {
return HType::Tagged();
HValue* context() { return OperandAt(0); }
- virtual Representation RequiredInputRepresentation(int index) {
+ virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
HValue* function() const { return OperandAt(1); }
Handle<ScopeInfo> scope_info() const { return scope_info_; }
- virtual Representation RequiredInputRepresentation(int index) {
+ virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
return Representation::Tagged();
}
- virtual OStream& PrintDataTo(OStream& os) const; // NOLINT
+ virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext)
void HRepresentationChangesPhase::InsertRepresentationChangesForValue(
HValue* value) {
Representation r = value->representation();
- if (r.IsNone()) return;
+ if (r.IsNone()) {
+#ifdef DEBUG
+ for (HUseIterator it(value->uses()); !it.Done(); it.Advance()) {
+ HValue* use_value = it.value();
+ int use_index = it.index();
+ Representation req = use_value->RequiredInputRepresentation(use_index);
+ DCHECK(req.IsNone());
+ }
+#endif
+ return;
+ }
if (value->HasNoUses()) {
if (value->IsForceRepresentation()) value->DeleteAndReplaceWith(NULL);
return;
}
-OStream& operator<<(OStream& os, const HType& t) {
+std::ostream& operator<<(std::ostream& os, const HType& t) {
// Note: The c1visualizer syntax for locals allows only a sequence of the
// following characters: A-Za-z0-9_-|:
switch (t.kind_) {
#define HYDROGEN_TYPES_H_
#include <climits>
+#include <iosfwd>
#include "src/base/macros.h"
// Forward declarations.
template <typename T> class Handle;
class Object;
-class OStream;
#define HTYPE_LIST(V) \
V(Any, 0x0) /* 0000 0000 0000 0000 */ \
static HType FromType(typename T::TypeHandle type) WARN_UNUSED_RESULT;
static HType FromValue(Handle<Object> value) WARN_UNUSED_RESULT;
- friend OStream& operator<<(OStream& os, const HType& t);
+ friend std::ostream& operator<<(std::ostream& os, const HType& t);
private:
enum Kind {
};
-OStream& operator<<(OStream& os, const HType& t);
+std::ostream& operator<<(std::ostream& os, const HType& t);
} } // namespace v8::internal
#endif // HYDROGEN_TYPES_H_
#include "src/hydrogen.h"
-#include <algorithm>
+#include <sstream>
#include "src/v8.h"
#include "src/allocation-site-scopes.h"
-#include "src/codegen.h"
+#include "src/ast-numbering.h"
#include "src/full-codegen.h"
-#include "src/hashmap.h"
#include "src/hydrogen-bce.h"
#include "src/hydrogen-bch.h"
#include "src/hydrogen-canonicalize.h"
#include "src/parser.h"
#include "src/runtime/runtime.h"
#include "src/scopeinfo.h"
-#include "src/scopes.h"
#include "src/typing.h"
#if V8_TARGET_ARCH_IA32
entry->set_position(position);
} else {
DCHECK(!FLAG_hydrogen_track_positions ||
- !graph()->info()->IsOptimizing());
+ !graph()->info()->IsOptimizing() || instr->IsAbnormalExit());
}
first_ = last_ = entry;
}
}
-HValue* HGraphBuilder::BuildAllocateElementsAndInitializeElementsHeader(
- ElementsKind kind,
- HValue* capacity) {
+HValue* HGraphBuilder::BuildAllocateAndInitializeArray(ElementsKind kind,
+ HValue* capacity) {
// The HForceRepresentation is to prevent possible deopt on int-smi
// conversion after allocation but before the new object fields are set.
capacity = AddUncasted<HForceRepresentation>(capacity, Representation::Smi());
HValue* size_in_bytes = BuildCalculateElementsSize(kind, capacity);
- HValue* new_elements = BuildAllocateElements(kind, size_in_bytes);
- BuildInitializeElementsHeader(new_elements, kind, capacity);
- return new_elements;
+ HValue* new_array = BuildAllocateElements(kind, size_in_bytes);
+ BuildInitializeElementsHeader(new_array, kind, capacity);
+ return new_array;
}
DCHECK(val == NULL);
HLoadKeyed* load = Add<HLoadKeyed>(
elements, checked_key, dependency, elements_kind, load_mode);
- if (FLAG_opt_safe_uint32_operations &&
- (elements_kind == EXTERNAL_UINT32_ELEMENTS ||
- elements_kind == UINT32_ELEMENTS)) {
+ if (elements_kind == EXTERNAL_UINT32_ELEMENTS ||
+ elements_kind == UINT32_ELEMENTS) {
graph()->RecordUint32Instruction(load);
}
return load;
(Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) >>
ElementsKindToShiftSize(new_kind)));
- HValue* new_elements = BuildAllocateElementsAndInitializeElementsHeader(
- new_kind, new_capacity);
+ HValue* new_elements =
+ BuildAllocateAndInitializeArray(new_kind, new_capacity);
BuildCopyElements(elements, kind, new_elements,
new_kind, length, new_capacity);
}
}
- // Since we're about to store a hole value, the store instruction below must
- // assume an elements kind that supports heap object values.
- if (IsFastSmiOrObjectElementsKind(elements_kind)) {
- elements_kind = FAST_HOLEY_ELEMENTS;
- }
-
if (initial_capacity >= 0) {
for (int i = 0; i < initial_capacity; i++) {
HInstruction* key = Add<HConstant>(i);
? Add<HConstant>(factory->the_hole_value())
: Add<HConstant>(nan_double);
+ // Since we're about to store a hole value, the store instruction below must
+ // assume an elements kind that supports heap object values.
+ if (IsFastSmiOrObjectElementsKind(elements_kind)) {
+ elements_kind = FAST_HOLEY_ELEMENTS;
+ }
+
BuildFillElementsWithValue(elements, elements_kind, from, to, hole);
}
+void HGraphBuilder::BuildCopyProperties(HValue* from_properties,
+ HValue* to_properties, HValue* length,
+ HValue* capacity) {
+ ElementsKind kind = FAST_ELEMENTS;
+
+ BuildFillElementsWithValue(to_properties, kind, length, capacity,
+ graph()->GetConstantUndefined());
+
+ LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
+
+ HValue* key = builder.BeginBody(length, graph()->GetConstant0(), Token::GT);
+
+ key = AddUncasted<HSub>(key, graph()->GetConstant1());
+ key->ClearFlag(HValue::kCanOverflow);
+
+ HValue* element =
+ Add<HLoadKeyed>(from_properties, key, static_cast<HValue*>(NULL), kind);
+
+ Add<HStoreKeyed>(to_properties, key, element, kind);
+
+ builder.EndBody();
+}
+
+
void HGraphBuilder::BuildCopyElements(HValue* from_elements,
ElementsKind from_elements_kind,
HValue* to_elements,
length, NULL);
}
- if (capacity == NULL) {
- capacity = AddLoadFixedArrayLength(to_elements);
- }
-
LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
HValue* key = builder.BeginBody(length, graph()->GetConstant0(),
}
-OStream& operator<<(OStream& os, const HBasicBlock& b) {
+std::ostream& operator<<(std::ostream& os, const HBasicBlock& b) {
return os << "B" << b.block_id();
}
maximum_environment_size_(0),
no_side_effects_scope_count_(0),
disallow_adding_new_values_(false),
- next_inline_id_(0),
- inlined_functions_(5, info->zone()) {
+ inlined_functions_(FLAG_hydrogen_track_positions ? 5 : 0, info->zone()),
+ inlining_id_to_function_id_(FLAG_hydrogen_track_positions ? 5 : 0,
+ info->zone()) {
if (info->IsStub()) {
CallInterfaceDescriptor descriptor =
info->code_stub()->GetCallInterfaceDescriptor();
os << "--- FUNCTION SOURCE (" << shared->DebugName()->ToCString().get()
<< ") id{" << info()->optimization_id() << "," << id << "} ---\n";
{
- ConsStringIteratorOp op;
StringCharacterStream stream(String::cast(script->source()),
- &op,
shared->start_position());
// fun->end_position() points to the last character in the stream. We
// need to compensate by adding one to calculate the length.
}
}
- int inline_id = next_inline_id_++;
+ int inline_id = inlining_id_to_function_id_.length();
+ inlining_id_to_function_id_.Add(id, zone());
if (inline_id != 0) {
CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
OFStream os(tracing_scope.file());
os << "INLINE (" << shared->DebugName()->ToCString().get() << ") id{"
<< info()->optimization_id() << "," << id << "} AS " << inline_id
- << " AT " << position << endl;
+ << " AT " << position << std::endl;
}
return inline_id;
return pos.raw();
}
- return inlined_functions_[pos.inlining_id()].start_position() +
- pos.position();
+ const int id = inlining_id_to_function_id_[pos.inlining_id()];
+ return inlined_functions_[id].start_position() + pos.position();
}
// Must be performed before canonicalization to ensure that Canonicalize
// will not remove semantically meaningful ToInt32 operations e.g. BIT_OR with
// zero.
- if (FLAG_opt_safe_uint32_operations) Run<HUint32AnalysisPhase>();
+ Run<HUint32AnalysisPhase>();
if (FLAG_use_canonicalizing) Run<HCanonicalizePhase>();
DCHECK(!CompileTimeValue::IsCompileTimeValue(value));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
CHECK_ALIVE(VisitForValue(value));
if (IsAccessor()) return true;
Handle<Map> map = this->map();
- map->LookupTransition(NULL, *name_, &lookup_);
+ map->LookupTransition(NULL, *name_, NONE, &lookup_);
if (lookup_.IsTransitionToField() && map->unused_property_fields() > 0) {
// Construct the object field access.
int descriptor = transition()->LastAdded();
HControlInstruction* smi_check = NULL;
handled_string = false;
- for (int i = 0; i < types->length() && count < kMaxLoadPolymorphism; ++i) {
+ for (i = 0; i < types->length() && count < kMaxLoadPolymorphism; ++i) {
PropertyAccessInfo info(this, access_type, ToType(types->at(i)), name);
if (info.type()->Is(Type::String())) {
if (handled_string) continue;
// know about and do not want to handle ones we've never seen. Otherwise
// use a generic IC.
if (count == types->length() && FLAG_deoptimize_uncommon_cases) {
- FinishExitWithHardDeoptimization("Uknown map in polymorphic access");
+ FinishExitWithHardDeoptimization("Unknown map in polymorphic access");
} else {
HInstruction* instr = BuildNamedGeneric(access_type, expr, object, name,
value);
bool is_uninitialized) {
if (!prop->key()->IsPropertyName()) {
// Keyed store.
- HValue* value = environment()->ExpressionStackAt(0);
- HValue* key = environment()->ExpressionStackAt(1);
- HValue* object = environment()->ExpressionStackAt(2);
+ HValue* value = Pop();
+ HValue* key = Pop();
+ HValue* object = Pop();
bool has_side_effects = false;
- HandleKeyedElementAccess(object, key, value, expr, ast_id, return_id, STORE,
- &has_side_effects);
- Drop(3);
- Push(value);
- Add<HSimulate>(return_id, REMOVABLE_SIMULATE);
- return ast_context()->ReturnValue(Pop());
+ HValue* result = HandleKeyedElementAccess(
+ object, key, value, expr, ast_id, return_id, STORE, &has_side_effects);
+ if (has_side_effects) {
+ if (!ast_context()->IsEffect()) Push(value);
+ Add<HSimulate>(ast_id, REMOVABLE_SIMULATE);
+ if (!ast_context()->IsEffect()) Drop(1);
+ }
+ if (result == NULL) return;
+ return ast_context()->ReturnValue(value);
}
// Named store.
}
+static bool CanInlineElementAccess(Handle<Map> map) {
+ return map->IsJSObjectMap() && !map->has_slow_elements_kind() &&
+ !map->has_indexed_interceptor();
+}
+
+
HInstruction* HOptimizedGraphBuilder::TryBuildConsolidatedElementLoad(
HValue* object,
HValue* key,
Handle<Map> most_general_consolidated_map;
for (int i = 0; i < maps->length(); ++i) {
Handle<Map> map = maps->at(i);
- if (!map->IsJSObjectMap()) return NULL;
+ if (!CanInlineElementAccess(map)) return NULL;
// Don't allow mixing of JSArrays with JSObjects.
if (map->instance_type() == JS_ARRAY_TYPE) {
if (has_non_js_array_access) return NULL;
MapHandleList possible_transitioned_maps(maps->length());
for (int i = 0; i < maps->length(); ++i) {
Handle<Map> map = maps->at(i);
+ DCHECK(!map->IsStringMap());
ElementsKind elements_kind = map->elements_kind();
- if (IsFastElementsKind(elements_kind) &&
+ if (CanInlineElementAccess(map) && IsFastElementsKind(elements_kind) &&
elements_kind != GetInitialFastElementsKind()) {
possible_transitioned_maps.Add(map);
}
if (untransitionable_maps.length() == 1) {
Handle<Map> untransitionable_map = untransitionable_maps[0];
HInstruction* instr = NULL;
- if (untransitionable_map->has_slow_elements_kind() ||
- !untransitionable_map->IsJSObjectMap()) {
+ if (!CanInlineElementAccess(untransitionable_map)) {
instr = AddInstruction(BuildKeyedGeneric(access_type, expr, object, key,
val));
} else {
store_mode);
}
*has_side_effects |= instr->HasObservableSideEffects();
- return access_type == STORE ? NULL : instr;
+ return access_type == STORE ? val : instr;
}
HBasicBlock* join = graph()->CreateBasicBlock();
for (int i = 0; i < untransitionable_maps.length(); ++i) {
Handle<Map> map = untransitionable_maps[i];
- if (!map->IsJSObjectMap()) continue;
ElementsKind elements_kind = map->elements_kind();
HBasicBlock* this_map = graph()->CreateBasicBlock();
HBasicBlock* other_map = graph()->CreateBasicBlock();
set_current_block(this_map);
HInstruction* access = NULL;
- if (IsDictionaryElementsKind(elements_kind)) {
+ if (!CanInlineElementAccess(map)) {
access = AddInstruction(BuildKeyedGeneric(access_type, expr, object, key,
val));
} else {
NoObservableSideEffectsScope scope(this);
FinishExitWithHardDeoptimization("Unknown map in polymorphic element access");
set_current_block(join);
- return access_type == STORE ? NULL : Pop();
+ return access_type == STORE ? val : Pop();
}
bool monomorphic = ComputeReceiverTypes(expr, obj, &types, zone());
bool force_generic = false;
- if (access_type == STORE &&
- (monomorphic || (types != NULL && !types->is_empty()))) {
+ if (access_type == STORE && expr->GetKeyType() == PROPERTY) {
+ // Non-Generic accesses assume that elements are being accessed, and will
+ // deopt for non-index keys, which the IC knows will occur.
+ // TODO(jkummerow): Consider adding proper support for property accesses.
+ force_generic = true;
+ monomorphic = false;
+ } else if (access_type == STORE &&
+ (monomorphic || (types != NULL && !types->is_empty()))) {
// Stores can't be mono/polymorphic if their prototype chain has dictionary
// elements. However a receiver map that has dictionary elements itself
// should be left to normal mono/poly behavior (the other maps may benefit
break;
}
}
+ } else if (access_type == LOAD && !monomorphic &&
+ (types != NULL && !types->is_empty())) {
+ // Polymorphic loads have to go generic if any of the maps are strings.
+ // If some, but not all of the maps are strings, we should go generic
+ // because polymorphic access wants to key on ElementsKind and isn't
+ // compatible with strings.
+ for (int i = 0; i < types->length(); i++) {
+ Handle<Map> current_map = types->at(i);
+ if (current_map->IsStringMap()) {
+ force_generic = true;
+ break;
+ }
+ }
}
if (monomorphic) {
Handle<Map> map = types->first();
- if (map->has_slow_elements_kind() || !map->IsJSObjectMap()) {
+ if (!CanInlineElementAccess(map)) {
instr = AddInstruction(BuildKeyedGeneric(access_type, expr, obj, key,
val));
} else {
// step, but don't transfer ownership to target_info.
target_info.SetAstValueFactory(top_info()->ast_value_factory(), false);
Handle<SharedFunctionInfo> target_shared(target->shared());
- if (!Parser::Parse(&target_info) || !Scope::Analyze(&target_info)) {
+ if (!Compiler::ParseAndAnalyze(&target_info)) {
if (target_info.isolate()->has_pending_exception()) {
// Parse or scope error, never optimize this function.
SetStackOverflow();
}
-bool HOptimizedGraphBuilder::TryInlineApply(Handle<JSFunction> function,
- Call* expr,
- int arguments_count) {
+bool HOptimizedGraphBuilder::TryInlineIndirectCall(Handle<JSFunction> function,
+ Call* expr,
+ int arguments_count) {
return TryInline(function,
arguments_count,
NULL,
bool HOptimizedGraphBuilder::TryInlineBuiltinMethodCall(
- Call* expr,
- HValue* receiver,
- Handle<Map> receiver_map) {
+ Call* expr, Handle<JSFunction> function, Handle<Map> receiver_map,
+ int args_count_no_receiver) {
+ if (!function->shared()->HasBuiltinFunctionId()) return false;
+ BuiltinFunctionId id = function->shared()->builtin_function_id();
+ int argument_count = args_count_no_receiver + 1; // Plus receiver.
+
+ if (receiver_map.is_null()) {
+ HValue* receiver = environment()->ExpressionStackAt(args_count_no_receiver);
+ if (receiver->IsConstant() &&
+ HConstant::cast(receiver)->handle(isolate())->IsHeapObject()) {
+ receiver_map =
+ handle(Handle<HeapObject>::cast(
+ HConstant::cast(receiver)->handle(isolate()))->map());
+ }
+ }
// Try to inline calls like Math.* as operations in the calling function.
- if (!expr->target()->shared()->HasBuiltinFunctionId()) return false;
- BuiltinFunctionId id = expr->target()->shared()->builtin_function_id();
- int argument_count = expr->arguments()->length() + 1; // Plus receiver.
switch (id) {
case kStringCharCodeAt:
case kStringCharAt:
if (receiver_map->is_observed()) return false;
if (!receiver_map->is_extensible()) return false;
- Drop(expr->arguments()->length());
+ Drop(args_count_no_receiver);
HValue* result;
HValue* reduced_length;
HValue* receiver = Pop();
Handle<JSObject> prototype(JSObject::cast(receiver_map->prototype()));
BuildCheckPrototypeMaps(prototype, Handle<JSObject>());
- const int argc = expr->arguments()->length();
+ const int argc = args_count_no_receiver;
if (argc != 1) return false;
HValue* value_to_push = Pop();
// Threshold for fast inlined Array.shift().
HConstant* inline_threshold = Add<HConstant>(static_cast<int32_t>(16));
- Drop(expr->arguments()->length());
+ Drop(args_count_no_receiver);
HValue* receiver = Pop();
HValue* function = Pop();
HValue* result;
}
-bool HOptimizedGraphBuilder::TryCallApply(Call* expr) {
+void HOptimizedGraphBuilder::HandleIndirectCall(Call* expr, HValue* function,
+ int arguments_count) {
+ Handle<JSFunction> known_function;
+ int args_count_no_receiver = arguments_count - 1;
+ if (function->IsConstant() &&
+ HConstant::cast(function)->handle(isolate())->IsJSFunction()) {
+ HValue* receiver = environment()->ExpressionStackAt(args_count_no_receiver);
+ Handle<Map> receiver_map;
+ if (receiver->IsConstant() &&
+ HConstant::cast(receiver)->handle(isolate())->IsHeapObject()) {
+ receiver_map =
+ handle(Handle<HeapObject>::cast(
+ HConstant::cast(receiver)->handle(isolate()))->map());
+ }
+
+ known_function =
+ Handle<JSFunction>::cast(HConstant::cast(function)->handle(isolate()));
+ if (TryInlineBuiltinMethodCall(expr, known_function, receiver_map,
+ args_count_no_receiver)) {
+ if (FLAG_trace_inlining) {
+ PrintF("Inlining builtin ");
+ known_function->ShortPrint();
+ PrintF("\n");
+ }
+ return;
+ }
+
+ if (TryInlineIndirectCall(known_function, expr, args_count_no_receiver)) {
+ return;
+ }
+ }
+
+ PushArgumentsFromEnvironment(arguments_count);
+ HInvokeFunction* call =
+ New<HInvokeFunction>(function, known_function, arguments_count);
+ Drop(1); // Function
+ ast_context()->ReturnInstruction(call, expr->id());
+}
+
+
+bool HOptimizedGraphBuilder::TryIndirectCall(Call* expr) {
DCHECK(expr->expression()->IsProperty());
if (!expr->IsMonomorphic()) {
}
Handle<Map> function_map = expr->GetReceiverTypes()->first();
if (function_map->instance_type() != JS_FUNCTION_TYPE ||
- !expr->target()->shared()->HasBuiltinFunctionId() ||
- expr->target()->shared()->builtin_function_id() != kFunctionApply) {
+ !expr->target()->shared()->HasBuiltinFunctionId()) {
return false;
}
- if (current_info()->scope()->arguments() == NULL) return false;
+ switch (expr->target()->shared()->builtin_function_id()) {
+ case kFunctionCall: {
+ if (expr->arguments()->length() == 0) return false;
+ BuildFunctionCall(expr);
+ return true;
+ }
+ case kFunctionApply: {
+ // For .apply, only the pattern f.apply(receiver, arguments)
+ // is supported.
+ if (current_info()->scope()->arguments() == NULL) return false;
- ZoneList<Expression*>* args = expr->arguments();
- if (args->length() != 2) return false;
+ ZoneList<Expression*>* args = expr->arguments();
+ if (args->length() != 2) return false;
+
+ VariableProxy* arg_two = args->at(1)->AsVariableProxy();
+ if (arg_two == NULL || !arg_two->var()->IsStackAllocated()) return false;
+ HValue* arg_two_value = LookupAndMakeLive(arg_two->var());
+ if (!arg_two_value->CheckFlag(HValue::kIsArguments)) return false;
+ BuildFunctionApply(expr);
+ return true;
+ }
+ default: { return false; }
+ }
+ UNREACHABLE();
+}
- VariableProxy* arg_two = args->at(1)->AsVariableProxy();
- if (arg_two == NULL || !arg_two->var()->IsStackAllocated()) return false;
- HValue* arg_two_value = LookupAndMakeLive(arg_two->var());
- if (!arg_two_value->CheckFlag(HValue::kIsArguments)) return false;
- // Found pattern f.apply(receiver, arguments).
- CHECK_ALIVE_OR_RETURN(VisitForValue(args->at(0)), true);
+void HOptimizedGraphBuilder::BuildFunctionApply(Call* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ CHECK_ALIVE(VisitForValue(args->at(0)));
HValue* receiver = Pop(); // receiver
HValue* function = Pop(); // f
Drop(1); // apply
+ Handle<Map> function_map = expr->GetReceiverTypes()->first();
HValue* checked_function = AddCheckMap(function, function_map);
if (function_state()->outer() == NULL) {
length,
elements);
ast_context()->ReturnInstruction(result, expr->id());
- return true;
} else {
// We are inside inlined function and we know exactly what is inside
// arguments object. But we need to be able to materialize at deopt.
for (int i = 1; i < arguments_count; i++) {
Push(arguments_values->at(i));
}
+ HandleIndirectCall(expr, function, arguments_count);
+ }
+}
- Handle<JSFunction> known_function;
- if (function->IsConstant() &&
- HConstant::cast(function)->handle(isolate())->IsJSFunction()) {
- known_function = Handle<JSFunction>::cast(
- HConstant::cast(function)->handle(isolate()));
- int args_count = arguments_count - 1; // Excluding receiver.
- if (TryInlineApply(known_function, expr, args_count)) return true;
- }
- PushArgumentsFromEnvironment(arguments_count);
- HInvokeFunction* call = New<HInvokeFunction>(
- function, known_function, arguments_count);
- Drop(1); // Function.
- ast_context()->ReturnInstruction(call, expr->id());
- return true;
- }
+// f.call(...)
+void HOptimizedGraphBuilder::BuildFunctionCall(Call* expr) {
+ HValue* function = Top(); // f
+ Handle<Map> function_map = expr->GetReceiverTypes()->first();
+ HValue* checked_function = AddCheckMap(function, function_map);
+
+ // f and call are on the stack in the unoptimized code
+ // during evaluation of the arguments.
+ CHECK_ALIVE(VisitExpressions(expr->arguments()));
+
+ int args_length = expr->arguments()->length();
+ int receiver_index = args_length - 1;
+ // Patch the receiver.
+ HValue* receiver = BuildWrapReceiver(
+ environment()->ExpressionStackAt(receiver_index), checked_function);
+ environment()->SetExpressionStackAt(receiver_index, receiver);
+
+ // Call must not be on the stack from now on.
+ int call_index = args_length + 1;
+ environment()->RemoveExpressionStackAt(call_index);
+
+ HandleIndirectCall(expr, function, args_length);
}
HConstant::cast(function)->handle(isolate()));
expr->set_target(known_function);
- if (TryCallApply(expr)) return;
+ if (TryIndirectCall(expr)) return;
CHECK_ALIVE(VisitExpressions(expr->arguments()));
Handle<Map> map = types->length() == 1 ? types->first() : Handle<Map>();
- if (TryInlineBuiltinMethodCall(expr, receiver, map)) {
+ if (TryInlineBuiltinMethodCall(expr, known_function, map,
+ expr->arguments()->length())) {
if (FLAG_trace_inlining) {
PrintF("Inlining builtin ");
known_function->ShortPrint();
LookupIterator::OWN_SKIP_INTERCEPTOR);
GlobalPropertyAccess type = LookupGlobalProperty(var, &it, LOAD);
if (type == kUseCell) {
- Handle<GlobalObject> global(current_info()->global_object());
known_global_function = expr->ComputeGlobalTarget(global, &it);
}
if (known_global_function) {
break;
case Token::SHR:
instr = AddUncasted<HShr>(left, right);
- if (FLAG_opt_safe_uint32_operations && instr->IsShr() &&
- CanBeZero(right)) {
+ if (instr->IsShr() && CanBeZero(right)) {
graph()->RecordUint32Instruction(instr);
}
break;
}
+void HOptimizedGraphBuilder::GenerateIsJSProxy(CallRuntime* call) {
+ DCHECK(call->arguments()->length() == 1);
+ CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+ HValue* value = Pop();
+ HIfContinuation continuation;
+ IfBuilder if_proxy(this);
+
+ HValue* smicheck = if_proxy.IfNot<HIsSmiAndBranch>(value);
+ if_proxy.And();
+ HValue* map = Add<HLoadNamedField>(value, smicheck, HObjectAccess::ForMap());
+ HValue* instance_type = Add<HLoadNamedField>(
+ map, static_cast<HValue*>(NULL), HObjectAccess::ForMapInstanceType());
+ if_proxy.If<HCompareNumericAndBranch>(
+ instance_type, Add<HConstant>(FIRST_JS_PROXY_TYPE), Token::GTE);
+ if_proxy.And();
+ if_proxy.If<HCompareNumericAndBranch>(
+ instance_type, Add<HConstant>(LAST_JS_PROXY_TYPE), Token::LTE);
+
+ if_proxy.CaptureContinuation(&continuation);
+ return ast_context()->ReturnContinuation(&continuation, call->id());
+}
+
+
void HOptimizedGraphBuilder::GenerateIsNonNegativeSmi(CallRuntime* call) {
return Bailout(kInlinedRuntimeFunctionIsNonNegativeSmi);
}
}
+HValue* HEnvironment::RemoveExpressionStackAt(int index_from_top) {
+ int count = index_from_top + 1;
+ int index = values_.length() - count;
+ DCHECK(HasExpressionAt(index));
+ // Simulate popping 'count' elements and then
+ // pushing 'count - 1' elements back.
+ pop_count_ += Max(count - push_count_, 0);
+ push_count_ = Max(push_count_ - count, 0) + (count - 1);
+ return values_.Remove(index);
+}
+
+
void HEnvironment::Drop(int count) {
for (int i = 0; i < count; ++i) {
Pop();
}
-OStream& operator<<(OStream& os, const HEnvironment& env) {
+std::ostream& operator<<(std::ostream& os, const HEnvironment& env) {
for (int i = 0; i < env.length(); i++) {
if (i == 0) os << "parameters\n";
if (i == env.parameter_count()) os << "specials\n";
for (int j = 0; j < total; ++j) {
HPhi* phi = current->phis()->at(j);
PrintIndent();
- OStringStream os;
+ std::ostringstream os;
os << phi->merged_index() << " " << NameOf(phi) << " " << *phi << "\n";
- trace_.Add(os.c_str());
+ trace_.Add(os.str().c_str());
}
}
HInstruction* instruction = it.Current();
int uses = instruction->UseCount();
PrintIndent();
- OStringStream os;
+ std::ostringstream os;
os << "0 " << uses << " " << NameOf(instruction) << " " << *instruction;
if (FLAG_hydrogen_track_positions &&
instruction->has_position() &&
os << pos.position();
}
os << " <|@\n";
- trace_.Add(os.c_str());
+ trace_.Add(os.str().c_str());
}
}
trace_.Add("%d ",
LifetimePosition::FromInstructionIndex(i).Value());
linstr->PrintTo(&trace_);
- OStringStream os;
+ std::ostringstream os;
os << " [hir:" << NameOf(linstr->hydrogen_value()) << "] <|@\n";
- trace_.Add(os.c_str());
+ trace_.Add(os.str().c_str());
}
}
}
}
-void HStatistics::Print(const char* stats_name) {
+void HStatistics::Print() {
PrintF(
"\n"
"----------------------------------------"
"----------------------------------------\n"
- "--- %s timing results:\n"
+ "--- Hydrogen timing results:\n"
"----------------------------------------"
- "----------------------------------------\n",
- stats_name);
+ "----------------------------------------\n");
base::TimeDelta sum;
for (int i = 0; i < times_.length(); ++i) {
sum += times_[i];
double normalized_time = source_size_in_kb > 0
? total.InMillisecondsF() / source_size_in_kb
: 0;
- double normalized_size_in_kb = source_size_in_kb > 0
- ? total_size_ / 1024 / source_size_in_kb
- : 0;
+ double normalized_size_in_kb =
+ source_size_in_kb > 0
+ ? static_cast<double>(total_size_) / 1024 / source_size_in_kb
+ : 0;
PrintF("%33s %8.3f ms %7.3f kB allocated\n",
"Average per kB source", normalized_time, normalized_size_in_kb);
}
};
-OStream& operator<<(OStream& os, const HBasicBlock& b);
+std::ostream& operator<<(std::ostream& os, const HBasicBlock& b);
class HPredecessorIterator FINAL BASE_EMBEDDED {
HEnvironment* start_environment() const { return start_environment_; }
void FinalizeUniqueness();
- bool ProcessArgumentsObject();
void OrderBlocks();
void AssignDominators();
void RestoreActualValues();
phase.Run();
}
- void EliminateRedundantBoundsChecksUsingInductionVariables();
-
Isolate* isolate_;
int next_block_id_;
HBasicBlock* entry_block_;
int start_position_;
};
- int next_inline_id_;
ZoneList<InlinedFunctionInfo> inlined_functions_;
+ ZoneList<int> inlining_id_to_function_id_;
DISALLOW_COPY_AND_ASSIGN(HGraph);
};
}
void SetExpressionStackAt(int index_from_top, HValue* value);
+ HValue* RemoveExpressionStackAt(int index_from_top);
HEnvironment* Copy() const;
HEnvironment* CopyWithoutHistory() const;
};
-OStream& operator<<(OStream& os, const HEnvironment& env);
+std::ostream& operator<<(std::ostream& os, const HEnvironment& env);
class HOptimizedGraphBuilder;
ElementsKind kind,
HValue* capacity);
- HValue* BuildAllocateElementsAndInitializeElementsHeader(ElementsKind kind,
- HValue* capacity);
+ // Build allocation and header initialization code for respective successor
+ // of FixedArrayBase.
+ HValue* BuildAllocateAndInitializeArray(ElementsKind kind, HValue* capacity);
// |array| must have been allocated with enough room for
// 1) the JSArray and 2) an AllocationMemento if mode requires it.
HValue* from,
HValue* to);
+ void BuildCopyProperties(HValue* from_properties, HValue* to_properties,
+ HValue* length, HValue* capacity);
+
void BuildCopyElements(HValue* from_elements,
ElementsKind from_elements_kind,
HValue* to_elements,
void VisitLogicalExpression(BinaryOperation* expr);
void VisitArithmeticExpression(BinaryOperation* expr);
- bool PreProcessOsrEntry(IterationStatement* statement);
void VisitLoopBody(IterationStatement* stmt,
HBasicBlock* loop_entry);
void EnsureArgumentsArePushedForAccess();
bool TryArgumentsAccess(Property* expr);
- // Try to optimize fun.apply(receiver, arguments) pattern.
- bool TryCallApply(Call* expr);
+ // Shared code for .call and .apply optimizations.
+ void HandleIndirectCall(Call* expr, HValue* function, int arguments_count);
+ // Try to optimize indirect calls such as fun.apply(receiver, arguments)
+ // or fun.call(...).
+ bool TryIndirectCall(Call* expr);
+ void BuildFunctionApply(Call* expr);
+ void BuildFunctionCall(Call* expr);
bool TryHandleArrayCall(Call* expr, HValue* function);
bool TryHandleArrayCallNew(CallNew* expr, HValue* function);
BailoutId id,
BailoutId assignment_id,
HValue* implicit_return_value);
- bool TryInlineApply(Handle<JSFunction> function,
- Call* expr,
- int arguments_count);
- bool TryInlineBuiltinMethodCall(Call* expr,
- HValue* receiver,
- Handle<Map> receiver_map);
+ bool TryInlineIndirectCall(Handle<JSFunction> function, Call* expr,
+ int arguments_count);
+ bool TryInlineBuiltinMethodCall(Call* expr, Handle<JSFunction> function,
+ Handle<Map> receiver_map,
+ int args_count_no_receiver);
bool TryInlineBuiltinFunctionCall(Call* expr);
enum ApiCallType {
kCallApiFunction,
source_size_(0) { }
void Initialize(CompilationInfo* info);
- void Print(const char* stats_name);
+ void Print();
void SaveTiming(const char* name, base::TimeDelta time, unsigned size);
void IncrementFullCodeGen(base::TimeDelta full_code_gen) {
return NULL;
}
+ isolate->CountUsage(v8::Isolate::UseCounterFeature::kBreakIterator);
+
return break_iterator;
}
}
-void Assembler::ror(Register dst, uint8_t imm8) {
+void Assembler::ror(const Operand& dst, uint8_t imm8) {
EnsureSpace ensure_space(this);
DCHECK(is_uint5(imm8)); // illegal shift count
if (imm8 == 1) {
EMIT(0xD1);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
} else {
EMIT(0xC1);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
EMIT(imm8);
}
}
-void Assembler::ror_cl(Register dst) {
+void Assembler::ror_cl(const Operand& dst) {
EnsureSpace ensure_space(this);
EMIT(0xD3);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
}
}
-void Assembler::cvtss2sd(XMMRegister dst, XMMRegister src) {
+void Assembler::cvtss2sd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF3);
EMIT(0x0F);
}
-void Assembler::cvtsd2ss(XMMRegister dst, XMMRegister src) {
+void Assembler::cvtsd2ss(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
EMIT(0x0F);
}
-void Assembler::addsd(XMMRegister dst, XMMRegister src) {
- EnsureSpace ensure_space(this);
- EMIT(0xF2);
- EMIT(0x0F);
- EMIT(0x58);
- emit_sse_operand(dst, src);
-}
-
-
void Assembler::addsd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
}
-void Assembler::mulsd(XMMRegister dst, XMMRegister src) {
- EnsureSpace ensure_space(this);
- EMIT(0xF2);
- EMIT(0x0F);
- EMIT(0x59);
- emit_sse_operand(dst, src);
-}
-
-
void Assembler::mulsd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
}
-void Assembler::subsd(XMMRegister dst, XMMRegister src) {
- EnsureSpace ensure_space(this);
- EMIT(0xF2);
- EMIT(0x0F);
- EMIT(0x5C);
- emit_sse_operand(dst, src);
-}
-
-
void Assembler::subsd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
}
-void Assembler::divsd(XMMRegister dst, XMMRegister src) {
+void Assembler::divsd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
EMIT(0x0F);
}
-void Assembler::sqrtsd(XMMRegister dst, XMMRegister src) {
- EnsureSpace ensure_space(this);
- EMIT(0xF2);
- EMIT(0x0F);
- EMIT(0x51);
- emit_sse_operand(dst, src);
-}
-
-
void Assembler::sqrtsd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0xF2);
}
+void Assembler::pslld(XMMRegister reg, int8_t shift) {
+ EnsureSpace ensure_space(this);
+ EMIT(0x66);
+ EMIT(0x0F);
+ EMIT(0x72);
+ emit_sse_operand(esi, reg); // esi == 6
+ EMIT(shift);
+}
+
+
+void Assembler::psrld(XMMRegister reg, int8_t shift) {
+ EnsureSpace ensure_space(this);
+ EMIT(0x66);
+ EMIT(0x0F);
+ EMIT(0x72);
+ emit_sse_operand(edx, reg); // edx == 2
+ EMIT(shift);
+}
+
+
void Assembler::psllq(XMMRegister reg, int8_t shift) {
EnsureSpace ensure_space(this);
EMIT(0x66);
void rcl(Register dst, uint8_t imm8);
void rcr(Register dst, uint8_t imm8);
- void ror(Register dst, uint8_t imm8);
- void ror_cl(Register dst);
+
+ void ror(Register dst, uint8_t imm8) { ror(Operand(dst), imm8); }
+ void ror(const Operand& dst, uint8_t imm8);
+ void ror_cl(Register dst) { ror_cl(Operand(dst)); }
+ void ror_cl(const Operand& dst);
void sar(Register dst, uint8_t imm8) { sar(Operand(dst), imm8); }
void sar(const Operand& dst, uint8_t imm8);
void cvtsi2sd(XMMRegister dst, Register src) { cvtsi2sd(dst, Operand(src)); }
void cvtsi2sd(XMMRegister dst, const Operand& src);
- void cvtss2sd(XMMRegister dst, XMMRegister src);
- void cvtsd2ss(XMMRegister dst, XMMRegister src);
-
- void addsd(XMMRegister dst, XMMRegister src);
+ void cvtss2sd(XMMRegister dst, const Operand& src);
+ void cvtss2sd(XMMRegister dst, XMMRegister src) {
+ cvtss2sd(dst, Operand(src));
+ }
+ void cvtsd2ss(XMMRegister dst, const Operand& src);
+ void cvtsd2ss(XMMRegister dst, XMMRegister src) {
+ cvtsd2ss(dst, Operand(src));
+ }
+ void addsd(XMMRegister dst, XMMRegister src) { addsd(dst, Operand(src)); }
void addsd(XMMRegister dst, const Operand& src);
- void subsd(XMMRegister dst, XMMRegister src);
+ void subsd(XMMRegister dst, XMMRegister src) { subsd(dst, Operand(src)); }
void subsd(XMMRegister dst, const Operand& src);
- void mulsd(XMMRegister dst, XMMRegister src);
+ void mulsd(XMMRegister dst, XMMRegister src) { mulsd(dst, Operand(src)); }
void mulsd(XMMRegister dst, const Operand& src);
- void divsd(XMMRegister dst, XMMRegister src);
+ void divsd(XMMRegister dst, XMMRegister src) { divsd(dst, Operand(src)); }
+ void divsd(XMMRegister dst, const Operand& src);
void xorpd(XMMRegister dst, XMMRegister src);
- void sqrtsd(XMMRegister dst, XMMRegister src);
+ void sqrtsd(XMMRegister dst, XMMRegister src) { sqrtsd(dst, Operand(src)); }
void sqrtsd(XMMRegister dst, const Operand& src);
void andpd(XMMRegister dst, XMMRegister src);
void por(XMMRegister dst, XMMRegister src);
void ptest(XMMRegister dst, XMMRegister src);
+ void pslld(XMMRegister reg, int8_t shift);
+ void psrld(XMMRegister reg, int8_t shift);
void psllq(XMMRegister reg, int8_t shift);
void psllq(XMMRegister dst, XMMRegister src);
void psrlq(XMMRegister reg, int8_t shift);
__ bind(&loop);
__ mov(receiver, Operand(ebp, kArgumentsOffset)); // load arguments
- // Use inline caching to speed up access to arguments.
if (FLAG_vector_ics) {
- __ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(0)));
+ // TODO(mvstanton): Vector-based ics need additional infrastructure to
+ // be embedded here. For now, just call the runtime.
+ __ push(receiver);
+ __ push(key);
+ __ CallRuntime(Runtime::kGetProperty, 2);
+ } else {
+ // Use inline caching to speed up access to arguments.
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
+ __ call(ic, RelocInfo::CODE_TARGET);
+ // It is important that we do not have a test instruction after the
+ // call. A test instruction after the call is used to indicate that
+ // we have generated an inline version of the keyed load. In this
+ // case, we know that we are not generating a test instruction next.
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
- __ call(ic, RelocInfo::CODE_TARGET);
- // It is important that we do not have a test instruction after the
- // call. A test instruction after the call is used to indicate that
- // we have generated an inline version of the keyed load. In this
- // case, we know that we are not generating a test instruction next.
// Push the nth argument.
__ push(eax);
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is on the stack.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = ebx;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+ Register result = eax;
+ DCHECK(!result.is(scratch));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ ret(0);
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
// The key is in edx and the parameter count is in eax.
DCHECK(edx.is(ArgumentsAccessReadDescriptor::index()));
__ mov(FieldOperand(ebx, edx, times_half_pointer_size,
FixedArray::kHeaderSize),
Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate)));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ sub(FieldOperand(ebx, with_types_offset), Immediate(Smi::FromInt(1)));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ add(FieldOperand(ebx, generic_offset), Immediate(Smi::FromInt(1)));
__ jmp(&slow_start);
}
void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
// If the receiver is a smi trigger the non-string case.
STATIC_ASSERT(kSmiTag == 0);
- __ JumpIfSmi(object_, receiver_not_string_);
-
- // Fetch the instance type of the receiver into result register.
- __ mov(result_, FieldOperand(object_, HeapObject::kMapOffset));
- __ movzx_b(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ test(result_, Immediate(kIsNotStringMask));
- __ j(not_zero, receiver_not_string_);
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ mov(result_, FieldOperand(object_, HeapObject::kMapOffset));
+ __ movzx_b(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ test(result_, Immediate(kIsNotStringMask));
+ __ j(not_zero, receiver_not_string_);
+ }
// If the index is non-smi trigger the non-smi case.
STATIC_ASSERT(kSmiTag == 0);
// ebx: instance type
// ecx: sub string length (smi)
// edx: from index (smi)
- StringCharAtGenerator generator(
- eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(eax, edx, ecx, eax, &runtime, &runtime,
+ &runtime, STRING_INDEX_IS_NUMBER,
+ RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ ret(3 * kPointerSize);
generator.SkipSlow(masm, &runtime);
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in eax.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(eax, &check_heap_number, Label::kNear);
+ __ Ret();
+
+ __ bind(&check_heap_number);
+ __ CompareMap(eax, masm->isolate()->factory()->heap_number_map());
+ __ j(not_equal, &call_builtin, Label::kNear);
+ __ Ret();
+
+ __ bind(&call_builtin);
+ __ pop(ecx); // Pop return address.
+ __ push(eax);
+ __ push(ecx); // Push return address.
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(MacroAssembler* masm,
Register left,
Register right,
__ mov(FieldOperand(eax, FixedArray::kLengthOffset), ebx);
__ mov(edi, FieldOperand(edx, JSObject::kElementsOffset));
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ jmp(&initialization_loop_entry, Label::kNear);
+ __ bind(&initialization_loop);
+ __ mov(FieldOperand(eax, ebx, times_2, FixedArray::kHeaderSize),
+ masm->isolate()->factory()->the_hole_value());
+ __ bind(&initialization_loop_entry);
+ __ sub(ebx, Immediate(Smi::FromInt(1)));
+ __ j(not_sign, &initialization_loop);
+
+ __ mov(ebx, FieldOperand(edi, FixedDoubleArray::kLengthOffset));
__ jmp(&entry);
// ebx: target map
// Register state for IC load call (from ic-ia32.cc).
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0, false);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0, false);
}
NameOfXMMRegister(regop),
NameOfXMMRegister(rm));
data++;
+ } else if (*data == 0x72) {
+ data++;
+ int mod, regop, rm;
+ get_modrm(*data, &mod, ®op, &rm);
+ int8_t imm8 = static_cast<int8_t>(data[1]);
+ DCHECK(regop == esi || regop == edx);
+ AppendToBuffer("%s %s,%d", (regop == esi) ? "pslld" : "psrld",
+ NameOfXMMRegister(rm), static_cast<int>(imm8));
+ data += 2;
} else if (*data == 0x73) {
data++;
int mod, regop, rm;
//------------------------------------------------------------------------------
-static const char* cpu_regs[8] = {
+static const char* const cpu_regs[8] = {
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
};
-static const char* byte_cpu_regs[8] = {
+static const char* const byte_cpu_regs[8] = {
"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"
};
-static const char* xmm_regs[8] = {
+static const char* const xmm_regs[8] = {
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
};
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
__ push(eax);
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ push(eax);
// Check for proxies.
__ bind(&call_runtime);
__ push(eax);
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
__ cmp(FieldOperand(eax, HeapObject::kMapOffset),
isolate()->factory()->meta_map());
__ j(not_equal, &fixed_array);
// No need for a write barrier, we are storing a Smi in the feedback vector.
__ LoadHeapObject(ebx, FeedbackVector());
- __ mov(FieldOperand(ebx, FixedArray::OffsetOfElementAt(slot)),
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ mov(FieldOperand(ebx, FixedArray::OffsetOfElementAt(vector_index)),
Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate())));
__ mov(ebx, Immediate(Smi::FromInt(1))); // Smi indicates slow check
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ mov(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Immediate(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
__ cmp(eax, isolate()->factory()->undefined_value());
Label done;
__ mov(LoadDescriptor::NameRegister(), proxy->var()->name());
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ mov(LoadDescriptor::NameRegister(), var->name());
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(eax);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in eax.
DCHECK(!CompileTimeValue::IsCompileTimeValue(value));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ push(Operand(esp, 0)); // Duplicate receiver.
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
VisitForStackValue(property->obj());
}
break;
+ case KEYED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(result_register());
+ }
+ break;
case KEYED_PROPERTY: {
if (expr->is_compound()) {
VisitForStackValue(property->obj());
EmitNamedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(result_register());
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(result_register());
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ mov(load_receiver, Operand(esp, kPointerSize));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
isolate()->factory()->done_string()); // "done"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->DoneFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->DoneFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // result.done in eax
Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
isolate()->factory()->value_string()); // "value"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->ValueFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->ValueFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // result.value in eax
context()->DropAndPlug(2, eax); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), eax, ecx, edx, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, eax, ecx, edx, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ mov(context_register(),
Operand(ebp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ mov(ebx, map);
+ __ mov(ebx, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ mov(ebx, FieldOperand(ebx, GlobalObject::kNativeContextOffset));
+ __ mov(ebx, ContextOperand(ebx, Context::ITERATOR_RESULT_MAP_INDEX));
__ pop(ecx);
__ mov(edx, isolate()->factory()->ToBoolean(done));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ mov(FieldOperand(eax, HeapObject::kMapOffset), ebx);
__ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
isolate()->factory()->empty_fixed_array());
__ mov(LoadDescriptor::NameRegister(), Immediate(key->value()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Immediate(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Immediate(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in eax.
+ DCHECK(lit != NULL);
+ __ push(eax);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = ebx;
+ __ mov(scratch, FieldOperand(eax, JSFunction::kPrototypeOrInitialMapOffset));
+ __ Push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ push(Operand(esp, kPointerSize)); // constructor
+ } else {
+ __ push(Operand(esp, 0)); // prototype
+ }
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ push(eax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; eax: home_object
+ Register scratch = ecx;
+ Register scratch2 = edx;
+ __ mov(scratch, result_register()); // home_object
+ __ mov(eax, MemOperand(esp, kPointerSize)); // value
+ __ mov(scratch2, MemOperand(esp, 0)); // this
+ __ mov(MemOperand(esp, kPointerSize), scratch2); // this
+ __ mov(MemOperand(esp, 0), scratch); // home_object
+ // stack: this, home_object. eax: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ push(eax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = ecx;
+ Register scratch2 = edx;
+ __ mov(scratch2, MemOperand(esp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; eax: key, edx: value
+ __ mov(scratch, MemOperand(esp, kPointerSize)); // this
+ __ mov(MemOperand(esp, 2 * kPointerSize), scratch);
+ __ mov(scratch, MemOperand(esp, 0)); // home_object
+ __ mov(MemOperand(esp, kPointerSize), scratch);
+ __ mov(MemOperand(esp, 0), eax);
+ __ mov(eax, scratch2);
+ // stack: this, home_object, key; eax: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ push(eax); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// eax : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ push(eax);
__ push(Immediate(key->value()));
+ __ push(eax);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(eax);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // eax : value
+ // stack : receiver ('this'), home_object, key
+
+ __ push(eax);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(eax);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ pop(LoadDescriptor::ReceiverRegister()); // Object.
- __ Move(LoadDescriptor::NameRegister(), result_register()); // Key.
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ pop(LoadDescriptor::ReceiverRegister()); // Object.
+ __ Move(LoadDescriptor::NameRegister(), result_register()); // Key.
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(eax);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ SuperReference* super_ref = callee->AsProperty()->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ push(eax);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ push(eax);
+ __ push(eax);
+ __ push(Operand(esp, kPointerSize * 2));
+ VisitForStackValue(prop->key());
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ mov(Operand(esp, kPointerSize), eax);
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ Move(edx, Immediate(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ Move(edx, Immediate(SmiFromSlot(expr->CallFeedbackSlot())));
__ mov(edi, Operand(esp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
__ push(Immediate(isolate()->factory()->undefined_value()));
}
+ // Push the enclosing function.
+ __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
// Push the receiver of the enclosing function.
__ push(Operand(ebp, (2 + info_->scope()->num_parameters()) * kPointerSize));
// Push the language mode.
__ push(Immediate(Smi::FromInt(scope()->start_position())));
// Do the runtime call.
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// edx (receiver). Touch up the stack with the right values.
__ mov(Operand(esp, (arg_count + 0) * kPointerSize), edx);
__ mov(Operand(esp, (arg_count + 1) * kPointerSize), eax);
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
SetSourcePosition(expr->position());
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ push(eax); // Function.
__ push(edx); // Receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the function
// and receiver and have the slow path jump around this code.
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ LoadHeapObject(ebx, FeedbackVector());
- __ mov(edx, Immediate(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ mov(edx, Immediate(SmiFromSlot(expr->CallNewFeedbackSlot())));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(eax, if_false);
+ Register map = ebx;
+ __ mov(map, FieldOperand(eax, HeapObject::kMapOffset));
+ __ CmpInstanceType(map, FIRST_JS_PROXY_TYPE);
+ __ j(less, if_false);
+ __ CmpInstanceType(map, LAST_JS_PROXY_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(less_equal, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ mov(LoadDescriptor::NameRegister(), Immediate(expr->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
if (expr->is_postfix() && !context()->IsEffect()) {
__ push(Immediate(Smi::FromInt(0)));
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ mov(LoadDescriptor::ReceiverRegister(), Operand(esp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ mov(LoadDescriptor::ReceiverRegister(),
- Operand(esp, kPointerSize)); // Object.
- __ mov(LoadDescriptor::NameRegister(), Operand(esp, 0)); // Key.
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ mov(LoadDescriptor::ReceiverRegister(), Operand(esp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ __ push(MemOperand(esp, kPointerSize));
+ __ push(result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ push(result_register());
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ mov(LoadDescriptor::ReceiverRegister(),
+ Operand(esp, kPointerSize)); // Object.
+ __ mov(LoadDescriptor::NameRegister(), Operand(esp, 0)); // Key.
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ mov(Operand(esp, kPointerSize), eax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 2 * kPointerSize), eax);
+ break;
case KEYED_PROPERTY:
__ mov(Operand(esp, 2 * kPointerSize), eax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 3 * kPointerSize), eax);
+ break;
}
}
}
case NAMED_PROPERTY:
__ mov(Operand(esp, kPointerSize), eax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 2 * kPointerSize), eax);
+ break;
case KEYED_PROPERTY:
__ mov(Operand(esp, 2 * kPointerSize), eax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 3 * kPointerSize), eax);
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(eax);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(eax);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ pop(StoreDescriptor::NameRegister());
__ pop(StoreDescriptor::ReceiverRegister());
__ mov(LoadDescriptor::NameRegister(), Immediate(proxy->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return eax; }
+const Register StoreTransitionDescriptor::MapRegister() { return ebx; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() {
return ebx;
}
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // esi -- context
+ Register registers[] = {esi};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ mov(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ mov(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(eax));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(instr->hydrogen()->slot())));
+ Immediate(Smi::FromInt(index)));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#if V8_TARGET_ARCH_IA32
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift by 0 and
// the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
}
-void MacroAssembler::LoadUint32(XMMRegister dst,
- Register src) {
+void MacroAssembler::LoadUint32(XMMRegister dst, const Operand& src) {
Label done;
cmp(src, Immediate(0));
- ExternalReference uint32_bias =
- ExternalReference::address_of_uint32_bias();
+ ExternalReference uint32_bias = ExternalReference::address_of_uint32_bias();
Cvtsi2sd(dst, src);
j(not_sign, &done, Label::kNear);
addsd(dst, Operand::StaticVariable(uint32_bias));
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on ia32.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
push(ebp);
mov(ebp, esp);
// Save the frame pointer and the context in top.
ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress, isolate());
ExternalReference context_address(Isolate::kContextAddress, isolate());
+ ExternalReference c_function_address(Isolate::kCFunctionAddress, isolate());
mov(Operand::StaticVariable(c_entry_fp_address), ebp);
mov(Operand::StaticVariable(context_address), esi);
+ mov(Operand::StaticVariable(c_function_address), ebx);
}
}
-void MacroAssembler::Move(XMMRegister dst, double val) {
- // TODO(titzer): recognize double constants with ExternalReferences.
- uint64_t int_val = bit_cast<uint64_t, double>(val);
- if (int_val == 0) {
- xorps(dst, dst);
+void MacroAssembler::Move(XMMRegister dst, uint32_t src) {
+ if (src == 0) {
+ pxor(dst, dst);
} else {
- int32_t lower = static_cast<int32_t>(int_val);
- int32_t upper = static_cast<int32_t>(int_val >> kBitsPerInt);
- push(Immediate(upper));
- push(Immediate(lower));
- movsd(dst, Operand(esp, 0));
- add(esp, Immediate(kDoubleSize));
+ unsigned cnt = base::bits::CountPopulation32(src);
+ unsigned nlz = base::bits::CountLeadingZeros32(src);
+ unsigned ntz = base::bits::CountTrailingZeros32(src);
+ if (nlz + cnt + ntz == 32) {
+ pcmpeqd(dst, dst);
+ if (ntz == 0) {
+ psrld(dst, 32 - cnt);
+ } else {
+ pslld(dst, 32 - cnt);
+ if (nlz != 0) psrld(dst, nlz);
+ }
+ } else {
+ push(eax);
+ mov(eax, Immediate(src));
+ movd(dst, Operand(eax));
+ pop(eax);
+ }
+ }
+}
+
+
+void MacroAssembler::Move(XMMRegister dst, uint64_t src) {
+ uint32_t lower = static_cast<uint32_t>(src);
+ uint32_t upper = static_cast<uint32_t>(src >> 32);
+ if (upper == 0) {
+ Move(dst, lower);
+ } else {
+ unsigned cnt = base::bits::CountPopulation64(src);
+ unsigned nlz = base::bits::CountLeadingZeros64(src);
+ unsigned ntz = base::bits::CountTrailingZeros64(src);
+ if (nlz + cnt + ntz == 64) {
+ pcmpeqd(dst, dst);
+ if (ntz == 0) {
+ psrlq(dst, 64 - cnt);
+ } else {
+ psllq(dst, 64 - cnt);
+ if (nlz != 0) psrlq(dst, nlz);
+ }
+ } else if (lower == 0) {
+ Move(dst, upper);
+ psllq(dst, 32);
+ } else if (CpuFeatures::IsSupported(SSE4_1)) {
+ CpuFeatureScope scope(this, SSE4_1);
+ push(eax);
+ Move(eax, Immediate(lower));
+ movd(dst, Operand(eax));
+ Move(eax, Immediate(upper));
+ pinsrd(dst, Operand(eax), 1);
+ pop(eax);
+ } else {
+ push(Immediate(upper));
+ push(Immediate(lower));
+ movsd(dst, Operand(esp, 0));
+ add(esp, Immediate(kDoubleSize));
+ }
}
}
j(not_carry, is_smi);
}
- void LoadUint32(XMMRegister dst, Register src);
+ void LoadUint32(XMMRegister dst, Register src) {
+ LoadUint32(dst, Operand(src));
+ }
+ void LoadUint32(XMMRegister dst, const Operand& src);
// Jump the register contains a smi.
inline void JumpIfSmi(Register value,
void Move(const Operand& dst, const Immediate& x);
// Move an immediate into an XMM register.
- void Move(XMMRegister dst, double val);
+ void Move(XMMRegister dst, uint32_t src);
+ void Move(XMMRegister dst, uint64_t src);
+ void Move(XMMRegister dst, double src) { Move(dst, bit_cast<uint64_t>(src)); }
// Push a handle value.
void Push(Handle<Object> handle) { push(Immediate(handle)); }
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Expects object in eax and returns map with validated enum cache
}
-// Generate StoreTransition code, value is passed in r0 register.
-// When leaving generated code after success, the receiver_reg and name_reg
-// may be clobbered. Upon branch to miss_label, the receiver and name
-// registers have their original values.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register scratch3, Label* miss_label, Label* slow) {
- // r0 : value
- Label exit;
-
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ Move(scratch1, constant);
- __ cmp(value_reg, scratch1);
- __ b(ne, miss_label);
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- if (!it.Done()) {
- __ ldr(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- __ CompareMap(scratch1, it.Current(), &do_store);
- it.Advance();
- if (it.Done()) {
- __ b(ne, miss_label);
- break;
- }
- __ b(eq, &do_store);
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ LoadRoot(scratch3, Heap::kMutableHeapNumberMapRootIndex);
- __ AllocateHeapNumber(storage_reg, scratch1, scratch2, scratch3, slow,
- TAG_RESULT, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiUntag(scratch1, value_reg);
- __ vmov(s0, scratch1);
- __ vcvt_f64_s32(d0, s0);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex, miss_label,
- DONT_DO_SMI_CHECK);
- __ vldr(d0, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ vstr(d0, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ push(receiver_reg);
- __ mov(r2, Operand(transition));
- __ Push(r2, r0);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ mov(scratch1, Operand(transition));
- __ str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kLRHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
- OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(r0));
- __ Ret();
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- // TODO(verwaest): Share this code as a code stub.
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ str(storage_reg, FieldMemOperand(receiver_reg, offset));
- } else {
- __ str(value_reg, FieldMemOperand(receiver_reg, offset));
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kLRHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array
- __ ldr(scratch1,
- FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ str(storage_reg, FieldMemOperand(scratch1, offset));
- } else {
- __ str(value_reg, FieldMemOperand(scratch1, offset));
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ mov(this->name(), Operand(name));
+ __ mov(StoreTransitionDescriptor::MapRegister(), Operand(transition));
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kLRHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register r0).
- DCHECK(value_reg.is(r0));
- __ bind(&exit);
- __ Ret();
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ Move(scratch1(), handle(constant, isolate()));
+ __ cmp(value_reg, scratch1());
+ __ b(ne, miss_label);
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- __ ldr(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- __ CompareMap(scratch1(), it.Current(), &do_store);
- it.Advance();
- if (it.Done()) {
- __ b(ne, miss_label);
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ __ ldr(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
+ Label do_store;
+ while (true) {
+ __ CompareMap(scratch1(), it.Current(), &do_store);
+ it.Advance();
+ if (it.Done()) {
+ __ b(ne, miss_label);
+ break;
+ }
+ __ b(eq, &do_store);
}
- __ b(eq, &do_store);
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is in lr.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = r3;
- Register result = r0;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ Ret();
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
void KeyedStoreIC::GenerateMiss(MacroAssembler* masm) {
// Push receiver, key and value for runtime call.
__ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
}
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length,
Register value, Register key, Register receiver, Register receiver_map,
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// ---------- S t a t e --------------
// -- r0 : value
// -- r1 : key
// -----------------------------------
Label slow, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
// Register usage.
Register value = StoreDescriptor::ValueRegister();
// r4 and r5 are used as general scratch registers.
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
// Check that the object isn't a smi.
__ JumpIfSmi(receiver, &slow);
// Get the map of the object.
// r1: key.
// r2: receiver.
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ ldr(r4, FieldMemOperand(key, HeapObject::kMapOffset));
+ __ ldrb(r4, FieldMemOperand(r4, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(r4, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, r3, r4, r5, r6);
+ // Cache miss.
+ __ b(&miss);
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
__ cmp(key, Operand(ip));
__ b(hs, &extra);
- KeyedStoreGenerateGenericHelper(
+ KeyedStoreGenerateMegamorphicHelper(
masm, &fast_object, &fast_double, &slow, kCheckMap, kDontIncrementLength,
value, key, receiver, receiver_map, elements_map, elements);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength, value,
- key, receiver, receiver_map, elements_map,
- elements);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength, value, key, receiver,
+ receiver_map, elements_map, elements);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
}
-// Generate StoreTransition code, value is passed in x0 register.
-// When leaving generated code after success, the receiver_reg and storage_reg
-// may be clobbered. Upon branch to miss_label, the receiver and name registers
-// have their original values.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register scratch3, Label* miss_label, Label* slow) {
- Label exit;
-
- DCHECK(!AreAliased(receiver_reg, storage_reg, value_reg, scratch1, scratch2,
- scratch3));
-
- // We don't need scratch3.
- scratch3 = NoReg;
-
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ LoadObject(scratch1, constant);
- __ Cmp(value_reg, scratch1);
- __ B(ne, miss_label);
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- if (!it.Done()) {
- __ Ldr(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- __ CompareMap(scratch1, it.Current());
- it.Advance();
- if (it.Done()) {
- __ B(ne, miss_label);
- break;
- }
- __ B(eq, &do_store);
- }
- __ Bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- UseScratchRegisterScope temps(masm());
- DoubleRegister temp_double = temps.AcquireD();
- __ SmiUntagToDouble(temp_double, value_reg, kSpeculativeUntag);
-
- Label do_store;
- __ JumpIfSmi(value_reg, &do_store);
-
- __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex, miss_label,
- DONT_DO_SMI_CHECK);
- __ Ldr(temp_double, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
-
- __ Bind(&do_store);
- __ AllocateHeapNumber(storage_reg, slow, scratch1, scratch2, temp_double,
- NoReg, MUTABLE);
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ Mov(scratch1, Operand(transition));
- __ Push(receiver_reg, scratch1, value_reg);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ Mov(scratch1, Operand(transition));
- __ Str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kLRHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
- OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(x0));
- __ Ret();
- return;
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ Mov(this->name(), Operand(name));
+ __ Mov(StoreTransitionDescriptor::MapRegister(), Operand(transition));
+}
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- // TODO(verwaest): Share this code as a code stub.
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- Register prop_reg = representation.IsDouble() ? storage_reg : value_reg;
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- __ Str(prop_reg, FieldMemOperand(receiver_reg, offset));
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ Mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kLRHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array
- __ Ldr(scratch1,
- FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
- __ Str(prop_reg, FieldMemOperand(scratch1, offset));
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ Mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kLRHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- }
- __ Bind(&exit);
- // Return the value (register x0).
- DCHECK(value_reg.is(x0));
- __ Ret();
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ LoadObject(scratch1(), handle(constant, isolate()));
+ __ Cmp(value_reg, scratch1());
+ __ B(ne, miss_label);
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- __ Ldr(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- __ CompareMap(scratch1(), it.Current());
- it.Advance();
- if (it.Done()) {
- __ B(ne, miss_label);
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ __ Ldr(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
+ Label do_store;
+ while (true) {
+ __ CompareMap(scratch1(), it.Current());
+ it.Advance();
+ if (it.Done()) {
+ __ B(ne, miss_label);
+ break;
+ }
+ __ B(eq, &do_store);
}
- __ B(eq, &do_store);
+ __ Bind(&do_store);
}
- __ Bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is in lr.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register result = x0;
- Register scratch = x3;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ Ret();
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ Bind(&miss);
- GenerateMiss(masm);
-}
-
-
void KeyedStoreIC::GenerateMiss(MacroAssembler* masm) {
ASM_LOCATION("KeyedStoreIC::GenerateMiss");
}
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length,
Register value, Register key, Register receiver, Register receiver_map,
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
- ASM_LOCATION("KeyedStoreIC::GenerateGeneric");
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
+ ASM_LOCATION("KeyedStoreIC::GenerateMegamorphic");
Label slow;
Label array;
Label fast_object;
Label fast_object_grow;
Label fast_double_grow;
Label fast_double;
+ Label maybe_name_key;
+ Label miss;
Register value = StoreDescriptor::ValueRegister();
Register key = StoreDescriptor::NameRegister();
Register elements = x4;
Register elements_map = x5;
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
__ JumpIfSmi(receiver, &slow);
__ Ldr(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
// x1: key
// x2: receiver
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+ __ bind(&maybe_name_key);
+ __ Ldr(x10, FieldMemOperand(key, HeapObject::kMapOffset));
+ __ Ldrb(x10, FieldMemOperand(x10, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(x10, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, x3, x4, x5, x6);
+ // Cache miss.
+ __ B(&miss);
__ Bind(&extra);
// Extra capacity case: Check if there is extra capacity to
__ B(eq, &extra); // We can handle the case where we are appending 1 element.
__ B(lo, &slow);
- KeyedStoreGenerateGenericHelper(
+ KeyedStoreGenerateMegamorphicHelper(
masm, &fast_object, &fast_double, &slow, kCheckMap, kDontIncrementLength,
value, key, receiver, receiver_map, elements_map, elements);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength, value,
- key, receiver, receiver_map, elements_map,
- elements);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength, value, key, receiver,
+ receiver_map, elements_map, elements);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
// TODO(verwaest): Cleanup. holder() is actually the receiver.
Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
Handle<Map> transition, Handle<Name> name) {
- Label miss, slow;
+ Label miss;
// Ensure no transitions to deprecated maps are followed.
__ CheckMapDeprecated(transition, scratch1(), &miss);
DCHECK(holder()->HasFastProperties());
}
- GenerateStoreTransition(transition, name, receiver(), this->name(), value(),
- scratch1(), scratch2(), scratch3(), &miss, &slow);
+ int descriptor = transition->LastAdded();
+ DescriptorArray* descriptors = transition->instance_descriptors();
+ PropertyDetails details = descriptors->GetDetails(descriptor);
+ Representation representation = details.representation();
+ DCHECK(!representation.IsNone());
+
+ // Stub is never generated for objects that require access checks.
+ DCHECK(!transition->is_access_check_needed());
+
+ // Call to respective StoreTransitionStub.
+ if (details.type() == CONSTANT) {
+ GenerateConstantCheck(descriptors->GetValue(descriptor), value(), &miss);
+
+ GenerateRestoreNameAndMap(name, transition);
+ StoreTransitionStub stub(isolate());
+ GenerateTailCall(masm(), stub.GetCode());
+
+ } else {
+ if (representation.IsHeapObject()) {
+ GenerateFieldTypeChecks(descriptors->GetFieldType(descriptor), value(),
+ &miss);
+ }
+ StoreTransitionStub::StoreMode store_mode =
+ Map::cast(transition->GetBackPointer())->unused_property_fields() == 0
+ ? StoreTransitionStub::ExtendStorageAndStoreMapAndValue
+ : StoreTransitionStub::StoreMapAndValue;
+
+ GenerateRestoreNameAndMap(name, transition);
+ StoreTransitionStub stub(isolate(),
+ FieldIndex::ForDescriptor(*transition, descriptor),
+ representation, store_mode);
+ GenerateTailCall(masm(), stub.GetCode());
+ }
GenerateRestoreName(&miss, name);
TailCallBuiltin(masm(), MissBuiltin(kind()));
- GenerateRestoreName(&slow, name);
- TailCallBuiltin(masm(), SlowBuiltin(kind()));
return GetCode(kind(), Code::FAST, name);
}
Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(LookupIterator* it) {
Label miss;
- GenerateStoreField(it, value(), &miss);
+ DCHECK(it->representation().IsHeapObject());
+
+ GenerateFieldTypeChecks(*it->GetFieldType(), value(), &miss);
+ StoreFieldStub stub(isolate(), it->GetFieldIndex(), it->representation());
+ GenerateTailCall(masm(), stub.GetCode());
+
__ bind(&miss);
TailCallBuiltin(masm(), MissBuiltin(kind()));
return GetCode(kind(), Code::FAST, it->name());
Handle<Map> receiver_map = receiver_maps->at(i);
Handle<Code> cached_stub;
- if ((receiver_map->instance_type() & kNotStringTag) == 0) {
- cached_stub = isolate()->builtins()->KeyedLoadIC_String();
+ if (receiver_map->IsStringMap()) {
+ cached_stub = LoadIndexedStringStub(isolate()).GetCode();
} else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
cached_stub = isolate()->builtins()->KeyedLoadIC_Slow();
} else {
void GenerateRestoreName(Label* label, Handle<Name> name);
private:
- void GenerateStoreTransition(Handle<Map> transition, Handle<Name> name,
- Register receiver_reg, Register name_reg,
- Register value_reg, Register scratch1,
- Register scratch2, Register scratch3,
- Label* miss_label, Label* slow);
-
- void GenerateStoreField(LookupIterator* lookup, Register value_reg,
- Label* miss_label);
+ void GenerateRestoreNameAndMap(Handle<Name> name, Handle<Map> transition);
+
+ void GenerateConstantCheck(Object* constant, Register value_reg,
+ Label* miss_label);
+
+ void GenerateFieldTypeChecks(HeapType* field_type, Register value_reg,
+ Label* miss_label);
static Builtins::Name SlowBuiltin(Code::Kind kind) {
switch (kind) {
}
-// Receiver_reg is preserved on jumps to miss_label, but may be destroyed if
-// store is successful.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register unused, Label* miss_label, Label* slow) {
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ CmpObject(value_reg, constant);
- __ j(not_equal, miss_label);
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- if (!it.Done()) {
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
- }
- __ j(equal, &do_store, Label::kNear);
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ AllocateHeapNumber(storage_reg, scratch1, scratch2, slow, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiUntag(value_reg);
- __ Cvtsi2sd(xmm0, value_reg);
- __ SmiTag(value_reg);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, isolate()->factory()->heap_number_map(), miss_label,
- DONT_DO_SMI_CHECK);
- __ movsd(xmm0, FieldOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ movsd(FieldOperand(storage_reg, HeapNumber::kValueOffset), xmm0);
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ pop(scratch1); // Return address.
- __ push(receiver_reg);
- __ push(Immediate(transition));
- __ push(value_reg);
- __ push(scratch1);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ mov(scratch1, Immediate(transition));
- __ mov(FieldOperand(receiver_reg, HeapObject::kMapOffset), scratch1);
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kDontSaveFPRegs, OMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(eax));
- __ ret(0);
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- // TODO(verwaest): Share this code as a code stub.
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ mov(FieldOperand(receiver_reg, offset), storage_reg);
- } else {
- __ mov(FieldOperand(receiver_reg, offset), value_reg);
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array (optimistically).
- __ mov(scratch1, FieldOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ mov(FieldOperand(scratch1, offset), storage_reg);
- } else {
- __ mov(FieldOperand(scratch1, offset), value_reg);
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ mov(this->name(), Immediate(name));
+ __ mov(StoreTransitionDescriptor::MapRegister(), Immediate(transition));
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register eax).
- DCHECK(value_reg.is(eax));
- __ ret(0);
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ CmpObject(value_reg, handle(constant, isolate()));
+ __ j(not_equal, miss_label);
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ Label do_store;
+ while (true) {
+ __ CompareMap(value_reg, it.Current());
+ it.Advance();
+ if (it.Done()) {
+ __ j(not_equal, miss_label);
+ break;
+ }
+ __ j(equal, &do_store, Label::kNear);
}
- __ j(equal, &do_store, Label::kNear);
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is on the stack.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = ebx;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
- Register result = eax;
- DCHECK(!result.is(scratch));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ ret(0);
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
void KeyedStoreIC::GenerateSloppyArguments(MacroAssembler* masm) {
// Return address is on the stack.
Label slow, notin;
}
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length) {
Label transition_smi_elements;
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// Return address is on the stack.
Label slow, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
Register receiver = StoreDescriptor::ReceiverRegister();
Register key = StoreDescriptor::NameRegister();
DCHECK(receiver.is(edx));
1 << Map::kIsAccessCheckNeeded | 1 << Map::kIsObserved);
__ j(not_zero, &slow);
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
__ CmpInstanceType(edi, JS_ARRAY_TYPE);
__ j(equal, &array);
// Check that the object is some kind of JSObject.
// Slow case: call runtime.
__ bind(&slow);
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ mov(ebx, FieldOperand(key, HeapObject::kMapOffset));
+ __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(ebx, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, ebx, no_reg);
+ // Cache miss.
+ __ jmp(&miss);
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
__ cmp(key, FieldOperand(receiver, JSArray::kLengthOffset)); // Compare smis.
__ j(above_equal, &extra);
- KeyedStoreGenerateGenericHelper(masm, &fast_object, &fast_double, &slow,
- kCheckMap, kDontIncrementLength);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object, &fast_double, &slow,
+ kCheckMap, kDontIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
CacheHolderFlag flag;
Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate, &flag);
+ if (kind == Code::KEYED_STORE_IC) {
+ // Always set the "property" bit.
+ extra_ic_state =
+ KeyedStoreIC::IcCheckTypeField::update(extra_ic_state, PROPERTY);
+ DCHECK(STANDARD_STORE ==
+ KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
+ }
Handle<Code> ic;
// There are multiple string maps that all use the same prototype. That
if (!ic.is_null()) return ic;
}
-#ifdef DEBUG
- if (kind == Code::KEYED_STORE_IC) {
- DCHECK(STANDARD_STORE ==
- KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
- }
-#endif
-
PropertyICCompiler ic_compiler(isolate, kind, extra_ic_state, flag);
ic = ic_compiler.CompileMonomorphic(type, handler, name, PROPERTY);
Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
if (probe->IsCode()) return Handle<Code>::cast(probe);
+ Handle<Code> stub = ComputeKeyedLoadMonomorphicHandler(receiver_map);
+ PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
+ Handle<Code> code =
+ compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
+ isolate->factory()->empty_string(), ELEMENT);
+
+ Map::UpdateCodeCache(receiver_map, name, code);
+ return code;
+}
+
+
+Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphicHandler(
+ Handle<Map> receiver_map) {
+ Isolate* isolate = receiver_map->GetIsolate();
ElementsKind elements_kind = receiver_map->elements_kind();
Handle<Code> stub;
if (receiver_map->has_indexed_interceptor()) {
stub = LoadIndexedInterceptorStub(isolate).GetCode();
+ } else if (receiver_map->IsStringMap()) {
+ // We have a string.
+ stub = LoadIndexedStringStub(isolate).GetCode();
} else if (receiver_map->has_sloppy_arguments_elements()) {
stub = KeyedLoadSloppyArgumentsStub(isolate).GetCode();
} else if (receiver_map->has_fast_elements() ||
} else {
stub = LoadDictionaryElementStub(isolate).GetCode();
}
- PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
- Handle<Code> code =
- compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
- isolate->factory()->empty_string(), ELEMENT);
-
- Map::UpdateCodeCache(receiver_map, name, code);
- return code;
+ return stub;
}
namespace internal {
-enum IcCheckType { ELEMENT, PROPERTY };
-
-
class PropertyICCompiler : public PropertyAccessCompiler {
public:
// Finds the Code object stored in the Heap::non_monomorphic_cache().
ExtraICState extra_ic_state);
// Keyed
+ static Handle<Code> ComputeKeyedLoadMonomorphicHandler(
+ Handle<Map> receiver_map);
static Handle<Code> ComputeKeyedLoadMonomorphic(Handle<Map> receiver_map);
static Handle<Code> ComputeKeyedStoreMonomorphic(
}
-IC::State CallIC::FeedbackToState(Handle<TypeFeedbackVector> vector,
- Handle<Smi> slot) const {
- IC::State state = UNINITIALIZED;
- Object* feedback = vector->get(slot->value());
-
- if (feedback == *TypeFeedbackVector::MegamorphicSentinel(isolate())) {
- state = GENERIC;
- } else if (feedback->IsAllocationSite() || feedback->IsJSFunction()) {
- state = MONOMORPHIC;
- } else {
- CHECK(feedback == *TypeFeedbackVector::UninitializedSentinel(isolate()));
- }
-
- return state;
+inline Code* IC::get_host() {
+ return isolate()
+ ->inner_pointer_to_code_cache()
+ ->GetCacheEntry(address())
+ ->code;
}
}
} // namespace v8::internal
namespace v8 {
namespace internal {
+// static
void ICUtility::Clear(Isolate* isolate, Address address,
ConstantPoolArray* constant_pool) {
IC::Clear(isolate, address, constant_pool);
}
+// static
+template <class Nexus>
+void ICUtility::Clear(Isolate* isolate, Code::Kind kind, Code* host,
+ Nexus* nexus) {
+ IC::Clear<Nexus>(isolate, kind, host, nexus);
+}
+
+
+// Force instantiation of template instances for vector-based IC clearing.
+template void ICUtility::Clear<CallICNexus>(Isolate*, Code::Kind, Code*,
+ CallICNexus*);
+
+
CallICState::CallICState(ExtraICState extra_ic_state)
: argc_(ArgcBits::decode(extra_ic_state)),
call_type_(CallTypeBits::decode(extra_ic_state)) {}
}
-OStream& operator<<(OStream& os, const CallICState& s) {
+std::ostream& operator<<(std::ostream& os, const CallICState& s) {
return os << "(args(" << s.arg_count() << "), "
<< (s.call_type() == CallICState::METHOD ? "METHOD" : "FUNCTION")
<< ", ";
}
-OStream& operator<<(OStream& os, const BinaryOpICState& s) {
+std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s) {
os << "(" << Token::Name(s.op_);
if (s.mode_ == OVERWRITE_LEFT)
os << "_ReuseLeft";
// Clear the inline cache to initial state.
static void Clear(Isolate* isolate, Address address,
ConstantPoolArray* constant_pool);
+ // Clear a vector-based inline cache to initial state.
+ template <class Nexus>
+ static void Clear(Isolate* isolate, Code::Kind kind, Code* host,
+ Nexus* nexus);
};
};
-OStream& operator<<(OStream& os, const CallICState& s);
+std::ostream& operator<<(std::ostream& os, const CallICState& s);
// Mode to overwrite BinaryExpression values.
Isolate* isolate() const { return isolate_; }
private:
- friend OStream& operator<<(OStream& os, const BinaryOpICState& s);
+ friend std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
};
-OStream& operator<<(OStream& os, const BinaryOpICState& s);
+std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
class CompareICState {
void IC::TraceIC(const char* type, Handle<Object> name) {
if (FLAG_trace_ic) {
- Code* new_target = raw_target();
- State new_state = new_target->ic_state();
+ State new_state =
+ UseVector() ? nexus()->StateFromFeedback() : raw_target()->ic_state();
TraceIC(type, name, state(), new_state);
}
}
modifier = GetTransitionMarkModifier(
KeyedStoreIC::GetKeyedAccessStoreMode(extra_state));
}
- PrintF(" (%c->%c%s)", TransitionMarkFromState(old_state),
+ PrintF(" (%c->%c%s) ", TransitionMarkFromState(old_state),
TransitionMarkFromState(new_state), modifier);
#ifdef OBJECT_PRINT
OFStream os(stdout);
}
}
+
#define TRACE_IC(type, name) TraceIC(type, name)
-#define TRACE_VECTOR_IC(type, name, old_state, new_state) \
- TraceIC(type, name, old_state, new_state)
-IC::IC(FrameDepth depth, Isolate* isolate)
- : isolate_(isolate), target_set_(false), target_maps_set_(false) {
+
+IC::IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus,
+ bool for_queries_only)
+ : isolate_(isolate),
+ target_set_(false),
+ target_maps_set_(false),
+ nexus_(nexus) {
// To improve the performance of the (much used) IC code, we unfold a few
// levels of the stack frame iteration code. This yields a ~35% speedup when
// running DeltaBlue and a ~25% speedup of gbemu with the '--nouse-ic' flag.
}
pc_address_ = StackFrame::ResolveReturnAddressLocation(pc_address);
target_ = handle(raw_target(), isolate);
- state_ = target_->ic_state();
kind_ = target_->kind();
+ state_ = (!for_queries_only && UseVector()) ? nexus->StateFromFeedback()
+ : target_->ic_state();
+ old_state_ = state_;
extra_ic_state_ = target_->extra_ic_state();
}
}
+// static
+void IC::OnTypeFeedbackChanged(Isolate* isolate, Code* host,
+ TypeFeedbackVector* vector, State old_state,
+ State new_state) {
+ if (host->kind() != Code::FUNCTION) return;
+
+ if (FLAG_type_info_threshold > 0) {
+ int polymorphic_delta = 0; // "Polymorphic" here includes monomorphic.
+ int generic_delta = 0; // "Generic" here includes megamorphic.
+ ComputeTypeInfoCountDelta(old_state, new_state, &polymorphic_delta,
+ &generic_delta);
+ vector->change_ic_with_type_info_count(polymorphic_delta);
+ vector->change_ic_generic_count(generic_delta);
+ }
+ TypeFeedbackInfo* info = TypeFeedbackInfo::cast(host->type_feedback_info());
+ info->change_own_type_change_checksum();
+ host->set_profiler_ticks(0);
+ isolate->runtime_profiler()->NotifyICChanged();
+ // TODO(2029): When an optimized function is patched, it would
+ // be nice to propagate the corresponding type information to its
+ // unoptimized version for the benefit of later inlining.
+}
+
+
void IC::PostPatching(Address address, Code* target, Code* old_target) {
// Type vector based ICs update these statistics at a different time because
// they don't always patch on state change.
return StoreIC::Clear(isolate, address, target, constant_pool);
case Code::KEYED_STORE_IC:
return KeyedStoreIC::Clear(isolate, address, target, constant_pool);
- case Code::CALL_IC:
- return CallIC::Clear(isolate, address, target, constant_pool);
case Code::COMPARE_IC:
return CompareIC::Clear(isolate, address, target, constant_pool);
case Code::COMPARE_NIL_IC:
return CompareNilIC::Clear(address, target, constant_pool);
+ case Code::CALL_IC: // CallICs are vector-based and cleared differently.
case Code::BINARY_OP_IC:
case Code::TO_BOOLEAN_IC:
// Clearing these is tricky and does not
}
+template <class Nexus>
+void IC::Clear(Isolate* isolate, Code::Kind kind, Code* host, Nexus* nexus) {
+ switch (kind) {
+ case Code::CALL_IC:
+ return CallIC::Clear(isolate, host, nexus);
+ default:
+ UNREACHABLE();
+ }
+}
+
+
+// Force instantiation of template instances for vector-based IC clearing.
+template void IC::Clear(Isolate*, Code::Kind, Code*, CallICNexus*);
+
+
void KeyedLoadIC::Clear(Isolate* isolate, Address address, Code* target,
ConstantPoolArray* constant_pool) {
if (IsCleared(target)) return;
+
// Make sure to also clear the map used in inline fast cases. If we
// do not clear these maps, cached code can keep objects alive
// through the embedded maps.
}
-void CallIC::Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool) {
- // Currently, CallIC doesn't have state changes.
+void CallIC::Clear(Isolate* isolate, Code* host, CallICNexus* nexus) {
+ // Determine our state.
+ Object* feedback = nexus->vector()->Get(nexus->slot());
+ State state = nexus->StateFromFeedback();
+
+ if (state != UNINITIALIZED && !feedback->IsAllocationSite()) {
+ nexus->ConfigureUninitialized();
+ // The change in state must be processed.
+ OnTypeFeedbackChanged(isolate, host, nexus->vector(), state, UNINITIALIZED);
+ }
}
case POLYMORPHIC:
if (!target()->is_keyed_stub() || state() == PROTOTYPE_FAILURE) {
if (UpdatePolymorphicIC(name, code)) break;
+ // For keyed stubs, we can't know whether old handlers were for the
+ // same key.
CopyICToMegamorphicCache(name);
}
set_target(*megamorphic_stub());
// Fall through.
case MEGAMORPHIC:
UpdateMegamorphicCache(*receiver_type(), *name, *code);
+ // Indicate that we've handled this case.
+ target_set_ = true;
break;
case DEBUG_STUB:
break;
case DEFAULT:
- case GENERIC:
UNREACHABLE();
break;
+ case GENERIC:
+ // The generic keyed store stub re-uses store handlers, which can miss.
+ // That's ok, no reason to do anything.
+ DCHECK(target()->kind() == Code::KEYED_STORE_IC);
+ break;
}
}
}
+Handle<Code> LoadIC::initialize_stub_in_optimized_code(
+ Isolate* isolate, ExtraICState extra_state) {
+ if (FLAG_vector_ics) {
+ return VectorLoadStub(isolate, LoadICState(extra_state)).GetCode();
+ }
+ return initialize_stub(isolate, extra_state);
+}
+
+
+Handle<Code> KeyedLoadIC::initialize_stub(Isolate* isolate) {
+ if (FLAG_vector_ics) {
+ return KeyedLoadICTrampolineStub(isolate).GetCode();
+ }
+
+ return isolate->builtins()->KeyedLoadIC_Initialize();
+}
+
+
+Handle<Code> KeyedLoadIC::initialize_stub_in_optimized_code(Isolate* isolate) {
+ if (FLAG_vector_ics) {
+ return VectorKeyedLoadStub(isolate).GetCode();
+ }
+ return initialize_stub(isolate);
+}
+
+
Handle<Code> LoadIC::megamorphic_stub() {
if (kind() == Code::LOAD_IC) {
MegamorphicLoadStub stub(isolate(), LoadICState(extra_ic_state()));
void IC::UpdateMegamorphicCache(HeapType* type, Name* name, Code* code) {
- if (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC) return;
+ // Megamorphic state isn't implemented for keyed loads currently.
+ if (kind() == Code::KEYED_LOAD_IC) return;
Map* map = *TypeToMap(type, isolate());
isolate()->stub_cache()->Set(name, map, code);
}
}
-Handle<Code> KeyedLoadIC::LoadElementStub(Handle<JSObject> receiver) {
+Handle<Code> KeyedLoadIC::LoadElementStub(Handle<HeapObject> receiver) {
Handle<Map> receiver_map(receiver->map(), isolate());
MapHandleList target_receiver_maps;
- if (target().is_identical_to(string_stub())) {
- target_receiver_maps.Add(isolate()->factory()->string_map());
- } else {
- TargetMaps(&target_receiver_maps);
- }
+ TargetMaps(&target_receiver_maps);
+
if (target_receiver_maps.length() == 0) {
return PropertyICCompiler::ComputeKeyedLoadMonomorphic(receiver_map);
}
// monomorphic. If this optimistic assumption is not true, the IC will
// miss again and it will become polymorphic and support both the
// untransitioned and transitioned maps.
- if (state() == MONOMORPHIC && IsMoreGeneralElementsKindTransition(
- target_receiver_maps.at(0)->elements_kind(),
- receiver->GetElementsKind())) {
+ if (state() == MONOMORPHIC && !receiver->IsString() &&
+ IsMoreGeneralElementsKindTransition(
+ target_receiver_maps.at(0)->elements_kind(),
+ Handle<JSObject>::cast(receiver)->GetElementsKind())) {
return PropertyICCompiler::ComputeKeyedLoadMonomorphic(receiver_map);
}
LoadIC::Load(object, Handle<Name>::cast(key)),
Object);
} else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) {
- if (object->IsString() && key->IsNumber()) {
- if (state() == UNINITIALIZED) stub = string_stub();
- } else if (object->IsJSObject()) {
- Handle<JSObject> receiver = Handle<JSObject>::cast(object);
- if (!Object::ToSmi(isolate(), key).is_null()) {
+ if (object->IsJSObject() || (object->IsString() && key->IsNumber())) {
+ Handle<HeapObject> receiver = Handle<HeapObject>::cast(object);
+ if (object->IsString() || !Object::ToSmi(isolate(), key).is_null()) {
stub = LoadElementStub(receiver);
}
}
} else {
DCHECK(kind() == Code::KEYED_STORE_IC);
if (strict_mode() == STRICT) {
- return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
+ return isolate()->builtins()->KeyedStoreIC_Megamorphic_Strict();
} else {
- return isolate()->builtins()->KeyedStoreIC_Generic();
+ return isolate()->builtins()->KeyedStoreIC_Megamorphic();
}
}
}
return generic_stub();
}
- // If the maximum number of receiver maps has been exceeded, use the generic
- // version of the IC.
+ // If the maximum number of receiver maps has been exceeded, use the
+ // megamorphic version of the IC.
if (target_receiver_maps.length() > kMaxKeyedPolymorphism) {
- TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "max polymorph exceeded");
- return generic_stub();
+ return megamorphic_stub();
}
// Make sure all polymorphic handlers have the same store mode, otherwise the
StoreIC::Store(object, Handle<String>::cast(key), value,
JSReceiver::MAY_BE_STORE_FROM_KEYED),
Object);
- // TODO(jkummerow): Ideally we'd wrap this in "if (!is_target_set())",
- // but doing so causes Hydrogen crashes. Needs investigation.
- TRACE_GENERIC_IC(isolate(), "KeyedStoreIC",
- "unhandled internalized string key");
- TRACE_IC("StoreIC", key);
- set_target(*stub);
+ if (!is_target_set()) {
+ TRACE_GENERIC_IC(isolate(), "KeyedStoreIC",
+ "unhandled internalized string key");
+ TRACE_IC("StoreIC", key);
+ set_target(*stub);
+ }
return store_handle;
}
}
+// static
+void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
+ StrictMode strict_mode) {
+ PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+}
+
+
bool CallIC::DoCustomHandler(Handle<Object> receiver, Handle<Object> function,
- Handle<TypeFeedbackVector> vector,
- Handle<Smi> slot, const CallICState& state) {
+ const CallICState& callic_state) {
DCHECK(FLAG_use_ic && function->IsJSFunction());
// Are we the array function?
Handle<JSFunction>(isolate()->native_context()->array_function());
if (array_function.is_identical_to(Handle<JSFunction>::cast(function))) {
// Alter the slot.
- IC::State old_state = FeedbackToState(vector, slot);
- Object* feedback = vector->get(slot->value());
- if (!feedback->IsAllocationSite()) {
- Handle<AllocationSite> new_site =
- isolate()->factory()->NewAllocationSite();
- vector->set(slot->value(), *new_site);
- }
+ CallICNexus* nexus = casted_nexus<CallICNexus>();
+ nexus->ConfigureMonomorphicArray();
- CallIC_ArrayStub stub(isolate(), state);
+ CallIC_ArrayStub stub(isolate(), callic_state);
set_target(*stub.GetCode());
Handle<String> name;
if (array_function->shared()->name()->IsString()) {
name = Handle<String>(String::cast(array_function->shared()->name()),
isolate());
}
-
- IC::State new_state = FeedbackToState(vector, slot);
- OnTypeFeedbackChanged(isolate(), address(), old_state, new_state, true);
- TRACE_VECTOR_IC("CallIC (custom handler)", name, old_state, new_state);
+ TRACE_IC("CallIC", name);
+ OnTypeFeedbackChanged(isolate(), get_host(), nexus->vector(), state(),
+ MONOMORPHIC);
return true;
}
return false;
}
-void CallIC::PatchMegamorphic(Handle<Object> function,
- Handle<TypeFeedbackVector> vector,
- Handle<Smi> slot) {
- CallICState state(target()->extra_ic_state());
- IC::State old_state = FeedbackToState(vector, slot);
+void CallIC::PatchMegamorphic(Handle<Object> function) {
+ CallICState callic_state(target()->extra_ic_state());
// We are going generic.
- vector->set(slot->value(),
- *TypeFeedbackVector::MegamorphicSentinel(isolate()),
- SKIP_WRITE_BARRIER);
+ CallICNexus* nexus = casted_nexus<CallICNexus>();
+ nexus->ConfigureGeneric();
- CallICStub stub(isolate(), state);
+ CallICStub stub(isolate(), callic_state);
Handle<Code> code = stub.GetCode();
set_target(*code);
name = handle(js_function->shared()->name(), isolate());
}
- IC::State new_state = FeedbackToState(vector, slot);
- OnTypeFeedbackChanged(isolate(), address(), old_state, new_state, true);
- TRACE_VECTOR_IC("CallIC", name, old_state, new_state);
+ TRACE_IC("CallIC", name);
+ OnTypeFeedbackChanged(isolate(), get_host(), nexus->vector(), state(),
+ GENERIC);
}
-void CallIC::HandleMiss(Handle<Object> receiver, Handle<Object> function,
- Handle<TypeFeedbackVector> vector, Handle<Smi> slot) {
- CallICState state(target()->extra_ic_state());
- IC::State old_state = FeedbackToState(vector, slot);
+void CallIC::HandleMiss(Handle<Object> receiver, Handle<Object> function) {
+ CallICState callic_state(target()->extra_ic_state());
Handle<Object> name = isolate()->factory()->empty_string();
- Object* feedback = vector->get(slot->value());
+ CallICNexus* nexus = casted_nexus<CallICNexus>();
+ Object* feedback = nexus->GetFeedback();
// Hand-coded MISS handling is easier if CallIC slots don't contain smis.
DCHECK(!feedback->IsSmi());
if (feedback->IsJSFunction() || !function->IsJSFunction()) {
// We are going generic.
- vector->set(slot->value(),
- *TypeFeedbackVector::MegamorphicSentinel(isolate()),
- SKIP_WRITE_BARRIER);
+ nexus->ConfigureGeneric();
} else {
// The feedback is either uninitialized or an allocation site.
// It might be an allocation site because if we re-compile the full code
feedback->IsAllocationSite());
// Do we want to install a custom handler?
- if (FLAG_use_ic &&
- DoCustomHandler(receiver, function, vector, slot, state)) {
+ if (FLAG_use_ic && DoCustomHandler(receiver, function, callic_state)) {
return;
}
- vector->set(slot->value(), *function);
+ nexus->ConfigureMonomorphic(Handle<JSFunction>::cast(function));
}
if (function->IsJSFunction()) {
name = handle(js_function->shared()->name(), isolate());
}
- IC::State new_state = FeedbackToState(vector, slot);
- OnTypeFeedbackChanged(isolate(), address(), old_state, new_state, true);
- TRACE_VECTOR_IC("CallIC", name, old_state, new_state);
+ IC::State new_state = nexus->StateFromFeedback();
+ OnTypeFeedbackChanged(isolate(), get_host(), *vector(), state(), new_state);
+ TRACE_IC("CallIC", name);
}
TimerEventScope<TimerEventIcMiss> timer(isolate);
HandleScope scope(isolate);
DCHECK(args.length() == 4);
- CallIC ic(isolate);
Handle<Object> receiver = args.at<Object>(0);
Handle<Object> function = args.at<Object>(1);
Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(2);
Handle<Smi> slot = args.at<Smi>(3);
- ic.HandleMiss(receiver, function, vector, slot);
+ FeedbackVectorICSlot vector_slot = vector->ToICSlot(slot->value());
+ CallICNexus nexus(vector, vector_slot);
+ CallIC ic(isolate, &nexus);
+ ic.HandleMiss(receiver, function);
return *function;
}
TimerEventScope<TimerEventIcMiss> timer(isolate);
HandleScope scope(isolate);
DCHECK(args.length() == 4);
- // A miss on a custom call ic always results in going megamorphic.
- CallIC ic(isolate);
Handle<Object> function = args.at<Object>(1);
Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(2);
Handle<Smi> slot = args.at<Smi>(3);
- ic.PatchMegamorphic(function, vector, slot);
+ FeedbackVectorICSlot vector_slot = vector->ToICSlot(slot->value());
+ CallICNexus nexus(vector, vector_slot);
+ // A miss on a custom call ic always results in going megamorphic.
+ CallIC ic(isolate, &nexus);
+ ic.PatchMegamorphic(function);
return *function;
}
DCHECK(args.length() == 3);
StoreIC ic(IC::NO_EXTRA_FRAME, isolate);
Handle<Object> receiver = args.at<Object>(0);
- Handle<String> key = args.at<String>(1);
+ Handle<Name> key = args.at<Name>(1);
ic.UpdateState(receiver, key);
Handle<Object> result;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
RUNTIME_FUNCTION(StoreIC_MissFromStubFailure) {
TimerEventScope<TimerEventIcMiss> timer(isolate);
HandleScope scope(isolate);
- DCHECK(args.length() == 3);
+ DCHECK(args.length() == 3 || args.length() == 4);
StoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
Handle<Object> receiver = args.at<Object>(0);
- Handle<String> key = args.at<String>(1);
+ Handle<Name> key = args.at<Name>(1);
ic.UpdateState(receiver, key);
Handle<Object> result;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
}
-// Extend storage is called in a store inline cache when
-// it is necessary to extend the properties array of a
-// JSObject.
-RUNTIME_FUNCTION(SharedStoreIC_ExtendStorage) {
- TimerEventScope<TimerEventIcMiss> timer(isolate);
- HandleScope shs(isolate);
- DCHECK(args.length() == 3);
-
- // Convert the parameters
- Handle<JSObject> object = args.at<JSObject>(0);
- Handle<Map> transition = args.at<Map>(1);
- Handle<Object> value = args.at<Object>(2);
-
- // Check the object has run out out property space.
- DCHECK(object->HasFastProperties());
- DCHECK(object->map()->unused_property_fields() == 0);
-
- JSObject::MigrateToNewProperty(object, transition, value);
-
- // Return the stored value.
- return *value;
-}
-
-
// Used from ic-<arch>.cc.
RUNTIME_FUNCTION(KeyedStoreIC_Miss) {
TimerEventScope<TimerEventIcMiss> timer(isolate);
if (!allocation_site.is_null()) {
os << " using allocation site " << static_cast<void*>(*allocation_site);
}
- os << "]" << endl;
+ os << "]" << std::endl;
}
// Patch the inlined smi code as necessary.
PrototypeIterator iter(isolate, receiver,
PrototypeIterator::START_AT_RECEIVER);
bool found = false;
- while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN)) {
+ for (; !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN); iter.Advance()) {
Handle<Object> current = PrototypeIterator::GetCurrent(iter);
if (current->IsJSObject() &&
Handle<JSObject>::cast(current)->HasNamedInterceptor()) {
}
-RUNTIME_FUNCTION(VectorLoadIC_MissFromStubFailure) {
- // TODO(mvstanton): To be enabled when ICs can accept a vector and slot
- return NULL;
-}
-
-
-RUNTIME_FUNCTION(VectorKeyedLoadIC_MissFromStubFailure) {
- // TODO(mvstanton): To be enabled when ICs can accept a vector and slot
- return NULL;
+RUNTIME_FUNCTION(LoadIC_MissFromStubFailure) {
+ TimerEventScope<TimerEventIcMiss> timer(isolate);
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ LoadIC ic(IC::EXTRA_CALL_FRAME, isolate);
+ Handle<Object> receiver = args.at<Object>(0);
+ Handle<Name> key = args.at<Name>(1);
+ ic.UpdateState(receiver, key);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, ic.Load(receiver, key));
+ return *result;
}
ICU(CallIC_Customization_Miss) \
ICU(StoreIC_Miss) \
ICU(StoreIC_Slow) \
- ICU(SharedStoreIC_ExtendStorage) \
ICU(KeyedStoreIC_Miss) \
ICU(KeyedStoreIC_Slow) \
/* Utilities for IC stubs. */ \
// Construct the IC structure with the given number of extra
// JavaScript frames on the stack.
- IC(FrameDepth depth, Isolate* isolate);
+ IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL,
+ bool for_queries_only = false);
virtual ~IC() {}
State state() const { return state_; }
bool IsNameCompatibleWithPrototypeFailure(Handle<Object> name);
void MarkPrototypeFailure(Handle<Object> name) {
DCHECK(IsNameCompatibleWithPrototypeFailure(name));
+ old_state_ = state_;
state_ = PROTOTYPE_FAILURE;
}
static void Clear(Isolate* isolate, Address address,
ConstantPoolArray* constant_pool);
+ // Clear the vector-based inline cache to initial state.
+ template <class Nexus>
+ static void Clear(Isolate* isolate, Code::Kind kind, Code* host,
+ Nexus* nexus);
+
#ifdef DEBUG
bool IsLoadStub() const {
return target()->is_load_stub() || target()->is_keyed_load_stub();
return state == UNINITIALIZED || state == PREMONOMORPHIC;
}
+ static bool IsCleared(FeedbackNexus* nexus) {
+ InlineCacheState state = nexus->StateFromFeedback();
+ return state == UNINITIALIZED || state == PREMONOMORPHIC;
+ }
+
// Utility functions to convert maps to types and back. There are two special
// cases:
// - The heap_number_map is used as a marker which includes heap numbers as
inline void set_target(Code* code);
bool is_target_set() { return target_set_; }
+ bool UseVector() const {
+ bool use = (FLAG_vector_ics &&
+ (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) ||
+ kind() == Code::CALL_IC;
+ // If we are supposed to use the nexus, verify the nexus is non-null.
+ DCHECK(!use || nexus_ != NULL);
+ return use;
+ }
+
char TransitionMarkFromState(IC::State state);
void TraceIC(const char* type, Handle<Object> name);
void TraceIC(const char* type, Handle<Object> name, State old_state,
static void OnTypeFeedbackChanged(Isolate* isolate, Address address,
State old_state, State new_state,
bool target_remains_ic_stub);
+ // As a vector-based IC, type feedback must be updated differently.
+ static void OnTypeFeedbackChanged(Isolate* isolate, Code* host,
+ TypeFeedbackVector* vector, State old_state,
+ State new_state);
static void PostPatching(Address address, Code* target, Code* old_target);
// Compute the handler either by compiling or by retrieving a cached version.
return target_maps_.length() > 0 ? *target_maps_.at(0) : NULL;
}
- protected:
inline void UpdateTarget();
+ Handle<TypeFeedbackVector> vector() const { return nexus()->vector_handle(); }
+ FeedbackVectorICSlot slot() const { return nexus()->slot(); }
+ State saved_state() const {
+ return state() == PROTOTYPE_FAILURE ? old_state_ : state();
+ }
+
+ template <class NexusClass>
+ NexusClass* casted_nexus() {
+ return static_cast<NexusClass*>(nexus_);
+ }
+ FeedbackNexus* nexus() const { return nexus_; }
+
+ inline Code* get_host();
+
private:
inline Code* raw_target() const;
inline ConstantPoolArray* constant_pool() const;
// The original code target that missed.
Handle<Code> target_;
bool target_set_;
+ State old_state_; // For saving if we marked as prototype failure.
State state_;
Code::Kind kind_;
Handle<HeapType> receiver_type_;
MapHandleList target_maps_;
bool target_maps_set_;
+ FeedbackNexus* nexus_;
+
DISALLOW_IMPLICIT_CONSTRUCTORS(IC);
};
class CallIC : public IC {
public:
- explicit CallIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
+ CallIC(Isolate* isolate, CallICNexus* nexus)
+ : IC(EXTRA_CALL_FRAME, isolate, nexus) {
+ DCHECK(nexus != NULL);
+ }
- void PatchMegamorphic(Handle<Object> function,
- Handle<TypeFeedbackVector> vector, Handle<Smi> slot);
+ void PatchMegamorphic(Handle<Object> function);
- void HandleMiss(Handle<Object> receiver, Handle<Object> function,
- Handle<TypeFeedbackVector> vector, Handle<Smi> slot);
+ void HandleMiss(Handle<Object> receiver, Handle<Object> function);
// Returns true if a custom handler was installed.
bool DoCustomHandler(Handle<Object> receiver, Handle<Object> function,
- Handle<TypeFeedbackVector> vector, Handle<Smi> slot,
- const CallICState& state);
+ const CallICState& callic_state);
// Code generator routines.
static Handle<Code> initialize_stub(Isolate* isolate, int argc,
CallICState::CallType call_type);
- static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
-
- private:
- inline IC::State FeedbackToState(Handle<TypeFeedbackVector> vector,
- Handle<Smi> slot) const;
+ static void Clear(Isolate* isolate, Code* host, CallICNexus* nexus);
};
static Handle<Code> initialize_stub(Isolate* isolate,
ExtraICState extra_state);
+ static Handle<Code> initialize_stub_in_optimized_code(
+ Isolate* isolate, ExtraICState extra_state);
MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
Handle<Name> name);
virtual Handle<Code> CompileHandler(LookupIterator* lookup,
Handle<Object> unused,
- CacheHolderFlag cache_holder);
+ CacheHolderFlag cache_holder) OVERRIDE;
private:
virtual Handle<Code> pre_monomorphic_stub() const;
GenerateMiss(masm);
}
static void GenerateGeneric(MacroAssembler* masm);
- static void GenerateString(MacroAssembler* masm);
// Bit mask to be tested against bit field for the cases when
// generic stub should go into slow case.
static const int kSlowCaseBitFieldMask =
(1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor);
+ static Handle<Code> initialize_stub(Isolate* isolate);
+ static Handle<Code> initialize_stub_in_optimized_code(Isolate* isolate);
static Handle<Code> generic_stub(Isolate* isolate);
static Handle<Code> pre_monomorphic_stub(Isolate* isolate);
protected:
- Handle<Code> LoadElementStub(Handle<JSObject> receiver);
+ // receiver is HeapObject because it could be a String or a JSObject
+ Handle<Code> LoadElementStub(Handle<HeapObject> receiver);
virtual Handle<Code> pre_monomorphic_stub() const {
return pre_monomorphic_stub(isolate());
}
private:
Handle<Code> generic_stub() const { return generic_stub(isolate()); }
- Handle<Code> string_stub() {
- return isolate()->builtins()->KeyedLoadIC_String();
- }
static void Clear(Isolate* isolate, Address address, Code* target,
ConstantPoolArray* constant_pool);
JSReceiver::StoreFromKeyed store_mode);
virtual Handle<Code> CompileHandler(LookupIterator* lookup,
Handle<Object> value,
- CacheHolderFlag cache_holder);
+ CacheHolderFlag cache_holder) OVERRIDE;
private:
inline void set_target(Code* code);
class ExtraICStateKeyedAccessStoreMode
: public BitField<KeyedAccessStoreMode, 2, 4> {}; // NOLINT
+ class IcCheckTypeField : public BitField<IcCheckType, 6, 1> {};
+
static ExtraICState ComputeExtraICState(StrictMode flag,
KeyedAccessStoreMode mode) {
return StrictModeState::encode(flag) |
- ExtraICStateKeyedAccessStoreMode::encode(mode);
+ ExtraICStateKeyedAccessStoreMode::encode(mode) |
+ IcCheckTypeField::encode(ELEMENT);
}
static KeyedAccessStoreMode GetKeyedAccessStoreMode(
return ExtraICStateKeyedAccessStoreMode::decode(extra_state);
}
+ static IcCheckType GetKeyType(ExtraICState extra_state) {
+ return IcCheckTypeField::decode(extra_state);
+ }
+
KeyedStoreIC(FrameDepth depth, Isolate* isolate) : StoreIC(depth, isolate) {
DCHECK(target()->is_keyed_store_stub());
}
}
static void GenerateMiss(MacroAssembler* masm);
static void GenerateSlow(MacroAssembler* masm);
+ static void GenerateMegamorphic(MacroAssembler* masm, StrictMode strict_mode);
static void GenerateGeneric(MacroAssembler* masm, StrictMode strict_mode);
static void GenerateSloppyArguments(MacroAssembler* masm);
DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite);
DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss);
DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss);
-DECLARE_RUNTIME_FUNCTION(VectorLoadIC_MissFromStubFailure);
-DECLARE_RUNTIME_FUNCTION(VectorKeyedLoadIC_MissFromStubFailure);
+DECLARE_RUNTIME_FUNCTION(LoadIC_MissFromStubFailure);
// Support functions for callbacks handlers.
DECLARE_RUNTIME_FUNCTION(StoreCallbackProperty);
}
-// Generate StoreTransition code, value is passed in a0 register.
-// After executing generated code, the receiver_reg and name_reg
-// may be clobbered.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register scratch3, Label* miss_label, Label* slow) {
- // a0 : value.
- Label exit;
-
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ li(scratch1, constant);
- __ Branch(miss_label, ne, value_reg, Operand(scratch1));
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- Handle<Map> current;
- if (!it.Done()) {
- __ lw(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- // Do the CompareMap() directly within the Branch() functions.
- current = it.Current();
- it.Advance();
- if (it.Done()) {
- __ Branch(miss_label, ne, scratch1, Operand(current));
- break;
- }
- __ Branch(&do_store, eq, scratch1, Operand(current));
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ LoadRoot(scratch3, Heap::kMutableHeapNumberMapRootIndex);
- __ AllocateHeapNumber(storage_reg, scratch1, scratch2, scratch3, slow,
- TAG_RESULT, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiUntag(scratch1, value_reg);
- __ mtc1(scratch1, f6);
- __ cvt_d_w(f4, f6);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex, miss_label,
- DONT_DO_SMI_CHECK);
- __ ldc1(f4, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ sdc1(f4, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ push(receiver_reg);
- __ li(a2, Operand(transition));
- __ Push(a2, a0);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ li(scratch1, Operand(transition));
- __ sw(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kRAHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
- OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(a0));
- __ Ret(USE_DELAY_SLOT);
- __ mov(v0, a0);
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- // TODO(verwaest): Share this code as a code stub.
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ sw(storage_reg, FieldMemOperand(receiver_reg, offset));
- } else {
- __ sw(value_reg, FieldMemOperand(receiver_reg, offset));
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kRAHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array
- __ lw(scratch1, FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ sw(storage_reg, FieldMemOperand(scratch1, offset));
- } else {
- __ sw(value_reg, FieldMemOperand(scratch1, offset));
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ li(this->name(), Operand(name));
+ __ li(StoreTransitionDescriptor::MapRegister(), Operand(transition));
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kRAHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register v0).
- DCHECK(value_reg.is(a0));
- __ bind(&exit);
- __ Ret(USE_DELAY_SLOT);
- __ mov(v0, a0);
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ li(scratch1(), handle(constant, isolate()));
+ __ Branch(miss_label, ne, value_reg, Operand(scratch1()));
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- __ lw(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- Handle<Map> current;
- while (true) {
- // Do the CompareMap() directly within the Branch() functions.
- current = it.Current();
- it.Advance();
- if (it.Done()) {
- __ Branch(miss_label, ne, scratch1(), Operand(current));
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ __ lw(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
+ Label do_store;
+ Handle<Map> current;
+ while (true) {
+ // Do the CompareMap() directly within the Branch() functions.
+ current = it.Current();
+ it.Advance();
+ if (it.Done()) {
+ __ Branch(miss_label, ne, scratch1(), Operand(current));
+ break;
+ }
+ __ Branch(&do_store, eq, scratch1(), Operand(current));
}
- __ Branch(&do_store, eq, scratch1(), Operand(current));
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is in ra.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = a3;
- Register result = v0;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ Ret();
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length,
Register value, Register key, Register receiver, Register receiver_map,
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// ---------- S t a t e --------------
// -- a0 : value
// -- a1 : key
// -----------------------------------
Label slow, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
// Register usage.
Register value = StoreDescriptor::ValueRegister();
// t0 and t1 are used as general scratch registers.
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
// Check that the object isn't a smi.
__ JumpIfSmi(receiver, &slow);
// Get the map of the object.
// a1: key.
// a2: receiver.
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ lw(t0, FieldMemOperand(key, HeapObject::kMapOffset));
+ __ lb(t0, FieldMemOperand(t0, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(t0, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, a3, t0, t1, t2);
+ // Cache miss.
+ __ Branch(&miss);
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
__ lw(t0, FieldMemOperand(receiver, JSArray::kLengthOffset));
__ Branch(&extra, hs, key, Operand(t0));
- KeyedStoreGenerateGenericHelper(
+ KeyedStoreGenerateMegamorphicHelper(
masm, &fast_object, &fast_double, &slow, kCheckMap, kDontIncrementLength,
value, key, receiver, receiver_map, elements_map, elements);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength, value,
- key, receiver, receiver_map, elements_map,
- elements);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength, value, key, receiver,
+ receiver_map, elements_map, elements);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
}
-// Generate StoreTransition code, value is passed in a0 register.
-// After executing generated code, the receiver_reg and name_reg
-// may be clobbered.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register scratch3, Label* miss_label, Label* slow) {
- // a0 : value.
- Label exit;
-
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ li(scratch1, constant);
- __ Branch(miss_label, ne, value_reg, Operand(scratch1));
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- Handle<Map> current;
- if (!it.Done()) {
- __ ld(scratch1, FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- while (true) {
- // Do the CompareMap() directly within the Branch() functions.
- current = it.Current();
- it.Advance();
- if (it.Done()) {
- __ Branch(miss_label, ne, scratch1, Operand(current));
- break;
- }
- __ Branch(&do_store, eq, scratch1, Operand(current));
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ LoadRoot(scratch3, Heap::kMutableHeapNumberMapRootIndex);
- __ AllocateHeapNumber(storage_reg, scratch1, scratch2, scratch3, slow,
- TAG_RESULT, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiUntag(scratch1, value_reg);
- __ mtc1(scratch1, f6);
- __ cvt_d_w(f4, f6);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex, miss_label,
- DONT_DO_SMI_CHECK);
- __ ldc1(f4, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ sdc1(f4, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ push(receiver_reg);
- __ li(a2, Operand(transition));
- __ Push(a2, a0);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ li(scratch1, Operand(transition));
- __ sd(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kRAHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
- OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(a0));
- __ Ret(USE_DELAY_SLOT);
- __ mov(v0, a0);
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- // TODO(verwaest): Share this code as a code stub.
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ sd(storage_reg, FieldMemOperand(receiver_reg, offset));
- } else {
- __ sd(value_reg, FieldMemOperand(receiver_reg, offset));
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kRAHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array
- __ ld(scratch1, FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ sd(storage_reg, FieldMemOperand(scratch1, offset));
- } else {
- __ sd(value_reg, FieldMemOperand(scratch1, offset));
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ li(this->name(), Operand(name));
+ __ li(StoreTransitionDescriptor::MapRegister(), Operand(transition));
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kRAHasNotBeenSaved, kDontSaveFPRegs,
- EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register v0).
- DCHECK(value_reg.is(a0));
- __ bind(&exit);
- __ Ret(USE_DELAY_SLOT);
- __ mov(v0, a0);
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ li(scratch1(), handle(constant, isolate()));
+ __ Branch(miss_label, ne, value_reg, Operand(scratch1()));
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- __ ld(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
- Label do_store;
- Handle<Map> current;
- while (true) {
- // Do the CompareMap() directly within the Branch() functions.
- current = it.Current();
- it.Advance();
- if (it.Done()) {
- __ Branch(miss_label, ne, scratch1(), Operand(current));
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ __ ld(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
+ Label do_store;
+ Handle<Map> current;
+ while (true) {
+ // Do the CompareMap() directly within the Branch() functions.
+ current = it.Current();
+ it.Advance();
+ if (it.Done()) {
+ __ Branch(miss_label, ne, scratch1(), Operand(current));
+ break;
+ }
+ __ Branch(&do_store, eq, scratch1(), Operand(current));
}
- __ Branch(&do_store, eq, scratch1(), Operand(current));
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is in ra.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = a3;
- Register result = v0;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ Ret();
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length,
Register value, Register key, Register receiver, Register receiver_map,
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// ---------- S t a t e --------------
// -- a0 : value
// -- a1 : key
// -----------------------------------
Label slow, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
// Register usage.
Register value = StoreDescriptor::ValueRegister();
// a4 and a5 are used as general scratch registers.
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
// Check that the object isn't a smi.
__ JumpIfSmi(receiver, &slow);
// Get the map of the object.
// a1: key.
// a2: receiver.
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ ld(a4, FieldMemOperand(key, HeapObject::kMapOffset));
+ __ lb(a4, FieldMemOperand(a4, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(a4, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, a3, a4, a5, a6);
+ // Cache miss.
+ __ Branch(&miss);
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
__ ld(a4, FieldMemOperand(receiver, JSArray::kLengthOffset));
__ Branch(&extra, hs, key, Operand(a4));
- KeyedStoreGenerateGenericHelper(
+ KeyedStoreGenerateMegamorphicHelper(
masm, &fast_object, &fast_double, &slow, kCheckMap, kDontIncrementLength,
value, key, receiver, receiver_map, elements_map, elements);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength, value,
- key, receiver, receiver_map, elements_map,
- elements);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength, value, key, receiver,
+ receiver_map, elements_map, elements);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
}
-// Receiver_reg is preserved on jumps to miss_label, but may be destroyed if
-// store is successful.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register unused, Label* miss_label, Label* slow) {
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ Cmp(value_reg, constant);
- __ j(not_equal, miss_label);
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- if (!it.Done()) {
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
- }
- __ j(equal, &do_store, Label::kNear);
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ AllocateHeapNumber(storage_reg, scratch1, slow, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiToInteger32(scratch1, value_reg);
- __ Cvtlsi2sd(xmm0, scratch1);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, isolate()->factory()->heap_number_map(), miss_label,
- DONT_DO_SMI_CHECK);
- __ movsd(xmm0, FieldOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ movsd(FieldOperand(storage_reg, HeapNumber::kValueOffset), xmm0);
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ PopReturnAddressTo(scratch1);
- __ Push(receiver_reg);
- __ Push(transition);
- __ Push(value_reg);
- __ PushReturnAddressFrom(scratch1);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ Move(scratch1, transition);
- __ movp(FieldOperand(receiver_reg, HeapObject::kMapOffset), scratch1);
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kDontSaveFPRegs, OMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(rax));
- __ ret(0);
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- // TODO(verwaest): Share this code as a code stub.
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ movp(FieldOperand(receiver_reg, offset), storage_reg);
- } else {
- __ movp(FieldOperand(receiver_reg, offset), value_reg);
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ movp(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array (optimistically).
- __ movp(scratch1, FieldOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ movp(FieldOperand(scratch1, offset), storage_reg);
- } else {
- __ movp(FieldOperand(scratch1, offset), value_reg);
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ Move(this->name(), name);
+ __ Move(StoreTransitionDescriptor::MapRegister(), transition);
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ movp(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register rax).
- DCHECK(value_reg.is(rax));
- __ ret(0);
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ Cmp(value_reg, handle(constant, isolate()));
+ __ j(not_equal, miss_label);
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ Label do_store;
+ while (true) {
+ __ CompareMap(value_reg, it.Current());
+ it.Advance();
+ if (it.Done()) {
+ __ j(not_equal, miss_label);
+ break;
+ }
+ __ j(equal, &do_store, Label::kNear);
}
- __ j(equal, &do_store, Label::kNear);
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is on the stack.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = rbx;
- Register result = rax;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ ret(0);
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length) {
Label transition_smi_elements;
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// Return address is on the stack.
Label slow, slow_with_tagged_index, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
Register receiver = StoreDescriptor::ReceiverRegister();
Register key = StoreDescriptor::NameRegister();
DCHECK(receiver.is(rdx));
Immediate(1 << Map::kIsAccessCheckNeeded | 1 << Map::kIsObserved));
__ j(not_zero, &slow_with_tagged_index);
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow_with_tagged_index);
+ __ JumpIfNotSmi(key, &maybe_name_key);
__ SmiToInteger32(key, key);
__ CmpInstanceType(r9, JS_ARRAY_TYPE);
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
// Never returns to here.
+ __ bind(&maybe_name_key);
+ __ movp(r9, FieldOperand(key, HeapObject::kMapOffset));
+ __ movzxbp(r9, FieldOperand(r9, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(r9, &slow_with_tagged_index);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, rbx, no_reg);
+ // Cache miss.
+ __ jmp(&miss);
+
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
// element to the array by writing to array[array.length].
__ SmiCompareInteger32(FieldOperand(receiver, JSArray::kLengthOffset), key);
__ j(below_equal, &extra);
- KeyedStoreGenerateGenericHelper(masm, &fast_object, &fast_double, &slow,
- kCheckMap, kDontIncrementLength);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object, &fast_double, &slow,
+ kCheckMap, kDontIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
__ LoadAddress(kScratchRegister, key_offset);
// Check that the key in the entry matches the name.
- // Multiply entry offset by 16 to get the entry address. Since the
- // offset register already holds the entry offset times four, multiply
- // by a further four.
- __ cmpl(name, Operand(kScratchRegister, offset, scale_factor, 0));
+ __ cmpp(name, Operand(kScratchRegister, offset, scale_factor, 0));
__ j(not_equal, &miss);
// Get the map entry from the cache.
// Use key_offset + kPointerSize * 2, rather than loading map_offset.
+ DCHECK(isolate->stub_cache()->map_reference(table).address() -
+ isolate->stub_cache()->key_reference(table).address() ==
+ kPointerSize * 2);
__ movp(kScratchRegister,
Operand(kScratchRegister, offset, scale_factor, kPointerSize * 2));
__ cmpp(kScratchRegister, FieldOperand(receiver, HeapObject::kMapOffset));
}
-// Receiver_reg is preserved on jumps to miss_label, but may be destroyed if
-// store is successful.
-void NamedStoreHandlerCompiler::GenerateStoreTransition(
- Handle<Map> transition, Handle<Name> name, Register receiver_reg,
- Register storage_reg, Register value_reg, Register scratch1,
- Register scratch2, Register unused, Label* miss_label, Label* slow) {
- int descriptor = transition->LastAdded();
- DescriptorArray* descriptors = transition->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(descriptor);
- Representation representation = details.representation();
- DCHECK(!representation.IsNone());
-
- if (details.type() == CONSTANT) {
- Handle<Object> constant(descriptors->GetValue(descriptor), isolate());
- __ CmpObject(value_reg, constant);
- __ j(not_equal, miss_label);
- } else if (representation.IsSmi()) {
- __ JumpIfNotSmi(value_reg, miss_label);
- } else if (representation.IsHeapObject()) {
- __ JumpIfSmi(value_reg, miss_label);
- HeapType* field_type = descriptors->GetFieldType(descriptor);
- HeapType::Iterator<Map> it = field_type->Classes();
- if (!it.Done()) {
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
- }
- __ j(equal, &do_store, Label::kNear);
- }
- __ bind(&do_store);
- }
- } else if (representation.IsDouble()) {
- Label do_store, heap_number;
- __ AllocateHeapNumber(storage_reg, scratch1, scratch2, slow, MUTABLE);
-
- __ JumpIfNotSmi(value_reg, &heap_number);
- __ SmiUntag(value_reg);
- __ push(value_reg);
- __ fild_s(Operand(esp, 0));
- __ pop(value_reg);
- __ SmiTag(value_reg);
- __ jmp(&do_store);
-
- __ bind(&heap_number);
- __ CheckMap(value_reg, isolate()->factory()->heap_number_map(), miss_label,
- DONT_DO_SMI_CHECK);
- __ fld_d(FieldOperand(value_reg, HeapNumber::kValueOffset));
-
- __ bind(&do_store);
- __ fstp_d(FieldOperand(storage_reg, HeapNumber::kValueOffset));
- }
-
- // Stub never generated for objects that require access checks.
- DCHECK(!transition->is_access_check_needed());
-
- // Perform map transition for the receiver if necessary.
- if (details.type() == FIELD &&
- Map::cast(transition->GetBackPointer())->unused_property_fields() == 0) {
- // The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the properties array.
- __ pop(scratch1); // Return address.
- __ push(receiver_reg);
- __ push(Immediate(transition));
- __ push(value_reg);
- __ push(scratch1);
- __ TailCallExternalReference(
- ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
- isolate()),
- 3, 1);
- return;
- }
-
- // Update the map of the object.
- __ mov(scratch1, Immediate(transition));
- __ mov(FieldOperand(receiver_reg, HeapObject::kMapOffset), scratch1);
-
- // Update the write barrier for the map field.
- __ RecordWriteField(receiver_reg, HeapObject::kMapOffset, scratch1, scratch2,
- kDontSaveFPRegs, OMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
-
- if (details.type() == CONSTANT) {
- DCHECK(value_reg.is(eax));
- __ ret(0);
- return;
- }
-
- int index = transition->instance_descriptors()->GetFieldIndex(
- transition->LastAdded());
-
- // Adjust for the number of properties stored in the object. Even in the
- // face of a transition we can use the old map here because the size of the
- // object and the number of in-object properties is not going to change.
- index -= transition->inobject_properties();
-
- SmiCheck smi_check =
- representation.IsTagged() ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
- // TODO(verwaest): Share this code as a code stub.
- if (index < 0) {
- // Set the property straight into the object.
- int offset = transition->instance_size() + (index * kPointerSize);
- if (representation.IsDouble()) {
- __ mov(FieldOperand(receiver_reg, offset), storage_reg);
- } else {
- __ mov(FieldOperand(receiver_reg, offset), value_reg);
- }
-
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(receiver_reg, offset, storage_reg, scratch1,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- } else {
- // Write to the properties array.
- int offset = index * kPointerSize + FixedArray::kHeaderSize;
- // Get the properties array (optimistically).
- __ mov(scratch1, FieldOperand(receiver_reg, JSObject::kPropertiesOffset));
- if (representation.IsDouble()) {
- __ mov(FieldOperand(scratch1, offset), storage_reg);
- } else {
- __ mov(FieldOperand(scratch1, offset), value_reg);
- }
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ mov(this->name(), Immediate(name));
+ __ mov(StoreTransitionDescriptor::MapRegister(), Immediate(transition));
+}
- if (!representation.IsSmi()) {
- // Update the write barrier for the array address.
- if (!representation.IsDouble()) {
- __ mov(storage_reg, value_reg);
- }
- __ RecordWriteField(scratch1, offset, storage_reg, receiver_reg,
- kDontSaveFPRegs, EMIT_REMEMBERED_SET, smi_check);
- }
- }
- // Return the value (register eax).
- DCHECK(value_reg.is(eax));
- __ ret(0);
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ CmpObject(value_reg, handle(constant, isolate()));
+ __ j(not_equal, miss_label);
}
-void NamedStoreHandlerCompiler::GenerateStoreField(LookupIterator* lookup,
- Register value_reg,
- Label* miss_label) {
- DCHECK(lookup->representation().IsHeapObject());
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
__ JumpIfSmi(value_reg, miss_label);
- HeapType::Iterator<Map> it = lookup->GetFieldType()->Classes();
- Label do_store;
- while (true) {
- __ CompareMap(value_reg, it.Current());
- it.Advance();
- if (it.Done()) {
- __ j(not_equal, miss_label);
- break;
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ Label do_store;
+ while (true) {
+ __ CompareMap(value_reg, it.Current());
+ it.Advance();
+ if (it.Done()) {
+ __ j(not_equal, miss_label);
+ break;
+ }
+ __ j(equal, &do_store, Label::kNear);
}
- __ j(equal, &do_store, Label::kNear);
+ __ bind(&do_store);
}
- __ bind(&do_store);
-
- StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
- lookup->representation());
- GenerateTailCall(masm(), stub.GetCode());
}
}
-void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
- // Return address is on the stack.
- Label miss;
-
- Register receiver = LoadDescriptor::ReceiverRegister();
- Register index = LoadDescriptor::NameRegister();
- Register scratch = ebx;
- DCHECK(!scratch.is(receiver) && !scratch.is(index));
- Register result = eax;
- DCHECK(!result.is(scratch));
-
- StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
- &miss, // When not a string.
- &miss, // When not a number.
- &miss, // When index out of range.
- STRING_INDEX_IS_ARRAY_INDEX);
- char_at_generator.GenerateFast(masm);
- __ ret(0);
-
- StubRuntimeCallHelper call_helper;
- char_at_generator.GenerateSlow(masm, call_helper);
-
- __ bind(&miss);
- GenerateMiss(masm);
-}
-
-
void KeyedStoreIC::GenerateSloppyArguments(MacroAssembler* masm) {
// Return address is on the stack.
Label slow, notin;
}
-static void KeyedStoreGenerateGenericHelper(
+static void KeyedStoreGenerateMegamorphicHelper(
MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length) {
Label transition_smi_elements;
}
-void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm,
- StrictMode strict_mode) {
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
// Return address is on the stack.
Label slow, fast_object, fast_object_grow;
Label fast_double, fast_double_grow;
- Label array, extra, check_if_double_array;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
Register receiver = StoreDescriptor::ReceiverRegister();
Register key = StoreDescriptor::NameRegister();
DCHECK(receiver.is(edx));
1 << Map::kIsAccessCheckNeeded | 1 << Map::kIsObserved);
__ j(not_zero, &slow);
// Check that the key is a smi.
- __ JumpIfNotSmi(key, &slow);
+ __ JumpIfNotSmi(key, &maybe_name_key);
__ CmpInstanceType(edi, JS_ARRAY_TYPE);
__ j(equal, &array);
// Check that the object is some kind of JSObject.
// Slow case: call runtime.
__ bind(&slow);
PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ mov(ebx, FieldOperand(key, HeapObject::kMapOffset));
+ __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(ebx, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, ebx, no_reg);
+ // Cache miss.
+ __ jmp(&miss);
// Extra capacity case: Check if there is extra capacity to
// perform the store and update the length. Used for adding one
__ cmp(key, FieldOperand(receiver, JSArray::kLengthOffset)); // Compare smis.
__ j(above_equal, &extra);
- KeyedStoreGenerateGenericHelper(masm, &fast_object, &fast_double, &slow,
- kCheckMap, kDontIncrementLength);
- KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
- &slow, kDontCheckMap, kIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object, &fast_double, &slow,
+ kCheckMap, kDontIncrementLength);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
}
}
-const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) {
+const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) const {
CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0);
size_t index = data_ - start;
DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
}
+void StoreTransitionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {ContextRegister(), ReceiverRegister(), NameRegister(),
+ ValueRegister(), MapRegister()};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
void ElementTransitionAndStoreDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
Register registers[] = {ContextRegister(), ValueRegister(), MapRegister(),
#define INTERFACE_DESCRIPTOR_LIST(V) \
V(Load) \
V(Store) \
+ V(StoreTransition) \
V(ElementTransitionAndStore) \
V(Instanceof) \
V(VectorLoadICTrampoline) \
V(CallConstruct) \
V(RegExpConstructResult) \
V(TransitionElementsKind) \
+ V(AllocateHeapNumber) \
V(ArrayConstructorConstantArgCount) \
V(ArrayConstructor) \
V(InternalArrayConstructorConstantArgCount) \
static const Register ContextRegister();
- const char* DebugName(Isolate* isolate);
+ const char* DebugName(Isolate* isolate) const;
protected:
const CallInterfaceDescriptorData* data() const { return data_; }
};
+class StoreTransitionDescriptor : public StoreDescriptor {
+ public:
+ DECLARE_DESCRIPTOR(StoreTransitionDescriptor, StoreDescriptor)
+
+ // Extends StoreDescriptor with Map parameter.
+ enum ParameterIndices {
+ kReceiverIndex,
+ kNameIndex,
+ kValueIndex,
+ kMapIndex,
+ kParameterCount
+ };
+ static const Register MapRegister();
+};
+
+
class ElementTransitionAndStoreDescriptor : public StoreDescriptor {
public:
DECLARE_DESCRIPTOR(ElementTransitionAndStoreDescriptor, StoreDescriptor)
};
+class AllocateHeapNumberDescriptor : public CallInterfaceDescriptor {
+ public:
+ DECLARE_DESCRIPTOR(AllocateHeapNumberDescriptor, CallInterfaceDescriptor)
+};
+
+
class ArrayConstructorConstantArgCountDescriptor
: public CallInterfaceDescriptor {
public:
#include "src/interface.h"
+#include "src/base/lazy-instance.h"
+
namespace v8 {
namespace internal {
+// ---------------------------------------------------------------------------
+// Initialization.
+
+struct Interface::Cache {
+ template<int flags>
+ struct Create {
+ static void Construct(Interface* ptr) { ::new (ptr) Interface(flags); }
+ };
+ typedef Create<VALUE + FROZEN> ValueCreate;
+ typedef Create<VALUE + CONST + FROZEN> ConstCreate;
+
+ static base::LazyInstance<Interface, ValueCreate>::type value_interface;
+ static base::LazyInstance<Interface, ConstCreate>::type const_interface;
+};
+
+
+base::LazyInstance<Interface, Interface::Cache::ValueCreate>::type
+ Interface::Cache::value_interface = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<Interface, Interface::Cache::ConstCreate>::type
+ Interface::Cache::const_interface = LAZY_INSTANCE_INITIALIZER;
+
+
+Interface* Interface::NewValue() {
+ return Cache::value_interface.Pointer(); // Cached.
+}
+
+
+Interface* Interface::NewConst() {
+ return Cache::const_interface.Pointer(); // Cached.
+}
+
+
+// ---------------------------------------------------------------------------
+// Lookup.
+
Interface* Interface::Lookup(Handle<String> name, Zone* zone) {
DCHECK(IsModule());
ZoneHashMap* map = Chase()->exports_;
- if (map == NULL) return NULL;
+ if (map == nullptr) return nullptr;
ZoneAllocationPolicy allocator(zone);
- ZoneHashMap::Entry* p = map->Lookup(name.location(), name->Hash(), false,
- allocator);
- if (p == NULL) return NULL;
+ ZoneHashMap::Entry* p =
+ map->Lookup(name.location(), name->Hash(), false, allocator);
+ if (p == nullptr) return nullptr;
DCHECK(*static_cast<String**>(p->key) == *name);
- DCHECK(p->value != NULL);
+ DCHECK(p->value != nullptr);
return static_cast<Interface*>(p->value);
}
+// ---------------------------------------------------------------------------
+// Addition.
+
#ifdef DEBUG
// Current nesting depth for debug output.
class Nesting {
PrintF("%*s# Adding...\n", Nesting::current(), "");
PrintF("%*sthis = ", Nesting::current(), "");
this->Print(Nesting::current());
- const AstRawString* symbol = static_cast<const AstRawString*>(name);
- PrintF("%*s%.*s : ", Nesting::current(), "", symbol->length(),
- symbol->raw_data());
+ const AstRawString* raw = static_cast<const AstRawString*>(name);
+ PrintF("%*s%.*s : ", Nesting::current(), "",
+ raw->length(), raw->raw_data());
interface->Print(Nesting::current());
}
#endif
ZoneHashMap** map = &Chase()->exports_;
ZoneAllocationPolicy allocator(zone);
- if (*map == NULL) {
+ if (*map == nullptr) {
*map = new(zone->New(sizeof(ZoneHashMap)))
ZoneHashMap(ZoneHashMap::PointersMatch,
ZoneHashMap::kDefaultHashMapCapacity, allocator);
ZoneHashMap::Entry* p =
(*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator);
- if (p == NULL) {
+ if (p == nullptr) {
// This didn't have name but was frozen already, that's an error.
*ok = false;
- } else if (p->value == NULL) {
+ } else if (p->value == nullptr) {
p->value = interface;
} else {
#ifdef DEBUG
}
+// ---------------------------------------------------------------------------
+// Unification.
+
void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
if (this->forward_) return this->Chase()->Unify(that, zone, ok);
if (that->forward_) return this->Unify(that->Chase(), zone, ok);
- DCHECK(this->forward_ == NULL);
- DCHECK(that->forward_ == NULL);
+ DCHECK(this->forward_ == nullptr);
+ DCHECK(that->forward_ == nullptr);
*ok = true;
if (this == that) return;
#endif
// Merge the smaller interface into the larger, for performance.
- if (this->exports_ != NULL && (that->exports_ == NULL ||
+ if (this->exports_ != nullptr && (that->exports_ == nullptr ||
this->exports_->occupancy() >= that->exports_->occupancy())) {
this->DoUnify(that, ok, zone);
} else {
void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
- DCHECK(this->forward_ == NULL);
- DCHECK(that->forward_ == NULL);
+ DCHECK(this->forward_ == nullptr);
+ DCHECK(that->forward_ == nullptr);
DCHECK(!this->IsValue());
DCHECK(!that->IsValue());
DCHECK(this->index_ == -1);
// Try to merge all members from that into this.
ZoneHashMap* map = that->exports_;
- if (map != NULL) {
- for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
+ if (map != nullptr) {
+ for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok);
if (!*ok) return;
}
// If the new interface is larger than that's, then there were members in
// 'this' which 'that' didn't have. If 'that' was frozen that is an error.
- int this_size = this->exports_ == NULL ? 0 : this->exports_->occupancy();
- int that_size = map == NULL ? 0 : map->occupancy();
+ int this_size = this->exports_ == nullptr ? 0 : this->exports_->occupancy();
+ int that_size = map == nullptr ? 0 : map->occupancy();
if (that->IsFrozen() && this_size > that_size) {
*ok = false;
return;
}
+// ---------------------------------------------------------------------------
+// Printing.
+
#ifdef DEBUG
void Interface::Print(int n) {
int n0 = n > 0 ? n : 0;
if (FLAG_print_interface_details) {
PrintF("%p", static_cast<void*>(this));
- for (Interface* link = this->forward_; link != NULL; link = link->forward_)
+ for (Interface* link = this->forward_; link != nullptr;
+ link = link->forward_) {
PrintF("->%p", static_cast<void*>(link));
+ }
PrintF(" ");
}
} else if (IsModule()) {
PrintF("module %d %s{", Index(), IsFrozen() ? "" : "(unresolved) ");
ZoneHashMap* map = Chase()->exports_;
- if (map == NULL || map->occupancy() == 0) {
+ if (map == nullptr || map->occupancy() == 0) {
PrintF("}\n");
} else if (n < 0 || n0 >= 2 * FLAG_print_interface_depth) {
// Avoid infinite recursion on cyclic types.
PrintF("...}\n");
} else {
PrintF("\n");
- for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
+ for (ZoneHashMap::Entry* p = map->Start();
+ p != nullptr; p = map->Next(p)) {
String* name = *static_cast<String**>(p->key);
Interface* interface = static_cast<Interface*>(p->value);
PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray());
return new(zone) Interface(NONE);
}
- static Interface* NewValue() {
- static Interface value_interface(VALUE + FROZEN); // Cached.
- return &value_interface;
- }
+ static Interface* NewValue();
- static Interface* NewConst() {
- static Interface value_interface(VALUE + CONST + FROZEN); // Cached.
- return &value_interface;
- }
+ static Interface* NewConst();
static Interface* NewModule(Zone* zone) {
return new(zone) Interface(MODULE);
// ---------------------------------------------------------------------------
// Implementation.
private:
+ struct Cache;
+
enum Flags { // All flags are monotonic
NONE = 0,
VALUE = 1, // This type describes a value
#include <stdlib.h>
+#include <fstream> // NOLINT(readability/streams)
+#include <sstream>
+
#include "src/v8.h"
#include "src/ast.h"
#include "src/bootstrapper.h"
#include "src/codegen.h"
#include "src/compilation-cache.h"
+#include "src/compilation-statistics.h"
#include "src/cpu-profiler.h"
#include "src/debug.h"
#include "src/deoptimizer.h"
#include "src/heap/spaces.h"
-#include "src/heap/sweeper-thread.h"
#include "src/heap-profiler.h"
#include "src/hydrogen.h"
#include "src/ic/stub-cache.h"
void ThreadLocalTop::InitializeInternal() {
c_entry_fp_ = 0;
+ c_function_ = 0;
handler_ = 0;
#ifdef USE_SIMULATOR
simulator_ = NULL;
}
DCHECK(cursor + 4 <= elements->length());
-
Handle<Code> code = frames[i].code();
Handle<Smi> offset(Smi::FromInt(frames[i].offset()), this);
// The stack trace API should not expose receivers and function
}
+Handle<JSArray> Isolate::GetDetailedStackTrace(Handle<JSObject> error_object) {
+ Handle<Name> key_detailed = factory()->detailed_stack_trace_symbol();
+ Handle<Object> stack_trace =
+ JSObject::GetDataProperty(error_object, key_detailed);
+ if (stack_trace->IsJSArray()) return Handle<JSArray>::cast(stack_trace);
+
+ if (!capture_stack_trace_for_uncaught_exceptions_) return Handle<JSArray>();
+
+ // Try to get details from simple stack trace.
+ Handle<JSArray> detailed_stack_trace =
+ GetDetailedFromSimpleStackTrace(error_object);
+ if (!detailed_stack_trace.is_null()) {
+ // Save the detailed stack since the simple one might be withdrawn later.
+ JSObject::SetProperty(error_object, key_detailed, detailed_stack_trace,
+ STRICT).Assert();
+ }
+ return detailed_stack_trace;
+}
+
+
+class CaptureStackTraceHelper {
+ public:
+ CaptureStackTraceHelper(Isolate* isolate,
+ StackTrace::StackTraceOptions options)
+ : isolate_(isolate) {
+ if (options & StackTrace::kColumnOffset) {
+ column_key_ =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("column"));
+ }
+ if (options & StackTrace::kLineNumber) {
+ line_key_ =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("lineNumber"));
+ }
+ if (options & StackTrace::kScriptId) {
+ script_id_key_ =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptId"));
+ }
+ if (options & StackTrace::kScriptName) {
+ script_name_key_ =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptName"));
+ }
+ if (options & StackTrace::kScriptNameOrSourceURL) {
+ script_name_or_source_url_key_ = factory()->InternalizeOneByteString(
+ STATIC_CHAR_VECTOR("scriptNameOrSourceURL"));
+ }
+ if (options & StackTrace::kFunctionName) {
+ function_key_ = factory()->InternalizeOneByteString(
+ STATIC_CHAR_VECTOR("functionName"));
+ }
+ if (options & StackTrace::kIsEval) {
+ eval_key_ =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
+ }
+ if (options & StackTrace::kIsConstructor) {
+ constructor_key_ = factory()->InternalizeOneByteString(
+ STATIC_CHAR_VECTOR("isConstructor"));
+ }
+ }
+
+ Handle<JSObject> NewStackFrameObject(Handle<JSFunction> fun,
+ Handle<Code> code, Address pc,
+ bool is_constructor) {
+ Handle<JSObject> stack_frame =
+ factory()->NewJSObject(isolate_->object_function());
+
+ Handle<Script> script(Script::cast(fun->shared()->script()));
+
+ if (!line_key_.is_null()) {
+ int script_line_offset = script->line_offset()->value();
+ int position = code->SourcePosition(pc);
+ int line_number = Script::GetLineNumber(script, position);
+ // line_number is already shifted by the script_line_offset.
+ int relative_line_number = line_number - script_line_offset;
+ if (!column_key_.is_null() && relative_line_number >= 0) {
+ Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
+ int start = (relative_line_number == 0) ? 0 :
+ Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
+ int column_offset = position - start;
+ if (relative_line_number == 0) {
+ // For the case where the code is on the same line as the script
+ // tag.
+ column_offset += script->column_offset()->value();
+ }
+ JSObject::AddProperty(stack_frame, column_key_,
+ handle(Smi::FromInt(column_offset + 1), isolate_),
+ NONE);
+ }
+ JSObject::AddProperty(stack_frame, line_key_,
+ handle(Smi::FromInt(line_number + 1), isolate_),
+ NONE);
+ }
+
+ if (!script_id_key_.is_null()) {
+ JSObject::AddProperty(stack_frame, script_id_key_,
+ handle(script->id(), isolate_), NONE);
+ }
+
+ if (!script_name_key_.is_null()) {
+ JSObject::AddProperty(stack_frame, script_name_key_,
+ handle(script->name(), isolate_), NONE);
+ }
+
+ if (!script_name_or_source_url_key_.is_null()) {
+ Handle<Object> result = Script::GetNameOrSourceURL(script);
+ JSObject::AddProperty(stack_frame, script_name_or_source_url_key_, result,
+ NONE);
+ }
+
+ if (!function_key_.is_null()) {
+ Handle<Object> fun_name(fun->shared()->DebugName(), isolate_);
+ JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
+ }
+
+ if (!eval_key_.is_null()) {
+ Handle<Object> is_eval = factory()->ToBoolean(
+ script->compilation_type() == Script::COMPILATION_TYPE_EVAL);
+ JSObject::AddProperty(stack_frame, eval_key_, is_eval, NONE);
+ }
+
+ if (!constructor_key_.is_null()) {
+ Handle<Object> is_constructor_obj = factory()->ToBoolean(is_constructor);
+ JSObject::AddProperty(stack_frame, constructor_key_, is_constructor_obj,
+ NONE);
+ }
+
+ return stack_frame;
+ }
+
+ private:
+ inline Factory* factory() { return isolate_->factory(); }
+
+ Isolate* isolate_;
+ Handle<String> column_key_;
+ Handle<String> line_key_;
+ Handle<String> script_id_key_;
+ Handle<String> script_name_key_;
+ Handle<String> script_name_or_source_url_key_;
+ Handle<String> function_key_;
+ Handle<String> eval_key_;
+ Handle<String> constructor_key_;
+};
+
+
+Handle<JSArray> Isolate::GetDetailedFromSimpleStackTrace(
+ Handle<JSObject> error_object) {
+ Handle<Name> key = factory()->stack_trace_symbol();
+ Handle<Object> property = JSObject::GetDataProperty(error_object, key);
+ if (!property->IsJSArray()) return Handle<JSArray>();
+ Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
+
+ CaptureStackTraceHelper helper(this,
+ stack_trace_for_uncaught_exceptions_options_);
+
+ int frames_seen = 0;
+ Handle<FixedArray> elements(FixedArray::cast(simple_stack_trace->elements()));
+ int elements_limit = Smi::cast(simple_stack_trace->length())->value();
+
+ int frame_limit = stack_trace_for_uncaught_exceptions_frame_limit_;
+ if (frame_limit < 0) frame_limit = (elements_limit - 1) / 4;
+
+ Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
+ for (int i = 1; i < elements_limit && frames_seen < frame_limit; i += 4) {
+ Handle<Object> recv = handle(elements->get(i), this);
+ Handle<JSFunction> fun =
+ handle(JSFunction::cast(elements->get(i + 1)), this);
+ Handle<Code> code = handle(Code::cast(elements->get(i + 2)), this);
+ Handle<Smi> offset = handle(Smi::cast(elements->get(i + 3)), this);
+ Address pc = code->address() + offset->value();
+ bool is_constructor =
+ recv->IsJSObject() &&
+ Handle<JSObject>::cast(recv)->map()->constructor() == *fun;
+
+ Handle<JSObject> stack_frame =
+ helper.NewStackFrameObject(fun, code, pc, is_constructor);
+
+ FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
+ frames_seen++;
+ }
+
+ stack_trace->set_length(Smi::FromInt(frames_seen));
+ return stack_trace;
+}
+
+
Handle<JSArray> Isolate::CaptureCurrentStackTrace(
int frame_limit, StackTrace::StackTraceOptions options) {
+ CaptureStackTraceHelper helper(this, options);
+
// Ensure no negative values.
int limit = Max(frame_limit, 0);
Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
- Handle<String> column_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("column"));
- Handle<String> line_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("lineNumber"));
- Handle<String> script_id_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptId"));
- Handle<String> script_name_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptName"));
- Handle<String> script_name_or_source_url_key =
- factory()->InternalizeOneByteString(
- STATIC_CHAR_VECTOR("scriptNameOrSourceURL"));
- Handle<String> function_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("functionName"));
- Handle<String> eval_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
- Handle<String> constructor_key =
- factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isConstructor"));
-
StackTraceFrameIterator it(this);
int frames_seen = 0;
while (!it.done() && (frames_seen < limit)) {
if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
!this->context()->HasSameSecurityTokenAs(fun->context())) continue;
- // Create a JSObject to hold the information for the StackFrame.
- Handle<JSObject> stack_frame = factory()->NewJSObject(object_function());
-
- Handle<Script> script(Script::cast(fun->shared()->script()));
-
- if (options & StackTrace::kLineNumber) {
- int script_line_offset = script->line_offset()->value();
- int position = frames[i].code()->SourcePosition(frames[i].pc());
- int line_number = Script::GetLineNumber(script, position);
- // line_number is already shifted by the script_line_offset.
- int relative_line_number = line_number - script_line_offset;
- if (options & StackTrace::kColumnOffset && relative_line_number >= 0) {
- Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
- int start = (relative_line_number == 0) ? 0 :
- Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
- int column_offset = position - start;
- if (relative_line_number == 0) {
- // For the case where the code is on the same line as the script
- // tag.
- column_offset += script->column_offset()->value();
- }
- JSObject::AddProperty(
- stack_frame, column_key,
- handle(Smi::FromInt(column_offset + 1), this), NONE);
- }
- JSObject::AddProperty(
- stack_frame, line_key,
- handle(Smi::FromInt(line_number + 1), this), NONE);
- }
-
- if (options & StackTrace::kScriptId) {
- JSObject::AddProperty(
- stack_frame, script_id_key, handle(script->id(), this), NONE);
- }
-
- if (options & StackTrace::kScriptName) {
- JSObject::AddProperty(
- stack_frame, script_name_key, handle(script->name(), this), NONE);
- }
-
- if (options & StackTrace::kScriptNameOrSourceURL) {
- Handle<Object> result = Script::GetNameOrSourceURL(script);
- JSObject::AddProperty(
- stack_frame, script_name_or_source_url_key, result, NONE);
- }
-
- if (options & StackTrace::kFunctionName) {
- Handle<Object> fun_name(fun->shared()->DebugName(), this);
- JSObject::AddProperty(stack_frame, function_key, fun_name, NONE);
- }
-
- if (options & StackTrace::kIsEval) {
- Handle<Object> is_eval =
- script->compilation_type() == Script::COMPILATION_TYPE_EVAL ?
- factory()->true_value() : factory()->false_value();
- JSObject::AddProperty(stack_frame, eval_key, is_eval, NONE);
- }
-
- if (options & StackTrace::kIsConstructor) {
- Handle<Object> is_constructor = (frames[i].is_constructor()) ?
- factory()->true_value() : factory()->false_value();
- JSObject::AddProperty(
- stack_frame, constructor_key, is_constructor, NONE);
- }
+ Handle<JSObject> stack_frame = helper.NewStackFrameObject(
+ fun, frames[i].code(), frames[i].pc(), frames[i].is_constructor());
FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
frames_seen++;
void Isolate::PrintStack(StringStream* accumulator) {
- if (!IsInitialized()) {
- accumulator->Add(
- "\n==== JS stack trace is not available =======================\n\n");
- accumulator->Add(
- "\n==== Isolate for the thread is not initialized =============\n\n");
- return;
- }
// The MentionedObjectCache is not GC-proof at the moment.
DisallowHeapAllocation no_gc;
DCHECK(StringStream::IsMentionedObjectCacheClear(this));
// Advance to the next JavaScript frame and determine if the
// current frame is the top-level frame.
it.Advance();
- Handle<Object> is_top_level = it.done()
- ? factory()->true_value()
- : factory()->false_value();
+ Handle<Object> is_top_level = factory()->ToBoolean(it.done());
// Generate and print stack trace line.
Handle<String> line =
Execution::GetStackTraceLine(recv, fun, pos_obj, is_top_level);
}
+bool Isolate::ComputeLocationFromStackTrace(MessageLocation* target,
+ Handle<Object> exception) {
+ *target = MessageLocation(Handle<Script>(heap_.empty_script()), -1, -1);
+
+ if (!exception->IsJSObject()) return false;
+ Handle<Name> key = factory()->stack_trace_symbol();
+ Handle<Object> property =
+ JSObject::GetDataProperty(Handle<JSObject>::cast(exception), key);
+ if (!property->IsJSArray()) return false;
+ Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
+
+ Handle<FixedArray> elements(FixedArray::cast(simple_stack_trace->elements()));
+ int elements_limit = Smi::cast(simple_stack_trace->length())->value();
+
+ for (int i = 1; i < elements_limit; i += 4) {
+ Handle<JSFunction> fun =
+ handle(JSFunction::cast(elements->get(i + 1)), this);
+ if (fun->IsFromNativeScript()) continue;
+ Handle<Code> code = handle(Code::cast(elements->get(i + 2)), this);
+ Handle<Smi> offset = handle(Smi::cast(elements->get(i + 3)), this);
+ Address pc = code->address() + offset->value();
+
+ Object* script = fun->shared()->script();
+ if (script->IsScript() &&
+ !(Script::cast(script)->source()->IsUndefined())) {
+ int pos = code->SourcePosition(pc);
+ Handle<Script> casted_script(Script::cast(script));
+ *target = MessageLocation(casted_script, pos, pos + 1);
+ return true;
+ }
+ }
+ return false;
+}
+
+
bool Isolate::ShouldReportException(bool* can_be_caught_externally,
bool catchable_by_javascript) {
// Find the top-most try-catch handler.
}
+// Traverse prototype chain to find out whether the object is derived from
+// the Error object.
bool Isolate::IsErrorObject(Handle<Object> obj) {
if (!obj->IsJSObject()) return false;
static int fatal_exception_depth = 0;
+
+Handle<JSMessageObject> Isolate::CreateMessage(Handle<Object> exception,
+ MessageLocation* location) {
+ Handle<JSArray> stack_trace_object;
+ MessageLocation potential_computed_location;
+ if (capture_stack_trace_for_uncaught_exceptions_) {
+ if (IsErrorObject(exception)) {
+ // We fetch the stack trace that corresponds to this error object.
+ // If the lookup fails, the exception is probably not a valid Error
+ // object. In that case, we fall through and capture the stack trace
+ // at this throw site.
+ stack_trace_object =
+ GetDetailedStackTrace(Handle<JSObject>::cast(exception));
+ }
+ if (stack_trace_object.is_null()) {
+ // Not an error object, we capture stack and location at throw site.
+ stack_trace_object = CaptureCurrentStackTrace(
+ stack_trace_for_uncaught_exceptions_frame_limit_,
+ stack_trace_for_uncaught_exceptions_options_);
+ }
+ }
+ if (!location) {
+ if (!ComputeLocationFromStackTrace(&potential_computed_location,
+ exception)) {
+ ComputeLocation(&potential_computed_location);
+ }
+ location = &potential_computed_location;
+ }
+
+ // If the exception argument is a custom object, turn it into a string
+ // before throwing as uncaught exception. Note that the pending
+ // exception object to be set later must not be turned into a string.
+ if (exception->IsJSObject() && !IsErrorObject(exception)) {
+ MaybeHandle<Object> maybe_exception =
+ Execution::ToDetailString(this, exception);
+ if (!maybe_exception.ToHandle(&exception)) {
+ exception =
+ factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("exception"));
+ }
+ }
+ return MessageHandler::MakeMessageObject(this, "uncaught_exception", location,
+ HandleVector<Object>(&exception, 1),
+ stack_trace_object);
+}
+
+
+void ReportBootstrappingException(Handle<Object> exception,
+ MessageLocation* location) {
+ base::OS::PrintError("Exception thrown during bootstrapping\n");
+ if (location == NULL || location->script().is_null()) return;
+ // We are bootstrapping and caught an error where the location is set
+ // and we have a script for the location.
+ // In this case we could have an extension (or an internal error
+ // somewhere) and we print out the line number at which the error occured
+ // to the console for easier debugging.
+ int line_number =
+ location->script()->GetLineNumber(location->start_pos()) + 1;
+ if (exception->IsString() && location->script()->name()->IsString()) {
+ base::OS::PrintError(
+ "Extension or internal compilation error: %s in %s at line %d.\n",
+ String::cast(*exception)->ToCString().get(),
+ String::cast(location->script()->name())->ToCString().get(),
+ line_number);
+ } else if (location->script()->name()->IsString()) {
+ base::OS::PrintError(
+ "Extension or internal compilation error in %s at line %d.\n",
+ String::cast(location->script()->name())->ToCString().get(),
+ line_number);
+ } else {
+ base::OS::PrintError("Extension or internal compilation error.\n");
+ }
+#ifdef OBJECT_PRINT
+ // Since comments and empty lines have been stripped from the source of
+ // builtins, print the actual source here so that line numbers match.
+ if (location->script()->source()->IsString()) {
+ Handle<String> src(String::cast(location->script()->source()));
+ PrintF("Failing script:\n");
+ int len = src->length();
+ int line_number = 1;
+ PrintF("%5d: ", line_number);
+ for (int i = 0; i < len; i++) {
+ uint16_t character = src->Get(i);
+ PrintF("%c", character);
+ if (character == '\n' && i < len - 2) {
+ PrintF("%5d: ", ++line_number);
+ }
+ }
+ }
+#endif
+}
+
+
void Isolate::DoThrow(Object* exception, MessageLocation* location) {
DCHECK(!has_pending_exception());
bool report_exception = catchable_by_javascript && should_report_exception;
bool try_catch_needs_message =
can_be_caught_externally && try_catch_handler()->capture_message_;
- bool bootstrapping = bootstrapper()->IsActive();
bool rethrowing_message = thread_local_top()->rethrowing_message_;
thread_local_top()->rethrowing_message_ = false;
ComputeLocation(&potential_computed_location);
location = &potential_computed_location;
}
- // It's not safe to try to make message objects or collect stack traces
- // while the bootstrapper is active since the infrastructure may not have
- // been properly initialized.
- if (!bootstrapping) {
- Handle<JSArray> stack_trace_object;
- if (capture_stack_trace_for_uncaught_exceptions_) {
- if (IsErrorObject(exception_handle)) {
- // We fetch the stack trace that corresponds to this error object.
- Handle<Name> key = factory()->detailed_stack_trace_symbol();
- // Look up as own property. If the lookup fails, the exception is
- // probably not a valid Error object. In that case, we fall through
- // and capture the stack trace at this throw site.
- LookupIterator lookup(exception_handle, key,
- LookupIterator::OWN_SKIP_INTERCEPTOR);
- Handle<Object> stack_trace_property;
- if (Object::GetProperty(&lookup).ToHandle(&stack_trace_property) &&
- stack_trace_property->IsJSArray()) {
- stack_trace_object = Handle<JSArray>::cast(stack_trace_property);
- }
- }
- if (stack_trace_object.is_null()) {
- // Not an error object, we capture at throw site.
- stack_trace_object = CaptureCurrentStackTrace(
- stack_trace_for_uncaught_exceptions_frame_limit_,
- stack_trace_for_uncaught_exceptions_options_);
- }
- }
- Handle<Object> exception_arg = exception_handle;
- // If the exception argument is a custom object, turn it into a string
- // before throwing as uncaught exception. Note that the pending
- // exception object to be set later must not be turned into a string.
- if (exception_arg->IsJSObject() && !IsErrorObject(exception_arg)) {
- MaybeHandle<Object> maybe_exception =
- Execution::ToDetailString(this, exception_arg);
- if (!maybe_exception.ToHandle(&exception_arg)) {
- exception_arg = factory()->InternalizeOneByteString(
- STATIC_CHAR_VECTOR("exception"));
- }
- }
- Handle<Object> message_obj = MessageHandler::MakeMessageObject(
- this,
- "uncaught_exception",
- location,
- HandleVector<Object>(&exception_arg, 1),
- stack_trace_object);
+ if (bootstrapper()->IsActive()) {
+ // It's not safe to try to make message objects or collect stack traces
+ // while the bootstrapper is active since the infrastructure may not have
+ // been properly initialized.
+ ReportBootstrappingException(exception_handle, location);
+ } else {
+ Handle<Object> message_obj = CreateMessage(exception_handle, location);
+
thread_local_top()->pending_message_obj_ = *message_obj;
- if (location != NULL) {
- thread_local_top()->pending_message_script_ = *location->script();
- thread_local_top()->pending_message_start_pos_ = location->start_pos();
- thread_local_top()->pending_message_end_pos_ = location->end_pos();
- }
+ thread_local_top()->pending_message_script_ = *location->script();
+ thread_local_top()->pending_message_start_pos_ = location->start_pos();
+ thread_local_top()->pending_message_end_pos_ = location->end_pos();
// If the abort-on-uncaught-exception flag is specified, abort on any
// exception not caught by JavaScript, even when an external handler is
// present. This flag is intended for use by JavaScript developers, so
// print a user-friendly stack trace (not an internal one).
- if (fatal_exception_depth == 0 &&
- FLAG_abort_on_uncaught_exception &&
+ if (fatal_exception_depth == 0 && FLAG_abort_on_uncaught_exception &&
(report_exception || can_be_caught_externally)) {
fatal_exception_depth++;
- PrintF(stderr,
- "%s\n\nFROM\n",
+ PrintF(stderr, "%s\n\nFROM\n",
MessageHandler::GetLocalizedMessage(this, message_obj).get());
PrintCurrentStackTrace(stderr);
base::OS::Abort();
}
- } else if (location != NULL && !location->script().is_null()) {
- // We are bootstrapping and caught an error where the location is set
- // and we have a script for the location.
- // In this case we could have an extension (or an internal error
- // somewhere) and we print out the line number at which the error occured
- // to the console for easier debugging.
- int line_number =
- location->script()->GetLineNumber(location->start_pos()) + 1;
- if (exception->IsString() && location->script()->name()->IsString()) {
- base::OS::PrintError(
- "Extension or internal compilation error: %s in %s at line %d.\n",
- String::cast(exception)->ToCString().get(),
- String::cast(location->script()->name())->ToCString().get(),
- line_number);
- } else if (location->script()->name()->IsString()) {
- base::OS::PrintError(
- "Extension or internal compilation error in %s at line %d.\n",
- String::cast(location->script()->name())->ToCString().get(),
- line_number);
- } else {
- base::OS::PrintError("Extension or internal compilation error.\n");
- }
-#ifdef OBJECT_PRINT
- // Since comments and empty lines have been stripped from the source of
- // builtins, print the actual source here so that line numbers match.
- if (location->script()->source()->IsString()) {
- Handle<String> src(String::cast(location->script()->source()));
- PrintF("Failing script:\n");
- int len = src->length();
- int line_number = 1;
- PrintF("%5d: ", line_number);
- for (int i = 0; i < len; i++) {
- uint16_t character = src->Get(i);
- PrintF("%c", character);
- if (character == '\n' && i < len - 2) {
- PrintF("%5d: ", ++line_number);
- }
- }
- }
-#endif
}
}
if (thread_local_top_.pending_exception_ != heap()->termination_exception() &&
thread_local_top_.has_pending_message_ &&
- !thread_local_top_.pending_message_obj_->IsTheHole() &&
!thread_local_top_.pending_message_obj_->IsTheHole()) {
Handle<Script> script(
Script::cast(thread_local_top_.pending_message_script_));
StackHandler* handler = StackHandler::FromAddress(Isolate::handler(tltop));
do {
if (handler == promise_try) {
- // Mark the pushed try-catch handler to prevent a later duplicate event
- // triggered with the following reject.
return tltop->promise_on_stack_->promise();
}
handler = handler->next();
#endif
-Isolate::Isolate()
+Isolate::Isolate(bool enable_serializer)
: embedder_data_(),
- state_(UNINITIALIZED),
entry_stack_(NULL),
stack_trace_nesting_level_(0),
incomplete_message_(NULL),
unicode_cache_(NULL),
runtime_zone_(this),
inner_pointer_to_code_cache_(NULL),
- write_iterator_(NULL),
global_handles_(NULL),
eternal_handles_(NULL),
thread_manager_(NULL),
// TODO(bmeurer) Initialized lazily because it depends on flags; can
// be fixed once the default isolate cleanup is done.
random_number_generator_(NULL),
- serializer_enabled_(false),
+ serializer_enabled_(enable_serializer),
has_fatal_error_(false),
initialized_from_snapshot_(false),
cpu_profiler_(NULL),
function_entry_hook_(NULL),
deferred_handles_head_(NULL),
optimizing_compiler_thread_(NULL),
- sweeper_thread_(NULL),
- num_sweeper_threads_(0),
stress_deopt_count_(0),
next_optimization_id_(0),
use_counter_callback_(NULL),
void Isolate::Deinit() {
- if (state_ == INITIALIZED) {
- TRACE_ISOLATE(deinit);
-
- debug()->Unload();
+ TRACE_ISOLATE(deinit);
- FreeThreadResources();
+ debug()->Unload();
- if (concurrent_recompilation_enabled()) {
- optimizing_compiler_thread_->Stop();
- delete optimizing_compiler_thread_;
- optimizing_compiler_thread_ = NULL;
- }
-
- for (int i = 0; i < num_sweeper_threads_; i++) {
- sweeper_thread_[i]->Stop();
- delete sweeper_thread_[i];
- sweeper_thread_[i] = NULL;
- }
- delete[] sweeper_thread_;
- sweeper_thread_ = NULL;
+ FreeThreadResources();
- if (FLAG_job_based_sweeping &&
- heap_.mark_compact_collector()->sweeping_in_progress()) {
- heap_.mark_compact_collector()->EnsureSweepingCompleted();
- }
+ if (concurrent_recompilation_enabled()) {
+ optimizing_compiler_thread_->Stop();
+ delete optimizing_compiler_thread_;
+ optimizing_compiler_thread_ = NULL;
+ }
- if (FLAG_turbo_stats) GetTStatistics()->Print("TurboFan");
- if (FLAG_hydrogen_stats) GetHStatistics()->Print("Hydrogen");
+ if (heap_.mark_compact_collector()->sweeping_in_progress()) {
+ heap_.mark_compact_collector()->EnsureSweepingCompleted();
+ }
- if (FLAG_print_deopt_stress) {
- PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
- }
+ if (turbo_statistics() != NULL) {
+ OFStream os(stdout);
+ os << *turbo_statistics() << std::endl;
+ }
+ if (FLAG_hydrogen_stats) GetHStatistics()->Print();
- // We must stop the logger before we tear down other components.
- Sampler* sampler = logger_->sampler();
- if (sampler && sampler->IsActive()) sampler->Stop();
+ if (FLAG_print_deopt_stress) {
+ PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
+ }
- delete deoptimizer_data_;
- deoptimizer_data_ = NULL;
- builtins_.TearDown();
- bootstrapper_->TearDown();
+ // We must stop the logger before we tear down other components.
+ Sampler* sampler = logger_->sampler();
+ if (sampler && sampler->IsActive()) sampler->Stop();
- if (runtime_profiler_ != NULL) {
- delete runtime_profiler_;
- runtime_profiler_ = NULL;
- }
+ delete deoptimizer_data_;
+ deoptimizer_data_ = NULL;
+ builtins_.TearDown();
+ bootstrapper_->TearDown();
- delete basic_block_profiler_;
- basic_block_profiler_ = NULL;
+ if (runtime_profiler_ != NULL) {
+ delete runtime_profiler_;
+ runtime_profiler_ = NULL;
+ }
- heap_.TearDown();
- logger_->TearDown();
+ delete basic_block_profiler_;
+ basic_block_profiler_ = NULL;
- delete heap_profiler_;
- heap_profiler_ = NULL;
- delete cpu_profiler_;
- cpu_profiler_ = NULL;
+ heap_.TearDown();
+ logger_->TearDown();
- // The default isolate is re-initializable due to legacy API.
- state_ = UNINITIALIZED;
- }
+ delete heap_profiler_;
+ heap_profiler_ = NULL;
+ delete cpu_profiler_;
+ cpu_profiler_ = NULL;
}
bootstrapper_ = NULL;
delete inner_pointer_to_code_cache_;
inner_pointer_to_code_cache_ = NULL;
- delete write_iterator_;
- write_iterator_ = NULL;
delete thread_manager_;
thread_manager_ = NULL;
bool Isolate::Init(Deserializer* des) {
- DCHECK(state_ != INITIALIZED);
TRACE_ISOLATE(init);
stress_deopt_count_ = FLAG_deopt_every_n_times;
descriptor_lookup_cache_ = new DescriptorLookupCache();
unicode_cache_ = new UnicodeCache();
inner_pointer_to_code_cache_ = new InnerPointerToCodeCache(this);
- write_iterator_ = new ConsStringIteratorOp();
global_handles_ = new GlobalHandles(this);
eternal_handles_ = new EternalHandles();
bootstrapper_ = new Bootstrapper(this);
builtins_.SetUp(this, create_heap_objects);
if (FLAG_log_internal_timer_events) {
- set_event_logger(Logger::DefaultTimerEventsLogger);
- } else {
- set_event_logger(Logger::EmptyTimerEventsLogger);
+ set_event_logger(Logger::DefaultEventLoggerSentinel);
}
// Set default value if not yet set.
Max(Min(base::SysInfo::NumberOfProcessors(), 4), 1);
}
- if (!FLAG_job_based_sweeping) {
- num_sweeper_threads_ =
- SweeperThread::NumberOfThreads(max_available_threads_);
- }
-
if (FLAG_trace_hydrogen || FLAG_trace_hydrogen_stubs) {
PrintF("Concurrent recompilation has been disabled for tracing.\n");
} else if (OptimizingCompilerThread::Enabled(max_available_threads_)) {
optimizing_compiler_thread_->Start();
}
- if (num_sweeper_threads_ > 0) {
- sweeper_thread_ = new SweeperThread*[num_sweeper_threads_];
- for (int i = 0; i < num_sweeper_threads_; i++) {
- sweeper_thread_[i] = new SweeperThread(this);
- sweeper_thread_[i]->Start();
- }
- }
+ // Initialize runtime profiler before deserialization, because collections may
+ // occur, clearing/updating ICs.
+ runtime_profiler_ = new RuntimeProfiler(this);
// If we are deserializing, read the state into the now-empty heap.
if (!create_heap_objects) {
// Quiet the heap NaN if needed on target platform.
if (!create_heap_objects) Assembler::QuietNaN(heap_.nan_value());
- runtime_profiler_ = new RuntimeProfiler(this);
+ if (FLAG_trace_turbo) {
+ // Create an empty file.
+ std::ofstream(GetTurboCfgFileName().c_str(), std::ios_base::trunc);
+ }
// If we are deserializing, log non-function code objects and compiled
// functions found in the snapshot.
heap_.amount_of_external_allocated_memory_at_last_global_gc_)),
Internals::kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset);
- state_ = INITIALIZED;
time_millis_at_init_ = base::OS::TimeCurrentMillis();
+ heap_.NotifyDeserializationComplete();
+
if (!create_heap_objects) {
// Now that the heap is consistent, it's OK to generate the code for the
// deopt entry table that might have been referred to by optimized code in
}
-HStatistics* Isolate::GetTStatistics() {
- if (tstatistics() == NULL) set_tstatistics(new HStatistics());
- return tstatistics();
+CompilationStatistics* Isolate::GetTurboStatistics() {
+ if (turbo_statistics() == NULL)
+ set_turbo_statistics(new CompilationStatistics());
+ return turbo_statistics();
}
Handle<JSObject> Isolate::GetSymbolRegistry() {
- if (heap()->symbol_registry()->IsUndefined()) {
+ if (heap()->symbol_registry()->IsSmi()) {
Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
Handle<JSObject> registry = factory()->NewJSObjectFromMap(map);
heap()->set_symbol_registry(*registry);
}
+void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
+ promise_reject_callback_ = callback;
+}
+
+
+void Isolate::ReportPromiseReject(Handle<JSObject> promise,
+ Handle<Object> value,
+ v8::PromiseRejectEvent event) {
+ if (promise_reject_callback_ == NULL) return;
+ Handle<JSArray> stack_trace;
+ if (event == v8::kPromiseRejectWithNoHandler && value->IsJSObject()) {
+ stack_trace = GetDetailedStackTrace(Handle<JSObject>::cast(value));
+ }
+ promise_reject_callback_(v8::PromiseRejectMessage(
+ v8::Utils::PromiseToLocal(promise), event, v8::Utils::ToLocal(value),
+ v8::Utils::StackTraceToLocal(stack_trace)));
+}
+
+
void Isolate::EnqueueMicrotask(Handle<Object> microtask) {
DCHECK(microtask->IsJSFunction() || microtask->IsCallHandlerInfo());
Handle<FixedArray> queue(heap()->microtask_queue(), this);
}
+std::string Isolate::GetTurboCfgFileName() {
+ if (FLAG_trace_turbo_cfg_file == NULL) {
+ std::ostringstream os;
+ os << "turbo-" << base::OS::GetCurrentProcessId() << "-" << id() << ".cfg";
+ return os.str();
+ } else {
+ return FLAG_trace_turbo_cfg_file;
+ }
+}
+
+
bool StackLimitCheck::JsHasOverflowed() const {
StackGuard* stack_guard = isolate_->stack_guard();
#ifdef USE_SIMULATOR
class CodeStubDescriptor;
class CodeTracer;
class CompilationCache;
-class ConsStringIteratorOp;
+class CompilationStatistics;
class ContextSlotCache;
class Counters;
class CpuFeatures;
#define FOR_EACH_ISOLATE_ADDRESS_NAME(C) \
C(Handler, handler) \
C(CEntryFP, c_entry_fp) \
+ C(CFunction, c_function) \
C(Context, context) \
C(PendingException, pending_exception) \
C(ExternalCaughtException, external_caught_exception) \
class ThreadId {
public:
// Creates an invalid ThreadId.
- ThreadId() : id_(kInvalidId) {}
+ ThreadId() { base::NoBarrier_Store(&id_, kInvalidId); }
+
+ ThreadId& operator=(const ThreadId& other) {
+ base::NoBarrier_Store(&id_, base::NoBarrier_Load(&other.id_));
+ return *this;
+ }
// Returns ThreadId for current thread.
static ThreadId Current() { return ThreadId(GetCurrentThreadId()); }
// Compares ThreadIds for equality.
INLINE(bool Equals(const ThreadId& other) const) {
- return id_ == other.id_;
+ return base::NoBarrier_Load(&id_) == base::NoBarrier_Load(&other.id_);
}
// Checks whether this ThreadId refers to any thread.
INLINE(bool IsValid() const) {
- return id_ != kInvalidId;
+ return base::NoBarrier_Load(&id_) != kInvalidId;
}
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::GetCurrentThreadId).
- int ToInteger() const { return id_; }
+ int ToInteger() const { return static_cast<int>(base::NoBarrier_Load(&id_)); }
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::TerminateExecution).
private:
static const int kInvalidId = -1;
- explicit ThreadId(int id) : id_(id) {}
+ explicit ThreadId(int id) { base::NoBarrier_Store(&id_, id); }
static int AllocateThreadId();
static int GetCurrentThreadId();
- int id_;
+ base::Atomic32 id_;
static base::Atomic32 highest_thread_id_;
// Stack.
Address c_entry_fp_; // the frame pointer of the top c entry frame
Address handler_; // try-blocks are chained through the stack
+ Address c_function_; // C function that was called at c entry.
// Throwing an exception may cause a Promise rejection. For this purpose
// we keep track of a stack of nested promises and the corresponding
V(int, pending_microtask_count, 0) \
V(bool, autorun_microtasks, true) \
V(HStatistics*, hstatistics, NULL) \
- V(HStatistics*, tstatistics, NULL) \
+ V(CompilationStatistics*, turbo_statistics, NULL) \
V(HTracer*, htracer, NULL) \
V(CodeTracer*, code_tracer, NULL) \
V(bool, fp_stubs_generated, false) \
V(uint32_t, per_isolate_assert_data, 0xFFFFFFFFu) \
V(InterruptCallback, api_interrupt_callback, NULL) \
V(void*, api_interrupt_callback_data, NULL) \
+ V(PromiseRejectCallback, promise_reject_callback, NULL) \
ISOLATE_INIT_SIMULATOR_LIST(V)
#define THREAD_LOCAL_TOP_ACCESSOR(type, name) \
bool Init(Deserializer* des);
- bool IsInitialized() { return state_ == INITIALIZED; }
-
// True if at least one thread Enter'ed this isolate.
bool IsInUse() { return entry_stack_ != NULL; }
return thread->c_entry_fp_;
}
static Address handler(ThreadLocalTop* thread) { return thread->handler_; }
+ Address c_function() { return thread_local_top_.c_function_; }
inline Address* c_entry_fp_address() {
return &thread_local_top_.c_entry_fp_;
}
inline Address* handler_address() { return &thread_local_top_.handler_; }
+ inline Address* c_function_address() {
+ return &thread_local_top_.c_function_;
+ }
// Bottom JS entry.
Address js_entry_sp() {
void CaptureAndSetDetailedStackTrace(Handle<JSObject> error_object);
void CaptureAndSetSimpleStackTrace(Handle<JSObject> error_object,
Handle<Object> caller);
+ Handle<JSArray> GetDetailedStackTrace(Handle<JSObject> error_object);
+ Handle<JSArray> GetDetailedFromSimpleStackTrace(
+ Handle<JSObject> error_object);
// Returns if the top context may access the given global object. If
// the result is false, the pending exception is guaranteed to be
// Attempts to compute the current source location, storing the
// result in the target out parameter.
void ComputeLocation(MessageLocation* target);
+ bool ComputeLocationFromStackTrace(MessageLocation* target,
+ Handle<Object> exception);
+
+ Handle<JSMessageObject> CreateMessage(Handle<Object> exception,
+ MessageLocation* location);
// Out of resource exception helpers.
Object* StackOverflow();
return inner_pointer_to_code_cache_;
}
- ConsStringIteratorOp* write_iterator() { return write_iterator_; }
-
GlobalHandles* global_handles() { return global_handles_; }
EternalHandles* eternal_handles() { return eternal_handles_; }
return &jsregexp_canonrange_;
}
- ConsStringIteratorOp* objects_string_compare_iterator_a() {
- return &objects_string_compare_iterator_a_;
- }
-
- ConsStringIteratorOp* objects_string_compare_iterator_b() {
- return &objects_string_compare_iterator_b_;
- }
-
- StaticResource<ConsStringIteratorOp>* objects_string_iterator() {
- return &objects_string_iterator_;
- }
-
RuntimeState* runtime_state() { return &runtime_state_; }
Builtins* builtins() { return &builtins_; }
THREAD_LOCAL_TOP_ACCESSOR(LookupResult*, top_lookup_result)
- void enable_serializer() {
- // The serializer can only be enabled before the isolate init.
- DCHECK(state_ != INITIALIZED);
- serializer_enabled_ = true;
- }
-
bool serializer_enabled() const { return serializer_enabled_; }
bool IsDead() { return has_fatal_error_; }
return optimizing_compiler_thread_;
}
- int num_sweeper_threads() const {
- return num_sweeper_threads_;
- }
-
- SweeperThread** sweeper_threads() {
- return sweeper_thread_;
- }
-
int id() const { return static_cast<int>(id_); }
HStatistics* GetHStatistics();
- HStatistics* GetTStatistics();
+ CompilationStatistics* GetTurboStatistics();
HTracer* GetHTracer();
CodeTracer* GetCodeTracer();
void RemoveCallCompletedCallback(CallCompletedCallback callback);
void FireCallCompletedCallback();
+ void SetPromiseRejectCallback(PromiseRejectCallback callback);
+ void ReportPromiseReject(Handle<JSObject> promise, Handle<Object> value,
+ v8::PromiseRejectEvent event);
+
void EnqueueMicrotask(Handle<Object> microtask);
void RunMicrotasks();
BasicBlockProfiler* GetOrCreateBasicBlockProfiler();
BasicBlockProfiler* basic_block_profiler() { return basic_block_profiler_; }
- static Isolate* NewForTesting() { return new Isolate(); }
+ static Isolate* NewForTesting() { return new Isolate(false); }
+
+ std::string GetTurboCfgFileName();
private:
- Isolate();
+ explicit Isolate(bool enable_serializer);
friend struct GlobalState;
friend struct InitializeGlobalState;
- enum State {
- UNINITIALIZED, // Some components may not have been allocated.
- INITIALIZED // All components are fully initialized.
- };
-
// These fields are accessed through the API, offsets must be kept in sync
// with v8::internal::Internals (in include/v8.h) constants. This is also
// verified in Isolate::Init() using runtime checks.
void* embedder_data_[Internals::kNumIsolateDataSlots];
Heap heap_;
- State state_; // Will be padded to kApiPointerSize.
// The per-process lock should be acquired before the ThreadDataTable is
// modified.
UnicodeCache* unicode_cache_;
Zone runtime_zone_;
InnerPointerToCodeCache* inner_pointer_to_code_cache_;
- ConsStringIteratorOp* write_iterator_;
GlobalHandles* global_handles_;
EternalHandles* eternal_handles_;
ThreadManager* thread_manager_;
StringTracker* string_tracker_;
unibrow::Mapping<unibrow::Ecma262UnCanonicalize> jsregexp_uncanonicalize_;
unibrow::Mapping<unibrow::CanonicalizationRange> jsregexp_canonrange_;
- ConsStringIteratorOp objects_string_compare_iterator_a_;
- ConsStringIteratorOp objects_string_compare_iterator_b_;
- StaticResource<ConsStringIteratorOp> objects_string_iterator_;
unibrow::Mapping<unibrow::Ecma262Canonicalize>
regexp_macro_assembler_canonicalize_;
RegExpStack* regexp_stack_;
DeferredHandles* deferred_handles_head_;
OptimizingCompilerThread* optimizing_compiler_thread_;
- SweeperThread** sweeper_thread_;
- int num_sweeper_threads_;
// Counts deopt points if deopt_every_n_times is enabled.
unsigned int stress_deopt_count_;
private:
Zone* zone() { return &zone_; }
+ void CommitStateToJsonObject(Handle<JSObject> json_object, Handle<Map> map,
+ ZoneList<Handle<Object> >* properties);
+
Handle<String> source_;
int source_length_;
Handle<SeqOneByteString> seq_source_;
}
// Commit the intermediate state to the object and stop transitioning.
- JSObject::AllocateStorageForMap(json_object, map);
- int length = properties.length();
- for (int i = 0; i < length; i++) {
- Handle<Object> value = properties[i];
- FieldIndex index = FieldIndex::ForPropertyIndex(*map, i);
- json_object->FastPropertyAtPut(index, *value);
- }
+ CommitStateToJsonObject(json_object, map, &properties);
} else {
key = ParseJsonInternalizedString();
if (key.is_null() || c0_ != ':') return ReportUnexpectedCharacter();
// If we transitioned until the very end, transition the map now.
if (transitioning) {
- JSObject::AllocateStorageForMap(json_object, map);
- int length = properties.length();
- for (int i = 0; i < length; i++) {
- Handle<Object> value = properties[i];
- FieldIndex index = FieldIndex::ForPropertyIndex(*map, i);
- json_object->FastPropertyAtPut(index, *value);
- }
+ CommitStateToJsonObject(json_object, map, &properties);
}
}
AdvanceSkipWhitespace();
return scope.CloseAndEscape(json_object);
}
+
+template <bool seq_one_byte>
+void JsonParser<seq_one_byte>::CommitStateToJsonObject(
+ Handle<JSObject> json_object, Handle<Map> map,
+ ZoneList<Handle<Object> >* properties) {
+ JSObject::AllocateStorageForMap(json_object, map);
+ DCHECK(!json_object->map()->is_dictionary_map());
+
+ DisallowHeapAllocation no_gc;
+ Factory* factory = isolate()->factory();
+ // If the |json_object|'s map is exactly the same as |map| then the
+ // |properties| values correspond to the |map| and nothing more has to be
+ // done. But if the |json_object|'s map is different then we have to
+ // iterate descriptors to ensure that properties still correspond to the
+ // map.
+ bool slow_case = json_object->map() != *map;
+ DescriptorArray* descriptors = NULL;
+
+ int length = properties->length();
+ if (slow_case) {
+ descriptors = json_object->map()->instance_descriptors();
+ DCHECK(json_object->map()->NumberOfOwnDescriptors() == length);
+ }
+ for (int i = 0; i < length; i++) {
+ Handle<Object> value = (*properties)[i];
+ if (slow_case && value->IsMutableHeapNumber() &&
+ !descriptors->GetDetails(i).representation().IsDouble()) {
+ // Turn mutable heap numbers into immutable if the field representation
+ // is not double.
+ HeapNumber::cast(*value)->set_map(*factory->heap_number_map());
+ }
+ FieldIndex index = FieldIndex::ForPropertyIndex(*map, i);
+ json_object->FastPropertyAtPut(index, *value);
+ }
+}
+
+
// Parse a JSON array. Position must be right at '['.
template <bool seq_one_byte>
Handle<Object> JsonParser<seq_one_byte>::ParseJsonArray() {
function SetUpJSON() {
%CheckIsBootstrapping();
+ %AddNamedProperty($JSON, symbolToStringTag, "JSON", READ_ONLY | DONT_ENUM);
+
// Set up non-enumerable properties of the JSON object.
InstallFunctions($JSON, DONT_ENUM, $Array(
"parse", JSONParse,
#include "src/regexp-stack.h"
#include "src/runtime/runtime.h"
#include "src/string-search.h"
+#include "src/unicode-decoder.h"
#ifndef V8_INTERPRETED_REGEXP
#if V8_TARGET_ARCH_IA32
class DotPrinter: public NodeVisitor {
public:
- DotPrinter(OStream& os, bool ignore_case) // NOLINT
+ DotPrinter(std::ostream& os, bool ignore_case) // NOLINT
: os_(os),
ignore_case_(ignore_case) {}
void PrintNode(const char* label, RegExpNode* node);
FOR_EACH_NODE_TYPE(DECLARE_VISIT)
#undef DECLARE_VISIT
private:
- OStream& os_;
+ std::ostream& os_;
bool ignore_case_;
};
}
os_ << "\"];\n";
Visit(node);
- os_ << "}" << endl;
+ os_ << "}" << std::endl;
}
class TableEntryBodyPrinter {
public:
- TableEntryBodyPrinter(OStream& os, ChoiceNode* choice) // NOLINT
+ TableEntryBodyPrinter(std::ostream& os, ChoiceNode* choice) // NOLINT
: os_(os),
choice_(choice) {}
void Call(uc16 from, DispatchTable::Entry entry) {
}
private:
ChoiceNode* choice() { return choice_; }
- OStream& os_;
+ std::ostream& os_;
ChoiceNode* choice_;
};
class TableEntryHeaderPrinter {
public:
- explicit TableEntryHeaderPrinter(OStream& os) // NOLINT
+ explicit TableEntryHeaderPrinter(std::ostream& os) // NOLINT
: first_(true),
os_(os) {}
void Call(uc16 from, DispatchTable::Entry entry) {
private:
bool first_;
- OStream& os_;
+ std::ostream& os_;
};
class AttributePrinter {
public:
- explicit AttributePrinter(OStream& os) // NOLINT
+ explicit AttributePrinter(std::ostream& os) // NOLINT
: os_(os),
first_(true) {}
void PrintSeparator() {
}
private:
- OStream& os_;
+ std::ostream& os_;
bool first_;
};
class DispatchTableDumper {
public:
- explicit DispatchTableDumper(OStream& os) : os_(os) {}
+ explicit DispatchTableDumper(std::ostream& os) : os_(os) {}
void Call(uc16 key, DispatchTable::Entry entry);
private:
- OStream& os_;
+ std::ostream& os_;
};
#include "src/base/logging.h"
#include "src/base/platform/platform.h"
+#include "src/base/platform/time.h"
#include "src/base/sys-info.h"
#include "src/libplatform/worker-thread.h"
main_thread_queue_[isolate].push(task);
}
+
+double DefaultPlatform::MonotonicallyIncreasingTime() {
+ return base::TimeTicks::HighResolutionNow().ToInternalValue() /
+ static_cast<double>(base::Time::kMicrosecondsPerSecond);
+}
} } // namespace v8::platform
Task* task, ExpectedRuntime expected_runtime) OVERRIDE;
virtual void CallOnForegroundThread(v8::Isolate* isolate,
Task* task) OVERRIDE;
+ virtual double MonotonicallyIncreasingTime() OVERRIDE;
private:
static const int kMaxThreadPoolSize;
+++ /dev/null
-# 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.
-
-{
- 'variables': {
- 'v8_code': 1,
- },
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
- 'targets': [
- {
- 'target_name': 'libplatform-unittests',
- 'type': 'executable',
- 'dependencies': [
- '../../testing/gtest.gyp:gtest',
- '../../testing/gmock.gyp:gmock',
- '../../testing/gmock.gyp:gmock_main',
- '../../tools/gyp/v8.gyp:v8_libplatform',
- ],
- 'include_dirs': [
- '../..',
- ],
- 'sources': [ ### gcmole(all) ###
- 'default-platform-unittest.cc',
- 'task-queue-unittest.cc',
- 'worker-thread-unittest.cc',
- ],
- 'conditions': [
- ['os_posix == 1', {
- # TODO(svenpanne): This is a temporary work-around to fix the warnings
- # that show up because we use -std=gnu++0x instead of -std=c++11.
- 'cflags!': [
- '-pedantic',
- ],
- }],
- ],
- },
- ],
-}
#include "src/list.h"
+#include "src/base/macros.h"
#include "src/base/platform/platform.h"
namespace v8 {
void List<T, P>::AddAll(const Vector<T>& other, P alloc) {
int result_length = length_ + other.length();
if (capacity_ < result_length) Resize(result_length, alloc);
- for (int i = 0; i < other.length(); i++) {
- data_[length_ + i] = other.at(i);
+ if (base::is_fundamental<T>()) {
+ memcpy(data_ + length_, other.start(), sizeof(*data_) * other.length());
+ } else {
+ for (int i = 0; i < other.length(); i++) data_[length_ + i] = other.at(i);
}
length_ = result_length;
}
Vector<T> ToVector() const { return Vector<T>(data_, length_); }
- Vector<const T> ToConstVector() { return Vector<const T>(data_, length_); }
+ Vector<const T> ToConstVector() const {
+ return Vector<const T>(data_, length_);
+ }
// Adds a copy of the given 'element' to the end of the list,
// expanding the list if necessary.
// 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/lithium-codegen.h"
+#include <sstream>
+
+#include "src/v8.h"
+
#if V8_TARGET_ARCH_IA32
#include "src/ia32/lithium-ia32.h" // NOLINT
#include "src/ia32/lithium-codegen-ia32.h" // NOLINT
void LCodeGenBase::DeoptComment(const Deoptimizer::Reason& reason) {
- OStringStream os;
+ std::ostringstream os;
os << ";;; deoptimize at " << HSourcePosition(reason.raw_position) << " "
<< reason.mnemonic;
if (reason.detail != NULL) os << ": " << reason.detail;
- Comment("%s", os.c_str());
+ Comment("%s", os.str().c_str());
}
LOG_CODE_EVENT(info()->isolate(),
CodeStartLinePosInfoRecordEvent(
assembler.positions_recorder()));
- // TODO(yangguo) remove this once the code serializer handles code stubs.
- if (info()->will_serialize()) assembler.enable_serializer();
+ // Code serializer only takes unoptimized code.
+ DCHECK(!info()->will_serialize());
LCodeGen generator(this, &assembler, info());
MarkEmptyBlocks();
}
-void FunctionInfoWrapper::SetInitialProperties(Handle<String> name,
- int start_position,
- int end_position,
- int param_num,
- int literal_count,
- int slot_count,
- int parent_index) {
+void FunctionInfoWrapper::SetInitialProperties(
+ Handle<String> name, int start_position, int end_position, int param_num,
+ int literal_count, int slot_count, int ic_slot_count, int parent_index) {
HandleScope scope(isolate());
this->SetField(kFunctionNameOffset_, name);
this->SetSmiValueField(kStartPositionOffset_, start_position);
this->SetSmiValueField(kParamNumOffset_, param_num);
this->SetSmiValueField(kLiteralNumOffset_, literal_count);
this->SetSmiValueField(kSlotNumOffset_, slot_count);
+ this->SetSmiValueField(kICSlotNumOffset_, ic_slot_count);
this->SetSmiValueField(kParentIndexOffset_, parent_index);
}
Handle<SharedFunctionInfo> shared =
Handle<SharedFunctionInfo>::cast(raw_result);
result = Handle<TypeFeedbackVector>(shared->feedback_vector(), isolate());
- CHECK_EQ(result->length(), GetSlotCount());
+ CHECK_EQ(result->Slots(), GetSlotCount());
+ CHECK_EQ(result->ICSlots(), GetICSlotCount());
} else {
// Scripts may never have a SharedFunctionInfo created, so
// create a type feedback vector here.
int slot_count = GetSlotCount();
- result = isolate()->factory()->NewTypeFeedbackVector(slot_count);
+ int ic_slot_count = GetICSlotCount();
+ result =
+ isolate()->factory()->NewTypeFeedbackVector(slot_count, ic_slot_count);
}
return result;
}
void FunctionStarted(FunctionLiteral* fun) {
HandleScope scope(isolate());
FunctionInfoWrapper info = FunctionInfoWrapper::Create(isolate());
- info.SetInitialProperties(fun->name(), fun->start_position(),
- fun->end_position(), fun->parameter_count(),
- fun->materialized_literal_count(),
- fun->slot_count(),
- current_parent_index_);
+ info.SetInitialProperties(
+ fun->name(), fun->start_position(), fun->end_position(),
+ fun->parameter_count(), fun->materialized_literal_count(),
+ fun->slot_count(), fun->ic_slot_count(), current_parent_index_);
current_parent_index_ = len_;
SetElementSloppy(result_, len_, info.GetJSArray());
len_++;
: JSArrayBasedStruct<FunctionInfoWrapper>(array) {
}
- void SetInitialProperties(Handle<String> name,
- int start_position,
- int end_position,
- int param_num,
- int literal_count,
- int slot_count,
+ void SetInitialProperties(Handle<String> name, int start_position,
+ int end_position, int param_num, int literal_count,
+ int slot_count, int ic_slot_count,
int parent_index);
void SetFunctionCode(Handle<Code> function_code,
return this->GetSmiValueField(kSlotNumOffset_);
}
+ int GetICSlotCount() { return this->GetSmiValueField(kICSlotNumOffset_); }
+
private:
static const int kFunctionNameOffset_ = 0;
static const int kStartPositionOffset_ = 1;
static const int kSharedFunctionInfoOffset_ = 8;
static const int kLiteralNumOffset_ = 9;
static const int kSlotNumOffset_ = 10;
- static const int kSize_ = 11;
+ static const int kICSlotNumOffset_ = 11;
+ static const int kSize_ = 12;
friend class JSArrayBasedStruct<FunctionInfoWrapper>;
};
#define V8_LOG_INL_H_
#include "src/log.h"
+#include "src/isolate.h"
namespace v8 {
namespace internal {
}
+void Logger::CallEventLogger(Isolate* isolate, const char* name, StartEnd se,
+ bool expose_to_api) {
+ if (isolate->event_logger() != NULL) {
+ if (isolate->event_logger() == DefaultEventLoggerSentinel) {
+ LOG(isolate, TimerEvent(se, name));
+ } else if (expose_to_api) {
+ isolate->event_logger()(name, se);
+ }
+ }
+}
} } // namespace v8::internal
#endif // V8_LOG_INL_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <stdarg.h>
+#include "src/log.h"
+
+#include <cstdarg>
+#include <sstream>
#include "src/v8.h"
#include "src/cpu-profiler.h"
#include "src/deoptimizer.h"
#include "src/global-handles.h"
-#include "src/log.h"
+#include "src/log-inl.h"
#include "src/log-utils.h"
#include "src/macro-assembler.h"
#include "src/perf-jit.h"
if (paused_)
return;
- if (Succ(head_) == tail_) {
+ if (Succ(head_) == static_cast<int>(base::NoBarrier_Load(&tail_))) {
overflow_ = true;
} else {
buffer_[head_] = *sample;
// Waits for a signal and removes profiling data.
bool Remove(TickSample* sample) {
buffer_semaphore_.Wait(); // Wait for an element.
- *sample = buffer_[tail_];
+ *sample = buffer_[base::NoBarrier_Load(&tail_)];
bool result = overflow_;
- tail_ = Succ(tail_);
+ base::NoBarrier_Store(&tail_, static_cast<base::Atomic32>(
+ Succ(base::NoBarrier_Load(&tail_))));
overflow_ = false;
return result;
}
static const int kBufferSize = 128;
TickSample buffer_[kBufferSize]; // Buffer storage.
int head_; // Index to the buffer head.
- int tail_; // Index to the buffer tail.
+ base::Atomic32 tail_; // Index to the buffer tail.
bool overflow_; // Tell whether a buffer overflow has occurred.
// Sempahore used for buffer synchronization.
base::Semaphore buffer_semaphore_;
bool engaged_;
// Tells whether worker thread should continue running.
- bool running_;
+ base::Atomic32 running_;
// Tells whether we are currently recording tick samples.
bool paused_;
: base::Thread(Options("v8:Profiler")),
isolate_(isolate),
head_(0),
- tail_(0),
overflow_(false),
buffer_semaphore_(0),
engaged_(false),
- running_(false),
- paused_(false) {}
+ paused_(false) {
+ base::NoBarrier_Store(&tail_, 0);
+ base::NoBarrier_Store(&running_, 0);
+}
void Profiler::Engage() {
}
// Start thread processing the profiler buffer.
- running_ = true;
+ base::NoBarrier_Store(&running_, 1);
Start();
// Register to get ticks.
// Terminate the worker thread by setting running_ to false,
// inserting a fake element in the queue and then wait for
// the thread to terminate.
- running_ = false;
+ base::NoBarrier_Store(&running_, 0);
TickSample sample;
// Reset 'paused_' flag, otherwise semaphore may not be signalled.
resume();
void Profiler::Run() {
TickSample sample;
bool overflow = Remove(&sample);
- while (running_) {
+ while (base::NoBarrier_Load(&running_)) {
LOG(isolate_, TickEvent(&sample, overflow));
overflow = Remove(&sample);
}
}
-void Logger::DefaultTimerEventsLogger(const char* name, int se) {
- Isolate* isolate = Isolate::Current();
- LOG(isolate, TimerEvent(static_cast<StartEnd>(se), name));
-}
-
-
template <class TimerEvent>
void TimerEventScope<TimerEvent>::LogTimerEvent(Logger::StartEnd se) {
- if (TimerEvent::expose_to_api() ||
- isolate_->event_logger() == Logger::DefaultTimerEventsLogger) {
- isolate_->event_logger()(TimerEvent::name(), se);
- }
+ Logger::CallEventLogger(isolate_, TimerEvent::name(), se,
+ TimerEvent::expose_to_api());
}
}
-static void AddIsolateIdIfNeeded(OStream& os, // NOLINT
+static void AddIsolateIdIfNeeded(std::ostream& os, // NOLINT
Isolate* isolate) {
if (FLAG_logfile_per_isolate) os << "isolate-" << isolate << "-";
}
-static void PrepareLogFileName(OStream& os, // NOLINT
+static void PrepareLogFileName(std::ostream& os, // NOLINT
Isolate* isolate, const char* file_name) {
AddIsolateIdIfNeeded(os, isolate);
for (const char* p = file_name; *p; p++) {
FLAG_log_snapshot_positions = true;
}
- OStringStream log_file_name;
+ std::ostringstream log_file_name;
PrepareLogFileName(log_file_name, isolate, FLAG_logfile);
- log_->Initialize(log_file_name.c_str());
+ log_->Initialize(log_file_name.str().c_str());
if (FLAG_perf_basic_prof) {
}
if (FLAG_ll_prof) {
- ll_logger_ = new LowLevelLogger(log_file_name.c_str());
+ ll_logger_ = new LowLevelLogger(log_file_name.str().c_str());
addCodeEventListener(ll_logger_);
}
is_logging_ = true;
}
+ if (FLAG_log_internal_timer_events || FLAG_prof) timer_.Start();
+
if (FLAG_prof) {
profiler_ = new Profiler(isolate);
is_logging_ = true;
profiler_->Engage();
}
- if (FLAG_log_internal_timer_events || FLAG_prof) timer_.Start();
-
return true;
}
static void EnterExternal(Isolate* isolate);
static void LeaveExternal(Isolate* isolate);
- static void EmptyTimerEventsLogger(const char* name, int se) {}
- static void DefaultTimerEventsLogger(const char* name, int se);
+ static void DefaultEventLoggerSentinel(const char* name, int event) {}
+
+ INLINE(static void CallEventLogger(Isolate* isolate, const char* name,
+ StartEnd se, bool expose_to_api));
// ==== Events logged by --log-regexp ====
// Regexp compilation and execution events.
}
+bool LookupIterator::IsSpecialNumericIndex() const {
+ if (GetStoreTarget()->IsJSTypedArray() && name()->IsString()) {
+ Handle<String> name_string = Handle<String>::cast(name());
+ if (name_string->length() > 0) {
+ double d =
+ StringToDouble(isolate()->unicode_cache(), name_string, NO_FLAGS);
+ if (!std::isnan(d)) {
+ if (String::Equals(isolate()->factory()->minus_zero_string(),
+ name_string))
+ return true;
+
+ Factory* factory = isolate()->factory();
+ Handle<Object> num = factory->NewNumber(d);
+ Handle<String> roundtrip_string = factory->NumberToString(num);
+ if (String::Equals(name_string, roundtrip_string)) return true;
+ }
+ }
+ }
+ return false;
+}
+
+
void LookupIterator::InternalizeName() {
if (name_->IsUniqueName()) return;
name_ = factory()->InternalizeString(Handle<String>::cast(name_));
Handle<Object> GetDataValue() const;
void WriteDataValue(Handle<Object> value);
+ // Checks whether the receiver is an indexed exotic object
+ // and name is a special numeric index.
+ bool IsSpecialNumericIndex() const;
+
void InternalizeName();
private:
bool old_has_frame_;
};
+class FrameAndConstantPoolScope {
+ public:
+ FrameAndConstantPoolScope(MacroAssembler* masm, StackFrame::Type type)
+ : masm_(masm),
+ type_(type),
+ old_has_frame_(masm->has_frame()),
+ old_constant_pool_available_(FLAG_enable_ool_constant_pool &&
+ masm->is_ool_constant_pool_available()) {
+ masm->set_has_frame(true);
+ if (FLAG_enable_ool_constant_pool) {
+ masm->set_ool_constant_pool_available(true);
+ }
+ if (type_ != StackFrame::MANUAL && type_ != StackFrame::NONE) {
+ masm->EnterFrame(type, !old_constant_pool_available_);
+ }
+ }
+
+ ~FrameAndConstantPoolScope() {
+ masm_->LeaveFrame(type_);
+ masm_->set_has_frame(old_has_frame_);
+ if (FLAG_enable_ool_constant_pool) {
+ masm_->set_ool_constant_pool_available(old_constant_pool_available_);
+ }
+ }
+
+ // Normally we generate the leave-frame code when this object goes
+ // out of scope. Sometimes we may need to generate the code somewhere else
+ // in addition. Calling this will achieve that, but the object stays in
+ // scope, the MacroAssembler is still marked as being in a frame scope, and
+ // the code will be generated again when it goes out of scope.
+ void GenerateLeaveFrame() {
+ DCHECK(type_ != StackFrame::MANUAL && type_ != StackFrame::NONE);
+ masm_->LeaveFrame(type_);
+ }
+
+ private:
+ MacroAssembler* masm_;
+ StackFrame::Type type_;
+ bool old_has_frame_;
+ bool old_constant_pool_available_;
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(FrameAndConstantPoolScope);
+};
+
+// Class for scoping the the unavailability of constant pool access.
+class ConstantPoolUnavailableScope {
+ public:
+ explicit ConstantPoolUnavailableScope(MacroAssembler* masm)
+ : masm_(masm),
+ old_constant_pool_available_(FLAG_enable_ool_constant_pool &&
+ masm->is_ool_constant_pool_available()) {
+ if (FLAG_enable_ool_constant_pool) {
+ masm_->set_ool_constant_pool_available(false);
+ }
+ }
+ ~ConstantPoolUnavailableScope() {
+ if (FLAG_enable_ool_constant_pool) {
+ masm_->set_ool_constant_pool_available(old_constant_pool_available_);
+ }
+ }
+
+ private:
+ MacroAssembler* masm_;
+ int old_constant_pool_available_;
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ConstantPoolUnavailableScope);
+};
+
class AllowExternalCallThatCantCauseGC: public FrameScope {
public:
macro TO_OBJECT_INLINE(arg) = (IS_SPEC_OBJECT(%IS_VAR(arg)) ? arg : ToObject(arg));
macro JSON_NUMBER_TO_STRING(arg) = ((%_IsSmi(%IS_VAR(arg)) || arg - arg == 0) ? %_NumberToString(arg) : "null");
macro HAS_OWN_PROPERTY(obj, index) = (%_CallFunction(obj, index, ObjectHasOwnProperty));
+macro SHOULD_CREATE_WRAPPER(functionName, receiver) = (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(functionName));
# Private names.
# GET_PRIVATE should only be used if the property is known to exists on obj
macro OVERRIDE_CAPTURE(override, index) = ((override)[(index)]);
# PropertyDescriptor return value indices - must match
-# PropertyDescriptorIndices in runtime.cc.
+# PropertyDescriptorIndices in runtime-object.cc.
const IS_ACCESSOR_INDEX = 0;
const VALUE_INDEX = 1;
const GETTER_INDEX = 2;
// ECMA 262 - 15.8.2.14
var rngstate; // Initialized to a Uint32Array during genesis.
function MathRandom() {
- var r0 = (MathImul(18273, rngstate[0] & 0xFFFF) + (rngstate[0] >>> 16)) | 0;
+ var r0 = (MathImul(18030, rngstate[0] & 0xFFFF) + (rngstate[0] >>> 16)) | 0;
rngstate[0] = r0;
var r1 = (MathImul(36969, rngstate[1] & 0xFFFF) + (rngstate[1] >>> 16)) | 0;
rngstate[1] = r1;
%AddNamedProperty(global, "Math", $Math, DONT_ENUM);
%FunctionSetInstanceClassName(MathConstructor, 'Math');
+ %AddNamedProperty($Math, symbolToStringTag, "Math", READ_ONLY | DONT_ENUM);
+
// Set up math constants.
InstallConstants($Math, $Array(
// ECMA-262, section 15.8.1.1.
unexpected_strict_reserved: ["Unexpected strict mode reserved word"],
unexpected_eos: ["Unexpected end of input"],
malformed_regexp: ["Invalid regular expression: /", "%0", "/: ", "%1"],
+ malformed_regexp_flags: ["Invalid regular expression flags"],
unterminated_regexp: ["Invalid regular expression: missing /"],
regexp_flags: ["Cannot supply flags when constructing one RegExp from another"],
incompatible_method_receiver: ["Method ", "%0", " called on incompatible receiver ", "%1"],
invalid_module_path: ["Module does not export '", "%0", "', or export is not itself a module"],
module_type_error: ["Module '", "%0", "' used improperly"],
module_export_undefined: ["Export '", "%0", "' is not defined in module"],
- unexpected_super: ["'super' keyword unexpected here"]
+ unexpected_super: ["'super' keyword unexpected here"],
+ extends_value_not_a_function: ["Class extends value ", "%0", " is not a function or null"],
+ prototype_parent_not_an_object: ["Class extends value does not have valid prototype property ", "%0"],
+ duplicate_constructor: ["A class may only have one constructor"]
};
return str;
}
if (IS_SYMBOL(obj)) return %_CallFunction(obj, SymbolToString);
- if (IS_OBJECT(obj) && %GetDataProperty(obj, "toString") === ObjectToString) {
+ if (IS_OBJECT(obj)
+ && %GetDataProperty(obj, "toString") === DefaultObjectToString) {
var constructor = %GetDataProperty(obj, "constructor");
if (typeof constructor == "function") {
var constructorName = constructor.name;
if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
return %_CallFunction(obj, ErrorToString);
}
- return %_CallFunction(obj, ObjectToString);
+
+ return %_CallFunction(obj, NoSideEffectsObjectToString);
}
// To determine whether we can safely stringify an object using ErrorToString
function ToDetailString(obj) {
- if (obj != null && IS_OBJECT(obj) && obj.toString === ObjectToString) {
+ if (obj != null && IS_OBJECT(obj) && obj.toString === DefaultObjectToString) {
var constructor = obj.constructor;
if (typeof constructor == "function") {
var constructorName = constructor.name;
return MakeGenericError($Error, type, args);
}
+
+// The embedded versions are called from unoptimized code, with embedded
+// arguments. Those arguments cannot be arrays, which are context-dependent.
+function MakeTypeErrorEmbedded(type, arg) {
+ return MakeGenericError($TypeError, type, [arg]);
+}
+
+
+function MakeSyntaxErrorEmbedded(type, arg) {
+ return MakeGenericError($SyntaxError, type, [arg]);
+}
+
+
+function MakeReferenceErrorEmbedded(type, arg) {
+ return MakeGenericError($ReferenceError, type, [arg]);
+}
+
/**
* Find a line number given a specific source position.
* @param {number} position The source position.
var constructor = receiver.constructor;
if (!constructor) {
return requireConstructor ? null :
- %_CallFunction(receiver, ObjectToString);
+ %_CallFunction(receiver, NoSideEffectsObjectToString);
}
var constructorName = constructor.name;
if (!constructorName) {
return requireConstructor ? null :
- %_CallFunction(receiver, ObjectToString);
+ %_CallFunction(receiver, NoSideEffectsObjectToString);
}
return constructorName;
}
void Assembler::madd_d(FPURegister fd, FPURegister fr, FPURegister fs,
FPURegister ft) {
+ DCHECK(IsMipsArchVariant(kMips32r2));
GenInstrRegister(COP1X, fr, ft, fs, fd, MADD_D);
}
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is in ra.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = a3;
+ Register result = v0;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ Ret();
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
// Uses registers a0 to t0.
// Expected input (depending on whether args are in registers or on the stack):
// * object: a0 or at sp + 1 * kPointerSize.
__ Branch(&slow, ne, scratch, Operand(JS_FUNCTION_TYPE));
// Null is not instance of anything.
- __ Branch(&object_not_null,
- ne,
- scratch,
+ __ Branch(&object_not_null, ne, object,
Operand(isolate()->factory()->null_value()));
if (ReturnTrueFalseObject()) {
__ LoadRoot(v0, Heap::kFalseValueRootIndex);
// A monomorphic miss (i.e, here the cache is not uninitialized) goes
// megamorphic.
- __ LoadRoot(at, Heap::kUninitializedSymbolRootIndex);
+ __ LoadRoot(at, Heap::kuninitialized_symbolRootIndex);
__ Branch(&initialize, eq, t0, Operand(at));
// MegamorphicSentinel is an immortal immovable object (undefined) so no
// write-barrier is needed.
__ bind(&megamorphic);
__ sll(t0, a3, kPointerSizeLog2 - kSmiTagSize);
__ Addu(t0, a2, Operand(t0));
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ sw(at, FieldMemOperand(t0, FixedArray::kHeaderSize));
__ jmp(&done);
__ bind(&extra_checks_or_miss);
Label miss;
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ Branch(&slow_start, eq, t0, Operand(at));
- __ LoadRoot(at, Heap::kUninitializedSymbolRootIndex);
+ __ LoadRoot(at, Heap::kuninitialized_symbolRootIndex);
__ Branch(&miss, eq, t0, Operand(at));
if (!FLAG_trace_ic) {
__ Branch(&miss, ne, t1, Operand(JS_FUNCTION_TYPE));
__ sll(t0, a3, kPointerSizeLog2 - kSmiTagSize);
__ Addu(t0, a2, Operand(t0));
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ sw(at, FieldMemOperand(t0, FixedArray::kHeaderSize));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ lw(t0, FieldMemOperand(a2, with_types_offset));
+ __ Subu(t0, t0, Operand(Smi::FromInt(1)));
+ __ sw(t0, FieldMemOperand(a2, with_types_offset));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ lw(t0, FieldMemOperand(a2, generic_offset));
+ __ Addu(t0, t0, Operand(Smi::FromInt(1)));
+ __ sw(t0, FieldMemOperand(a2, generic_offset));
__ Branch(&slow_start);
}
DCHECK(!t0.is(index_));
DCHECK(!t0.is(result_));
DCHECK(!t0.is(object_));
-
- // If the receiver is a smi trigger the non-string case.
- __ JumpIfSmi(object_, receiver_not_string_);
-
- // Fetch the instance type of the receiver into result register.
- __ lw(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
- __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ And(t0, result_, Operand(kIsNotStringMask));
- __ Branch(receiver_not_string_, ne, t0, Operand(zero_reg));
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ // If the receiver is a smi trigger the non-string case.
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ lw(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ And(t0, result_, Operand(kIsNotStringMask));
+ __ Branch(receiver_not_string_, ne, t0, Operand(zero_reg));
+ }
// If the index is non-smi trigger the non-smi case.
__ JumpIfNotSmi(index_, &index_not_smi_);
// a2: length
// a3: from index (untagged)
__ SmiTag(a3, a3);
- StringCharAtGenerator generator(
- v0, a3, a2, v0, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(v0, a3, a2, v0, &runtime, &runtime, &runtime,
+ STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ DropAndRet(3);
generator.SkipSlow(masm, &runtime);
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in a0.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(a0, &check_heap_number);
+ __ Ret(USE_DELAY_SLOT);
+ __ mov(v0, a0);
+
+ __ bind(&check_heap_number);
+ __ lw(a1, FieldMemOperand(a0, HeapObject::kMapOffset));
+ __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
+ __ Branch(&call_builtin, ne, a1, Operand(at));
+ __ Ret(USE_DELAY_SLOT);
+ __ mov(v0, a0);
+
+ __ bind(&call_builtin);
+ __ push(a0);
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(
MacroAssembler* masm, Register left, Register right, Register scratch1,
Register scratch2, Register scratch3) {
FixedDoubleArray::kHeaderSize - kHeapObjectTag
+ Register::kExponentOffset));
__ Addu(dst_elements, array, Operand(FixedArray::kHeaderSize));
- __ Addu(array, array, Operand(kHeapObjectTag));
__ sll(dst_end, dst_end, 1);
__ Addu(dst_end, dst_elements, dst_end);
+
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
+ __ Branch(&initialization_loop_entry);
+ __ bind(&initialization_loop);
+ __ sw(scratch, MemOperand(dst_elements));
+ __ Addu(dst_elements, dst_elements, Operand(kPointerSize));
+ __ bind(&initialization_loop_entry);
+ __ Branch(&initialization_loop, lt, dst_elements, Operand(dst_end));
+
+ __ Addu(dst_elements, array, Operand(FixedArray::kHeaderSize));
+ __ Addu(array, array, Operand(kHeapObjectTag));
__ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
// Using offsetted addresses.
// dst_elements: begin of destination FixedArray element fields, not tagged
(kArchVariant == check)
#else
#define IsMipsArchVariant(check) \
- (CpuFeatures::IsSupported(check))
+ (CpuFeatures::IsSupported(static_cast<CpuFeature>(check)))
#endif
void DebugCodegen::GenerateLoadICDebugBreak(MacroAssembler* masm) {
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0);
}
}
break;
case S:
- UNIMPLEMENTED_MIPS();
+ switch (instr->FunctionFieldRaw()) {
+ case CVT_D_S:
+ Format(instr, "cvt.d.s 'fd, 'fs");
+ break;
+ default:
+ UNIMPLEMENTED_MIPS();
+ }
break;
case W:
switch (instr->FunctionFieldRaw()) {
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
Label loop, exit;
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ mov(a0, v0);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ push(a0);
// Check for proxies.
__ bind(&call_runtime);
__ push(a0); // Duplicate the enumerable object on the stack.
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
// If we got a map from the runtime call, we can do a fast
// modification check. Otherwise, we got a fixed array, and we have
__ li(a1, FeedbackVector());
__ li(a2, Operand(TypeFeedbackVector::MegamorphicSentinel(isolate())));
- __ sw(a2, FieldMemOperand(a1, FixedArray::OffsetOfElementAt(slot)));
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ sw(a2, FieldMemOperand(a1, FixedArray::OffsetOfElementAt(vector_index)));
__ li(a1, Operand(Smi::FromInt(1))); // Smi indicates slow check
__ lw(a2, MemOperand(sp, 0 * kPointerSize)); // Get enumerated object
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ li(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ li(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
Label done;
__ Branch(&done, ne, v0, Operand(isolate()->factory()->undefined_value()));
__ li(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ li(LoadDescriptor::NameRegister(), Operand(var->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(v0);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in v0.
DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ push(a0);
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
__ Push(scratch, result_register());
}
break;
+ case KEYED_SUPER_PROPERTY: {
+ const Register scratch = a1;
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(scratch, result_register());
+ if (expr->is_compound()) {
+ const Register scratch1 = t0;
+ __ lw(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ }
+ break;
+ }
case KEYED_PROPERTY:
// We need the key and receiver on both the stack and in v0 and a1.
if (expr->is_compound()) {
EmitNamedSuperPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(v0);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(v0);
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ lw(load_name, MemOperand(sp, 2 * kPointerSize));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
+ Operand(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
__ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->DoneFeedbackSlot())));
+ Operand(SmiFromSlot(expr->DoneFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // v0=result.done
__ mov(a0, v0);
__ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->ValueFeedbackSlot())));
+ Operand(SmiFromSlot(expr->ValueFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // v0=result.value
context()->DropAndPlug(2, v0); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), v0, a2, a3, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, v0, a2, a3, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ lw(context_register(),
MemOperand(fp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ li(a1, Operand(map));
+ __ lw(a1, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ lw(a1, FieldMemOperand(a1, GlobalObject::kNativeContextOffset));
+ __ lw(a1, ContextOperand(a1, Context::ITERATOR_RESULT_MAP_INDEX));
__ pop(a2);
__ li(a3, Operand(isolate()->factory()->ToBoolean(done)));
__ li(t0, Operand(isolate()->factory()->empty_fixed_array()));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ sw(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
__ sw(t0, FieldMemOperand(v0, JSObject::kPropertiesOffset));
__ sw(t0, FieldMemOperand(v0, JSObject::kElementsOffset));
__ li(LoadDescriptor::NameRegister(), Operand(key->value()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in v0.
+ DCHECK(lit != NULL);
+ __ push(v0);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = a1;
+ __ lw(scratch,
+ FieldMemOperand(v0, JSFunction::kPrototypeOrInitialMapOffset));
+ __ push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ lw(scratch, MemOperand(sp, kPointerSize)); // constructor
+ } else {
+ __ lw(scratch, MemOperand(sp, 0)); // prototype
+ }
+ __ push(scratch);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(v0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; v0: home_object
+ Register scratch = a2;
+ Register scratch2 = a3;
+ __ mov(scratch, result_register()); // home_object
+ __ lw(v0, MemOperand(sp, kPointerSize)); // value
+ __ lw(scratch2, MemOperand(sp, 0)); // this
+ __ sw(scratch2, MemOperand(sp, kPointerSize)); // this
+ __ sw(scratch, MemOperand(sp, 0)); // home_object
+ // stack: this, home_object; v0: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(v0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = a2;
+ Register scratch2 = a3;
+ __ lw(scratch2, MemOperand(sp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; v0: key, a3: value
+ __ lw(scratch, MemOperand(sp, kPointerSize)); // this
+ __ sw(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ lw(scratch, MemOperand(sp, 0)); // home_object
+ __ sw(scratch, MemOperand(sp, kPointerSize));
+ __ sw(v0, MemOperand(sp, 0));
+ __ Move(v0, scratch2);
+ // stack: this, home_object, key; v0: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ push(result_register()); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// v0 : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ Push(v0);
__ Push(key->value());
+ __ Push(v0);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(v0);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // v0 : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(v0);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(v0);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ Move(LoadDescriptor::NameRegister(), v0);
- __ pop(LoadDescriptor::ReceiverRegister());
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), v0);
+ __ pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(v0);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ const Register scratch = a1;
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Move(scratch, v0);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(scratch, v0, v0, scratch);
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ sw(v0, MemOperand(sp, kPointerSize));
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ li(a3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ li(a3, Operand(SmiFromSlot(expr->CallFeedbackSlot())));
__ lw(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
- // t2: copy of the first argument or undefined if it doesn't exist.
+ // t3: copy of the first argument or undefined if it doesn't exist.
if (arg_count > 0) {
- __ lw(t2, MemOperand(sp, arg_count * kPointerSize));
+ __ lw(t3, MemOperand(sp, arg_count * kPointerSize));
} else {
- __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
+ __ LoadRoot(t3, Heap::kUndefinedValueRootIndex);
}
+ // t2: the receiver of the enclosing function.
+ __ lw(t2, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+
// t1: the receiver of the enclosing function.
int receiver_offset = 2 + info_->scope()->num_parameters();
__ lw(t1, MemOperand(fp, receiver_offset * kPointerSize));
__ li(a1, Operand(Smi::FromInt(scope()->start_position())));
// Do the runtime call.
+ __ Push(t3);
__ Push(t2, t1, t0, a1);
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ lw(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ Push(a0);
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// v1 (receiver). Touch up the stack with the right values.
__ sw(v0, MemOperand(sp, (arg_count + 1) * kPointerSize));
__ sw(v1, MemOperand(sp, arg_count * kPointerSize));
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
SetSourcePosition(expr->position());
__ Push(context_register(), a2);
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ Push(v0, v1); // Function, receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the
// function and receiver and have the slow path jump around this
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ li(a2, FeedbackVector());
- __ li(a3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ li(a3, Operand(SmiFromSlot(expr->CallNewFeedbackSlot())));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(v0, if_false);
+ Register map = a1;
+ Register type_reg = a2;
+ __ GetObjectType(v0, map, type_reg);
+ __ Subu(type_reg, type_reg, Operand(FIRST_JS_PROXY_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ls, type_reg, Operand(LAST_JS_PROXY_TYPE - FIRST_JS_PROXY_TYPE),
+ if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ li(LoadDescriptor::NameRegister(), Operand(expr->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
+ Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
__ li(at, Operand(Smi::FromInt(0)));
__ push(at);
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ lw(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ lw(LoadDescriptor::ReceiverRegister(),
- MemOperand(sp, 1 * kPointerSize));
- __ lw(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ lw(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ const Register scratch = a1;
+ __ lw(scratch, MemOperand(sp, kPointerSize));
+ __ Push(scratch, result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ const Register scratch = a1;
+ const Register scratch1 = t0;
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(scratch, result_register());
+ __ lw(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ lw(LoadDescriptor::ReceiverRegister(),
+ MemOperand(sp, 1 * kPointerSize));
+ __ lw(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ sw(v0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ sw(v0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ sw(v0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ sw(v0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
case NAMED_PROPERTY:
__ sw(v0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ sw(v0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ sw(v0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ sw(v0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(v0);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(v0);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ mov(StoreDescriptor::ValueRegister(), result_register());
__ Pop(StoreDescriptor::ReceiverRegister(),
__ li(LoadDescriptor::NameRegister(), Operand(proxy->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return a0; }
+const Register StoreTransitionDescriptor::MapRegister() { return a3; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() { return a3; }
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // cp -- context
+ Register registers[] = {cp};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ li(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ li(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(a0));
- __ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(instr->hydrogen()->slot())));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
+ __ li(VectorLoadICDescriptor::SlotRegister(), Operand(Smi::FromInt(index)));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#if V8_TARGET_ARCH_MIPS
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift
// by 0 and the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
return DefineAsRegister(mul);
} else if (instr->representation().IsDouble()) {
- if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+ if (IsMipsArchVariant(kMips32r2)) {
if (instr->HasOneUse() && instr->uses().value()->IsAdd()) {
HAdd* add = HAdd::cast(instr->uses().value());
if (instr == add->left()) {
LInstruction* result = DefineAsRegister(add);
return result;
} else if (instr->representation().IsDouble()) {
- if (IsMipsArchVariant(kMips32r2) || IsMipsArchVariant(kMips32r6)) {
+ if (IsMipsArchVariant(kMips32r2)) {
if (instr->left()->IsMul())
return DoMultiplyAdd(HMul::cast(instr->left()), instr->right());
MacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size)
: Assembler(arg_isolate, buffer, size),
generating_stub_(false),
- has_frame_(false) {
+ has_frame_(false),
+ has_double_zero_reg_set_(false) {
if (isolate() != NULL) {
code_object_ = Handle<Object>(isolate()->heap()->undefined_value(),
isolate());
}
+void MacroAssembler::Mulhu(Register rd, Register rs, const Operand& rt) {
+ if (rt.is_reg()) {
+ if (!IsMipsArchVariant(kMips32r6)) {
+ multu(rs, rt.rm());
+ mfhi(rd);
+ } else {
+ muhu(rd, rs, rt.rm());
+ }
+ } else {
+ // li handles the relocation.
+ DCHECK(!rs.is(at));
+ li(at, rt);
+ if (!IsMipsArchVariant(kMips32r6)) {
+ multu(rs, at);
+ mfhi(rd);
+ } else {
+ muhu(rd, rs, at);
+ }
+ }
+}
+
+
void MacroAssembler::Multu(Register rs, const Operand& rt) {
if (rt.is_reg()) {
multu(rs, rt.rm());
static const DoubleRepresentation zero(0.0);
DoubleRepresentation value_rep(imm);
// Handle special values first.
- bool force_load = dst.is(kDoubleRegZero);
- if (value_rep == zero && !force_load) {
+ if (value_rep == zero && has_double_zero_reg_set_) {
mov_d(dst, kDoubleRegZero);
- } else if (value_rep == minus_zero && !force_load) {
+ } else if (value_rep == minus_zero && has_double_zero_reg_set_) {
neg_d(dst, kDoubleRegZero);
} else {
uint32_t lo, hi;
} else {
Mthc1(zero_reg, dst);
}
+ if (dst.is(kDoubleRegZero)) has_double_zero_reg_set_ = true;
}
}
b(offset);
break;
case eq:
- // We don't want any other register but scratch clobbered.
- DCHECK(!scratch.is(rs));
- r2 = scratch;
- li(r2, rt);
- beq(rs, r2, offset);
+ if (rt.imm32_ == 0) {
+ beq(rs, zero_reg, offset);
+ } else {
+ // We don't want any other register but scratch clobbered.
+ DCHECK(!scratch.is(rs));
+ r2 = scratch;
+ li(r2, rt);
+ beq(rs, r2, offset);
+ }
break;
case ne:
- // We don't want any other register but scratch clobbered.
- DCHECK(!scratch.is(rs));
- r2 = scratch;
- li(r2, rt);
- bne(rs, r2, offset);
+ if (rt.imm32_ == 0) {
+ bne(rs, zero_reg, offset);
+ } else {
+ // We don't want any other register but scratch clobbered.
+ DCHECK(!scratch.is(rs));
+ r2 = scratch;
+ li(r2, rt);
+ bne(rs, r2, offset);
+ }
break;
// Signed comparison.
case greater:
b(offset);
break;
case eq:
- DCHECK(!scratch.is(rs));
- r2 = scratch;
- li(r2, rt);
- offset = shifted_branch_offset(L, false);
- beq(rs, r2, offset);
+ if (rt.imm32_ == 0) {
+ offset = shifted_branch_offset(L, false);
+ beq(rs, zero_reg, offset);
+ } else {
+ DCHECK(!scratch.is(rs));
+ r2 = scratch;
+ li(r2, rt);
+ offset = shifted_branch_offset(L, false);
+ beq(rs, r2, offset);
+ }
break;
case ne:
- DCHECK(!scratch.is(rs));
- r2 = scratch;
- li(r2, rt);
- offset = shifted_branch_offset(L, false);
- bne(rs, r2, offset);
+ if (rt.imm32_ == 0) {
+ offset = shifted_branch_offset(L, false);
+ bne(rs, zero_reg, offset);
+ } else {
+ DCHECK(!scratch.is(rs));
+ r2 = scratch;
+ li(r2, rt);
+ offset = shifted_branch_offset(L, false);
+ bne(rs, r2, offset);
+ }
break;
// Signed comparison.
case greater:
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on mips.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
addiu(sp, sp, -5 * kPointerSize);
li(t8, Operand(Smi::FromInt(type)));
DEFINE_INSTRUCTION(Modu);
DEFINE_INSTRUCTION(Mulh);
DEFINE_INSTRUCTION2(Mult);
+ DEFINE_INSTRUCTION(Mulhu);
DEFINE_INSTRUCTION2(Multu);
DEFINE_INSTRUCTION2(Div);
DEFINE_INSTRUCTION2(Divu);
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Patch the relocated value (lui/ori pair).
bool generating_stub_;
bool has_frame_;
+ bool has_double_zero_reg_set_;
// This handle will be patched with the code object on installation.
Handle<Object> code_object_;
// a3: argc
// s0: argv, i.e. points to first arg
Label loop, entry;
- // TODO(plind): At least on simulator, argc in a3 is an int32_t with junk
- // in upper bits. Should fix the root cause, rather than use below
- // workaround to clear upper bits.
- __ dsll32(a3, a3, 0); // int32_t -> int64_t.
- __ dsrl32(a3, a3, 0);
__ dsll(a4, a3, kPointerSizeLog2);
__ daddu(a6, s0, a4);
__ b(&entry);
// Load deoptimization data from the code object.
// <deopt_data> = <code>[#deoptimization_data_offset]
- __ Uld(a1, MemOperand(v0, Code::kDeoptimizationDataOffset - kHeapObjectTag));
+ __ ld(a1, MemOperand(v0, Code::kDeoptimizationDataOffset - kHeapObjectTag));
// Load the OSR entrypoint offset from the deoptimization data.
// <osr_offset> = <deopt_data>[#header_size + #osr_pc_offset]
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is in ra.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = a3;
+ Register result = v0;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ Ret();
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
// Uses registers a0 to a4.
// Expected input (depending on whether args are in registers or on the stack):
// * object: a0 or at sp + 1 * kPointerSize.
__ Branch(&slow, ne, scratch, Operand(JS_FUNCTION_TYPE));
// Null is not instance of anything.
- __ Branch(&object_not_null,
- ne,
- scratch,
+ __ Branch(&object_not_null, ne, object,
Operand(isolate()->factory()->null_value()));
__ li(v0, Operand(Smi::FromInt(1)));
__ DropAndRet(HasArgsInRegisters() ? 0 : 2);
// A monomorphic miss (i.e, here the cache is not uninitialized) goes
// megamorphic.
- __ LoadRoot(at, Heap::kUninitializedSymbolRootIndex);
+ __ LoadRoot(at, Heap::kuninitialized_symbolRootIndex);
__ Branch(&initialize, eq, a4, Operand(at));
// MegamorphicSentinel is an immortal immovable object (undefined) so no
// write-barrier is needed.
__ bind(&megamorphic);
__ dsrl(a4, a3, 32- kPointerSizeLog2);
__ Daddu(a4, a2, Operand(a4));
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ sd(at, FieldMemOperand(a4, FixedArray::kHeaderSize));
__ jmp(&done);
DCHECK(!a4.is(object_));
// If the receiver is a smi trigger the non-string case.
- __ JumpIfSmi(object_, receiver_not_string_);
-
- // Fetch the instance type of the receiver into result register.
- __ ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
- __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ And(a4, result_, Operand(kIsNotStringMask));
- __ Branch(receiver_not_string_, ne, a4, Operand(zero_reg));
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ ld(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ lbu(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ And(a4, result_, Operand(kIsNotStringMask));
+ __ Branch(receiver_not_string_, ne, a4, Operand(zero_reg));
+ }
// If the index is non-smi trigger the non-smi case.
__ JumpIfNotSmi(index_, &index_not_smi_);
__ bind(&extra_checks_or_miss);
Label miss;
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ Branch(&slow_start, eq, a4, Operand(at));
- __ LoadRoot(at, Heap::kUninitializedSymbolRootIndex);
+ __ LoadRoot(at, Heap::kuninitialized_symbolRootIndex);
__ Branch(&miss, eq, a4, Operand(at));
if (!FLAG_trace_ic) {
__ Branch(&miss, ne, a5, Operand(JS_FUNCTION_TYPE));
__ dsrl(a4, a3, 32 - kPointerSizeLog2);
__ Daddu(a4, a2, Operand(a4));
- __ LoadRoot(at, Heap::kMegamorphicSymbolRootIndex);
+ __ LoadRoot(at, Heap::kmegamorphic_symbolRootIndex);
__ sd(at, FieldMemOperand(a4, FixedArray::kHeaderSize));
- __ Branch(&slow_start);
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ ld(a4, FieldMemOperand(a2, with_types_offset));
+ __ Dsubu(a4, a4, Operand(Smi::FromInt(1)));
+ __ sd(a4, FieldMemOperand(a2, with_types_offset));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ ld(a4, FieldMemOperand(a2, generic_offset));
+ __ Daddu(a4, a4, Operand(Smi::FromInt(1)));
+ __ Branch(USE_DELAY_SLOT, &slow_start);
+ __ sd(a4, FieldMemOperand(a2, generic_offset)); // In delay slot.
}
// We are here because tracing is on or we are going monomorphic.
// a1: instance type
// a2: length
// a3: from index (untagged)
- StringCharAtGenerator generator(
- v0, a3, a2, v0, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(v0, a3, a2, v0, &runtime, &runtime, &runtime,
+ STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ DropAndRet(3);
generator.SkipSlow(masm, &runtime);
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in a0.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(a0, &check_heap_number);
+ __ Ret(USE_DELAY_SLOT);
+ __ mov(v0, a0);
+
+ __ bind(&check_heap_number);
+ __ ld(a1, FieldMemOperand(a0, HeapObject::kMapOffset));
+ __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
+ __ Branch(&call_builtin, ne, a1, Operand(at));
+ __ Ret(USE_DELAY_SLOT);
+ __ mov(v0, a0);
+
+ __ bind(&call_builtin);
+ __ push(a0);
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(
MacroAssembler* masm, Register left, Register right, Register scratch1,
Register scratch2, Register scratch3) {
__ Daddu(src_elements, src_elements,
Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag + 4));
__ Daddu(dst_elements, array, Operand(FixedArray::kHeaderSize));
- __ Daddu(array, array, Operand(kHeapObjectTag));
__ SmiScale(dst_end, dst_end, kPointerSizeLog2);
__ Daddu(dst_end, dst_elements, dst_end);
+
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
+ __ Branch(&initialization_loop_entry);
+ __ bind(&initialization_loop);
+ __ sd(scratch, MemOperand(dst_elements));
+ __ Daddu(dst_elements, dst_elements, Operand(kPointerSize));
+ __ bind(&initialization_loop_entry);
+ __ Branch(&initialization_loop, lt, dst_elements, Operand(dst_end));
+
+ __ Daddu(dst_elements, array, Operand(FixedArray::kHeaderSize));
+ __ Daddu(array, array, Operand(kHeapObjectTag));
__ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
// Using offsetted addresses.
// dst_elements: begin of destination FixedArray element fields, not tagged
void DebugCodegen::GenerateLoadICDebugBreak(MacroAssembler* masm) {
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0);
}
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
Label loop, exit;
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ mov(a0, v0);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ push(a0);
// Check for proxies.
__ bind(&call_runtime);
__ push(a0); // Duplicate the enumerable object on the stack.
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
// If we got a map from the runtime call, we can do a fast
// modification check. Otherwise, we got a fixed array, and we have
__ li(a1, FeedbackVector());
__ li(a2, Operand(TypeFeedbackVector::MegamorphicSentinel(isolate())));
- __ sd(a2, FieldMemOperand(a1, FixedArray::OffsetOfElementAt(slot)));
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ sd(a2, FieldMemOperand(a1, FixedArray::OffsetOfElementAt(vector_index)));
__ li(a1, Operand(Smi::FromInt(1))); // Smi indicates slow check
__ ld(a2, MemOperand(sp, 0 * kPointerSize)); // Get enumerated object
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ li(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ li(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
Label done;
__ Branch(&done, ne, v0, Operand(isolate()->factory()->undefined_value()));
__ li(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ li(LoadDescriptor::NameRegister(), Operand(var->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(v0);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in v0.
DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ push(a0);
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
__ Push(scratch, result_register());
}
break;
+ case KEYED_SUPER_PROPERTY: {
+ const Register scratch = a1;
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(scratch, result_register());
+ if (expr->is_compound()) {
+ const Register scratch1 = a4;
+ __ ld(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ }
+ break;
+ }
case KEYED_PROPERTY:
// We need the key and receiver on both the stack and in v0 and a1.
if (expr->is_compound()) {
EmitNamedSuperPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(v0);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(v0);
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ ld(load_name, MemOperand(sp, 2 * kPointerSize));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
+ Operand(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
__ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->DoneFeedbackSlot())));
+ Operand(SmiFromSlot(expr->DoneFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // v0=result.done
__ mov(a0, v0);
__ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->ValueFeedbackSlot())));
+ Operand(SmiFromSlot(expr->ValueFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // v0=result.value
context()->DropAndPlug(2, v0); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), v0, a2, a3, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, v0, a2, a3, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ ld(context_register(),
MemOperand(fp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ li(a1, Operand(map));
+ __ ld(a1, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ ld(a1, FieldMemOperand(a1, GlobalObject::kNativeContextOffset));
+ __ ld(a1, ContextOperand(a1, Context::ITERATOR_RESULT_MAP_INDEX));
__ pop(a2);
__ li(a3, Operand(isolate()->factory()->ToBoolean(done)));
__ li(a4, Operand(isolate()->factory()->empty_fixed_array()));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ sd(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
__ sd(a4, FieldMemOperand(v0, JSObject::kPropertiesOffset));
__ sd(a4, FieldMemOperand(v0, JSObject::kElementsOffset));
__ li(LoadDescriptor::NameRegister(), Operand(key->value()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in v0.
+ DCHECK(lit != NULL);
+ __ push(v0);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = a1;
+ __ ld(scratch,
+ FieldMemOperand(v0, JSFunction::kPrototypeOrInitialMapOffset));
+ __ push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ ld(scratch, MemOperand(sp, kPointerSize)); // constructor
+ } else {
+ __ ld(scratch, MemOperand(sp, 0)); // prototype
+ }
+ __ push(scratch);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(v0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; v0: home_object
+ Register scratch = a2;
+ Register scratch2 = a3;
+ __ mov(scratch, result_register()); // home_object
+ __ ld(v0, MemOperand(sp, kPointerSize)); // value
+ __ ld(scratch2, MemOperand(sp, 0)); // this
+ __ sd(scratch2, MemOperand(sp, kPointerSize)); // this
+ __ sd(scratch, MemOperand(sp, 0)); // home_object
+ // stack: this, home_object; v0: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(v0);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = a2;
+ Register scratch2 = a3;
+ __ ld(scratch2, MemOperand(sp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; v0: key, a3: value
+ __ ld(scratch, MemOperand(sp, kPointerSize)); // this
+ __ sd(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ ld(scratch, MemOperand(sp, 0)); // home_object
+ __ sd(scratch, MemOperand(sp, kPointerSize));
+ __ sd(v0, MemOperand(sp, 0));
+ __ Move(v0, scratch2);
+ // stack: this, home_object, key; v0: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ push(result_register()); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// v0 : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ Push(v0);
__ Push(key->value());
+ __ Push(v0);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(v0);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // v0 : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(v0);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(v0);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ Move(LoadDescriptor::NameRegister(), v0);
- __ pop(LoadDescriptor::ReceiverRegister());
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), v0);
+ __ pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(v0);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ const Register scratch = a1;
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Move(scratch, v0);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(scratch, v0, v0, scratch);
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ sd(v0, MemOperand(sp, kPointerSize));
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ li(a3, Operand(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ li(a3, Operand(SmiFromSlot(expr->CallFeedbackSlot())));
__ ld(a1, MemOperand(sp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
- // a6: copy of the first argument or undefined if it doesn't exist.
+ // a7: copy of the first argument or undefined if it doesn't exist.
if (arg_count > 0) {
- __ ld(a6, MemOperand(sp, arg_count * kPointerSize));
+ __ ld(a7, MemOperand(sp, arg_count * kPointerSize));
} else {
- __ LoadRoot(a6, Heap::kUndefinedValueRootIndex);
+ __ LoadRoot(a7, Heap::kUndefinedValueRootIndex);
}
+ // a6: the receiver of the enclosing function.
+ __ ld(a6, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+
// a5: the receiver of the enclosing function.
int receiver_offset = 2 + info_->scope()->num_parameters();
__ ld(a5, MemOperand(fp, receiver_offset * kPointerSize));
__ li(a1, Operand(Smi::FromInt(scope()->start_position())));
// Do the runtime call.
+ __ Push(a7);
__ Push(a6, a5, a4, a1);
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ ld(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ Push(a0);
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// v1 (receiver). Touch up the stack with the right values.
__ sd(v0, MemOperand(sp, (arg_count + 1) * kPointerSize));
__ sd(v1, MemOperand(sp, arg_count * kPointerSize));
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
SetSourcePosition(expr->position());
__ Push(context_register(), a2);
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ Push(v0, v1); // Function, receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the
// function and receiver and have the slow path jump around this
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ li(a2, FeedbackVector());
- __ li(a3, Operand(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ li(a3, Operand(SmiFromSlot(expr->CallNewFeedbackSlot())));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(v0, if_false);
+ Register map = a1;
+ Register type_reg = a2;
+ __ GetObjectType(v0, map, type_reg);
+ __ Subu(type_reg, type_reg, Operand(FIRST_JS_PROXY_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ls, type_reg, Operand(LAST_JS_PROXY_TYPE - FIRST_JS_PROXY_TYPE),
+ if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ li(LoadDescriptor::NameRegister(), Operand(expr->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
+ Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
__ li(at, Operand(Smi::FromInt(0)));
__ push(at);
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ ld(LoadDescriptor::ReceiverRegister(),
- MemOperand(sp, 1 * kPointerSize));
- __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ ld(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ const Register scratch = a1;
+ __ ld(scratch, MemOperand(sp, kPointerSize));
+ __ Push(scratch, result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ const Register scratch = a1;
+ const Register scratch1 = a4;
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(scratch, result_register());
+ __ ld(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ ld(LoadDescriptor::ReceiverRegister(),
+ MemOperand(sp, 1 * kPointerSize));
+ __ ld(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ sd(v0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ sd(v0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ sd(v0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ sd(v0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
case NAMED_PROPERTY:
__ sd(v0, MemOperand(sp, kPointerSize));
break;
+ case NAMED_SUPER_PROPERTY:
+ __ sd(v0, MemOperand(sp, 2 * kPointerSize));
+ break;
case KEYED_PROPERTY:
__ sd(v0, MemOperand(sp, 2 * kPointerSize));
break;
+ case KEYED_SUPER_PROPERTY:
+ __ sd(v0, MemOperand(sp, 3 * kPointerSize));
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(v0);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(v0);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ mov(StoreDescriptor::ValueRegister(), result_register());
__ Pop(StoreDescriptor::ReceiverRegister(),
__ li(LoadDescriptor::NameRegister(), Operand(proxy->name()));
if (FLAG_vector_ics) {
__ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return a0; }
+const Register StoreTransitionDescriptor::MapRegister() { return a3; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() { return a3; }
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // cp -- context
+ Register registers[] = {cp};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ li(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ li(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(a0));
- __ li(VectorLoadICDescriptor::SlotRegister(),
- Operand(Smi::FromInt(instr->hydrogen()->slot())));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
+ __ li(VectorLoadICDescriptor::SlotRegister(), Operand(Smi::FromInt(index)));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#if V8_TARGET_ARCH_MIPS64
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift
// by 0 and the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
// Compute the handler entry address and jump to it. The handler table is
// a fixed array of (smi-tagged) code offsets.
// v0 = exception, a1 = code object, a2 = state.
- Uld(a3, FieldMemOperand(a1, Code::kHandlerTableOffset));
+ ld(a3, FieldMemOperand(a1, Code::kHandlerTableOffset));
Daddu(a3, a3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
dsrl(a2, a2, StackHandler::kKindWidth); // Handler index.
dsll(a2, a2, kPointerSizeLog2);
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on mips64.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
daddiu(sp, sp, -5 * kPointerSize);
li(t8, Operand(Smi::FromInt(type)));
DCHECK(!result.is(at));
base::MagicNumbersForDivision<uint32_t> mag =
base::SignedDivisionByConstant(static_cast<uint32_t>(divisor));
- li(at, Operand(mag.multiplier));
+ li(at, Operand(static_cast<int32_t>(mag.multiplier)));
Mulh(result, dividend, Operand(at));
bool neg = (mag.multiplier & (static_cast<uint32_t>(1) << 31)) != 0;
if (divisor > 0 && neg) {
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Patch the relocated value (lui/ori pair).
// regs.
// TODO(plind) - make the 32-bit MULT ops conform to spec regarding
// checking of 32-bit input values, and un-define operations of HW.
- *i64hilo = static_cast<int64_t>((int32_t)rs) *
- static_cast<int64_t>((int32_t)rt);
+ *i64hilo = rs * rt;
break;
case MULTU:
*u64hilo = static_cast<uint64_t>(rs_u) * static_cast<uint64_t>(rt_u);
// When running with the simulator transition into simulated execution at this
// point.
-#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
- reinterpret_cast<Object*>(Simulator::current(Isolate::Current())->Call( \
- FUNCTION_ADDR(entry), 5, p0, p1, p2, p3, p4))
+#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
+ reinterpret_cast<Object*>(Simulator::current(Isolate::Current())->Call( \
+ FUNCTION_ADDR(entry), 5, reinterpret_cast<int64_t*>(p0), \
+ reinterpret_cast<int64_t*>(p1), reinterpret_cast<int64_t*>(p2), \
+ reinterpret_cast<int64_t*>(p3), reinterpret_cast<int64_t*>(p4)))
+
#ifdef MIPS_ABI_N64
#define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6, p7, p8) \
mirror = new MapMirror(value);
} else if (IS_SET(value) || IS_WEAKSET(value)) {
mirror = new SetMirror(value);
+ } else if (IS_MAP_ITERATOR(value) || IS_SET_ITERATOR(value)) {
+ mirror = new IteratorMirror(value);
} else if (ObjectIsPromise(value)) {
mirror = new PromiseMirror(value);
} else if (IS_GENERATOR(value)) {
var PROMISE_TYPE = 'promise';
var MAP_TYPE = 'map';
var SET_TYPE = 'set';
+var ITERATOR_TYPE = 'iterator';
var GENERATOR_TYPE = 'generator';
// Maximum length when sending strings through the JSON protocol.
// - PromiseMirror
// - MapMirror
// - SetMirror
+// - IteratorMirror
// - GeneratorMirror
// - PropertyMirror
// - InternalPropertyMirror
/**
+ * Check whether the mirror reflects an iterator.
+ * @returns {boolean} True if the mirror reflects an iterator
+ */
+Mirror.prototype.isIterator = function() {
+ return this instanceof IteratorMirror;
+};
+
+
+/**
* Allocate a handle id for this object.
*/
Mirror.prototype.allocateHandle_ = function() {
inherits(SetMirror, ObjectMirror);
+function IteratorGetValues_(iter, next_function) {
+ var result = [];
+ var next;
+ while (!(next = %_CallFunction(iter, next_function)).done) {
+ result.push(next.value);
+ }
+ return result;
+}
+
+
/**
* Returns an array of elements of a set.
* This will keep elements alive for WeakSets.
return %GetWeakSetValues(this.value_);
}
- var result = [];
var iter = %_CallFunction(this.value_, builtins.SetValues);
- var next;
- while (!(next = iter.next()).done) {
- result.push(next.value);
+ return IteratorGetValues_(iter, builtins.SetIteratorNextJS);
+};
+
+
+function IteratorMirror(value) {
+ %_CallFunction(this, value, ITERATOR_TYPE, ObjectMirror);
+}
+inherits(IteratorMirror, ObjectMirror);
+
+
+/**
+ * Returns a preview of elements of an iterator.
+ * Does not change the backing iterator state.
+ *
+ * @returns {Array.<Object>} Array of elements of an iterator.
+ */
+IteratorMirror.prototype.preview = function() {
+ if (IS_MAP_ITERATOR(this.value_)) {
+ return IteratorGetValues_(%MapIteratorClone(this.value_),
+ builtins.MapIteratorNextJS);
+ } else if (IS_SET_ITERATOR(this.value_)) {
+ return IteratorGetValues_(%SetIteratorClone(this.value_),
+ builtins.SetIteratorNextJS);
}
- return result;
};
+++ /dev/null
-// Copyright 2011 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_MISC_INTRINSICS_H_
-#define V8_MISC_INTRINSICS_H_
-
-#include "include/v8.h"
-#include "src/globals.h"
-
-namespace v8 {
-namespace internal {
-
-// Returns the index of the leading 1 bit, counting the least significant bit at
-// index 0. (1 << IntegerLog2(x)) is a mask for the most significant bit of x.
-// Result is undefined if input is zero.
-int IntegerLog2(uint32_t value);
-
-#if defined(__GNUC__)
-
-inline int IntegerLog2(uint32_t value) {
- return 31 - __builtin_clz(value);
-}
-
-#elif defined(_MSC_VER)
-
-#pragma intrinsic(_BitScanReverse)
-
-inline int IntegerLog2(uint32_t value) {
- unsigned long result; // NOLINT: MSVC intrinsic demands this type.
- _BitScanReverse(&result, value);
- return result;
-}
-
-#else
-
-// Default version using regular operations. Code taken from:
-// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
-inline int IntegerLog2(uint32_t value) {
- int result, shift;
-
- shift = (value > 0xFFFF) << 4;
- value >>= shift;
- result = shift;
-
- shift = (value > 0xFF) << 3;
- value >>= shift;
- result |= shift;
-
- shift = (value > 0xF) << 2;
- value >>= shift;
- result |= shift;
-
- shift = (value > 0x3) << 1;
- value >>= shift;
- result |= shift;
-
- result |= (value >> 1);
-
- return result;
-}
-#endif
-
-} } // namespace v8::internal
-
-#endif // V8_MISC_INTRINSICS_H_
const i::Serializer& serializer,
const i::List<i::byte>& context_snapshot_data,
const i::Serializer& context_serializer) const {
- if (!startup_blob_file_)
- return;
+ if (!startup_blob_file_) return;
- i::List<i::byte> startup_blob;
- i::ListSnapshotSink sink(&startup_blob);
+ i::SnapshotByteSink sink;
int spaces[] = {i::NEW_SPACE, i::OLD_POINTER_SPACE,
i::OLD_DATA_SPACE, i::CODE_SPACE,
i::byte* snapshot_bytes = snapshot_data.begin();
sink.PutBlob(snapshot_bytes, snapshot_data.length(), "snapshot");
- for (size_t i = 0; i < arraysize(spaces); ++i)
- sink.PutInt(serializer.CurrentAllocationAddress(spaces[i]), "spaces");
+ for (size_t i = 0; i < arraysize(spaces); ++i) {
+ i::Vector<const uint32_t> chunks =
+ serializer.FinalAllocationChunks(spaces[i]);
+ // For the start-up snapshot, none of the reservations has more than
+ // one chunk (reservation for each space fits onto a single page).
+ CHECK_EQ(1, chunks.length());
+ sink.PutInt(chunks[0], "spaces");
+ }
i::byte* context_bytes = context_snapshot_data.begin();
sink.PutBlob(context_bytes, context_snapshot_data.length(), "context");
- for (size_t i = 0; i < arraysize(spaces); ++i)
- sink.PutInt(context_serializer.CurrentAllocationAddress(spaces[i]),
- "spaces");
+ for (size_t i = 0; i < arraysize(spaces); ++i) {
+ i::Vector<const uint32_t> chunks =
+ context_serializer.FinalAllocationChunks(spaces[i]);
+ // For the context snapshot, none of the reservations has more than
+ // one chunk (reservation for each space fits onto a single page).
+ CHECK_EQ(1, chunks.length());
+ sink.PutInt(chunks[0], "spaces");
+ }
+ const i::List<i::byte>& startup_blob = sink.data();
size_t written = fwrite(startup_blob.begin(), 1, startup_blob.length(),
startup_blob_file_);
- if (written != (size_t)startup_blob.length()) {
+ if (written != static_cast<size_t>(startup_blob.length())) {
i::PrintF("Writing snapshot file failed.. Aborting.\n");
exit(1);
}
void WriteSizeVar(const i::Serializer& ser, const char* prefix,
const char* name, int space) const {
- fprintf(fp_, "const int Snapshot::%s%s_space_used_ = %d;\n",
- prefix, name, ser.CurrentAllocationAddress(space));
+ i::Vector<const uint32_t> chunks = ser.FinalAllocationChunks(space);
+ // For the start-up snapshot, none of the reservations has more than
+ // one chunk (total reservation fits into a single page).
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp_, "const int Snapshot::%s%s_space_used_ = %d;\n", prefix, name,
+ chunks[0]);
}
void WriteSnapshotData(const i::List<i::byte>* data) const {
}
// If we don't do this then we end up with a stray root pointing at the
// context even after we have disposed of the context.
- internal_isolate->heap()->CollectAllGarbage(
- i::Heap::kNoGCFlags, "mksnapshot");
+ internal_isolate->heap()->CollectAllAvailableGarbage("mksnapshot");
i::Object* raw_context = *v8::Utils::OpenPersistent(context);
context.Reset();
// This results in a somewhat smaller snapshot, probably because it gets
// rid of some things that are cached between garbage collections.
- i::List<i::byte> snapshot_data;
- i::ListSnapshotSink snapshot_sink(&snapshot_data);
+ i::SnapshotByteSink snapshot_sink;
i::StartupSerializer ser(internal_isolate, &snapshot_sink);
ser.SerializeStrongReferences();
- i::List<i::byte> context_data;
- i::ListSnapshotSink contex_sink(&context_data);
- i::PartialSerializer context_ser(internal_isolate, &ser, &contex_sink);
+ i::SnapshotByteSink context_sink;
+ i::PartialSerializer context_ser(internal_isolate, &ser, &context_sink);
context_ser.Serialize(&raw_context);
ser.SerializeWeakReferences();
+ context_ser.FinalizeAllocation();
+ ser.FinalizeAllocation();
+
{
SnapshotWriter writer(argv[1]);
if (i::FLAG_raw_file && i::FLAG_raw_context_file)
BZip2Compressor bzip2;
writer.SetCompressor(&bzip2);
#endif
- writer.WriteSnapshot(snapshot_data, ser, context_data, context_ser);
+ writer.WriteSnapshot(snapshot_sink.data(), ser, context_sink.data(),
+ context_ser);
}
}
var observationState;
+// We have to wait until after bootstrapping to grab a reference to the
+// observationState object, since it's not possible to serialize that
+// reference into the snapshot.
function GetObservationStateJS() {
- if (IS_UNDEFINED(observationState))
+ if (IS_UNDEFINED(observationState)) {
observationState = %GetObservationState();
+ }
+ // TODO(adamk): Consider moving this code into heap.cc
if (IS_UNDEFINED(observationState.callbackInfoMap)) {
observationState.callbackInfoMap = %ObservationWeakMapCreate();
observationState.objectInfoMap = %ObservationWeakMapCreate();
return observationState;
}
-function GetWeakMapWrapper() {
- function MapWrapper(map) {
- this.map_ = map;
- };
-
- MapWrapper.prototype = {
- __proto__: null,
- get: function(key) {
- return %WeakCollectionGet(this.map_, key);
- },
- set: function(key, value) {
- %WeakCollectionSet(this.map_, key, value);
- },
- has: function(key) {
- return !IS_UNDEFINED(this.get(key));
- }
- };
-
- return MapWrapper;
-}
-
-var contextMaps;
-
-function GetContextMaps() {
- if (IS_UNDEFINED(contextMaps)) {
- var map = GetWeakMapWrapper();
- var observationState = GetObservationStateJS();
- contextMaps = {
- callbackInfoMap: new map(observationState.callbackInfoMap),
- objectInfoMap: new map(observationState.objectInfoMap),
- notifierObjectInfoMap: new map(observationState.notifierObjectInfoMap)
- };
- }
-
- return contextMaps;
-}
-
-function GetCallbackInfoMap() {
- return GetContextMaps().callbackInfoMap;
-}
-
-function GetObjectInfoMap() {
- return GetContextMaps().objectInfoMap;
-}
-
-function GetNotifierObjectInfoMap() {
- return GetContextMaps().notifierObjectInfoMap;
-}
-
function GetPendingObservers() {
return GetObservationStateJS().pendingObservers;
}
function ObjectInfoGetOrCreate(object) {
var objectInfo = ObjectInfoGet(object);
if (IS_UNDEFINED(objectInfo)) {
- if (!%IsJSProxy(object))
+ if (!%_IsJSProxy(object)) {
%SetIsObserved(object);
-
+ }
objectInfo = {
object: object,
changeObservers: null,
performing: null,
performingCount: 0,
};
- GetObjectInfoMap().set(object, objectInfo);
+ %WeakCollectionSet(GetObservationStateJS().objectInfoMap,
+ object, objectInfo);
}
return objectInfo;
}
function ObjectInfoGet(object) {
- return GetObjectInfoMap().get(object);
+ return %WeakCollectionGet(GetObservationStateJS().objectInfoMap, object);
}
function ObjectInfoGetFromNotifier(notifier) {
- return GetNotifierObjectInfoMap().get(notifier);
+ return %WeakCollectionGet(GetObservationStateJS().notifierObjectInfoMap,
+ notifier);
}
function ObjectInfoGetNotifier(objectInfo) {
if (IS_NULL(objectInfo.notifier)) {
objectInfo.notifier = { __proto__: notifierPrototype };
- GetNotifierObjectInfoMap().set(objectInfo.notifier, objectInfo);
+ %WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
+ objectInfo.notifier, objectInfo);
}
return objectInfo.notifier;
}
-function ObjectInfoGetObject(objectInfo) {
- return objectInfo.object;
-}
-
function ChangeObserversIsOptimized(changeObservers) {
- return typeof changeObservers === 'function' ||
- typeof changeObservers.callback === 'function';
+ return IS_SPEC_FUNCTION(changeObservers) ||
+ IS_SPEC_FUNCTION(changeObservers.callback);
}
// The set of observers on an object is called 'changeObservers'. The first
// priority. When a change record must be enqueued for the callback, it
// normalizes. When delivery clears any pending change records, it re-optimizes.
function CallbackInfoGet(callback) {
- return GetCallbackInfoMap().get(callback);
+ return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap, callback);
+}
+
+function CallbackInfoSet(callback, callbackInfo) {
+ %WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+ callback, callbackInfo);
}
function CallbackInfoGetOrCreate(callback) {
- var callbackInfo = GetCallbackInfoMap().get(callback);
+ var callbackInfo = CallbackInfoGet(callback);
if (!IS_UNDEFINED(callbackInfo))
return callbackInfo;
- var priority = GetNextCallbackPriority();
- GetCallbackInfoMap().set(callback, priority);
+ var priority = GetNextCallbackPriority();
+ CallbackInfoSet(callback, priority);
return priority;
}
}
function CallbackInfoNormalize(callback) {
- var callbackInfo = GetCallbackInfoMap().get(callback);
+ var callbackInfo = CallbackInfoGet(callback);
if (IS_NUMBER(callbackInfo)) {
var priority = callbackInfo;
callbackInfo = new InternalArray;
callbackInfo.priority = priority;
- GetCallbackInfoMap().set(callback, callbackInfo);
+ CallbackInfoSet(callback, callbackInfo);
}
return callbackInfo;
}
var hasType = !IS_UNDEFINED(type);
var newRecord = hasType ?
- { object: ObjectInfoGetObject(objectInfo), type: type } :
- { object: ObjectInfoGetObject(objectInfo) };
+ { object: objectInfo.object, type: type } :
+ { object: objectInfo.object };
for (var prop in changeRecord) {
if (prop === 'object' || (hasType && prop === 'type')) continue;
}
function CallbackDeliverPending(callback) {
- var callbackInfo = GetCallbackInfoMap().get(callback);
+ var callbackInfo = CallbackInfoGet(callback);
if (IS_UNDEFINED(callbackInfo) || IS_NUMBER(callbackInfo))
return false;
// Clear the pending change records from callback and return it to its
// "optimized" state.
var priority = callbackInfo.priority;
- GetCallbackInfoMap().set(callback, priority);
+ CallbackInfoSet(callback, priority);
- if (GetPendingObservers())
- delete GetPendingObservers()[priority];
+ var pendingObservers = GetPendingObservers();
+ if (!IS_NULL(pendingObservers))
+ delete pendingObservers[priority];
+ // TODO: combine the following runtime calls for perf optimization.
var delivered = [];
%MoveArrayContents(callbackInfo, delivered);
+ %DeliverObservationChangeRecords(callback, delivered);
- try {
- %_CallFunction(UNDEFINED, delivered, callback);
- } catch (ex) {} // TODO(rossberg): perhaps log uncaught exceptions.
return true;
}
function ObserveMicrotaskRunner() {
var pendingObservers = GetPendingObservers();
- if (pendingObservers) {
+ if (!IS_NULL(pendingObservers)) {
SetPendingObservers(null);
for (var i in pendingObservers) {
CallbackDeliverPending(pendingObservers[i]);
case PROPERTY_CELL_TYPE:
PropertyCell::cast(this)->PropertyCellVerify();
break;
+ case WEAK_CELL_TYPE:
+ WeakCell::cast(this)->WeakCellVerify();
+ break;
case JS_ARRAY_TYPE:
JSArray::cast(this)->JSArrayVerify();
break;
}
if (HasFastProperties()) {
- CHECK_EQ(map()->unused_property_fields(),
- (map()->inobject_properties() + properties()->length() -
- map()->NextFreePropertyIndex()));
+ int actual_unused_property_fields = map()->inobject_properties() +
+ properties()->length() -
+ map()->NextFreePropertyIndex();
+ if (map()->unused_property_fields() != actual_unused_property_fields) {
+ // This could actually happen in the middle of StoreTransitionStub
+ // when the new extended backing store is already set into the object and
+ // the allocation of the MutableHeapNumber triggers GC (in this case map
+ // is not updated yet).
+ CHECK_EQ(map()->unused_property_fields(),
+ actual_unused_property_fields - JSObject::kFieldsAdded);
+ }
DescriptorArray* descriptors = map()->instance_descriptors();
for (int i = 0; i < map()->NumberOfOwnDescriptors(); i++) {
if (descriptors->GetDetails(i).type() == FIELD) {
}
+void WeakCell::WeakCellVerify() {
+ CHECK(IsWeakCell());
+ VerifyObjectField(kValueOffset);
+ VerifyObjectField(kNextOffset);
+}
+
+
void Code::CodeVerify() {
CHECK(IsAligned(reinterpret_cast<intptr_t>(instruction_start()),
kCodeAlignment));
for (int i = 0; i < number_of_descriptors(); i++) {
Name* key = GetSortedKey(i);
if (key == current_key) {
- OFStream os(stdout);
- PrintDescriptors(os);
+ Print();
return false;
}
current_key = key;
uint32_t hash = GetSortedKey(i)->Hash();
if (hash < current) {
- OFStream os(stdout);
- PrintDescriptors(os);
+ Print();
return false;
}
current = hash;
bool TransitionArray::IsSortedNoDuplicates(int valid_entries) {
DCHECK(valid_entries == -1);
- Name* current_key = NULL;
- uint32_t current = 0;
+ Name* prev_key = NULL;
+ bool prev_is_data_property = false;
+ PropertyAttributes prev_attributes = NONE;
+ uint32_t prev_hash = 0;
for (int i = 0; i < number_of_transitions(); i++) {
Name* key = GetSortedKey(i);
- if (key == current_key) {
- OFStream os(stdout);
- PrintTransitions(os);
- return false;
+ uint32_t hash = key->Hash();
+ bool is_data_property = false;
+ PropertyAttributes attributes = NONE;
+ if (!IsSpecialTransition(key)) {
+ Map* target = GetTarget(i);
+ PropertyDetails details = GetTargetDetails(key, target);
+ is_data_property = details.type() == FIELD || details.type() == CONSTANT;
+ attributes = details.attributes();
+ } else {
+ // Duplicate entries are not allowed for non-property transitions.
+ CHECK_NE(prev_key, key);
}
- current_key = key;
- uint32_t hash = GetSortedKey(i)->Hash();
- if (hash < current) {
- OFStream os(stdout);
- PrintTransitions(os);
+
+ int cmp =
+ CompareKeys(prev_key, prev_hash, prev_is_data_property, prev_attributes,
+ key, hash, is_data_property, attributes);
+ if (cmp >= 0) {
+ Print();
return false;
}
- current = hash;
+ prev_key = key;
+ prev_hash = hash;
+ prev_attributes = attributes;
+ prev_is_data_property = is_data_property;
}
return true;
}
}
+void Code::VerifyEmbeddedObjectsInFullCode() {
+ // Check that no context-specific object has been embedded.
+ Heap* heap = GetIsolate()->heap();
+ int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
+ for (RelocIterator it(this, mask); !it.done(); it.next()) {
+ Object* obj = it.rinfo()->target_object();
+ if (obj->IsCell()) obj = Cell::cast(obj)->value();
+ if (obj->IsPropertyCell()) obj = PropertyCell::cast(obj)->value();
+ if (!obj->IsHeapObject()) continue;
+ Map* map = obj->IsMap() ? Map::cast(obj) : HeapObject::cast(obj)->map();
+ int i = 0;
+ while (map != heap->roots_array_start()[i++]) {
+ CHECK_LT(i, Heap::kStrongRootListLength);
+ }
+ }
+}
+
+
#endif // DEBUG
} } // namespace v8::internal
TYPE_CHECKER(Oddball, ODDBALL_TYPE)
TYPE_CHECKER(Cell, CELL_TYPE)
TYPE_CHECKER(PropertyCell, PROPERTY_CELL_TYPE)
+TYPE_CHECKER(WeakCell, WEAK_CELL_TYPE)
TYPE_CHECKER(SharedFunctionInfo, SHARED_FUNCTION_INFO_TYPE)
TYPE_CHECKER(JSGeneratorObject, JS_GENERATOR_OBJECT_TYPE)
TYPE_CHECKER(JSModule, JS_MODULE_TYPE)
}
+Handle<Object> Object::GetPrototypeSkipHiddenPrototypes(
+ Isolate* isolate, Handle<Object> receiver) {
+ PrototypeIterator iter(isolate, receiver);
+ while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN)) {
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
+ return PrototypeIterator::GetCurrent(iter);
+ }
+ iter.Advance();
+ }
+ return PrototypeIterator::GetCurrent(iter);
+}
+
+
MaybeHandle<Object> Object::GetPropertyOrElement(Handle<Object> object,
Handle<Name> name) {
uint32_t index;
DisallowHeapAllocation no_allocation;
if (!map->HasTransitionArray()) return Handle<Map>::null();
TransitionArray* transitions = map->transitions();
- int transition = transitions->Search(*key);
+ int transition = transitions->Search(FIELD, *key, NONE);
if (transition == TransitionArray::kNotFound) return Handle<Map>::null();
- PropertyDetails target_details = transitions->GetTargetDetails(transition);
- if (target_details.type() != FIELD) return Handle<Map>::null();
- if (target_details.attributes() != NONE) return Handle<Map>::null();
+ PropertyDetails details = transitions->GetTargetDetails(transition);
+ if (details.type() != FIELD) return Handle<Map>::null();
+ DCHECK_EQ(NONE, details.attributes());
return Handle<Map>(transitions->GetTarget(transition));
}
}
+Object* WeakCell::value() const { return READ_FIELD(this, kValueOffset); }
+
+
+void WeakCell::clear() {
+ DCHECK(GetHeap()->gc_state() == Heap::MARK_COMPACT);
+ WRITE_FIELD(this, kValueOffset, Smi::FromInt(0));
+}
+
+
+void WeakCell::initialize(HeapObject* val) {
+ WRITE_FIELD(this, kValueOffset, val);
+ WRITE_BARRIER(GetHeap(), this, kValueOffset, val);
+}
+
+
+bool WeakCell::cleared() const { return value() == Smi::FromInt(0); }
+
+
+Object* WeakCell::next() const { return READ_FIELD(this, kNextOffset); }
+
+
+void WeakCell::set_next(Object* val, WriteBarrierMode mode) {
+ WRITE_FIELD(this, kNextOffset, val);
+ if (mode == UPDATE_WRITE_BARRIER) {
+ WRITE_BARRIER(GetHeap(), this, kNextOffset, val);
+ }
+}
+
+
int JSObject::GetHeaderSize() {
InstanceType type = map()->instance_type();
// Check for the most common kind of JavaScript object before
}
-Object* FixedArray::get(int index) {
+Object* FixedArray::get(int index) const {
SLOW_DCHECK(index >= 0 && index < this->length());
return READ_FIELD(this, kHeaderSize + index * kPointerSize);
}
// Initialize the extended layout fields.
int extended_header_offset = get_extended_section_header_offset();
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt64CountOffset,
- extended.count_of(INT64));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedCodePtrCountOffset,
- extended.count_of(CODE_PTR));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedHeapPtrCountOffset,
- extended.count_of(HEAP_PTR));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt32CountOffset,
- extended.count_of(INT32));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedInt64CountOffset,
+ extended.count_of(INT64));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedCodePtrCountOffset,
+ extended.count_of(CODE_PTR));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedHeapPtrCountOffset,
+ extended.count_of(HEAP_PTR));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedInt32CountOffset,
+ extended.count_of(INT32));
}
// Perform a binary search in a fixed array. Low and high are entry indices. If
// there are three entries in this array it should be called with low=0 and
// high=2.
-template<SearchMode search_mode, typename T>
-int BinarySearch(T* array, Name* name, int low, int high, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int BinarySearch(T* array, Name* name, int low, int high, int valid_entries,
+ int* out_insertion_index) {
+ DCHECK(search_mode == ALL_ENTRIES || out_insertion_index == NULL);
uint32_t hash = name->Hash();
int limit = high;
for (; low <= limit; ++low) {
int sort_index = array->GetSortedKeyIndex(low);
Name* entry = array->GetKey(sort_index);
- if (entry->Hash() != hash) break;
+ uint32_t current_hash = entry->Hash();
+ if (current_hash != hash) {
+ if (out_insertion_index != NULL) {
+ *out_insertion_index = sort_index + (current_hash > hash ? 0 : 1);
+ }
+ return T::kNotFound;
+ }
if (entry->Equals(name)) {
if (search_mode == ALL_ENTRIES || sort_index < valid_entries) {
return sort_index;
}
}
+ if (out_insertion_index != NULL) *out_insertion_index = limit + 1;
return T::kNotFound;
}
// Perform a linear search in this fixed array. len is the number of entry
// indices that are valid.
-template<SearchMode search_mode, typename T>
-int LinearSearch(T* array, Name* name, int len, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int LinearSearch(T* array, Name* name, int len, int valid_entries,
+ int* out_insertion_index) {
uint32_t hash = name->Hash();
if (search_mode == ALL_ENTRIES) {
for (int number = 0; number < len; number++) {
int sorted_index = array->GetSortedKeyIndex(number);
Name* entry = array->GetKey(sorted_index);
uint32_t current_hash = entry->Hash();
- if (current_hash > hash) break;
+ if (current_hash > hash) {
+ if (out_insertion_index != NULL) *out_insertion_index = sorted_index;
+ return T::kNotFound;
+ }
if (current_hash == hash && entry->Equals(name)) return sorted_index;
}
+ if (out_insertion_index != NULL) *out_insertion_index = len;
+ return T::kNotFound;
} else {
DCHECK(len >= valid_entries);
+ DCHECK_EQ(NULL, out_insertion_index); // Not supported here.
for (int number = 0; number < valid_entries; number++) {
Name* entry = array->GetKey(number);
uint32_t current_hash = entry->Hash();
if (current_hash == hash && entry->Equals(name)) return number;
}
+ return T::kNotFound;
}
- return T::kNotFound;
}
-template<SearchMode search_mode, typename T>
-int Search(T* array, Name* name, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int Search(T* array, Name* name, int valid_entries, int* out_insertion_index) {
if (search_mode == VALID_ENTRIES) {
SLOW_DCHECK(array->IsSortedNoDuplicates(valid_entries));
} else {
}
int nof = array->number_of_entries();
- if (nof == 0) return T::kNotFound;
+ if (nof == 0) {
+ if (out_insertion_index != NULL) *out_insertion_index = 0;
+ return T::kNotFound;
+ }
// Fast case: do linear search for small arrays.
const int kMaxElementsForLinearSearch = 8;
nof <= kMaxElementsForLinearSearch) ||
(search_mode == VALID_ENTRIES &&
valid_entries <= (kMaxElementsForLinearSearch * 3))) {
- return LinearSearch<search_mode>(array, name, nof, valid_entries);
+ return LinearSearch<search_mode>(array, name, nof, valid_entries,
+ out_insertion_index);
}
// Slow case: perform binary search.
- return BinarySearch<search_mode>(array, name, 0, nof - 1, valid_entries);
+ return BinarySearch<search_mode>(array, name, 0, nof - 1, valid_entries,
+ out_insertion_index);
}
int DescriptorArray::Search(Name* name, int valid_descriptors) {
- return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors);
+ return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors, NULL);
}
}
-void Map::LookupTransition(JSObject* holder,
- Name* name,
+void Map::LookupTransition(JSObject* holder, Name* name,
+ PropertyAttributes attributes,
LookupResult* result) {
- int transition_index = this->SearchTransition(name);
+ int transition_index = this->SearchTransition(FIELD, name, attributes);
if (transition_index == TransitionArray::kNotFound) return result->NotFound();
result->TransitionResult(holder, this->GetTransition(transition_index));
}
CAST_ACCESSOR(Struct)
CAST_ACCESSOR(Symbol)
CAST_ACCESSOR(UnseededNumberDictionary)
+CAST_ACCESSOR(WeakCell)
CAST_ACCESSOR(WeakHashTable)
void Name::set_hash_field(uint32_t value) {
WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
#if V8_HOST_ARCH_64_BIT
- WRITE_UINT32_FIELD(this, kHashFieldOffset + kIntSize, 0);
+#if V8_TARGET_LITTLE_ENDIAN
+ WRITE_UINT32_FIELD(this, kHashFieldSlot + kIntSize, 0);
+#else
+ WRITE_UINT32_FIELD(this, kHashFieldSlot, 0);
+#endif
#endif
}
}
-int ConsStringIteratorOp::OffsetForDepth(int depth) {
- return depth & kDepthMask;
-}
+int ConsStringIterator::OffsetForDepth(int depth) { return depth & kDepthMask; }
-void ConsStringIteratorOp::PushLeft(ConsString* string) {
+void ConsStringIterator::PushLeft(ConsString* string) {
frames_[depth_++ & kDepthMask] = string;
}
-void ConsStringIteratorOp::PushRight(ConsString* string) {
+void ConsStringIterator::PushRight(ConsString* string) {
// Inplace update.
frames_[(depth_-1) & kDepthMask] = string;
}
-void ConsStringIteratorOp::AdjustMaximumDepth() {
+void ConsStringIterator::AdjustMaximumDepth() {
if (depth_ > maximum_depth_) maximum_depth_ = depth_;
}
-void ConsStringIteratorOp::Pop() {
+void ConsStringIterator::Pop() {
DCHECK(depth_ > 0);
DCHECK(depth_ <= maximum_depth_);
depth_--;
}
-StringCharacterStream::StringCharacterStream(String* string,
- ConsStringIteratorOp* op,
- int offset)
- : is_one_byte_(false),
- op_(op) {
+StringCharacterStream::StringCharacterStream(String* string, int offset)
+ : is_one_byte_(false) {
Reset(string, offset);
}
buffer8_ = NULL;
end_ = NULL;
ConsString* cons_string = String::VisitFlat(this, string, offset);
- op_->Reset(cons_string, offset);
+ iter_.Reset(cons_string, offset);
if (cons_string != NULL) {
- string = op_->Next(&offset);
+ string = iter_.Next(&offset);
if (string != NULL) String::VisitFlat(this, string, offset);
}
}
bool StringCharacterStream::HasMore() {
if (buffer8_ != end_) return true;
int offset;
- String* string = op_->Next(&offset);
+ String* string = iter_.Next(&offset);
DCHECK_EQ(offset, 0);
if (string == NULL) return false;
String::VisitFlat(this, string);
template<> inline
uint8_t FixedTypedArray<Uint8ClampedArrayTraits>::from_double(double value) {
- if (value < 0) return 0;
+ // Handle NaNs and less than zero values which clamp to zero.
+ if (!(value > 0)) return 0;
if (value > 0xFF) return 0xFF;
return static_cast<uint8_t>(lrint(value));
}
}
if (instance_type == ONE_BYTE_STRING_TYPE ||
instance_type == ONE_BYTE_INTERNALIZED_STRING_TYPE) {
+ // Strings may get concurrently truncated, hence we have to access its
+ // length synchronized.
return SeqOneByteString::SizeFor(
- reinterpret_cast<SeqOneByteString*>(this)->length());
+ reinterpret_cast<SeqOneByteString*>(this)->synchronized_length());
}
if (instance_type == BYTE_ARRAY_TYPE) {
return reinterpret_cast<ByteArray*>(this)->ByteArraySize();
}
if (instance_type == STRING_TYPE ||
instance_type == INTERNALIZED_STRING_TYPE) {
+ // Strings may get concurrently truncated, hence we have to access its
+ // length synchronized.
return SeqTwoByteString::SizeFor(
- reinterpret_cast<SeqTwoByteString*>(this)->length());
+ reinterpret_cast<SeqTwoByteString*>(this)->synchronized_length());
}
if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) {
return FixedDoubleArray::SizeFor(
int Code::builtin_index() {
- DCHECK_EQ(BUILTIN, kind());
return READ_INT32_FIELD(this, kKindSpecificFlags1Offset);
}
void Code::set_builtin_index(int index) {
- DCHECK_EQ(BUILTIN, kind());
WRITE_INT32_FIELD(this, kKindSpecificFlags1Offset, index);
}
Map* Map::elements_transition_map() {
- int index = transitions()->Search(GetHeap()->elements_transition_symbol());
+ int index =
+ transitions()->SearchSpecial(GetHeap()->elements_transition_symbol());
return transitions()->GetTarget(index);
}
bool Map::CanHaveMoreTransitions() {
if (!HasTransitionArray()) return true;
- return FixedArray::SizeFor(transitions()->length() +
- TransitionArray::kTransitionSize)
- <= Page::kMaxRegularHeapObjectSize;
+ return transitions()->number_of_transitions() <
+ TransitionArray::kMaxNumberOfTransitions;
}
}
-int Map::SearchTransition(Name* name) {
- if (HasTransitionArray()) return transitions()->Search(name);
+int Map::SearchSpecialTransition(Symbol* name) {
+ if (HasTransitionArray()) {
+ return transitions()->SearchSpecial(name);
+ }
+ return TransitionArray::kNotFound;
+}
+
+
+int Map::SearchTransition(PropertyType type, Name* name,
+ PropertyAttributes attributes) {
+ if (HasTransitionArray()) {
+ return transitions()->Search(type, name, attributes);
+ }
return TransitionArray::kNotFound;
}
Map* target = transitions()->GetTarget(i);
if (target->instance_descriptors() == instance_descriptors()) {
Name* key = transitions()->GetKey(i);
- int new_target_index = transition_array->Search(key);
- DCHECK(new_target_index != TransitionArray::kNotFound);
- DCHECK(transition_array->GetTarget(new_target_index) == target);
+ int new_target_index;
+ if (TransitionArray::IsSpecialTransition(key)) {
+ new_target_index = transition_array->SearchSpecial(Symbol::cast(key));
+ } else {
+ PropertyDetails details =
+ TransitionArray::GetTargetDetails(key, target);
+ new_target_index = transition_array->Search(details.type(), key,
+ details.attributes());
+ }
+ DCHECK_NE(TransitionArray::kNotFound, new_target_index);
+ DCHECK_EQ(target, transition_array->GetTarget(new_target_index));
}
}
#endif
ACCESSORS_TO_SMI(Script, line_offset, kLineOffsetOffset)
ACCESSORS_TO_SMI(Script, column_offset, kColumnOffsetOffset)
ACCESSORS(Script, context_data, Object, kContextOffset)
-ACCESSORS(Script, wrapper, Foreign, kWrapperOffset)
+ACCESSORS(Script, wrapper, HeapObject, kWrapperOffset)
ACCESSORS_TO_SMI(Script, type, kTypeOffset)
ACCESSORS(Script, line_ends, Object, kLineEndsOffset)
ACCESSORS(Script, eval_from_shared, Object, kEvalFromSharedOffset)
has_duplicate_parameters,
kHasDuplicateParameters)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, asm_function, kIsAsmFunction)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, deserialized, kDeserialized)
#if V8_HOST_ARCH_32_BIT
#else
-#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset) \
- STATIC_ASSERT(holder::offset % kPointerSize == 0); \
- int holder::name() const { \
- int value = READ_INT_FIELD(this, offset); \
- DCHECK(kHeapObjectTag == 1); \
- DCHECK((value & kHeapObjectTag) == 0); \
- return value >> 1; \
- } \
- void holder::set_##name(int value) { \
- DCHECK(kHeapObjectTag == 1); \
- DCHECK((value & 0xC0000000) == 0xC0000000 || \
- (value & 0xC0000000) == 0x0); \
- WRITE_INT_FIELD(this, \
- offset, \
- (value << 1) & ~kHeapObjectTag); \
- }
-
-#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset) \
- STATIC_ASSERT(holder::offset % kPointerSize == kIntSize); \
+#if V8_TARGET_LITTLE_ENDIAN
+#define PSEUDO_SMI_LO_ALIGN 0
+#define PSEUDO_SMI_HI_ALIGN kIntSize
+#else
+#define PSEUDO_SMI_LO_ALIGN kIntSize
+#define PSEUDO_SMI_HI_ALIGN 0
+#endif
+
+#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset) \
+ STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_LO_ALIGN); \
+ int holder::name() const { \
+ int value = READ_INT_FIELD(this, offset); \
+ DCHECK(kHeapObjectTag == 1); \
+ DCHECK((value & kHeapObjectTag) == 0); \
+ return value >> 1; \
+ } \
+ void holder::set_##name(int value) { \
+ DCHECK(kHeapObjectTag == 1); \
+ DCHECK((value & 0xC0000000) == 0xC0000000 || (value & 0xC0000000) == 0x0); \
+ WRITE_INT_FIELD(this, offset, (value << 1) & ~kHeapObjectTag); \
+ }
+
+#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset) \
+ STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_HI_ALIGN); \
INT_ACCESSORS(holder, name, offset)
}
+bool JSArrayBuffer::is_neuterable() {
+ return BooleanBit::get(flag(), kIsNeuterableBit);
+}
+
+
+void JSArrayBuffer::set_is_neuterable(bool value) {
+ set_flag(BooleanBit::set(flag(), kIsNeuterableBit, value));
+}
+
+
ACCESSORS(JSArrayBuffer, weak_next, Object, kWeakNextOffset)
ACCESSORS(JSArrayBuffer, weak_first_view, Object, kWeakFirstViewOffset)
// The string was flat.
if (cons_string == NULL) return hasher.GetHashField();
// This is a ConsString, iterate across it.
- ConsStringIteratorOp op(cons_string);
+ ConsStringIterator iter(cons_string);
int offset;
- while (NULL != (string = op.Next(&offset))) {
+ while (NULL != (string = iter.Next(&offset))) {
String::VisitFlat(&hasher, string, offset);
}
return hasher.GetHashField();
DCHECK(SlowEquals(canonical));
DCHECK(canonical->IsInternalizedString());
DCHECK(canonical->HasHashCode());
- WRITE_FIELD(this, kHashFieldOffset, canonical);
+ WRITE_FIELD(this, kHashFieldSlot, canonical);
// Setting the hash field to a tagged value sets the LSB, causing the hash
// code to be interpreted as uninitialized. We use this fact to recognize
// that we have a forwarded string.
String* String::GetForwardedInternalizedString() {
DCHECK(IsInternalizedString());
if (HasHashCode()) return this;
- String* canonical = String::cast(READ_FIELD(this, kHashFieldOffset));
+ String* canonical = String::cast(READ_FIELD(this, kHashFieldSlot));
DCHECK(canonical->IsInternalizedString());
DCHECK(SlowEquals(canonical));
DCHECK(canonical->HasHashCode());
}
-Object* JSReceiver::GetConstructor() {
- return map()->constructor();
-}
-
-
Maybe<bool> JSReceiver::HasProperty(Handle<JSReceiver> object,
Handle<Name> name) {
if (object->IsJSProxy()) {
}
-void NameDictionary::DoGenerateNewEnumerationIndices(
+Handle<FixedArray> NameDictionary::DoGenerateNewEnumerationIndices(
Handle<NameDictionary> dictionary) {
- DerivedDictionary::GenerateNewEnumerationIndices(dictionary);
+ return DerivedDictionary::GenerateNewEnumerationIndices(dictionary);
}
}
+int Map::SlackForArraySize(int old_size, int size_limit) {
+ const int max_slack = size_limit - old_size;
+ CHECK(max_slack >= 0);
+ if (old_size < 4) return Min(max_slack, 1);
+ return Min(max_slack, old_size / 2);
+}
+
+
void JSArray::EnsureSize(Handle<JSArray> array, int required_size) {
DCHECK(array->HasFastSmiOrObjectElements());
Handle<FixedArray> elts = handle(FixedArray::cast(array->elements()));
void Object::Print() {
OFStream os(stdout);
this->Print(os);
- os << flush;
+ os << std::flush;
}
-void Object::Print(OStream& os) { // NOLINT
+void Object::Print(std::ostream& os) { // NOLINT
if (IsSmi()) {
Smi::cast(this)->SmiPrint(os);
} else {
}
-void HeapObject::PrintHeader(OStream& os, const char* id) { // NOLINT
+void HeapObject::PrintHeader(std::ostream& os, const char* id) { // NOLINT
os << "" << reinterpret_cast<void*>(this) << ": [" << id << "]\n";
}
-void HeapObject::HeapObjectPrint(OStream& os) { // NOLINT
+void HeapObject::HeapObjectPrint(std::ostream& os) { // NOLINT
InstanceType instance_type = map()->instance_type();
HandleScope scope(GetIsolate());
case PROPERTY_CELL_TYPE:
PropertyCell::cast(this)->PropertyCellPrint(os);
break;
+ case WEAK_CELL_TYPE:
+ WeakCell::cast(this)->WeakCellPrint(os);
+ break;
case JS_ARRAY_BUFFER_TYPE:
JSArrayBuffer::cast(this)->JSArrayBufferPrint(os);
break;
}
-void ByteArray::ByteArrayPrint(OStream& os) { // NOLINT
+void ByteArray::ByteArrayPrint(std::ostream& os) { // NOLINT
os << "byte array, data starts at " << GetDataStartAddress();
}
-void FreeSpace::FreeSpacePrint(OStream& os) { // NOLINT
+void FreeSpace::FreeSpacePrint(std::ostream& os) { // NOLINT
os << "free space, size " << Size();
}
-#define EXTERNAL_ARRAY_PRINTER(Type, type, TYPE, ctype, size) \
- void External##Type##Array::External##Type##ArrayPrint(OStream& os) { \
- os << "external " #type " array"; \
+#define EXTERNAL_ARRAY_PRINTER(Type, type, TYPE, ctype, size) \
+ void External##Type##Array::External##Type##ArrayPrint(std::ostream& os) { \
+ os << "external " #type " array"; \
}
TYPED_ARRAYS(EXTERNAL_ARRAY_PRINTER)
template <class Traits>
-void FixedTypedArray<Traits>::FixedTypedArrayPrint(OStream& os) { // NOLINT
+void FixedTypedArray<Traits>::FixedTypedArrayPrint(
+ std::ostream& os) { // NOLINT
os << "fixed " << Traits::Designator();
}
-void JSObject::PrintProperties(OStream& os) { // NOLINT
+void JSObject::PrintProperties(std::ostream& os) { // NOLINT
if (HasFastProperties()) {
DescriptorArray* descs = map()->instance_descriptors();
for (int i = 0; i < map()->NumberOfOwnDescriptors(); i++) {
template <class T>
-static void DoPrintElements(OStream& os, Object* object) { // NOLINT
+static void DoPrintElements(std::ostream& os, Object* object) { // NOLINT
T* p = T::cast(object);
for (int i = 0; i < p->length(); i++) {
os << " " << i << ": " << p->get_scalar(i) << "\n";
}
-void JSObject::PrintElements(OStream& os) { // NOLINT
+void JSObject::PrintElements(std::ostream& os) { // NOLINT
// Don't call GetElementsKind, its validation code can cause the printer to
// fail when debugging.
switch (map()->elements_kind()) {
}
-void JSObject::PrintTransitions(OStream& os) { // NOLINT
+void JSObject::PrintTransitions(std::ostream& os) { // NOLINT
if (!map()->HasTransitionArray()) return;
- TransitionArray* transitions = map()->transitions();
- for (int i = 0; i < transitions->number_of_transitions(); i++) {
- Name* key = transitions->GetKey(i);
- os << " ";
- key->NamePrint(os);
- os << ": ";
- if (key == GetHeap()->frozen_symbol()) {
- os << " (transition to frozen)\n";
- } else if (key == GetHeap()->elements_transition_symbol()) {
- os << " (transition to "
- << ElementsKindToString(transitions->GetTarget(i)->elements_kind())
- << ")\n";
- } else if (key == GetHeap()->observed_symbol()) {
- os << " (transition to Object.observe)\n";
- } else {
- switch (transitions->GetTargetDetails(i).type()) {
- case FIELD: {
- os << " (transition to field)\n";
- break;
- }
- case CONSTANT:
- os << " (transition to constant)\n";
- break;
- case CALLBACKS:
- os << " (transition to callback)\n";
- break;
- // Values below are never in the target descriptor array.
- case NORMAL:
- UNREACHABLE();
- break;
- }
- }
- }
+ map()->transitions()->PrintTransitions(os, false);
}
-void JSObject::JSObjectPrint(OStream& os) { // NOLINT
+void JSObject::JSObjectPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSObject");
// Don't call GetElementsKind, its validation code can cause the printer to
// fail when debugging.
}
-void JSModule::JSModulePrint(OStream& os) { // NOLINT
+void JSModule::JSModulePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSModule");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n"
<< " - context = ";
}
-void Symbol::SymbolPrint(OStream& os) { // NOLINT
+void Symbol::SymbolPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Symbol");
os << " - hash: " << Hash();
os << "\n - name: " << Brief(name());
+ if (name()->IsUndefined()) {
+ os << " (" << PrivateSymbolToName() << ")";
+ }
os << "\n - private: " << is_private();
os << "\n - own: " << is_own();
os << "\n";
}
-void Map::MapPrint(OStream& os) { // NOLINT
+void Map::MapPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Map");
os << " - type: " << TypeToString(instance_type()) << "\n";
os << " - instance size: " << instance_size() << "\n";
os << "\n - pre-allocated property fields: "
<< pre_allocated_property_fields() << "\n";
os << " - unused property fields: " << unused_property_fields() << "\n";
+ if (is_dictionary_map()) os << " - dictionary_map\n";
+ if (is_prototype_map()) os << " - prototype_map\n";
if (is_hidden_prototype()) os << " - hidden_prototype\n";
if (has_named_interceptor()) os << " - named_interceptor\n";
if (has_indexed_interceptor()) os << " - indexed_interceptor\n";
}
-void CodeCache::CodeCachePrint(OStream& os) { // NOLINT
+void CodeCache::CodeCachePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "CodeCache");
os << "\n - default_cache: " << Brief(default_cache());
os << "\n - normal_type_cache: " << Brief(normal_type_cache());
}
-void PolymorphicCodeCache::PolymorphicCodeCachePrint(OStream& os) { // NOLINT
+void PolymorphicCodeCache::PolymorphicCodeCachePrint(
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "PolymorphicCodeCache");
os << "\n - cache: " << Brief(cache());
}
-void TypeFeedbackInfo::TypeFeedbackInfoPrint(OStream& os) { // NOLINT
+void TypeFeedbackInfo::TypeFeedbackInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "TypeFeedbackInfo");
os << " - ic_total_count: " << ic_total_count()
<< ", ic_with_type_info_count: " << ic_with_type_info_count()
}
-void AliasedArgumentsEntry::AliasedArgumentsEntryPrint(OStream& os) { // NOLINT
+void AliasedArgumentsEntry::AliasedArgumentsEntryPrint(
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AliasedArgumentsEntry");
os << "\n - aliased_context_slot: " << aliased_context_slot();
}
-void FixedArray::FixedArrayPrint(OStream& os) { // NOLINT
+void FixedArray::FixedArrayPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "FixedArray");
os << " - length: " << length();
for (int i = 0; i < length(); i++) {
}
-void FixedDoubleArray::FixedDoubleArrayPrint(OStream& os) { // NOLINT
+void FixedDoubleArray::FixedDoubleArrayPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "FixedDoubleArray");
os << " - length: " << length();
for (int i = 0; i < length(); i++) {
}
-void ConstantPoolArray::ConstantPoolArrayPrint(OStream& os) { // NOLINT
+void ConstantPoolArray::ConstantPoolArrayPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "ConstantPoolArray");
os << " - length: " << length();
for (int i = 0; i <= last_index(INT32, SMALL_SECTION); i++) {
}
-void JSValue::JSValuePrint(OStream& os) { // NOLINT
+void JSValue::JSValuePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "ValueObject");
value()->Print(os);
}
-void JSMessageObject::JSMessageObjectPrint(OStream& os) { // NOLINT
+void JSMessageObject::JSMessageObjectPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSMessageObject");
os << " - type: " << Brief(type());
os << "\n - arguments: " << Brief(arguments());
}
-void String::StringPrint(OStream& os) { // NOLINT
+void String::StringPrint(std::ostream& os) { // NOLINT
if (StringShape(this).IsInternalized()) {
os << "#";
} else if (StringShape(this).IsCons()) {
}
-void Name::NamePrint(OStream& os) { // NOLINT
- if (IsString())
+void Name::NamePrint(std::ostream& os) { // NOLINT
+ if (IsString()) {
String::cast(this)->StringPrint(os);
- else
+ } else if (IsSymbol()) {
+ Symbol::cast(this)->name()->Print(os);
+ } else {
os << Brief(this);
+ }
}
// Static so that subsequent calls frees previously allocated space.
// This also means that previous results will be overwritten.
static char* buffer = NULL;
- if (buffer != NULL) free(buffer);
+ if (buffer != NULL) delete[] buffer;
buffer = new char[length()+1];
WriteToFlat(this, reinterpret_cast<uint8_t*>(buffer), 0, length());
buffer[length()] = 0;
};
-void JSDate::JSDatePrint(OStream& os) { // NOLINT
+void JSDate::JSDatePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSDate");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - value = ";
}
-void JSProxy::JSProxyPrint(OStream& os) { // NOLINT
+void JSProxy::JSProxyPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSProxy");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - handler = ";
}
-void JSFunctionProxy::JSFunctionProxyPrint(OStream& os) { // NOLINT
+void JSFunctionProxy::JSFunctionProxyPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSFunctionProxy");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - handler = ";
}
-void JSSet::JSSetPrint(OStream& os) { // NOLINT
+void JSSet::JSSetPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSSet");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - table = " << Brief(table());
}
-void JSMap::JSMapPrint(OStream& os) { // NOLINT
+void JSMap::JSMapPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSMap");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - table = " << Brief(table());
template <class Derived, class TableType>
-void OrderedHashTableIterator<
- Derived, TableType>::OrderedHashTableIteratorPrint(OStream& os) { // NOLINT
+void
+OrderedHashTableIterator<Derived, TableType>::OrderedHashTableIteratorPrint(
+ std::ostream& os) { // NOLINT
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - table = " << Brief(table());
os << "\n - index = " << Brief(index());
template void OrderedHashTableIterator<
JSSetIterator,
- OrderedHashSet>::OrderedHashTableIteratorPrint(OStream& os); // NOLINT
+ OrderedHashSet>::OrderedHashTableIteratorPrint(std::ostream& os); // NOLINT
template void OrderedHashTableIterator<
JSMapIterator,
- OrderedHashMap>::OrderedHashTableIteratorPrint(OStream& os); // NOLINT
+ OrderedHashMap>::OrderedHashTableIteratorPrint(std::ostream& os); // NOLINT
-void JSSetIterator::JSSetIteratorPrint(OStream& os) { // NOLINT
+void JSSetIterator::JSSetIteratorPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSSetIterator");
OrderedHashTableIteratorPrint(os);
}
-void JSMapIterator::JSMapIteratorPrint(OStream& os) { // NOLINT
+void JSMapIterator::JSMapIteratorPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSMapIterator");
OrderedHashTableIteratorPrint(os);
}
-void JSWeakMap::JSWeakMapPrint(OStream& os) { // NOLINT
+void JSWeakMap::JSWeakMapPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSWeakMap");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - table = " << Brief(table());
}
-void JSWeakSet::JSWeakSetPrint(OStream& os) { // NOLINT
+void JSWeakSet::JSWeakSetPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSWeakSet");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - table = " << Brief(table());
}
-void JSArrayBuffer::JSArrayBufferPrint(OStream& os) { // NOLINT
+void JSArrayBuffer::JSArrayBufferPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSArrayBuffer");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - backing_store = " << backing_store() << "\n";
}
-void JSTypedArray::JSTypedArrayPrint(OStream& os) { // NOLINT
+void JSTypedArray::JSTypedArrayPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSTypedArray");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - buffer = " << Brief(buffer());
}
-void JSDataView::JSDataViewPrint(OStream& os) { // NOLINT
+void JSDataView::JSDataViewPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "JSDataView");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - buffer =" << Brief(buffer());
}
-void JSFunction::JSFunctionPrint(OStream& os) { // NOLINT
+void JSFunction::JSFunctionPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Function");
os << " - map = " << reinterpret_cast<void*>(map()) << "\n";
os << " - initial_map = ";
}
-void SharedFunctionInfo::SharedFunctionInfoPrint(OStream& os) { // NOLINT
+void SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "SharedFunctionInfo");
os << " - name: " << Brief(name());
os << "\n - expected_nof_properties: " << expected_nof_properties();
}
-void JSGlobalProxy::JSGlobalProxyPrint(OStream& os) { // NOLINT
+void JSGlobalProxy::JSGlobalProxyPrint(std::ostream& os) { // NOLINT
os << "global_proxy ";
JSObjectPrint(os);
os << "native context : " << Brief(native_context());
}
-void JSGlobalObject::JSGlobalObjectPrint(OStream& os) { // NOLINT
+void JSGlobalObject::JSGlobalObjectPrint(std::ostream& os) { // NOLINT
os << "global ";
JSObjectPrint(os);
os << "native context : " << Brief(native_context());
}
-void JSBuiltinsObject::JSBuiltinsObjectPrint(OStream& os) { // NOLINT
+void JSBuiltinsObject::JSBuiltinsObjectPrint(std::ostream& os) { // NOLINT
os << "builtins ";
JSObjectPrint(os);
}
-void Cell::CellPrint(OStream& os) { // NOLINT
+void Cell::CellPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Cell");
}
-void PropertyCell::PropertyCellPrint(OStream& os) { // NOLINT
+void PropertyCell::PropertyCellPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "PropertyCell");
}
-void Code::CodePrint(OStream& os) { // NOLINT
+void WeakCell::WeakCellPrint(std::ostream& os) { // NOLINT
+ HeapObject::PrintHeader(os, "WeakCell");
+}
+
+
+void Code::CodePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Code");
#ifdef ENABLE_DISASSEMBLER
if (FLAG_use_verbose_printer) {
}
-void Foreign::ForeignPrint(OStream& os) { // NOLINT
+void Foreign::ForeignPrint(std::ostream& os) { // NOLINT
os << "foreign address : " << foreign_address();
}
void ExecutableAccessorInfo::ExecutableAccessorInfoPrint(
- OStream& os) { // NOLINT
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "ExecutableAccessorInfo");
os << "\n - name: " << Brief(name());
os << "\n - flag: " << Brief(flag());
}
-void DeclaredAccessorInfo::DeclaredAccessorInfoPrint(OStream& os) { // NOLINT
+void DeclaredAccessorInfo::DeclaredAccessorInfoPrint(
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "DeclaredAccessorInfo");
os << "\n - name: " << Brief(name());
os << "\n - flag: " << Brief(flag());
void DeclaredAccessorDescriptor::DeclaredAccessorDescriptorPrint(
- OStream& os) { // NOLINT
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "DeclaredAccessorDescriptor");
os << "\n - internal field: " << Brief(serialized_data());
os << "\n";
}
-void Box::BoxPrint(OStream& os) { // NOLINT
+void Box::BoxPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Box");
os << "\n - value: " << Brief(value());
os << "\n";
}
-void AccessorPair::AccessorPairPrint(OStream& os) { // NOLINT
+void AccessorPair::AccessorPairPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AccessorPair");
os << "\n - getter: " << Brief(getter());
os << "\n - setter: " << Brief(setter());
}
-void AccessCheckInfo::AccessCheckInfoPrint(OStream& os) { // NOLINT
+void AccessCheckInfo::AccessCheckInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AccessCheckInfo");
os << "\n - named_callback: " << Brief(named_callback());
os << "\n - indexed_callback: " << Brief(indexed_callback());
}
-void InterceptorInfo::InterceptorInfoPrint(OStream& os) { // NOLINT
+void InterceptorInfo::InterceptorInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "InterceptorInfo");
os << "\n - getter: " << Brief(getter());
os << "\n - setter: " << Brief(setter());
}
-void CallHandlerInfo::CallHandlerInfoPrint(OStream& os) { // NOLINT
+void CallHandlerInfo::CallHandlerInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "CallHandlerInfo");
os << "\n - callback: " << Brief(callback());
os << "\n - data: " << Brief(data());
}
-void FunctionTemplateInfo::FunctionTemplateInfoPrint(OStream& os) { // NOLINT
+void FunctionTemplateInfo::FunctionTemplateInfoPrint(
+ std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "FunctionTemplateInfo");
os << "\n - class name: " << Brief(class_name());
os << "\n - tag: " << Brief(tag());
}
-void ObjectTemplateInfo::ObjectTemplateInfoPrint(OStream& os) { // NOLINT
+void ObjectTemplateInfo::ObjectTemplateInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "ObjectTemplateInfo");
os << " - tag: " << Brief(tag());
os << "\n - property_list: " << Brief(property_list());
}
-void SignatureInfo::SignatureInfoPrint(OStream& os) { // NOLINT
+void SignatureInfo::SignatureInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "SignatureInfo");
os << "\n - receiver: " << Brief(receiver());
os << "\n - args: " << Brief(args());
}
-void TypeSwitchInfo::TypeSwitchInfoPrint(OStream& os) { // NOLINT
+void TypeSwitchInfo::TypeSwitchInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "TypeSwitchInfo");
os << "\n - types: " << Brief(types());
os << "\n";
}
-void AllocationSite::AllocationSitePrint(OStream& os) { // NOLINT
+void AllocationSite::AllocationSitePrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AllocationSite");
os << " - weak_next: " << Brief(weak_next());
os << "\n - dependent code: " << Brief(dependent_code());
}
-void AllocationMemento::AllocationMementoPrint(OStream& os) { // NOLINT
+void AllocationMemento::AllocationMementoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AllocationMemento");
os << " - allocation site: ";
if (IsValid()) {
}
-void Script::ScriptPrint(OStream& os) { // NOLINT
+void Script::ScriptPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Script");
os << "\n - source: " << Brief(source());
os << "\n - name: " << Brief(name());
}
-void DebugInfo::DebugInfoPrint(OStream& os) { // NOLINT
+void DebugInfo::DebugInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "DebugInfo");
os << "\n - shared: " << Brief(shared());
os << "\n - original_code: " << Brief(original_code());
}
-void BreakPointInfo::BreakPointInfoPrint(OStream& os) { // NOLINT
+void BreakPointInfo::BreakPointInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "BreakPointInfo");
os << "\n - code_position: " << code_position()->value();
os << "\n - source_position: " << source_position()->value();
}
-void DescriptorArray::PrintDescriptors(OStream& os) { // NOLINT
- os << "Descriptor array " << number_of_descriptors() << "\n";
+void DescriptorArray::Print() {
+ OFStream os(stdout);
+ this->PrintDescriptors(os);
+ os << std::flush;
+}
+
+
+void DescriptorArray::PrintDescriptors(std::ostream& os) { // NOLINT
+ os << "Descriptor array " << number_of_descriptors() << "\n";
for (int i = 0; i < number_of_descriptors(); i++) {
Descriptor desc;
Get(i, &desc);
- os << " " << i << ": " << desc;
+ os << " " << i << ": " << desc << "\n";
}
os << "\n";
}
-void TransitionArray::PrintTransitions(OStream& os) { // NOLINT
- os << "Transition array %d\n", number_of_transitions();
+void TransitionArray::Print() {
+ OFStream os(stdout);
+ this->PrintTransitions(os);
+ os << std::flush;
+}
+
+
+void TransitionArray::PrintTransitions(std::ostream& os,
+ bool print_header) { // NOLINT
+ if (print_header) {
+ os << "Transition array " << number_of_transitions() << "\n";
+ }
for (int i = 0; i < number_of_transitions(); i++) {
- os << " " << i << ": ";
- GetKey(i)->NamePrint(os);
+ Name* key = GetKey(i);
+ Map* target = GetTarget(i);
+ os << " ";
+ key->NamePrint(os);
os << ": ";
- switch (GetTargetDetails(i).type()) {
- case FIELD: {
- os << " (transition to field)\n";
- break;
+ if (key == GetHeap()->frozen_symbol()) {
+ os << " (transition to frozen)";
+ } else if (key == GetHeap()->elements_transition_symbol()) {
+ os << " (transition to " << ElementsKindToString(target->elements_kind())
+ << ")";
+ } else if (key == GetHeap()->observed_symbol()) {
+ os << " (transition to Object.observe)";
+ } else {
+ PropertyDetails details = GetTargetDetails(key, target);
+ switch (details.type()) {
+ case FIELD: {
+ os << " (transition to field)";
+ break;
+ }
+ case CONSTANT:
+ os << " (transition to constant " << Brief(GetTargetValue(i)) << ")";
+ break;
+ case CALLBACKS:
+ os << " (transition to callback " << Brief(GetTargetValue(i)) << ")";
+ break;
+ // Values below are never in the target descriptor array.
+ case NORMAL:
+ UNREACHABLE();
+ break;
}
- case CONSTANT:
- os << " (transition to constant)\n";
- break;
- case CALLBACKS:
- os << " (transition to callback)\n";
- break;
- // Values below are never in the target descriptor array.
- case NORMAL:
- UNREACHABLE();
- break;
+ os << ", attrs: " << details.attributes();
}
+ os << " -> " << Brief(target) << "\n";
}
- os << "\n";
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#include "src/accessors.h"
Debug* debug = isolate->debug();
// Handle stepping into a getter if step into is active.
// TODO(rossberg): should this apply to getters that are function proxies?
- if (debug->StepInActive() && getter->IsJSFunction()) {
- debug->HandleStepIn(
- Handle<JSFunction>::cast(getter), Handle<Object>::null(), 0, false);
+ if (debug->is_active()) {
+ debug->HandleStepIn(getter, Handle<Object>::null(), 0, false);
}
return Execution::Call(isolate, getter, receiver, 0, NULL, true);
Debug* debug = isolate->debug();
// Handle stepping into a setter if step into is active.
// TODO(rossberg): should this apply to getters that are function proxies?
- if (debug->StepInActive() && setter->IsJSFunction()) {
- debug->HandleStepIn(
- Handle<JSFunction>::cast(setter), Handle<Object>::null(), 0, false);
+ if (debug->is_active()) {
+ debug->HandleStepIn(setter, Handle<Object>::null(), 0, false);
}
Handle<Object> argv[] = { value };
}
-bool JSObject::IsDirty() {
- Object* cons_obj = map()->constructor();
- if (!cons_obj->IsJSFunction())
- return true;
- JSFunction* fun = JSFunction::cast(cons_obj);
- if (!fun->shared()->IsApiFunction())
- return true;
- // If the object is fully fast case and has the same map it was
- // created with then no changes can have been made to it.
- return map() != fun->initial_map()
- || !HasFastObjectElements()
- || !HasFastProperties();
-}
-
-
MaybeHandle<Object> Object::GetElementWithReceiver(Isolate* isolate,
Handle<Object> object,
Handle<Object> receiver,
}
+MaybeHandle<Object> Object::SetElementWithReceiver(
+ Isolate* isolate, Handle<Object> object, Handle<Object> receiver,
+ uint32_t index, Handle<Object> value, StrictMode strict_mode) {
+ // Iterate up the prototype chain until an element is found or the null
+ // prototype is encountered.
+ bool done = false;
+ for (PrototypeIterator iter(isolate, object,
+ object->IsJSProxy() || object->IsJSObject()
+ ? PrototypeIterator::START_AT_RECEIVER
+ : PrototypeIterator::START_AT_PROTOTYPE);
+ !iter.IsAtEnd() && !done; iter.Advance()) {
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
+ // TODO(dslomov): implement.
+ isolate->ThrowIllegalOperation();
+ return MaybeHandle<Object>();
+ }
+
+ Handle<JSObject> js_object =
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+
+ // Check access rights if needed.
+ if (js_object->IsAccessCheckNeeded()) {
+ if (!isolate->MayIndexedAccess(js_object, index, v8::ACCESS_SET)) {
+ isolate->ReportFailedAccessCheck(js_object, v8::ACCESS_SET);
+ RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
+ return isolate->factory()->undefined_value();
+ }
+ }
+
+ if (js_object->HasIndexedInterceptor()) {
+ Maybe<PropertyAttributes> from_interceptor =
+ JSObject::GetElementAttributeFromInterceptor(js_object, receiver,
+ index);
+ if (!from_interceptor.has_value) return MaybeHandle<Object>();
+ if ((from_interceptor.value & READ_ONLY) != 0) {
+ return WriteToReadOnlyElement(isolate, receiver, index, value,
+ strict_mode);
+ }
+ done = from_interceptor.value != ABSENT;
+ }
+
+ if (!done &&
+ js_object->elements() != isolate->heap()->empty_fixed_array()) {
+ ElementsAccessor* accessor = js_object->GetElementsAccessor();
+ PropertyAttributes attrs =
+ accessor->GetAttributes(receiver, js_object, index);
+ if ((attrs & READ_ONLY) != 0) {
+ return WriteToReadOnlyElement(isolate, receiver, index, value,
+ strict_mode);
+ }
+ Handle<AccessorPair> accessor_pair;
+ if (accessor->GetAccessorPair(receiver, js_object, index)
+ .ToHandle(&accessor_pair)) {
+ return JSObject::SetElementWithCallback(receiver, accessor_pair, index,
+ value, js_object, strict_mode);
+ } else {
+ done = attrs != ABSENT;
+ }
+ }
+ }
+
+ if (!receiver->IsJSObject()) {
+ return WriteToReadOnlyElement(isolate, receiver, index, value, strict_mode);
+ }
+ Handle<JSObject> target = Handle<JSObject>::cast(receiver);
+ ElementsAccessor* accessor = target->GetElementsAccessor();
+ PropertyAttributes attrs = accessor->GetAttributes(receiver, target, index);
+ if ((attrs & READ_ONLY) != 0) {
+ return WriteToReadOnlyElement(isolate, receiver, index, value, strict_mode);
+ }
+ PropertyAttributes new_attrs = attrs != ABSENT ? attrs : NONE;
+ return JSObject::SetElement(target, index, value, new_attrs, strict_mode,
+ false);
+}
+
+
Map* Object::GetRootMap(Isolate* isolate) {
DisallowHeapAllocation no_alloc;
if (IsSmi()) {
void Object::ShortPrint(StringStream* accumulator) {
- OStringStream os;
+ std::ostringstream os;
os << Brief(this);
- accumulator->Add(os.c_str());
+ accumulator->Add(os.str().c_str());
}
-OStream& operator<<(OStream& os, const Brief& v) {
+std::ostream& operator<<(std::ostream& os, const Brief& v) {
if (v.value->IsSmi()) {
Smi::cast(v.value)->SmiPrint(os);
} else {
}
-void Smi::SmiPrint(OStream& os) const { // NOLINT
+void Smi::SmiPrint(std::ostream& os) const { // NOLINT
os << value();
}
return;
}
- ConsStringIteratorOp op;
- StringCharacterStream stream(this, &op);
+ StringCharacterStream stream(this);
bool truncated = false;
if (len > kMaxShortPrintLength) {
}
-void String::PrintUC16(OStream& os, int start, int end) { // NOLINT
+void String::PrintUC16(std::ostream& os, int start, int end) { // NOLINT
if (end < 0) end = length();
- ConsStringIteratorOp op;
- StringCharacterStream stream(this, &op, start);
+ StringCharacterStream stream(this, start);
for (int i = start; i < end && stream.HasMore(); i++) {
os << AsUC16(stream.GetNext());
}
}
-void HeapObject::HeapObjectShortPrint(OStream& os) { // NOLINT
+void HeapObject::HeapObjectShortPrint(std::ostream& os) { // NOLINT
Heap* heap = GetHeap();
if (!heap->Contains(this)) {
os << "!!!INVALID POINTER!!!";
}
case SYMBOL_TYPE: {
Symbol* symbol = Symbol::cast(this);
- os << "<Symbol: " << symbol->Hash();
- if (!symbol->name()->IsUndefined()) {
- os << " ";
- HeapStringAllocator allocator;
- StringStream accumulator(&allocator);
- String::cast(symbol->name())->StringShortPrint(&accumulator);
- os << accumulator.ToCString().get();
- }
- os << ">";
+ symbol->SymbolShortPrint(os);
break;
}
case HEAP_NUMBER_TYPE: {
case PROPERTY_CELL_TYPE:
PropertyCell::BodyDescriptor::IterateBody(this, v);
break;
+ case WEAK_CELL_TYPE:
+ WeakCell::BodyDescriptor::IterateBody(this, v);
+ break;
case SYMBOL_TYPE:
Symbol::BodyDescriptor::IterateBody(this, v);
break;
}
-void HeapNumber::HeapNumberPrint(OStream& os) { // NOLINT
+void HeapNumber::HeapNumberPrint(std::ostream& os) { // NOLINT
os << value();
}
}
-void JSObject::EnqueueChangeRecord(Handle<JSObject> object,
- const char* type_str,
- Handle<Name> name,
- Handle<Object> old_value) {
+MaybeHandle<Object> JSObject::EnqueueChangeRecord(Handle<JSObject> object,
+ const char* type_str,
+ Handle<Name> name,
+ Handle<Object> old_value) {
DCHECK(!object->IsJSGlobalProxy());
DCHECK(!object->IsJSGlobalObject());
Isolate* isolate = object->GetIsolate();
Handle<Object> args[] = { type, object, name, old_value };
int argc = name.is_null() ? 2 : old_value->IsTheHole() ? 3 : 4;
- Execution::Call(isolate,
- Handle<JSFunction>(isolate->observers_notify_change()),
- isolate->factory()->undefined_value(),
- argc, args).Assert();
+ return Execution::Call(isolate,
+ Handle<JSFunction>(isolate->observers_notify_change()),
+ isolate->factory()->undefined_value(), argc, args);
}
void Map::ConnectElementsTransition(Handle<Map> parent, Handle<Map> child) {
Isolate* isolate = parent->GetIsolate();
Handle<Name> name = isolate->factory()->elements_transition_symbol();
- ConnectTransition(parent, child, name, FULL_TRANSITION);
+ ConnectTransition(parent, child, name, SPECIAL_TRANSITION);
}
}
DCHECK(number_of_fields == old_number_of_fields + 1);
- // This migration is a transition from a map that has run out out property
+ // This migration is a transition from a map that has run out of property
// space. Therefore it could be done by extending the backing store.
Handle<FixedArray> old_storage = handle(object->properties(), isolate);
Handle<FixedArray> new_storage =
}
-void JSObject::GeneralizeFieldRepresentation(Handle<JSObject> object,
- int modify_index,
- Representation new_representation,
- Handle<HeapType> new_field_type) {
- Handle<Map> new_map = Map::GeneralizeRepresentation(
- handle(object->map()), modify_index, new_representation, new_field_type,
- FORCE_FIELD);
- MigrateToMap(object, new_map);
-}
-
-
int Map::NumberOfFields() {
DescriptorArray* descriptors = instance_descriptors();
int result = 0;
// Invalidates a transition target at |key|, and installs |new_descriptors| over
// the current instance_descriptors to ensure proper sharing of descriptor
// arrays.
-void Map::DeprecateTarget(Name* key, DescriptorArray* new_descriptors) {
+void Map::DeprecateTarget(PropertyType type, Name* key,
+ PropertyAttributes attributes,
+ DescriptorArray* new_descriptors) {
if (HasTransitionArray()) {
TransitionArray* transitions = this->transitions();
- int transition = transitions->Search(key);
+ int transition = transitions->Search(type, key, attributes);
if (transition != TransitionArray::kNotFound) {
transitions->GetTarget(transition)->DeprecateTransitionTree();
}
for (int i = verbatim; i < length; i++) {
if (!current->HasTransitionArray()) break;
Name* name = descriptors->GetKey(i);
+ PropertyDetails details = descriptors->GetDetails(i);
TransitionArray* transitions = current->transitions();
- int transition = transitions->Search(name);
+ int transition =
+ transitions->Search(details.type(), name, details.attributes());
if (transition == TransitionArray::kNotFound) break;
Map* next = transitions->GetTarget(transition);
DescriptorArray* next_descriptors = next->instance_descriptors();
- PropertyDetails details = descriptors->GetDetails(i);
PropertyDetails next_details = next_descriptors->GetDetails(i);
if (details.type() != next_details.type()) break;
if (details.attributes() != next_details.attributes()) break;
Handle<Map> target_map = root_map;
for (int i = root_nof; i < old_nof; ++i) {
- int j = target_map->SearchTransition(old_descriptors->GetKey(i));
+ PropertyDetails old_details = old_descriptors->GetDetails(i);
+ int j = target_map->SearchTransition(old_details.type(),
+ old_descriptors->GetKey(i),
+ old_details.attributes());
if (j == TransitionArray::kNotFound) break;
Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
Handle<DescriptorArray> tmp_descriptors = handle(
tmp_map->instance_descriptors(), isolate);
// Check if target map is incompatible.
- PropertyDetails old_details = old_descriptors->GetDetails(i);
PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
PropertyType old_type = old_details.type();
PropertyType tmp_type = tmp_details.type();
- if (tmp_details.attributes() != old_details.attributes() ||
- ((tmp_type == CALLBACKS || old_type == CALLBACKS) &&
- (tmp_type != old_type ||
- tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i)))) {
+ DCHECK_EQ(old_details.attributes(), tmp_details.attributes());
+ if ((tmp_type == CALLBACKS || old_type == CALLBACKS) &&
+ (tmp_type != old_type ||
+ tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i))) {
return CopyGeneralizeAllRepresentations(
old_map, modify_index, store_mode, "incompatible");
}
// Find the last compatible target map in the transition tree.
for (int i = target_nof; i < old_nof; ++i) {
- int j = target_map->SearchTransition(old_descriptors->GetKey(i));
+ PropertyDetails old_details = old_descriptors->GetDetails(i);
+ int j = target_map->SearchTransition(old_details.type(),
+ old_descriptors->GetKey(i),
+ old_details.attributes());
if (j == TransitionArray::kNotFound) break;
Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
Handle<DescriptorArray> tmp_descriptors(
tmp_map->instance_descriptors(), isolate);
// Check if target map is compatible.
- PropertyDetails old_details = old_descriptors->GetDetails(i);
PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
- if (tmp_details.attributes() != old_details.attributes() ||
- ((tmp_details.type() == CALLBACKS || old_details.type() == CALLBACKS) &&
- (tmp_details.type() != old_details.type() ||
- tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i)))) {
+ DCHECK_EQ(old_details.attributes(), tmp_details.attributes());
+ if ((tmp_details.type() == CALLBACKS || old_details.type() == CALLBACKS) &&
+ (tmp_details.type() != old_details.type() ||
+ tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i))) {
return CopyGeneralizeAllRepresentations(
old_map, modify_index, store_mode, "incompatible");
}
int split_nof = split_map->NumberOfOwnDescriptors();
DCHECK_NE(old_nof, split_nof);
- split_map->DeprecateTarget(
- old_descriptors->GetKey(split_nof), *new_descriptors);
+ PropertyDetails split_prop_details = old_descriptors->GetDetails(split_nof);
+ split_map->DeprecateTarget(split_prop_details.type(),
+ old_descriptors->GetKey(split_nof),
+ split_prop_details.attributes(), *new_descriptors);
if (FLAG_trace_generalization) {
PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
// Add missing transitions.
Handle<Map> new_map = split_map;
for (int i = split_nof; i < old_nof; ++i) {
+ if (!new_map->CanHaveMoreTransitions()) {
+ return CopyGeneralizeAllRepresentations(old_map, modify_index, store_mode,
+ "can't have more transitions");
+ }
new_map = CopyInstallDescriptors(new_map, i, new_descriptors);
}
new_map->set_owns_descriptors(true);
Map* new_map = root_map;
for (int i = root_nof; i < old_nof; ++i) {
- int j = new_map->SearchTransition(old_descriptors->GetKey(i));
+ PropertyDetails old_details = old_descriptors->GetDetails(i);
+ int j = new_map->SearchTransition(old_details.type(),
+ old_descriptors->GetKey(i),
+ old_details.attributes());
if (j == TransitionArray::kNotFound) return MaybeHandle<Map>();
new_map = new_map->GetTransition(j);
DescriptorArray* new_descriptors = new_map->instance_descriptors();
PropertyDetails new_details = new_descriptors->GetDetails(i);
- PropertyDetails old_details = old_descriptors->GetDetails(i);
if (old_details.attributes() != new_details.attributes() ||
!old_details.representation().fits_into(new_details.representation())) {
return MaybeHandle<Map>();
}
if (data_store_mode == SUPER_PROPERTY) {
- if (strict_mode == STRICT) {
- Handle<Object> args[1] = {it->name()};
- THROW_NEW_ERROR(it->isolate(),
- NewReferenceError("not_defined", HandleVector(args, 1)),
- Object);
- }
- return value;
+ LookupIterator own_lookup(it->GetReceiver(), it->name(),
+ LookupIterator::OWN);
+
+ return JSObject::SetProperty(&own_lookup, value, strict_mode, store_mode,
+ NORMAL_PROPERTY);
}
return AddDataProperty(it, value, NONE, strict_mode, store_mode);
}
-Handle<Object> Object::SetDataProperty(LookupIterator* it,
- Handle<Object> value) {
+MaybeHandle<Object> Object::WriteToReadOnlyElement(Isolate* isolate,
+ Handle<Object> receiver,
+ uint32_t index,
+ Handle<Object> value,
+ StrictMode strict_mode) {
+ if (strict_mode != STRICT) return value;
+
+ Handle<Object> args[] = {isolate->factory()->NewNumberFromUint(index),
+ receiver};
+ THROW_NEW_ERROR(isolate, NewTypeError("strict_read_only_property",
+ HandleVector(args, arraysize(args))),
+ Object);
+}
+
+
+MaybeHandle<Object> Object::SetDataProperty(LookupIterator* it,
+ Handle<Object> value) {
// Proxies are handled on the WithHandler path. Other non-JSObjects cannot
// have own properties.
Handle<JSObject> receiver = Handle<JSObject>::cast(it->GetReceiver());
// Send the change record if there are observers.
if (is_observed && !value->SameValue(*maybe_old.ToHandleChecked())) {
- JSObject::EnqueueChangeRecord(receiver, "update", it->name(),
- maybe_old.ToHandleChecked());
+ RETURN_ON_EXCEPTION(it->isolate(), JSObject::EnqueueChangeRecord(
+ receiver, "update", it->name(),
+ maybe_old.ToHandleChecked()),
+ Object);
}
return value;
// instead. If the prototype is Null, the proxy is detached.
if (receiver->IsJSGlobalProxy()) return value;
+ // If the receiver is Indexed Exotic object (currently only typed arrays),
+ // disallow adding properties with numeric names.
+ if (it->IsSpecialNumericIndex()) return value;
+
// Possibly migrate to the most up-to-date map that will be able to store
// |value| under it->name() with |attributes|.
it->PrepareTransitionToDataProperty(value, attributes, store_mode);
// Send the change record if there are observers.
if (receiver->map()->is_observed() &&
!it->name().is_identical_to(it->factory()->hidden_string())) {
- JSObject::EnqueueChangeRecord(receiver, "add", it->name(),
- it->factory()->the_hole_value());
+ RETURN_ON_EXCEPTION(it->isolate(), JSObject::EnqueueChangeRecord(
+ receiver, "add", it->name(),
+ it->factory()->the_hole_value()),
+ Object);
}
return value;
}
-void JSObject::MigrateToNewProperty(Handle<JSObject> object,
- Handle<Map> map,
- Handle<Object> value) {
- JSObject::MigrateToMap(object, map);
- if (map->GetLastDescriptorDetails().type() != FIELD) return;
- object->WriteToField(map->LastAdded(), *value);
-}
-
-
void JSObject::WriteToField(int descriptor, Object* value) {
DisallowHeapAllocation no_gc;
!Name::Equals(it.isolate()->factory()->prototype_string(),
name) ||
!Handle<JSFunction>::cast(object)->should_have_prototype()) {
- EnqueueChangeRecord(object, "update", name, old_value);
+ RETURN_ON_EXCEPTION(
+ it.isolate(),
+ EnqueueChangeRecord(object, "update", name, old_value),
+ Object);
}
}
return value;
if (old_value->SameValue(*value)) {
old_value = it.isolate()->factory()->the_hole_value();
}
- EnqueueChangeRecord(object, "reconfigure", name, old_value);
+ RETURN_ON_EXCEPTION(
+ it.isolate(),
+ EnqueueChangeRecord(object, "reconfigure", name, old_value),
+ Object);
}
return value;
}
if (old_value->SameValue(*value)) {
old_value = it.isolate()->factory()->the_hole_value();
}
- EnqueueChangeRecord(object, "reconfigure", name, old_value);
+ RETURN_ON_EXCEPTION(
+ it.isolate(),
+ EnqueueChangeRecord(object, "reconfigure", name, old_value),
+ Object);
}
return value;
if (old_value->SameValue(*value)) {
old_value = it.isolate()->factory()->the_hole_value();
}
- EnqueueChangeRecord(object, "reconfigure", name, old_value);
+ RETURN_ON_EXCEPTION(
+ it.isolate(),
+ EnqueueChangeRecord(object, "reconfigure", name, old_value),
+ Object);
}
return value;
// callbacks or interceptor calls.
AssertNoContextChange ncc(isolate);
+ Maybe<PropertyAttributes> from_interceptor =
+ GetElementAttributeFromInterceptor(object, receiver, index);
+ if (!from_interceptor.has_value) return Maybe<PropertyAttributes>();
+ if (from_interceptor.value != ABSENT) return maybe(from_interceptor.value);
+
+ return GetElementAttributeWithoutInterceptor(object, receiver, index,
+ check_prototype);
+}
+
+
+Maybe<PropertyAttributes> JSObject::GetElementAttributeFromInterceptor(
+ Handle<JSObject> object, Handle<Object> receiver, uint32_t index) {
+ Isolate* isolate = object->GetIsolate();
+ AssertNoContextChange ncc(isolate);
+
Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor());
PropertyCallbackArguments args(
isolate, interceptor->data(), *receiver, *object);
v8::Handle<v8::Value> result = args.Call(getter, index);
if (!result.IsEmpty()) return maybe(NONE);
}
-
- return GetElementAttributeWithoutInterceptor(
- object, receiver, index, check_prototype);
+ RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate, Maybe<PropertyAttributes>());
+ return maybe(ABSENT);
}
int number_of_elements = dictionary->NumberOfElements();
if (number_of_elements > kMaxNumberOfDescriptors) return;
+ Handle<FixedArray> iteration_order;
if (number_of_elements != dictionary->NextEnumerationIndex()) {
- NameDictionary::DoGenerateNewEnumerationIndices(dictionary);
+ iteration_order =
+ NameDictionary::DoGenerateNewEnumerationIndices(dictionary);
+ } else {
+ iteration_order = NameDictionary::BuildIterationIndicesArray(dictionary);
}
- int instance_descriptor_length = 0;
+ int instance_descriptor_length = iteration_order->length();
int number_of_fields = 0;
// Compute the length of the instance descriptor.
- int capacity = dictionary->Capacity();
- for (int i = 0; i < capacity; i++) {
- Object* k = dictionary->KeyAt(i);
- if (dictionary->IsKey(k)) {
- Object* value = dictionary->ValueAt(i);
- PropertyType type = dictionary->DetailsAt(i).type();
- DCHECK(type != FIELD);
- instance_descriptor_length++;
- if (type == NORMAL && !value->IsJSFunction()) {
- number_of_fields += 1;
- }
+ for (int i = 0; i < instance_descriptor_length; i++) {
+ int index = Smi::cast(iteration_order->get(i))->value();
+ DCHECK(dictionary->IsKey(dictionary->KeyAt(index)));
+
+ Object* value = dictionary->ValueAt(index);
+ PropertyType type = dictionary->DetailsAt(index).type();
+ DCHECK(type != FIELD);
+ if (type == NORMAL && !value->IsJSFunction()) {
+ number_of_fields += 1;
}
}
// Fill in the instance descriptor and the fields.
int current_offset = 0;
- for (int i = 0; i < capacity; i++) {
- Object* k = dictionary->KeyAt(i);
- if (dictionary->IsKey(k)) {
- Object* value = dictionary->ValueAt(i);
- Handle<Name> key;
- if (k->IsSymbol()) {
- key = handle(Symbol::cast(k));
- } else {
- // Ensure the key is a unique name before writing into the
- // instance descriptor.
- key = factory->InternalizeString(handle(String::cast(k)));
- }
+ for (int i = 0; i < instance_descriptor_length; i++) {
+ int index = Smi::cast(iteration_order->get(i))->value();
+ Object* k = dictionary->KeyAt(index);
+ DCHECK(dictionary->IsKey(k));
- PropertyDetails details = dictionary->DetailsAt(i);
- int enumeration_index = details.dictionary_index();
- PropertyType type = details.type();
-
- if (value->IsJSFunction()) {
- ConstantDescriptor d(key,
- handle(value, isolate),
- details.attributes());
- descriptors->Set(enumeration_index - 1, &d);
- } else if (type == NORMAL) {
- if (current_offset < inobject_props) {
- object->InObjectPropertyAtPut(current_offset,
- value,
- UPDATE_WRITE_BARRIER);
- } else {
- int offset = current_offset - inobject_props;
- fields->set(offset, value);
- }
- FieldDescriptor d(key,
- current_offset++,
- details.attributes(),
- // TODO(verwaest): value->OptimalRepresentation();
- Representation::Tagged());
- descriptors->Set(enumeration_index - 1, &d);
- } else if (type == CALLBACKS) {
- CallbacksDescriptor d(key,
- handle(value, isolate),
- details.attributes());
- descriptors->Set(enumeration_index - 1, &d);
+ Object* value = dictionary->ValueAt(index);
+ Handle<Name> key;
+ if (k->IsSymbol()) {
+ key = handle(Symbol::cast(k));
+ } else {
+ // Ensure the key is a unique name before writing into the
+ // instance descriptor.
+ key = factory->InternalizeString(handle(String::cast(k)));
+ }
+
+ PropertyDetails details = dictionary->DetailsAt(index);
+ int enumeration_index = details.dictionary_index();
+ PropertyType type = details.type();
+
+ if (value->IsJSFunction()) {
+ ConstantDescriptor d(key, handle(value, isolate), details.attributes());
+ descriptors->Set(enumeration_index - 1, &d);
+ } else if (type == NORMAL) {
+ if (current_offset < inobject_props) {
+ object->InObjectPropertyAtPut(current_offset, value,
+ UPDATE_WRITE_BARRIER);
} else {
- UNREACHABLE();
+ int offset = current_offset - inobject_props;
+ fields->set(offset, value);
}
+ FieldDescriptor d(key, current_offset++, details.attributes(),
+ // TODO(verwaest): value->OptimalRepresentation();
+ Representation::Tagged());
+ descriptors->Set(enumeration_index - 1, &d);
+ } else if (type == CALLBACKS) {
+ CallbacksDescriptor d(key, handle(value, isolate), details.attributes());
+ descriptors->Set(enumeration_index - 1, &d);
+ } else {
+ UNREACHABLE();
}
}
DCHECK(current_offset == number_of_fields);
if (!maybe.has_value) return MaybeHandle<Object>();
if (!maybe.value) {
Handle<String> name = factory->Uint32ToString(index);
- EnqueueChangeRecord(object, "delete", name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "delete", name, old_value),
+ Object);
}
}
ReoptimizeIfPrototype(holder);
if (is_observed) {
- EnqueueChangeRecord(object, "delete", name, old_value);
+ RETURN_ON_EXCEPTION(
+ it.isolate(),
+ EnqueueChangeRecord(object, "delete", name, old_value), Object);
}
return result;
DCHECK(!object->map()->is_extensible());
if (object->map()->is_observed()) {
- EnqueueChangeRecord(object, "preventExtensions", Handle<Name>(),
- isolate->factory()->the_hole_value());
+ RETURN_ON_EXCEPTION(
+ isolate,
+ EnqueueChangeRecord(object, "preventExtensions", Handle<Name>(),
+ isolate->factory()->the_hole_value()),
+ Object);
}
return object;
}
}
Handle<Map> old_map(object->map(), isolate);
- int transition_index = old_map->SearchTransition(
- isolate->heap()->frozen_symbol());
+ int transition_index =
+ old_map->SearchSpecialTransition(isolate->heap()->frozen_symbol());
if (transition_index != TransitionArray::kNotFound) {
Handle<Map> transition_map(old_map->GetTransition(transition_index));
DCHECK(transition_map->has_dictionary_elements());
Handle<Map> new_map;
Handle<Map> old_map(object->map(), isolate);
DCHECK(!old_map->is_observed());
- int transition_index = old_map->SearchTransition(
- isolate->heap()->observed_symbol());
+ int transition_index =
+ old_map->SearchSpecialTransition(isolate->heap()->observed_symbol());
if (transition_index != TransitionArray::kNotFound) {
new_map = handle(old_map->GetTransition(transition_index), isolate);
DCHECK(new_map->is_observed());
if (is_observed) {
const char* type = preexists ? "reconfigure" : "add";
- EnqueueChangeRecord(object, type, name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, type, name, old_value), Object);
}
return isolate->factory()->undefined_value();
if (old_size == 0) {
descriptors = DescriptorArray::Allocate(map->GetIsolate(), 0, 1);
} else {
- EnsureDescriptorSlack(map, old_size < 4 ? 1 : old_size / 2);
+ EnsureDescriptorSlack(
+ map, SlackForArraySize(old_size, kMaxNumberOfDescriptors));
descriptors = handle(map->instance_descriptors());
}
}
}
DCHECK(result->NumberOfOwnDescriptors() == map->NumberOfOwnDescriptors() + 1);
- ConnectTransition(map, result, name, SIMPLE_TRANSITION);
+ ConnectTransition(map, result, name, SIMPLE_PROPERTY_TRANSITION);
return result;
}
DCHECK(child->is_prototype_map());
} else {
Handle<TransitionArray> transitions =
- TransitionArray::CopyInsert(parent, name, child, flag);
- parent->set_transitions(*transitions);
+ TransitionArray::Insert(parent, name, child, flag);
+ if (!parent->HasTransitionArray() ||
+ *transitions != parent->transitions()) {
+ parent->set_transitions(*transitions);
+ }
child->SetBackPointer(*parent);
}
}
result->set_unused_property_fields(unused_property_fields);
Handle<Name> name = handle(descriptors->GetKey(new_descriptor));
- ConnectTransition(map, result, name, SIMPLE_TRANSITION);
+ ConnectTransition(map, result, name, SIMPLE_PROPERTY_TRANSITION);
return result;
}
DCHECK(kind != map->elements_kind());
}
- bool insert_transition =
- flag == INSERT_TRANSITION && !map->HasElementsTransition();
+ bool insert_transition = flag == INSERT_TRANSITION &&
+ map->CanHaveMoreTransitions() &&
+ !map->HasElementsTransition();
if (insert_transition && map->owns_descriptors()) {
// In case the map owned its own descriptors, share the descriptors and
new_map->InitializeDescriptors(map->instance_descriptors());
}
- Handle<Name> name = isolate->factory()->observed_symbol();
- ConnectTransition(map, new_map, name, FULL_TRANSITION);
-
+ if (map->CanHaveMoreTransitions()) {
+ Handle<Name> name = isolate->factory()->observed_symbol();
+ ConnectTransition(map, new_map, name, SPECIAL_TRANSITION);
+ }
return new_map;
}
int number_of_own_descriptors = map->NumberOfOwnDescriptors();
Handle<DescriptorArray> new_descriptors =
DescriptorArray::CopyUpTo(descriptors, number_of_own_descriptors);
- return CopyReplaceDescriptors(
- map, new_descriptors, OMIT_TRANSITION, MaybeHandle<Name>());
+ return CopyReplaceDescriptors(map, new_descriptors, OMIT_TRANSITION,
+ MaybeHandle<Name>(), SPECIAL_TRANSITION);
}
Handle<DescriptorArray> new_desc = DescriptorArray::CopyUpToAddAttributes(
handle(map->instance_descriptors(), isolate), num_descriptors, FROZEN);
Handle<Map> new_map = CopyReplaceDescriptors(
- map, new_desc, INSERT_TRANSITION, isolate->factory()->frozen_symbol());
+ map, new_desc, INSERT_TRANSITION, isolate->factory()->frozen_symbol(),
+ SPECIAL_TRANSITION);
new_map->freeze();
new_map->set_is_extensible(false);
new_map->set_elements_kind(DICTIONARY_ELEMENTS);
// Migrate to the newest map before storing the property.
map = Update(map);
- int index = map->SearchTransition(*name);
+ int index = map->SearchTransition(FIELD, *name, attributes);
if (index != TransitionArray::kNotFound) {
Handle<Map> transition(map->GetTransition(index));
int descriptor = transition->LastAdded();
- // TODO(verwaest): Handle attributes better.
- DescriptorArray* descriptors = transition->instance_descriptors();
- if (descriptors->GetDetails(descriptor).attributes() != attributes) {
- return Map::Normalize(map, CLEAR_INOBJECT_PROPERTIES);
- }
+ DCHECK_EQ(attributes, transition->instance_descriptors()
+ ->GetDetails(descriptor)
+ .attributes());
return Map::PrepareForDataProperty(transition, descriptor, value);
}
? KEEP_INOBJECT_PROPERTIES
: CLEAR_INOBJECT_PROPERTIES;
- int index = map->SearchTransition(*name);
+ int index = map->SearchTransition(CALLBACKS, *name, attributes);
if (index != TransitionArray::kNotFound) {
Handle<Map> transition(map->GetTransition(index));
DescriptorArray* descriptors = transition->instance_descriptors();
- // Fast path, assume that we're modifying the last added descriptor.
int descriptor = transition->LastAdded();
- if (descriptors->GetKey(descriptor) != *name) {
- // If not, search for the descriptor.
- descriptor = descriptors->SearchWithCache(*name, *transition);
- }
-
- if (descriptors->GetDetails(descriptor).type() != CALLBACKS) {
- return Map::Normalize(map, mode);
- }
+ DCHECK(descriptors->GetKey(descriptor)->Equals(*name));
- // TODO(verwaest): Handle attributes better.
- if (descriptors->GetDetails(descriptor).attributes() != attributes) {
- return Map::Normalize(map, mode);
- }
+ DCHECK_EQ(CALLBACKS, descriptors->GetDetails(descriptor).type());
+ DCHECK_EQ(attributes, descriptors->GetDetails(descriptor).attributes());
Handle<Object> maybe_pair(descriptors->GetValue(descriptor), isolate);
if (!maybe_pair->IsAccessorPair()) {
DescriptorArray* old_descriptors = map->instance_descriptors();
int descriptor = old_descriptors->SearchWithCache(*name, *map);
if (descriptor != DescriptorArray::kNotFound) {
+ if (descriptor != map->LastAdded()) {
+ return Map::Normalize(map, mode);
+ }
PropertyDetails old_details = old_descriptors->GetDetails(descriptor);
if (old_details.type() != CALLBACKS) {
return Map::Normalize(map, mode);
descriptors, map->NumberOfOwnDescriptors(), 1);
new_descriptors->Append(descriptor);
- return CopyReplaceDescriptors(
- map, new_descriptors, flag, descriptor->GetKey(), SIMPLE_TRANSITION);
+ return CopyReplaceDescriptors(map, new_descriptors, flag,
+ descriptor->GetKey(),
+ SIMPLE_PROPERTY_TRANSITION);
}
SimpleTransitionFlag simple_flag =
(insertion_index == descriptors->number_of_descriptors() - 1)
- ? SIMPLE_TRANSITION
- : FULL_TRANSITION;
+ ? SIMPLE_PROPERTY_TRANSITION
+ : PROPERTY_TRANSITION;
return CopyReplaceDescriptors(map, new_descriptors, flag, key, simple_flag);
}
int value = Smi::cast(*IteratorField())->value();
int index = -value - 1;
int number_of_transitions = transition_array_->number_of_transitions();
- while (index < number_of_transitions) {
+ if (index < number_of_transitions) {
*IteratorField() = Smi::FromInt(value - 1);
return transition_array_->GetTarget(index);
}
if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
return SmartArrayPointer<char>(NULL);
}
- Heap* heap = GetHeap();
-
// Negative length means the to the end of the string.
if (length < 0) length = kMaxInt - offset;
// Compute the size of the UTF-8 string. Start at the specified offset.
- Access<ConsStringIteratorOp> op(
- heap->isolate()->objects_string_iterator());
- StringCharacterStream stream(this, op.value(), offset);
+ StringCharacterStream stream(this, offset);
int character_position = offset;
int utf8_bytes = 0;
int last = unibrow::Utf16::kNoPreviousCharacter;
if (robust_flag == ROBUST_STRING_TRAVERSAL && !LooksValid()) {
return SmartArrayPointer<uc16>();
}
- Heap* heap = GetHeap();
-
- Access<ConsStringIteratorOp> op(
- heap->isolate()->objects_string_iterator());
- StringCharacterStream stream(this, op.value());
+ StringCharacterStream stream(this);
uc16* result = NewArray<uc16>(length() + 1);
}
-void ConsStringIteratorOp::Initialize(ConsString* cons_string, int offset) {
+void ConsStringIterator::Initialize(ConsString* cons_string, int offset) {
DCHECK(cons_string != NULL);
root_ = cons_string;
consumed_ = offset;
}
-String* ConsStringIteratorOp::Continue(int* offset_out) {
+String* ConsStringIterator::Continue(int* offset_out) {
DCHECK(depth_ != 0);
DCHECK_EQ(0, *offset_out);
bool blew_stack = StackBlown();
}
-String* ConsStringIteratorOp::Search(int* offset_out) {
+String* ConsStringIterator::Search(int* offset_out) {
ConsString* cons_string = root_;
// Reset the stack, pushing the root string.
depth_ = 1;
}
-String* ConsStringIteratorOp::NextLeaf(bool* blew_stack) {
+String* ConsStringIterator::NextLeaf(bool* blew_stack) {
while (true) {
// Tree traversal complete.
if (depth_ == 0) {
class StringComparator {
class State {
public:
- explicit inline State(ConsStringIteratorOp* op)
- : op_(op), is_one_byte_(true), length_(0), buffer8_(NULL) {}
+ State() : is_one_byte_(true), length_(0), buffer8_(NULL) {}
- inline void Init(String* string) {
+ void Init(String* string) {
ConsString* cons_string = String::VisitFlat(this, string);
- op_->Reset(cons_string);
+ iter_.Reset(cons_string);
if (cons_string != NULL) {
int offset;
- string = op_->Next(&offset);
+ string = iter_.Next(&offset);
String::VisitFlat(this, string, offset);
}
}
}
// Advance state.
int offset;
- String* next = op_->Next(&offset);
+ String* next = iter_.Next(&offset);
DCHECK_EQ(0, offset);
DCHECK(next != NULL);
String::VisitFlat(this, next);
}
- ConsStringIteratorOp* const op_;
+ ConsStringIterator iter_;
bool is_one_byte_;
int length_;
union {
};
private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(State);
+ DISALLOW_COPY_AND_ASSIGN(State);
};
public:
- inline StringComparator(ConsStringIteratorOp* op_1,
- ConsStringIteratorOp* op_2)
- : state_1_(op_1),
- state_2_(op_2) {
- }
+ inline StringComparator() {}
template<typename Chars1, typename Chars2>
static inline bool Equals(State* state_1, State* state_2, int to_check) {
private:
State state_1_;
State state_2_;
- DISALLOW_IMPLICIT_CONSTRUCTORS(StringComparator);
+
+ DISALLOW_COPY_AND_ASSIGN(StringComparator);
};
return CompareRawStringContents(str1, str2, len);
}
- Isolate* isolate = GetIsolate();
- StringComparator comparator(isolate->objects_string_compare_iterator_a(),
- isolate->objects_string_compare_iterator_b());
-
+ StringComparator comparator;
return comparator.Equals(this, other);
}
bool String::ComputeArrayIndex(uint32_t* index) {
int length = this->length();
if (length == 0 || length > kMaxArrayIndexSize) return false;
- ConsStringIteratorOp op;
- StringCharacterStream stream(this, &op);
+ StringCharacterStream stream(this);
return StringToArrayIndex(&stream, index);
}
}
-// Wrappers for scripts are kept alive and cached in weak global
-// handles referred from foreign objects held by the scripts as long as
-// they are used. When they are not used anymore, the garbage
-// collector will call the weak callback on the global handle
-// associated with the wrapper and get rid of both the wrapper and the
-// handle.
-static void ClearWrapperCacheWeakCallback(
- const v8::WeakCallbackData<v8::Value, void>& data) {
- Object** location = reinterpret_cast<Object**>(data.GetParameter());
- JSValue* wrapper = JSValue::cast(*location);
- Script::cast(wrapper->value())->ClearWrapperCache();
-}
-
-
-void Script::ClearWrapperCache() {
- Foreign* foreign = wrapper();
- Object** location = reinterpret_cast<Object**>(foreign->foreign_address());
- DCHECK_EQ(foreign->foreign_address(), reinterpret_cast<Address>(location));
- foreign->set_foreign_address(0);
- GlobalHandles::Destroy(location);
- GetIsolate()->counters()->script_wrappers()->Decrement();
-}
-
-
Handle<JSObject> Script::GetWrapper(Handle<Script> script) {
- if (script->wrapper()->foreign_address() != NULL) {
- // Return a handle for the existing script wrapper from the cache.
- return Handle<JSValue>(
- *reinterpret_cast<JSValue**>(script->wrapper()->foreign_address()));
- }
Isolate* isolate = script->GetIsolate();
+ if (!script->wrapper()->IsUndefined()) {
+ Handle<WeakCell> cell(WeakCell::cast(script->wrapper()));
+ if (!cell->cleared()) {
+ // Return a handle for the existing script wrapper from the cache.
+ return handle(JSObject::cast(cell->value()));
+ }
+ // If we found an empty WeakCell, that means the script wrapper was
+ // GCed. We are not notified directly of that, so we decrement here
+ // so that we at least don't count double for any given script.
+ isolate->counters()->script_wrappers()->Decrement();
+ }
// Construct a new script wrapper.
isolate->counters()->script_wrappers()->Increment();
Handle<JSFunction> constructor = isolate->script_function();
Handle<JSValue> result =
Handle<JSValue>::cast(isolate->factory()->NewJSObject(constructor));
-
result->set_value(*script);
-
- // Create a new weak global handle and use it to cache the wrapper
- // for future use. The cache will automatically be cleared by the
- // garbage collector when it is not used anymore.
- Handle<Object> handle = isolate->global_handles()->Create(*result);
- GlobalHandles::MakeWeak(handle.location(),
- reinterpret_cast<void*>(handle.location()),
- &ClearWrapperCacheWeakCallback);
- script->wrapper()->set_foreign_address(
- reinterpret_cast<Address>(handle.location()));
+ Handle<WeakCell> cell = isolate->factory()->NewWeakCell(result);
+ script->set_wrapper(*cell);
return result;
}
// Output the source code without any allocation in the heap.
-OStream& operator<<(OStream& os, const SourceCodeOf& v) {
+std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v) {
const SharedFunctionInfo* s = v.value;
// For some native functions there is no source.
if (!s->HasSourceCode()) return os << "<No Source>";
void SharedFunctionInfo::ClearTypeFeedbackInfo() {
- TypeFeedbackVector* vector = feedback_vector();
- Heap* heap = GetHeap();
- int length = vector->length();
-
- for (int i = 0; i < length; i++) {
- Object* obj = vector->get(i);
- if (obj->IsHeapObject()) {
- InstanceType instance_type =
- HeapObject::cast(obj)->map()->instance_type();
- switch (instance_type) {
- case ALLOCATION_SITE_TYPE:
- // AllocationSites are not cleared because they do not store
- // information that leaks.
- break;
- // Fall through...
- default:
- vector->set(i, TypeFeedbackVector::RawUninitializedSentinel(heap),
- SKIP_WRITE_BARRIER);
- }
- }
- }
+ feedback_vector()->ClearSlots(this);
}
}
+void Code::MakeYoung() {
+ byte* sequence = FindCodeAgeSequence();
+ if (sequence != NULL) MakeCodeAgeSequenceYoung(sequence, GetIsolate());
+}
+
+
void Code::MakeOlder(MarkingParity current_parity) {
byte* sequence = FindCodeAgeSequence();
if (sequence != NULL) {
#ifdef ENABLE_DISASSEMBLER
void DeoptimizationInputData::DeoptimizationInputDataPrint(
- OStream& os) { // NOLINT
+ std::ostream& os) { // NOLINT
disasm::NameConverter converter;
int deopt_count = DeoptCount();
os << "Deoptimization Input Data (deopt points = " << deopt_count << ")\n";
void DeoptimizationOutputData::DeoptimizationOutputDataPrint(
- OStream& os) { // NOLINT
+ std::ostream& os) { // NOLINT
os << "Deoptimization Output Data (deopt points = " << this->DeoptPoints()
<< ")\n";
if (this->DeoptPoints() == 0) return;
}
-void Code::PrintExtraICState(OStream& os, // NOLINT
+void Code::PrintExtraICState(std::ostream& os, // NOLINT
Kind kind, ExtraICState extra) {
os << "extra_ic_state = ";
if ((kind == STORE_IC || kind == KEYED_STORE_IC) && (extra == STRICT)) {
}
-void Code::Disassemble(const char* name, OStream& os) { // NOLINT
+void Code::Disassemble(const char* name, std::ostream& os) { // NOLINT
os << "kind = " << Kind2String(kind()) << "\n";
if (IsCodeStubOrIC()) {
const char* n = CodeStub::MajorName(CodeStub::GetMajorKey(this), true);
os << "Safepoints (size = " << table.size() << ")\n";
for (unsigned i = 0; i < table.length(); i++) {
unsigned pc_offset = table.GetPcOffset(i);
- os << (instruction_start() + pc_offset) << " ";
+ os << static_cast<const void*>(instruction_start() + pc_offset) << " ";
// TODO(svenpanne) Add some basic formatting to our streams.
Vector<char> buf1 = Vector<char>::New(30);
SNPrintF(buf1, "%4d", pc_offset);
it.rinfo()->Print(GetIsolate(), os);
}
os << "\n";
+
+#ifdef OBJECT_PRINT
+ if (FLAG_enable_ool_constant_pool) {
+ ConstantPoolArray* pool = constant_pool();
+ if (pool->length()) {
+ os << "Constant Pool\n";
+ pool->Print(os);
+ os << "\n";
+ }
+ }
+#endif
}
#endif // ENABLE_DISASSEMBLER
return true;
}
-static void EnqueueSpliceRecord(Handle<JSArray> object,
- uint32_t index,
- Handle<JSArray> deleted,
- uint32_t add_count) {
+MUST_USE_RESULT static MaybeHandle<Object> EnqueueSpliceRecord(
+ Handle<JSArray> object, uint32_t index, Handle<JSArray> deleted,
+ uint32_t add_count) {
Isolate* isolate = object->GetIsolate();
HandleScope scope(isolate);
Handle<Object> index_object = isolate->factory()->NewNumberFromUint(index);
Handle<Object> args[] =
{ object, index_object, deleted, add_count_object };
- Execution::Call(isolate,
- Handle<JSFunction>(isolate->observers_enqueue_splice()),
- isolate->factory()->undefined_value(),
- arraysize(args),
- args).Assert();
+ return Execution::Call(
+ isolate, Handle<JSFunction>(isolate->observers_enqueue_splice()),
+ isolate->factory()->undefined_value(), arraysize(args), args);
}
-static void BeginPerformSplice(Handle<JSArray> object) {
+MUST_USE_RESULT static MaybeHandle<Object> BeginPerformSplice(
+ Handle<JSArray> object) {
Isolate* isolate = object->GetIsolate();
HandleScope scope(isolate);
Handle<Object> args[] = { object };
- Execution::Call(isolate,
- Handle<JSFunction>(isolate->observers_begin_perform_splice()),
- isolate->factory()->undefined_value(),
- arraysize(args),
- args).Assert();
+ return Execution::Call(
+ isolate, Handle<JSFunction>(isolate->observers_begin_perform_splice()),
+ isolate->factory()->undefined_value(), arraysize(args), args);
}
-static void EndPerformSplice(Handle<JSArray> object) {
+MUST_USE_RESULT static MaybeHandle<Object> EndPerformSplice(
+ Handle<JSArray> object) {
Isolate* isolate = object->GetIsolate();
HandleScope scope(isolate);
Handle<Object> args[] = { object };
- Execution::Call(isolate,
- Handle<JSFunction>(isolate->observers_end_perform_splice()),
- isolate->factory()->undefined_value(),
- arraysize(args),
- args).Assert();
+ return Execution::Call(
+ isolate, Handle<JSFunction>(isolate->observers_end_perform_splice()),
+ isolate->factory()->undefined_value(), arraysize(args), args);
}
CHECK(array->length()->ToArrayIndex(&new_length));
if (old_length == new_length) return hresult;
- BeginPerformSplice(array);
+ RETURN_ON_EXCEPTION(isolate, BeginPerformSplice(array), Object);
for (int i = 0; i < indices.length(); ++i) {
// For deletions where the property was an accessor, old_values[i]
// will be the hole, which instructs EnqueueChangeRecord to elide
// the "oldValue" property.
- JSObject::EnqueueChangeRecord(
- array, "delete", isolate->factory()->Uint32ToString(indices[i]),
- old_values[i]);
+ RETURN_ON_EXCEPTION(
+ isolate,
+ JSObject::EnqueueChangeRecord(
+ array, "delete", isolate->factory()->Uint32ToString(indices[i]),
+ old_values[i]),
+ Object);
}
- JSObject::EnqueueChangeRecord(
- array, "update", isolate->factory()->length_string(),
- old_length_handle);
+ RETURN_ON_EXCEPTION(isolate,
+ JSObject::EnqueueChangeRecord(
+ array, "update", isolate->factory()->length_string(),
+ old_length_handle),
+ Object);
- EndPerformSplice(array);
+ RETURN_ON_EXCEPTION(isolate, EndPerformSplice(array), Object);
uint32_t index = Min(old_length, new_length);
uint32_t add_count = new_length > old_length ? new_length - old_length : 0;
STRICT).Assert();
}
- EnqueueSpliceRecord(array, index, deleted, add_count);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueSpliceRecord(array, index, deleted, add_count), Object);
return hresult;
}
DCHECK(new_map->prototype() == *value);
JSObject::MigrateToMap(real_receiver, new_map);
- if (!dictionary_elements_in_chain &&
+ if (from_javascript && !dictionary_elements_in_chain &&
new_map->DictionaryElementsInPrototypeChainOnly()) {
// If the prototype chain didn't previously have element callbacks, then
// KeyedStoreICs need to be cleared to ensure any that involve this
}
-MaybeHandle<Object> JSObject::SetElementWithCallback(Handle<JSObject> object,
- Handle<Object> structure,
- uint32_t index,
- Handle<Object> value,
- Handle<JSObject> holder,
- StrictMode strict_mode) {
- Isolate* isolate = object->GetIsolate();
+MaybeHandle<Object> JSObject::SetElementWithCallback(
+ Handle<Object> object, Handle<Object> structure, uint32_t index,
+ Handle<Object> value, Handle<JSObject> holder, StrictMode strict_mode) {
+ Isolate* isolate = holder->GetIsolate();
// We should never get here to initialize a const with the hole
// value since a const declaration would conflict with the setter.
if (call_fun == NULL) return value;
Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
Handle<String> key(isolate->factory()->NumberToString(number));
- LOG(isolate, ApiNamedPropertyAccess("store", *object, *key));
+ LOG(isolate, ApiNamedPropertyAccess("store", *holder, *key));
PropertyCallbackArguments
args(isolate, data->data(), *object, *holder);
args.Call(call_fun,
CHECK(old_length_handle->ToArrayIndex(&old_length));
CHECK(new_length_handle->ToArrayIndex(&new_length));
- BeginPerformSplice(Handle<JSArray>::cast(object));
- EnqueueChangeRecord(object, "add", name, old_value);
- EnqueueChangeRecord(object, "update", isolate->factory()->length_string(),
- old_length_handle);
- EndPerformSplice(Handle<JSArray>::cast(object));
+ RETURN_ON_EXCEPTION(
+ isolate, BeginPerformSplice(Handle<JSArray>::cast(object)), Object);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "add", name, old_value), Object);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "update",
+ isolate->factory()->length_string(),
+ old_length_handle),
+ Object);
+ RETURN_ON_EXCEPTION(
+ isolate, EndPerformSplice(Handle<JSArray>::cast(object)), Object);
Handle<JSArray> deleted = isolate->factory()->NewJSArray(0);
- EnqueueSpliceRecord(Handle<JSArray>::cast(object), old_length, deleted,
- new_length - old_length);
+ RETURN_ON_EXCEPTION(
+ isolate,
+ EnqueueSpliceRecord(Handle<JSArray>::cast(object), old_length,
+ deleted, new_length - old_length),
+ Object);
} else {
- EnqueueChangeRecord(object, "add", name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "add", name, old_value), Object);
}
} else if (old_value->IsTheHole()) {
- EnqueueChangeRecord(object, "reconfigure", name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "reconfigure", name, old_value),
+ Object);
} else {
Handle<Object> new_value =
Object::GetElement(isolate, object, index).ToHandleChecked();
bool value_changed = !old_value->SameValue(*new_value);
if (old_attributes != new_attributes) {
if (!value_changed) old_value = isolate->factory()->the_hole_value();
- EnqueueChangeRecord(object, "reconfigure", name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "reconfigure", name, old_value),
+ Object);
} else if (value_changed) {
- EnqueueChangeRecord(object, "update", name, old_value);
+ RETURN_ON_EXCEPTION(
+ isolate, EnqueueChangeRecord(object, "update", name, old_value),
+ Object);
}
}
// we keep it here instead to satisfy certain compilers.
#ifdef OBJECT_PRINT
template <typename Derived, typename Shape, typename Key>
-void Dictionary<Derived, Shape, Key>::Print(OStream& os) { // NOLINT
+void Dictionary<Derived, Shape, Key>::Print(std::ostream& os) { // NOLINT
int capacity = DerivedHashTable::Capacity();
for (int i = 0; i < capacity; i++) {
Object* k = DerivedHashTable::KeyAt(i);
} else {
os << Brief(k);
}
- os << ": " << Brief(ValueAt(i)) << "\n";
+ os << ": " << Brief(ValueAt(i)) << " " << DetailsAt(i) << "\n";
}
}
}
}
+const char* Symbol::PrivateSymbolToName() const {
+ Heap* heap = GetIsolate()->heap();
+#define SYMBOL_CHECK_AND_PRINT(name) \
+ if (this == heap->name()) return #name;
+ PRIVATE_SYMBOL_LIST(SYMBOL_CHECK_AND_PRINT)
+#undef SYMBOL_CHECK_AND_PRINT
+ return "UNKNOWN";
+}
+
+
+void Symbol::SymbolShortPrint(std::ostream& os) {
+ os << "<Symbol: " << Hash();
+ if (!name()->IsUndefined()) {
+ os << " ";
+ HeapStringAllocator allocator;
+ StringStream accumulator(&allocator);
+ String::cast(name())->StringShortPrint(&accumulator);
+ os << accumulator.ToCString().get();
+ } else {
+ os << " (" << PrivateSymbolToName() << ")";
+ }
+ os << ">";
+}
+
+
// StringSharedKeys are used as keys in the eval cache.
class StringSharedKey : public HashTableKey {
public:
bool IsMatch(Object* other) OVERRIDE {
DisallowHeapAllocation no_allocation;
- if (!other->IsFixedArray()) return false;
+ if (!other->IsFixedArray()) {
+ if (!other->IsNumber()) return false;
+ uint32_t other_hash = static_cast<uint32_t>(other->Number());
+ return Hash() == other_hash;
+ }
FixedArray* other_array = FixedArray::cast(other);
SharedFunctionInfo* shared = SharedFunctionInfo::cast(other_array->get(0));
if (shared != *shared_) return false;
uint32_t HashForObject(Object* obj) OVERRIDE {
DisallowHeapAllocation no_allocation;
+ if (obj->IsNumber()) {
+ return static_cast<uint32_t>(obj->Number());
+ }
FixedArray* other_array = FixedArray::cast(obj);
SharedFunctionInfo* shared = SharedFunctionInfo::cast(other_array->get(0));
String* source = String::cast(other_array->get(1));
Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::Add(
Handle<NameDictionary>, Handle<Name>, Handle<Object>, PropertyDetails);
-template void
-Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
- GenerateNewEnumerationIndices(Handle<NameDictionary>);
+template Handle<FixedArray> Dictionary<
+ NameDictionary, NameDictionaryShape,
+ Handle<Name> >::BuildIterationIndicesArray(Handle<NameDictionary>);
+
+template Handle<FixedArray> Dictionary<
+ NameDictionary, NameDictionaryShape,
+ Handle<Name> >::GenerateNewEnumerationIndices(Handle<NameDictionary>);
template int
Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
int Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
NumberOfEnumElements();
-template
-int HashTable<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
- FindEntry(uint32_t);
+template bool Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape,
+ uint32_t>::HasComplexElements();
+
+template int HashTable<SeededNumberDictionary, SeededNumberDictionaryShape,
+ uint32_t>::FindEntry(uint32_t);
Handle<Object> JSObject::PrepareSlowElementsForSort(
}
+void StringTable::EnsureCapacityForDeserialization(Isolate* isolate,
+ int expected) {
+ Handle<StringTable> table = isolate->factory()->string_table();
+ // We need a key instance for the virtual hash function.
+ InternalizedStringKey dummy_key(Handle<String>::null());
+ table = StringTable::EnsureCapacity(table, expected, &dummy_key);
+ isolate->factory()->set_string_table(table);
+}
+
+
Handle<String> StringTable::LookupString(Isolate* isolate,
Handle<String> string) {
InternalizedStringKey key(string);
RelocInfo::kNoPosition);
int entry = FindEntry(&key);
if (entry == kNotFound) return isolate->factory()->undefined_value();
- return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
+ int index = EntryToIndex(entry);
+ if (!get(index)->IsFixedArray()) return isolate->factory()->undefined_value();
+ return Handle<Object>(get(index + 1), isolate);
}
-Handle<Object> CompilationCacheTable::LookupEval(Handle<String> src,
- Handle<Context> context,
- StrictMode strict_mode,
- int scope_position) {
+Handle<Object> CompilationCacheTable::LookupEval(
+ Handle<String> src, Handle<SharedFunctionInfo> outer_info,
+ StrictMode strict_mode, int scope_position) {
Isolate* isolate = GetIsolate();
- Handle<SharedFunctionInfo> shared(context->closure()->shared());
- StringSharedKey key(src, shared, strict_mode, scope_position);
+ // Cache key is the tuple (source, outer shared function info, scope position)
+ // to unambiguously identify the context chain the cached eval code assumes.
+ StringSharedKey key(src, outer_info, strict_mode, scope_position);
int entry = FindEntry(&key);
if (entry == kNotFound) return isolate->factory()->undefined_value();
+ int index = EntryToIndex(entry);
+ if (!get(index)->IsFixedArray()) return isolate->factory()->undefined_value();
return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
}
Handle<SharedFunctionInfo> shared(context->closure()->shared());
StringSharedKey key(src, shared, FLAG_use_strict ? STRICT : SLOPPY,
RelocInfo::kNoPosition);
+ int entry = cache->FindEntry(&key);
+ if (entry != kNotFound) {
+ Handle<Object> k = key.AsHandle(isolate);
+ cache->set(EntryToIndex(entry), *k);
+ cache->set(EntryToIndex(entry) + 1, *value);
+ return cache;
+ }
+
cache = EnsureCapacity(cache, 1, &key);
- Handle<Object> k = key.AsHandle(isolate);
- int entry = cache->FindInsertionEntry(key.Hash());
+ entry = cache->FindInsertionEntry(key.Hash());
+ Handle<Object> k =
+ isolate->factory()->NewNumber(static_cast<double>(key.Hash()));
cache->set(EntryToIndex(entry), *k);
- cache->set(EntryToIndex(entry) + 1, *value);
+ cache->set(EntryToIndex(entry) + 1, Smi::FromInt(kHashGenerations));
cache->ElementAdded();
return cache;
}
Handle<CompilationCacheTable> CompilationCacheTable::PutEval(
Handle<CompilationCacheTable> cache, Handle<String> src,
- Handle<Context> context, Handle<SharedFunctionInfo> value,
+ Handle<SharedFunctionInfo> outer_info, Handle<SharedFunctionInfo> value,
int scope_position) {
Isolate* isolate = cache->GetIsolate();
- Handle<SharedFunctionInfo> shared(context->closure()->shared());
- StringSharedKey key(src, shared, value->strict_mode(), scope_position);
+ StringSharedKey key(src, outer_info, value->strict_mode(), scope_position);
+ int entry = cache->FindEntry(&key);
+ if (entry != kNotFound) {
+ Handle<Object> k = key.AsHandle(isolate);
+ cache->set(EntryToIndex(entry), *k);
+ cache->set(EntryToIndex(entry) + 1, *value);
+ return cache;
+ }
+
cache = EnsureCapacity(cache, 1, &key);
- Handle<Object> k = key.AsHandle(isolate);
- int entry = cache->FindInsertionEntry(key.Hash());
+ entry = cache->FindInsertionEntry(key.Hash());
+ Handle<Object> k =
+ isolate->factory()->NewNumber(static_cast<double>(key.Hash()));
cache->set(EntryToIndex(entry), *k);
- cache->set(EntryToIndex(entry) + 1, *value);
+ cache->set(EntryToIndex(entry) + 1, Smi::FromInt(kHashGenerations));
cache->ElementAdded();
return cache;
}
}
+void CompilationCacheTable::Age() {
+ DisallowHeapAllocation no_allocation;
+ Object* the_hole_value = GetHeap()->the_hole_value();
+ for (int entry = 0, size = Capacity(); entry < size; entry++) {
+ int entry_index = EntryToIndex(entry);
+ int value_index = entry_index + 1;
+
+ if (get(entry_index)->IsNumber()) {
+ Smi* count = Smi::cast(get(value_index));
+ count = Smi::FromInt(count->value() - 1);
+ if (count->value() == 0) {
+ NoWriteBarrierSet(this, entry_index, the_hole_value);
+ NoWriteBarrierSet(this, value_index, the_hole_value);
+ ElementRemoved();
+ } else {
+ NoWriteBarrierSet(this, value_index, count);
+ }
+ } else if (get(entry_index)->IsFixedArray()) {
+ SharedFunctionInfo* info = SharedFunctionInfo::cast(get(value_index));
+ if (info->code()->kind() != Code::FUNCTION || info->code()->IsOld()) {
+ NoWriteBarrierSet(this, entry_index, the_hole_value);
+ NoWriteBarrierSet(this, value_index, the_hole_value);
+ ElementRemoved();
+ }
+ }
+ }
+}
+
+
void CompilationCacheTable::Remove(Object* value) {
DisallowHeapAllocation no_allocation;
Object* the_hole_value = GetHeap()->the_hole_value();
}
-template<typename Derived, typename Shape, typename Key>
-void Dictionary<Derived, Shape, Key>::GenerateNewEnumerationIndices(
+template <typename Derived, typename Shape, typename Key>
+Handle<FixedArray> Dictionary<Derived, Shape, Key>::BuildIterationIndicesArray(
Handle<Derived> dictionary) {
Factory* factory = dictionary->GetIsolate()->factory();
int length = dictionary->NumberOfElements();
- // Allocate and initialize iteration order array.
Handle<FixedArray> iteration_order = factory->NewFixedArray(length);
- for (int i = 0; i < length; i++) {
- iteration_order->set(i, Smi::FromInt(i));
- }
-
- // Allocate array with enumeration order.
Handle<FixedArray> enumeration_order = factory->NewFixedArray(length);
- // Fill the enumeration order array with property details.
+ // Fill both the iteration order array and the enumeration order array
+ // with property details.
int capacity = dictionary->Capacity();
int pos = 0;
for (int i = 0; i < capacity; i++) {
if (dictionary->IsKey(dictionary->KeyAt(i))) {
int index = dictionary->DetailsAt(i).dictionary_index();
- enumeration_order->set(pos++, Smi::FromInt(index));
+ iteration_order->set(pos, Smi::FromInt(i));
+ enumeration_order->set(pos, Smi::FromInt(index));
+ pos++;
}
}
+ DCHECK(pos == length);
// Sort the arrays wrt. enumeration order.
iteration_order->SortPairs(*enumeration_order, enumeration_order->length());
+ return iteration_order;
+}
+
+
+template <typename Derived, typename Shape, typename Key>
+Handle<FixedArray>
+Dictionary<Derived, Shape, Key>::GenerateNewEnumerationIndices(
+ Handle<Derived> dictionary) {
+ int length = dictionary->NumberOfElements();
- // Overwrite the enumeration_order with the enumeration indices.
+ Handle<FixedArray> iteration_order = BuildIterationIndicesArray(dictionary);
+ DCHECK(iteration_order->length() == length);
+
+ // Iterate over the dictionary using the enumeration order and update
+ // the dictionary with new enumeration indices.
for (int i = 0; i < length; i++) {
int index = Smi::cast(iteration_order->get(i))->value();
+ DCHECK(dictionary->IsKey(dictionary->KeyAt(index)));
+
int enum_index = PropertyDetails::kInitialIndex + i;
- enumeration_order->set(index, Smi::FromInt(enum_index));
- }
- // Update the dictionary with new indices.
- capacity = dictionary->Capacity();
- pos = 0;
- for (int i = 0; i < capacity; i++) {
- if (dictionary->IsKey(dictionary->KeyAt(i))) {
- int enum_index = Smi::cast(enumeration_order->get(pos++))->value();
- PropertyDetails details = dictionary->DetailsAt(i);
- PropertyDetails new_details = PropertyDetails(
- details.attributes(), details.type(), enum_index);
- dictionary->DetailsAtPut(i, new_details);
- }
+ PropertyDetails details = dictionary->DetailsAt(index);
+ PropertyDetails new_details =
+ PropertyDetails(details.attributes(), details.type(), enum_index);
+ dictionary->DetailsAtPut(index, new_details);
}
// Set the next enumeration index.
dictionary->SetNextEnumerationIndex(PropertyDetails::kInitialIndex+length);
+ return iteration_order;
}
}
-template<typename Derived, typename Shape, typename Key>
+template <typename Derived, typename Shape, typename Key>
+bool Dictionary<Derived, Shape, Key>::HasComplexElements() {
+ int capacity = DerivedHashTable::Capacity();
+ for (int i = 0; i < capacity; i++) {
+ Object* k = DerivedHashTable::KeyAt(i);
+ if (DerivedHashTable::IsKey(k) && !FilterKey(k, NONE)) {
+ PropertyDetails details = DetailsAt(i);
+ if (details.IsDeleted()) continue;
+ if (details.type() == CALLBACKS) return true;
+ PropertyAttributes attr = details.attributes();
+ if (attr & (READ_ONLY | DONT_DELETE | DONT_ENUM)) return true;
+ }
+ }
+ return false;
+}
+
+
+template <typename Derived, typename Shape, typename Key>
void Dictionary<Derived, Shape, Key>::CopyKeysTo(
- FixedArray* storage,
- PropertyAttributes filter,
+ FixedArray* storage, PropertyAttributes filter,
typename Dictionary<Derived, Shape, Key>::SortMode sort_mode) {
DCHECK(storage->length() >= NumberOfElementsFilterAttributes(filter));
int capacity = DerivedHashTable::Capacity();
void JSArrayBuffer::Neuter() {
- DCHECK(is_external());
+ CHECK(is_neuterable());
+ CHECK(is_external());
set_backing_store(NULL);
set_byte_length(Smi::FromInt(0));
}
void JSArrayBufferView::NeuterView() {
+ CHECK(JSArrayBuffer::cast(buffer())->is_neuterable());
set_byte_offset(Smi::FromInt(0));
set_byte_length(Smi::FromInt(0));
}
#ifndef V8_OBJECTS_H_
#define V8_OBJECTS_H_
+#include <iosfwd>
+
#include "src/allocation.h"
#include "src/assert-scope.h"
#include "src/bailout-reason.h"
#include "src/property-details.h"
#include "src/smart-pointers.h"
#include "src/unicode-inl.h"
+#include "src/unicode-decoder.h"
#include "src/zone.h"
#if V8_TARGET_ARCH_ARM
// - DebugInfo
// - BreakPointInfo
// - CodeCache
+// - WeakCell
//
// Formats of Object*:
// Smi: [31 bit signed int] 0
namespace v8 {
namespace internal {
-class OStream;
-
enum KeyedAccessStoreMode {
STANDARD_STORE,
STORE_TRANSITION_SMI_TO_OBJECT,
}
+enum IcCheckType { ELEMENT, PROPERTY };
+
+
// Setter that skips the write barrier if mode is SKIP_WRITE_BARRIER.
enum WriteBarrierMode { SKIP_WRITE_BARRIER, UPDATE_WRITE_BARRIER };
// either extends the current map with a new property, or it modifies the
// property that was added last to the current map.
enum SimpleTransitionFlag {
- SIMPLE_TRANSITION,
- FULL_TRANSITION
+ SIMPLE_PROPERTY_TRANSITION,
+ PROPERTY_TRANSITION,
+ SPECIAL_TRANSITION
};
V(FIXED_DOUBLE_ARRAY_TYPE) \
V(CONSTANT_POOL_ARRAY_TYPE) \
V(SHARED_FUNCTION_INFO_TYPE) \
+ V(WEAK_CELL_TYPE) \
\
V(JS_MESSAGE_OBJECT_TYPE) \
\
FIXED_ARRAY_TYPE,
CONSTANT_POOL_ARRAY_TYPE,
SHARED_FUNCTION_INFO_TYPE,
+ WEAK_CELL_TYPE,
// All the following types are subtypes of JSReceiver, which corresponds to
// objects in the JS sense. The first and the last type in this range are
class LookupIterator;
class StringStream;
class TypeFeedbackVector;
+class WeakCell;
// We cannot just say "class HeapType;" if it is created from a template... =8-?
template<class> class TypeImpl;
struct HeapTypeConfig;
#endif
#ifdef OBJECT_PRINT
-#define DECLARE_PRINTER(Name) void Name##Print(OStream& os); // NOLINT
+#define DECLARE_PRINTER(Name) void Name##Print(std::ostream& os); // NOLINT
#else
#define DECLARE_PRINTER(Name)
#endif
V(AccessCheckNeeded) \
V(Cell) \
V(PropertyCell) \
+ V(WeakCell) \
V(ObjectHashTable) \
V(WeakHashTable) \
V(OrderedHashTable)
StorePropertyMode data_store_mode = NORMAL_PROPERTY);
MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyProperty(
LookupIterator* it, Handle<Object> value, StrictMode strict_mode);
- static Handle<Object> SetDataProperty(LookupIterator* it,
- Handle<Object> value);
+ MUST_USE_RESULT static MaybeHandle<Object> WriteToReadOnlyElement(
+ Isolate* isolate, Handle<Object> receiver, uint32_t index,
+ Handle<Object> value, StrictMode strict_mode);
+ MUST_USE_RESULT static MaybeHandle<Object> SetDataProperty(
+ LookupIterator* it, Handle<Object> value);
MUST_USE_RESULT static MaybeHandle<Object> AddDataProperty(
LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
StrictMode strict_mode, StoreFromKeyed store_mode);
Handle<Object> receiver,
uint32_t index);
+ MUST_USE_RESULT static MaybeHandle<Object> SetElementWithReceiver(
+ Isolate* isolate, Handle<Object> object, Handle<Object> receiver,
+ uint32_t index, Handle<Object> value, StrictMode strict_mode);
+
+ static inline Handle<Object> GetPrototypeSkipHiddenPrototypes(
+ Isolate* isolate, Handle<Object> receiver);
+
// Returns the permanent hash code associated with this object. May return
// undefined if not yet created.
Object* GetHash();
void Print();
// Prints this object with details.
- void Print(OStream& os); // NOLINT
+ void Print(std::ostream& os); // NOLINT
#endif
private:
};
-OStream& operator<<(OStream& os, const Brief& v);
+std::ostream& operator<<(std::ostream& os, const Brief& v);
// Smi represents integer Numbers that can be stored in 31 bits.
DECLARE_CAST(Smi)
// Dispatched behavior.
- void SmiPrint(OStream& os) const; // NOLINT
+ void SmiPrint(std::ostream& os) const; // NOLINT
DECLARE_VERIFIER(Smi)
static const int kMinValue =
const DisallowHeapAllocation& promise);
// Dispatched behavior.
- void HeapObjectShortPrint(OStream& os); // NOLINT
+ void HeapObjectShortPrint(std::ostream& os); // NOLINT
#ifdef OBJECT_PRINT
- void PrintHeader(OStream& os, const char* id); // NOLINT
+ void PrintHeader(std::ostream& os, const char* id); // NOLINT
#endif
DECLARE_PRINTER(HeapObject)
DECLARE_VERIFIER(HeapObject)
// Dispatched behavior.
bool HeapNumberBooleanValue();
- void HeapNumberPrint(OStream& os); // NOLINT
+ void HeapNumberPrint(std::ostream& os); // NOLINT
DECLARE_VERIFIER(HeapNumber)
inline int get_exponent();
MUST_USE_RESULT static inline Maybe<PropertyAttributes>
GetOwnElementAttribute(Handle<JSReceiver> object, uint32_t index);
- // Return the constructor function (may be Heap::null_value()).
- inline Object* GetConstructor();
-
// Retrieves a permanent object identity hash code. The undefined value might
// be returned in case no hash was created yet.
inline Object* GetIdentityHash();
Handle<Object> receiver,
Handle<Name> name);
- // Returns true if this is an instance of an api function and has
- // been modified since it was created. May give false positives.
- bool IsDirty();
-
// Accessors for hidden properties object.
//
// Hidden properties are not own properties of the object itself.
// These methods do not perform access checks!
MUST_USE_RESULT static MaybeHandle<AccessorPair> GetOwnElementAccessorPair(
- Handle<JSObject> object,
- uint32_t index);
+ Handle<JSObject> object, uint32_t index);
MUST_USE_RESULT static MaybeHandle<Object> SetFastElement(
Handle<JSObject> object,
DECLARE_PRINTER(JSObject)
DECLARE_VERIFIER(JSObject)
#ifdef OBJECT_PRINT
- void PrintProperties(OStream& os); // NOLINT
- void PrintElements(OStream& os); // NOLINT
- void PrintTransitions(OStream& os); // NOLINT
+ void PrintProperties(std::ostream& os); // NOLINT
+ void PrintElements(std::ostream& os); // NOLINT
+ void PrintTransitions(std::ostream& os); // NOLINT
#endif
static void PrintElementsTransition(
Context* GetCreationContext();
// Enqueue change record for Object.observe. May cause GC.
- static void EnqueueChangeRecord(Handle<JSObject> object,
- const char* type,
- Handle<Name> name,
- Handle<Object> old_value);
-
- static void MigrateToNewProperty(Handle<JSObject> object,
- Handle<Map> transition,
- Handle<Object> value);
+ MUST_USE_RESULT static MaybeHandle<Object> EnqueueChangeRecord(
+ Handle<JSObject> object, const char* type, Handle<Name> name,
+ Handle<Object> old_value);
private:
friend class DictionaryElementsAccessor;
Handle<Map> new_map,
int expected_additional_properties);
- static void GeneralizeFieldRepresentation(Handle<JSObject> object,
- int modify_index,
- Representation new_representation,
- Handle<HeapType> new_field_type);
-
static void UpdateAllocationSite(Handle<JSObject> object,
ElementsKind to_kind);
GetElementAttributeWithInterceptor(Handle<JSObject> object,
Handle<JSReceiver> receiver,
uint32_t index, bool continue_search);
+
+ // Queries indexed interceptor on an object for property attributes.
+ //
+ // We determine property attributes as follows:
+ // - if interceptor has a query callback, then the property attributes are
+ // the result of query callback for index.
+ // - otherwise if interceptor has a getter callback and it returns
+ // non-empty value on index, then the property attributes is NONE
+ // (property is present, and it is enumerable, configurable, writable)
+ // - otherwise there are no property attributes that can be inferred for
+ // interceptor, and this function returns ABSENT.
+ MUST_USE_RESULT static Maybe<PropertyAttributes>
+ GetElementAttributeFromInterceptor(Handle<JSObject> object,
+ Handle<Object> receiver,
+ uint32_t index);
+
MUST_USE_RESULT static Maybe<PropertyAttributes>
GetElementAttributeWithoutInterceptor(Handle<JSObject> object,
Handle<JSReceiver> receiver,
uint32_t index,
bool continue_search);
MUST_USE_RESULT static MaybeHandle<Object> SetElementWithCallback(
- Handle<JSObject> object,
- Handle<Object> structure,
- uint32_t index,
- Handle<Object> value,
- Handle<JSObject> holder,
- StrictMode strict_mode);
+ Handle<Object> object, Handle<Object> structure, uint32_t index,
+ Handle<Object> value, Handle<JSObject> holder, StrictMode strict_mode);
MUST_USE_RESULT static MaybeHandle<Object> SetElementWithInterceptor(
Handle<JSObject> object,
uint32_t index,
class FixedArray: public FixedArrayBase {
public:
// Setter and getter for elements.
- inline Object* get(int index);
+ inline Object* get(int index) const;
static inline Handle<Object> get(Handle<FixedArray> array, int index);
// Setter that uses write barrier.
inline void set(int index, Object* value);
// get_extended_section_header_offset().
static const int kExtendedInt64CountOffset = 0;
static const int kExtendedCodePtrCountOffset =
- kExtendedInt64CountOffset + kPointerSize;
+ kExtendedInt64CountOffset + kInt32Size;
static const int kExtendedHeapPtrCountOffset =
- kExtendedCodePtrCountOffset + kPointerSize;
+ kExtendedCodePtrCountOffset + kInt32Size;
static const int kExtendedInt32CountOffset =
- kExtendedHeapPtrCountOffset + kPointerSize;
+ kExtendedHeapPtrCountOffset + kInt32Size;
static const int kExtendedFirstOffset =
- kExtendedInt32CountOffset + kPointerSize;
+ kExtendedInt32CountOffset + kInt32Size;
// Dispatched behavior.
void ConstantPoolIterateBody(ObjectVisitor* v);
static const int kDescriptorSize = 3;
#ifdef OBJECT_PRINT
+ // For our gdb macros, we should perhaps change these in the future.
+ void Print();
+
// Print all the descriptors.
- void PrintDescriptors(OStream& os); // NOLINT
+ void PrintDescriptors(std::ostream& os); // NOLINT
#endif
#ifdef DEBUG
enum SearchMode { ALL_ENTRIES, VALID_ENTRIES };
-template<SearchMode search_mode, typename T>
-inline int LinearSearch(T* array, Name* name, int len, int valid_entries);
-
-
-template<SearchMode search_mode, typename T>
-inline int Search(T* array, Name* name, int valid_entries = 0);
+template <SearchMode search_mode, typename T>
+inline int Search(T* array, Name* name, int valid_entries = 0,
+ int* out_insertion_index = NULL);
// HashTable is a subclass of FixedArray that implements a hash table
uint16_t c1,
uint16_t c2);
+ static void EnsureCapacityForDeserialization(Isolate* isolate, int expected);
+
DECLARE_CAST(StringTable)
private:
// Returns the number of enumerable elements in the dictionary.
int NumberOfEnumElements();
+ // Returns true if the dictionary contains any elements that are non-writable,
+ // non-configurable, non-enumerable, or have getters/setters.
+ bool HasComplexElements();
+
enum SortMode { UNSORTED, SORTED };
// Copies keys to preallocated fixed array.
void CopyKeysTo(FixedArray* storage,
static Handle<Derived> EnsureCapacity(Handle<Derived> obj, int n, Key key);
#ifdef OBJECT_PRINT
- void Print(OStream& os); // NOLINT
+ void Print(std::ostream& os); // NOLINT
#endif
// Returns the key (slow).
Object* SlowReverseLookup(Object* value);
Handle<Object> value,
PropertyDetails details);
+ // Returns iteration indices array for the |dictionary|.
+ // Values are direct indices in the |HashTable| array.
+ static Handle<FixedArray> BuildIterationIndicesArray(
+ Handle<Derived> dictionary);
+
protected:
// Generic at put operation.
MUST_USE_RESULT static Handle<Derived> AtPut(
uint32_t hash);
// Generate new enumeration indices to avoid enumeration index overflow.
- static void GenerateNewEnumerationIndices(Handle<Derived> dictionary);
+ // Returns iteration indices array for the |dictionary|.
+ static Handle<FixedArray> GenerateNewEnumerationIndices(
+ Handle<Derived> dictionary);
static const int kMaxNumberKeyIndex = DerivedHashTable::kPrefixStartIndex;
static const int kNextEnumerationIndexIndex = kMaxNumberKeyIndex + 1;
};
// Copies enumerable keys to preallocated fixed array.
void CopyEnumKeysTo(FixedArray* storage);
- inline static void DoGenerateNewEnumerationIndices(
+ inline static Handle<FixedArray> DoGenerateNewEnumerationIndices(
Handle<NameDictionary> dictionary);
// Find entry for key, otherwise return kNotFound. Optimized version of
};
// Properties of scopes.
- class ScopeTypeField: public BitField<ScopeType, 0, 3> {};
- class CallsEvalField: public BitField<bool, 3, 1> {};
- class StrictModeField: public BitField<StrictMode, 4, 1> {};
- class FunctionVariableField: public BitField<FunctionVariableInfo, 5, 2> {};
- class FunctionVariableMode: public BitField<VariableMode, 7, 3> {};
- class AsmModuleField : public BitField<bool, 10, 1> {};
- class AsmFunctionField : public BitField<bool, 11, 1> {};
+ class ScopeTypeField : public BitField<ScopeType, 0, 4> {};
+ class CallsEvalField : public BitField<bool, 4, 1> {};
+ class StrictModeField : public BitField<StrictMode, 5, 1> {};
+ class FunctionVariableField : public BitField<FunctionVariableInfo, 6, 2> {};
+ class FunctionVariableMode : public BitField<VariableMode, 8, 3> {};
+ class AsmModuleField : public BitField<bool, 11, 1> {};
+ class AsmFunctionField : public BitField<bool, 12, 1> {};
// BitFields representing the encoded information for context locals in the
// ContextLocalInfoEntries part.
DECLARE_CAST(DeoptimizationInputData)
#ifdef ENABLE_DISASSEMBLER
- void DeoptimizationInputDataPrint(OStream& os); // NOLINT
+ void DeoptimizationInputDataPrint(std::ostream& os); // NOLINT
#endif
private:
DECLARE_CAST(DeoptimizationOutputData)
#if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
- void DeoptimizationOutputDataPrint(OStream& os); // NOLINT
+ void DeoptimizationOutputDataPrint(std::ostream& os); // NOLINT
#endif
};
// Printing
static const char* ICState2String(InlineCacheState state);
static const char* StubType2String(StubType type);
- static void PrintExtraICState(OStream& os, // NOLINT
+ static void PrintExtraICState(std::ostream& os, // NOLINT
Kind kind, ExtraICState extra);
- void Disassemble(const char* name, OStream& os); // NOLINT
+ void Disassemble(const char* name, std::ostream& os); // NOLINT
#endif // ENABLE_DISASSEMBLER
// [instruction_size]: Size of the native instructions
inline void set_profiler_ticks(int ticks);
// [builtin_index]: For BUILTIN kind, tells which builtin index it has.
+ // For builtins, tells which builtin index it has.
+ // Note that builtins can have a code kind other than BUILTIN, which means
+ // that for arbitrary code objects, this index value may be random garbage.
+ // To verify in that case, compare the code object to the indexed builtin.
inline int builtin_index();
inline void set_builtin_index(int id);
// compilation stub.
static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);
static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);
+ void MakeYoung();
void MakeOlder(MarkingParity);
static bool IsYoungSequence(Isolate* isolate, byte* sequence);
bool IsOld();
void VerifyEmbeddedObjectsDependency();
#endif
+#ifdef DEBUG
+ void VerifyEmbeddedObjectsInFullCode();
+#endif // DEBUG
+
inline bool CanContainWeakObjects() {
return is_optimized_code() || is_weak_stub();
}
static const int kMaxLoopNestingMarker = 6;
// Layout description.
- static const int kInstructionSizeOffset = HeapObject::kHeaderSize;
- static const int kRelocationInfoOffset = kInstructionSizeOffset + kIntSize;
+ static const int kRelocationInfoOffset = HeapObject::kHeaderSize;
static const int kHandlerTableOffset = kRelocationInfoOffset + kPointerSize;
static const int kDeoptimizationDataOffset =
kHandlerTableOffset + kPointerSize;
kDeoptimizationDataOffset + kPointerSize;
static const int kNextCodeLinkOffset = kTypeFeedbackInfoOffset + kPointerSize;
static const int kGCMetadataOffset = kNextCodeLinkOffset + kPointerSize;
- static const int kICAgeOffset =
- kGCMetadataOffset + kPointerSize;
+ static const int kInstructionSizeOffset = kGCMetadataOffset + kPointerSize;
+ static const int kICAgeOffset = kInstructionSizeOffset + kIntSize;
static const int kFlagsOffset = kICAgeOffset + kIntSize;
static const int kKindSpecificFlags1Offset = kFlagsOffset + kIntSize;
static const int kKindSpecificFlags2Offset =
static const int kPrologueOffset = kKindSpecificFlags2Offset + kIntSize;
static const int kConstantPoolOffset = kPrologueOffset + kPointerSize;
- static const int kHeaderPaddingStart = kConstantPoolOffset + kIntSize;
+ static const int kHeaderPaddingStart = kConstantPoolOffset + kPointerSize;
// Add padding to align the instruction start following right after
// the Code object header.
inline Map* elements_transition_map();
inline Map* GetTransition(int transition_index);
- inline int SearchTransition(Name* name);
+ inline int SearchSpecialTransition(Symbol* name);
+ inline int SearchTransition(PropertyType type, Name* name,
+ PropertyAttributes attributes);
inline FixedArrayBase* GetInitialElements();
DECL_ACCESSORS(transitions, TransitionArray)
Name* name,
LookupResult* result);
- inline void LookupTransition(JSObject* holder,
- Name* name,
+ inline void LookupTransition(JSObject* holder, Name* name,
+ PropertyAttributes attributes,
LookupResult* result);
inline PropertyDetails GetLastDescriptorDetails();
static void AppendCallbackDescriptors(Handle<Map> map,
Handle<Object> descriptors);
+ static inline int SlackForArraySize(int old_size, int size_limit);
+
static void EnsureDescriptorSlack(Handle<Map> map, int slack);
// Returns the found code or undefined if absent.
bool IsJSObjectMap() {
return instance_type() >= FIRST_JS_OBJECT_TYPE;
}
+ bool IsStringMap() { return instance_type() < FIRST_NONSTRING_TYPE; }
bool IsJSProxyMap() {
InstanceType type = instance_type();
return FIRST_JS_PROXY_TYPE <= type && type <= LAST_JS_PROXY_TYPE;
static Handle<Map> CopyAddDescriptor(Handle<Map> map,
Descriptor* descriptor,
TransitionFlag flag);
- static Handle<Map> CopyReplaceDescriptors(
- Handle<Map> map,
- Handle<DescriptorArray> descriptors,
- TransitionFlag flag,
- MaybeHandle<Name> maybe_name,
- SimpleTransitionFlag simple_flag = FULL_TRANSITION);
+ static Handle<Map> CopyReplaceDescriptors(Handle<Map> map,
+ Handle<DescriptorArray> descriptors,
+ TransitionFlag flag,
+ MaybeHandle<Name> maybe_name,
+ SimpleTransitionFlag simple_flag);
static Handle<Map> CopyReplaceDescriptor(Handle<Map> map,
Handle<DescriptorArray> descriptors,
Descriptor* descriptor,
void ZapTransitions();
void DeprecateTransitionTree();
- void DeprecateTarget(Name* key, DescriptorArray* new_descriptors);
+ void DeprecateTarget(PropertyType type, Name* key,
+ PropertyAttributes attributes,
+ DescriptorArray* new_descriptors);
Map* FindLastMatchMap(int verbatim, int length, DescriptorArray* descriptors);
// [context_data]: context data for the context this script was compiled in.
DECL_ACCESSORS(context_data, Object)
- // [wrapper]: the wrapper cache.
- DECL_ACCESSORS(wrapper, Foreign)
+ // [wrapper]: the wrapper cache. This is either undefined or a WeakCell.
+ DECL_ACCESSORS(wrapper, HeapObject)
// [type]: the script type.
DECL_ACCESSORS(type, Smi)
// Get the JS object wrapping the given script; create it if none exists.
static Handle<JSObject> GetWrapper(Handle<Script> script);
- void ClearWrapperCache();
// Dispatched behavior.
DECLARE_PRINTER(Script)
V(Array.prototype, pop, ArrayPop) \
V(Array.prototype, shift, ArrayShift) \
V(Function.prototype, apply, FunctionApply) \
+ V(Function.prototype, call, FunctionCall) \
V(String.prototype, charCodeAt, StringCharCodeAt) \
V(String.prototype, charAt, StringCharAt) \
V(String, fromCharCode, StringFromCharCode) \
+ V(Math, random, MathRandom) \
V(Math, floor, MathFloor) \
V(Math, round, MathRound) \
V(Math, ceil, MathCeil) \
V(Math, pow, MathPow) \
V(Math, max, MathMax) \
V(Math, min, MathMin) \
+ V(Math, cos, MathCos) \
+ V(Math, sin, MathSin) \
+ V(Math, tan, MathTan) \
+ V(Math, acos, MathAcos) \
+ V(Math, asin, MathAsin) \
+ V(Math, atan, MathAtan) \
+ V(Math, atan2, MathAtan2) \
V(Math, imul, MathImul) \
V(Math, clz32, MathClz32) \
V(Math, fround, MathFround)
// Indicates that this function is an asm function.
DECL_BOOLEAN_ACCESSORS(asm_function)
+ // Indicates that the the shared function info is deserialized from cache.
+ DECL_BOOLEAN_ACCESSORS(deserialized)
+
inline FunctionKind kind();
inline void set_kind(FunctionKind kind);
// garbage collections.
// To avoid wasting space on 64-bit architectures we use
// the following trick: we group integer fields into pairs
- // First integer in each pair is shifted left by 1.
- // By doing this we guarantee that LSB of each kPointerSize aligned
- // word is not set and thus this word cannot be treated as pointer
- // to HeapObject during old space traversal.
+// The least significant integer in each pair is shifted left by 1.
+// By doing this we guarantee that LSB of each kPointerSize aligned
+// word is not set and thus this word cannot be treated as pointer
+// to HeapObject during old space traversal.
+#if V8_TARGET_LITTLE_ENDIAN
static const int kLengthOffset =
kFeedbackVectorOffset + kPointerSize;
static const int kFormalParameterCountOffset =
// Total size.
static const int kSize = kProfilerTicksOffset + kIntSize;
-#endif
+#elif V8_TARGET_BIG_ENDIAN
+ static const int kFormalParameterCountOffset =
+ kFeedbackVectorOffset + kPointerSize;
+ static const int kLengthOffset = kFormalParameterCountOffset + kIntSize;
+
+ static const int kNumLiteralsOffset = kLengthOffset + kIntSize;
+ static const int kExpectedNofPropertiesOffset = kNumLiteralsOffset + kIntSize;
+
+ static const int kStartPositionAndTypeOffset =
+ kExpectedNofPropertiesOffset + kIntSize;
+ static const int kEndPositionOffset = kStartPositionAndTypeOffset + kIntSize;
+
+ static const int kCompilerHintsOffset = kEndPositionOffset + kIntSize;
+ static const int kFunctionTokenPositionOffset =
+ kCompilerHintsOffset + kIntSize;
+
+ static const int kCountersOffset = kFunctionTokenPositionOffset + kIntSize;
+ static const int kOptCountAndBailoutReasonOffset = kCountersOffset + kIntSize;
+
+ static const int kProfilerTicksOffset =
+ kOptCountAndBailoutReasonOffset + kIntSize;
+ static const int kAstNodeCountOffset = kProfilerTicksOffset + kIntSize;
+
+ // Total size.
+ static const int kSize = kAstNodeCountOffset + kIntSize;
+
+#else
+#error Unknown byte ordering
+#endif // Big endian
+#endif // 64-bit
+
static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
kIsGenerator,
kIsConciseMethod,
kIsAsmFunction,
+ kDeserialized,
kCompilerHintsCount // Pseudo entry
};
};
-OStream& operator<<(OStream& os, const SourceCodeOf& v);
+std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
class JSGeneratorObject: public JSObject {
};
+// This cache is used in two different variants. For regexp caching, it simply
+// maps identifying info of the regexp to the cached regexp object. Scripts and
+// eval code only gets cached after a second probe for the code object. To do
+// so, on first "put" only a hash identifying the source is entered into the
+// cache, mapping it to a lifetime count of the hash. On each call to Age all
+// such lifetimes get reduced, and removed once they reach zero. If a second put
+// is called while such a hash is live in the cache, the hash gets replaced by
+// an actual cache entry. Age also removes stale live entries from the cache.
+// Such entries are identified by SharedFunctionInfos pointing to either the
+// recompilation stub, or to "old" code. This avoids memory leaks due to
+// premature caching of scripts and eval strings that are never needed later.
class CompilationCacheTable: public HashTable<CompilationCacheTable,
CompilationCacheShape,
HashTableKey*> {
public:
// Find cached value for a string key, otherwise return null.
Handle<Object> Lookup(Handle<String> src, Handle<Context> context);
- Handle<Object> LookupEval(Handle<String> src, Handle<Context> context,
- StrictMode strict_mode, int scope_position);
+ Handle<Object> LookupEval(Handle<String> src,
+ Handle<SharedFunctionInfo> shared,
+ StrictMode strict_mode, int scope_position);
Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
static Handle<CompilationCacheTable> Put(
Handle<CompilationCacheTable> cache, Handle<String> src,
Handle<Context> context, Handle<Object> value);
static Handle<CompilationCacheTable> PutEval(
Handle<CompilationCacheTable> cache, Handle<String> src,
- Handle<Context> context, Handle<SharedFunctionInfo> value,
+ Handle<SharedFunctionInfo> context, Handle<SharedFunctionInfo> value,
int scope_position);
static Handle<CompilationCacheTable> PutRegExp(
Handle<CompilationCacheTable> cache, Handle<String> src,
JSRegExp::Flags flags, Handle<FixedArray> value);
void Remove(Object* value);
+ void Age();
+ static const int kHashGenerations = 10;
DECLARE_CAST(CompilationCacheTable)
inline void set_inlined_type_change_checksum(int checksum);
inline bool matches_inlined_type_change_checksum(int checksum);
-
DECLARE_CAST(TypeFeedbackInfo)
// Dispatched behavior.
DECLARE_PRINTER(Name)
// Layout description.
- static const int kHashFieldOffset = HeapObject::kHeaderSize;
- static const int kSize = kHashFieldOffset + kPointerSize;
+ static const int kHashFieldSlot = HeapObject::kHeaderSize;
+#if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
+ static const int kHashFieldOffset = kHashFieldSlot;
+#else
+ static const int kHashFieldOffset = kHashFieldSlot + kIntSize;
+#endif
+ static const int kSize = kHashFieldSlot + kPointerSize;
// Mask constant for checking if a name has a computed hash code
// and if it is a string that is an array index. The least significant bit
typedef FixedBodyDescriptor<kNameOffset, kFlagsOffset, kSize> BodyDescriptor;
+ void SymbolShortPrint(std::ostream& os);
+
private:
static const int kPrivateBit = 0;
static const int kOwnBit = 1;
+ const char* PrivateSymbolToName() const;
+
DISALLOW_IMPLICIT_CONSTRUCTORS(Symbol);
};
// Dispatched behavior.
void StringShortPrint(StringStream* accumulator);
- void PrintUC16(OStream& os, int start = 0, int end = -1); // NOLINT
+ void PrintUC16(std::ostream& os, int start = 0, int end = -1); // NOLINT
#ifdef OBJECT_PRINT
char* ToAsciiArray();
#endif
};
-// A ConsStringOp that returns null.
-// Useful when the operation to apply on a ConsString
-// requires an expensive data structure.
-class ConsStringNullOp {
- public:
- inline ConsStringNullOp() {}
- static inline String* Operate(String*, unsigned*, int32_t*, unsigned*);
- private:
- DISALLOW_COPY_AND_ASSIGN(ConsStringNullOp);
-};
-
-
// This maintains an off-stack representation of the stack frames required
// to traverse a ConsString, allowing an entirely iterative and restartable
// traversal of the entire string
-class ConsStringIteratorOp {
+class ConsStringIterator {
public:
- inline ConsStringIteratorOp() {}
- inline explicit ConsStringIteratorOp(ConsString* cons_string,
- int offset = 0) {
+ inline ConsStringIterator() {}
+ inline explicit ConsStringIterator(ConsString* cons_string, int offset = 0) {
Reset(cons_string, offset);
}
inline void Reset(ConsString* cons_string, int offset = 0) {
int depth_;
int maximum_depth_;
int consumed_;
- DISALLOW_COPY_AND_ASSIGN(ConsStringIteratorOp);
+ DISALLOW_COPY_AND_ASSIGN(ConsStringIterator);
};
class StringCharacterStream {
public:
inline StringCharacterStream(String* string,
- ConsStringIteratorOp* op,
int offset = 0);
inline uint16_t GetNext();
inline bool HasMore();
inline void VisitTwoByteString(const uint16_t* chars, int length);
private:
+ ConsStringIterator iter_;
bool is_one_byte_;
union {
const uint8_t* buffer8_;
const uint16_t* buffer16_;
};
const uint8_t* end_;
- ConsStringIteratorOp* op_;
DISALLOW_COPY_AND_ASSIGN(StringCharacterStream);
};
};
+class WeakCell : public HeapObject {
+ public:
+ inline Object* value() const;
+
+ // This should not be called by anyone except GC.
+ inline void clear();
+
+ // This should not be called by anyone except allocator.
+ inline void initialize(HeapObject* value);
+
+ inline bool cleared() const;
+
+ DECL_ACCESSORS(next, Object)
+
+ DECLARE_CAST(WeakCell)
+
+ DECLARE_PRINTER(WeakCell)
+ DECLARE_VERIFIER(WeakCell)
+
+ // Layout description.
+ static const int kValueOffset = HeapObject::kHeaderSize;
+ static const int kNextOffset = kValueOffset + kPointerSize;
+ static const int kSize = kNextOffset + kPointerSize;
+
+ typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
+};
+
+
// The JSProxy describes EcmaScript Harmony proxies
class JSProxy: public JSReceiver {
public:
DECL_ACCESSORS(kind, Object)
#ifdef OBJECT_PRINT
- void OrderedHashTableIteratorPrint(OStream& os); // NOLINT
+ void OrderedHashTableIteratorPrint(std::ostream& os); // NOLINT
#endif
static const int kTableOffset = JSObject::kHeaderSize;
inline bool should_be_freed();
inline void set_should_be_freed(bool value);
+ inline bool is_neuterable();
+ inline void set_is_neuterable(bool value);
+
// [weak_next]: linked list of array buffers.
DECL_ACCESSORS(weak_next, Object)
// Bit position in a flag
static const int kIsExternalBit = 0;
static const int kShouldBeFreed = 1;
+ static const int kIsNeuterableBit = 2;
DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
};
namespace v8 {
namespace internal {
+class OptimizingCompilerThread::CompileTask : public v8::Task {
+ public:
+ CompileTask(Isolate* isolate, OptimizedCompileJob* job)
+ : isolate_(isolate), job_(job) {}
+
+ virtual ~CompileTask() {}
+
+ private:
+ // v8::Task overrides.
+ virtual void Run() OVERRIDE {
+ DisallowHeapAllocation no_allocation;
+ DisallowHandleAllocation no_handles;
+ DisallowHandleDereference no_deref;
+
+ // The function may have already been optimized by OSR. Simply continue.
+ OptimizedCompileJob::Status status = job_->OptimizeGraph();
+ USE(status); // Prevent an unused-variable error in release mode.
+ DCHECK(status != OptimizedCompileJob::FAILED);
+
+ // The function may have already been optimized by OSR. Simply continue.
+ // Use a mutex to make sure that functions marked for install
+ // are always also queued.
+ {
+ base::LockGuard<base::Mutex> lock_guard(
+ &isolate_->optimizing_compiler_thread()->output_queue_mutex_);
+ isolate_->optimizing_compiler_thread()->output_queue_.Enqueue(job_);
+ }
+ isolate_->stack_guard()->RequestInstallCode();
+ {
+ base::LockGuard<base::Mutex> lock_guard(
+ &isolate_->optimizing_compiler_thread()->input_queue_mutex_);
+ isolate_->optimizing_compiler_thread()->input_queue_length_--;
+ }
+ isolate_->optimizing_compiler_thread()->input_queue_semaphore_.Signal();
+ }
+
+ Isolate* isolate_;
+ OptimizedCompileJob* job_;
+
+ DISALLOW_COPY_AND_ASSIGN(CompileTask);
+};
+
+
OptimizingCompilerThread::~OptimizingCompilerThread() {
DCHECK_EQ(0, input_queue_length_);
DeleteArray(input_queue_);
thread_id_ = ThreadId::Current().ToInteger();
}
#endif
- Isolate::SetIsolateThreadLocals(isolate_, NULL);
DisallowHeapAllocation no_allocation;
DisallowHandleAllocation no_handles;
DisallowHandleDereference no_deref;
+ if (job_based_recompilation_) {
+ return;
+ }
+
base::ElapsedTimer total_timer;
- if (FLAG_trace_concurrent_recompilation) total_timer.Start();
+ if (tracing_enabled_) total_timer.Start();
while (true) {
input_queue_semaphore_.Wait();
case CONTINUE:
break;
case STOP:
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
time_spent_total_ = total_timer.Elapsed();
}
stop_semaphore_.Signal();
}
base::ElapsedTimer compiling_timer;
- if (FLAG_trace_concurrent_recompilation) compiling_timer.Start();
+ if (tracing_enabled_) compiling_timer.Start();
CompileNext();
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
time_spent_compiling_ += compiling_timer.Elapsed();
}
}
OptimizedCompileJob* OptimizingCompilerThread::NextInput() {
base::LockGuard<base::Mutex> access_input_queue_(&input_queue_mutex_);
+ DCHECK(!job_based_recompilation_);
if (input_queue_length_ == 0) return NULL;
OptimizedCompileJob* job = input_queue_[InputQueueIndex(0)];
DCHECK_NE(NULL, job);
void OptimizingCompilerThread::FlushInputQueue(bool restore_function_code) {
+ DCHECK(!job_based_recompilation_);
OptimizedCompileJob* job;
while ((job = NextInput())) {
// This should not block, since we have one signal on the input queue
DCHECK(!IsOptimizerThread());
base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(FLUSH));
if (FLAG_block_concurrent_recompilation) Unblock();
- input_queue_semaphore_.Signal();
- stop_semaphore_.Wait();
+ if (!job_based_recompilation_) {
+ input_queue_semaphore_.Signal();
+ stop_semaphore_.Wait();
+ }
FlushOutputQueue(true);
if (FLAG_concurrent_osr) FlushOsrBuffer(true);
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
PrintF(" ** Flushed concurrent recompilation queues.\n");
}
}
DCHECK(!IsOptimizerThread());
base::Release_Store(&stop_thread_, static_cast<base::AtomicWord>(STOP));
if (FLAG_block_concurrent_recompilation) Unblock();
- input_queue_semaphore_.Signal();
- stop_semaphore_.Wait();
+ if (!job_based_recompilation_) {
+ input_queue_semaphore_.Signal();
+ stop_semaphore_.Wait();
+ }
- if (FLAG_concurrent_recompilation_delay != 0) {
+ if (job_based_recompilation_) {
+ while (true) {
+ {
+ base::LockGuard<base::Mutex> access_input_queue(&input_queue_mutex_);
+ if (!input_queue_length_) break;
+ }
+ input_queue_semaphore_.Wait();
+ }
+ } else if (FLAG_concurrent_recompilation_delay != 0) {
// At this point the optimizing compiler thread's event loop has stopped.
// There is no need for a mutex when reading input_queue_length_.
while (input_queue_length_ > 0) CompileNext();
if (FLAG_concurrent_osr) FlushOsrBuffer(false);
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
double percentage = time_spent_compiling_.PercentOf(time_spent_total_);
PrintF(" ** Compiler thread did %.2f%% useful work\n", percentage);
}
- if ((FLAG_trace_osr || FLAG_trace_concurrent_recompilation) &&
- FLAG_concurrent_osr) {
+ if ((FLAG_trace_osr || tracing_enabled_) && FLAG_concurrent_osr) {
PrintF("[COSR hit rate %d / %d]\n", osr_hits_, osr_attempts_);
}
BackEdgeTable::RemoveStackCheck(code, offset);
} else {
if (function->IsOptimized()) {
- if (FLAG_trace_concurrent_recompilation) {
+ if (tracing_enabled_) {
PrintF(" ** Aborting compilation for ");
function->ShortPrint();
PrintF(" as it has already been optimized.\n");
input_queue_[InputQueueIndex(input_queue_length_)] = job;
input_queue_length_++;
}
- if (FLAG_block_concurrent_recompilation) {
+ if (job_based_recompilation_) {
+ V8::GetCurrentPlatform()->CallOnBackgroundThread(
+ new CompileTask(isolate_, job), v8::Platform::kShortRunningTask);
+ } else if (FLAG_block_concurrent_recompilation) {
blocked_jobs_++;
} else {
input_queue_semaphore_.Signal();
void OptimizingCompilerThread::Unblock() {
DCHECK(!IsOptimizerThread());
+ if (job_based_recompilation_) {
+ return;
+ }
while (blocked_jobs_ > 0) {
input_queue_semaphore_.Signal();
blocked_jobs_--;
osr_buffer_cursor_(0),
osr_hits_(0),
osr_attempts_(0),
- blocked_jobs_(0) {
+ blocked_jobs_(0),
+ tracing_enabled_(FLAG_trace_concurrent_recompilation),
+ job_based_recompilation_(FLAG_job_based_recompilation) {
base::NoBarrier_Store(&stop_thread_,
static_cast<base::AtomicWord>(CONTINUE));
input_queue_ = NewArray<OptimizedCompileJob*>(input_queue_capacity_);
#endif
private:
+ class CompileTask;
+
enum StopFlag { CONTINUE, STOP, FLUSH };
void FlushInputQueue(bool restore_function_code);
// Queue of recompilation tasks ready to be installed (excluding OSR).
UnboundQueue<OptimizedCompileJob*> output_queue_;
+ // Used for job based recompilation which has multiple producers on
+ // different threads.
+ base::Mutex output_queue_mutex_;
// Cyclic buffer of recompilation tasks for OSR.
OptimizedCompileJob** osr_buffer_;
int osr_attempts_;
int blocked_jobs_;
+
+ // Copies of FLAG_trace_concurrent_recompilation and
+ // FLAG_job_based_recompilation that will be used from the background thread.
+ //
+ // Since flags might get modified while the background thread is running, it
+ // is not safe to access them directly.
+ bool tracing_enabled_;
+ bool job_based_recompilation_;
};
} } // namespace v8::internal
#include "src/ostreams.h"
-#include <algorithm>
-#include <cmath>
-
-#include "src/base/platform/platform.h" // For isinf/isnan with MSVC
-
#if V8_OS_WIN
#define snprintf sprintf_s
#endif
namespace v8 {
namespace internal {
-// Be lazy and delegate the value=>char conversion to snprintf.
-template<class T>
-OStream& OStream::print(const char* format, T x) {
- char buf[32];
- int n = snprintf(buf, sizeof(buf), format, x);
- return (n < 0) ? *this : write(buf, n);
-}
-
-
-OStream& OStream::operator<<(short x) { // NOLINT(runtime/int)
- return print(hex_ ? "%hx" : "%hd", x);
-}
-
-
-OStream& OStream::operator<<(unsigned short x) { // NOLINT(runtime/int)
- return print(hex_ ? "%hx" : "%hu", x);
-}
-
-
-OStream& OStream::operator<<(int x) {
- return print(hex_ ? "%x" : "%d", x);
-}
-
-
-OStream& OStream::operator<<(unsigned int x) {
- return print(hex_ ? "%x" : "%u", x);
-}
-
-
-OStream& OStream::operator<<(long x) { // NOLINT(runtime/int)
- return print(hex_ ? "%lx" : "%ld", x);
-}
-
-
-OStream& OStream::operator<<(unsigned long x) { // NOLINT(runtime/int)
- return print(hex_ ? "%lx" : "%lu", x);
-}
-
-
-OStream& OStream::operator<<(long long x) { // NOLINT(runtime/int)
- return print(hex_ ? "%llx" : "%lld", x);
-}
-
-
-OStream& OStream::operator<<(unsigned long long x) { // NOLINT(runtime/int)
- return print(hex_ ? "%llx" : "%llu", x);
-}
-
-
-OStream& OStream::operator<<(double x) {
- if (std::isinf(x)) return *this << (x < 0 ? "-inf" : "inf");
- if (std::isnan(x)) return *this << "nan";
- return print("%g", x);
-}
-
-
-OStream& OStream::operator<<(void* x) {
- return print("%p", x);
-}
-
-
-OStream& OStream::operator<<(char x) {
- return put(x);
-}
-
-
-OStream& OStream::operator<<(signed char x) {
- return put(x);
-}
-
-
-OStream& OStream::operator<<(unsigned char x) {
- return put(x);
-}
-
-
-OStream& OStream::dec() {
- hex_ = false;
- return *this;
-}
-
-
-OStream& OStream::hex() {
- hex_ = true;
- return *this;
-}
+OFStreamBase::OFStreamBase(FILE* f) : f_(f) {}
-OStream& flush(OStream& os) { // NOLINT(runtime/references)
- return os.flush();
-}
-
-
-OStream& endl(OStream& os) { // NOLINT(runtime/references)
- return flush(os.put('\n'));
-}
-
-
-OStream& hex(OStream& os) { // NOLINT(runtime/references)
- return os.hex();
-}
-
-
-OStream& dec(OStream& os) { // NOLINT(runtime/references)
- return os.dec();
-}
+OFStreamBase::~OFStreamBase() {}
-OStringStream& OStringStream::write(const char* s, size_t n) {
- size_t new_size = size_ + n;
- if (new_size < size_) return *this; // Overflow => no-op.
- reserve(new_size + 1);
- memcpy(data_ + size_, s, n);
- size_ = new_size;
- data_[size_] = '\0';
- return *this;
+OFStreamBase::int_type OFStreamBase::sync() {
+ std::fflush(f_);
+ return 0;
}
-OStringStream& OStringStream::flush() {
- return *this;
+OFStreamBase::int_type OFStreamBase::overflow(int_type c) {
+ return (c != EOF) ? std::fputc(c, f_) : c;
}
-void OStringStream::reserve(size_t requested_capacity) {
- if (requested_capacity <= capacity_) return;
- size_t new_capacity = // Handle possible overflow by not doubling.
- std::max(std::max(capacity_ * 2, capacity_), requested_capacity);
- char * new_data = allocate(new_capacity);
- memcpy(new_data, data_, size_);
- deallocate(data_, capacity_);
- capacity_ = new_capacity;
- data_ = new_data;
-}
-
+OFStream::OFStream(FILE* f) : OFStreamBase(f), std::ostream(this) {}
-OFStream& OFStream::write(const char* s, size_t n) {
- if (f_) fwrite(s, n, 1, f_);
- return *this;
-}
+OFStream::~OFStream() {}
-OFStream& OFStream::flush() {
- if (f_) fflush(f_);
- return *this;
-}
+namespace {
// Locale-independent predicates.
-static bool IsPrint(uint16_t c) { return 0x20 <= c && c <= 0x7e; }
-static bool IsSpace(uint16_t c) { return (0x9 <= c && c <= 0xd) || c == 0x20; }
-static bool IsOK(uint16_t c) { return (IsPrint(c) || IsSpace(c)) && c != '\\'; }
+bool IsPrint(uint16_t c) { return 0x20 <= c && c <= 0x7e; }
+bool IsSpace(uint16_t c) { return (0x9 <= c && c <= 0xd) || c == 0x20; }
+bool IsOK(uint16_t c) { return (IsPrint(c) || IsSpace(c)) && c != '\\'; }
-static OStream& PrintUC16(OStream& os, uint16_t c, bool (*pred)(uint16_t)) {
+std::ostream& PrintUC16(std::ostream& os, uint16_t c, bool (*pred)(uint16_t)) {
char buf[10];
const char* format = pred(c) ? "%c" : (c <= 0xff) ? "\\x%02x" : "\\u%04x";
snprintf(buf, sizeof(buf), format, c);
return os << buf;
}
+} // namespace
-OStream& operator<<(OStream& os, const AsReversiblyEscapedUC16& c) {
+
+std::ostream& operator<<(std::ostream& os, const AsReversiblyEscapedUC16& c) {
return PrintUC16(os, c.value, IsOK);
}
-OStream& operator<<(OStream& os, const AsUC16& c) {
+std::ostream& operator<<(std::ostream& os, const AsUC16& c) {
return PrintUC16(os, c.value, IsPrint);
}
-} } // namespace v8::internal
+
+} // namespace internal
+} // namespace v8
#ifndef V8_OSTREAMS_H_
#define V8_OSTREAMS_H_
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
+#include <cstddef>
+#include <cstdio>
+#include <cstring>
+#include <ostream> // NOLINT
+#include <streambuf>
#include "include/v8config.h"
#include "src/base/macros.h"
namespace v8 {
namespace internal {
-// An abstract base class for output streams with a cut-down standard interface.
-class OStream {
- public:
- OStream() : hex_(false) { }
- virtual ~OStream() { }
-
- // For manipulators like 'os << endl' or 'os << flush', etc.
- OStream& operator<<(OStream& (*manipulator)(OStream& os)) {
- return manipulator(*this);
- }
-
- // Numeric conversions.
- OStream& operator<<(short x); // NOLINT(runtime/int)
- OStream& operator<<(unsigned short x); // NOLINT(runtime/int)
- OStream& operator<<(int x);
- OStream& operator<<(unsigned int x);
- OStream& operator<<(long x); // NOLINT(runtime/int)
- OStream& operator<<(unsigned long x); // NOLINT(runtime/int)
- OStream& operator<<(long long x); // NOLINT(runtime/int)
- OStream& operator<<(unsigned long long x); // NOLINT(runtime/int)
- OStream& operator<<(double x);
- OStream& operator<<(void* x);
-
- // Character output.
- OStream& operator<<(char x);
- OStream& operator<<(signed char x);
- OStream& operator<<(unsigned char x);
- OStream& operator<<(const char* s) { return write(s, strlen(s)); }
- OStream& put(char c) { return write(&c, 1); }
-
- // Primitive format flag handling, can be extended if needed.
- OStream& dec();
- OStream& hex();
-
- virtual OStream& write(const char* s, size_t n) = 0;
- virtual OStream& flush() = 0;
-
- private:
- template<class T> OStream& print(const char* format, T x);
-
- bool hex_;
-
- DISALLOW_COPY_AND_ASSIGN(OStream);
-};
-
-
-// Some manipulators.
-OStream& flush(OStream& os); // NOLINT(runtime/references)
-OStream& endl(OStream& os); // NOLINT(runtime/references)
-OStream& dec(OStream& os); // NOLINT(runtime/references)
-OStream& hex(OStream& os); // NOLINT(runtime/references)
-
-
-// An output stream writing to a character buffer.
-class OStringStream: public OStream {
- public:
- OStringStream() : size_(0), capacity_(32), data_(allocate(capacity_)) {
- data_[0] = '\0';
- }
- ~OStringStream() { deallocate(data_, capacity_); }
-
- size_t size() const { return size_; }
- size_t capacity() const { return capacity_; }
- const char* data() const { return data_; }
-
- // Internally, our character data is always 0-terminated.
- const char* c_str() const { return data(); }
+class OFStreamBase : public std::streambuf {
+ protected:
+ explicit OFStreamBase(FILE* f);
+ virtual ~OFStreamBase();
- virtual OStringStream& write(const char* s, size_t n) OVERRIDE;
- virtual OStringStream& flush() OVERRIDE;
+ virtual int_type sync() FINAL;
+ virtual int_type overflow(int_type c) FINAL;
private:
- // Primitive allocator interface, can be extracted if needed.
- static char* allocate (size_t n) { return new char[n]; }
- static void deallocate (char* s, size_t n) { delete[] s; }
-
- void reserve(size_t requested_capacity);
-
- size_t size_;
- size_t capacity_;
- char* data_;
+ FILE* const f_;
- DISALLOW_COPY_AND_ASSIGN(OStringStream);
+ DISALLOW_COPY_AND_ASSIGN(OFStreamBase);
};
// An output stream writing to a file.
-class OFStream: public OStream {
+class OFStream FINAL : private virtual OFStreamBase, public std::ostream {
public:
- explicit OFStream(FILE* f) : f_(f) { }
- virtual ~OFStream() { }
-
- virtual OFStream& write(const char* s, size_t n) OVERRIDE;
- virtual OFStream& flush() OVERRIDE;
+ explicit OFStream(FILE* f);
+ ~OFStream();
private:
- FILE* const f_;
-
DISALLOW_COPY_AND_ASSIGN(OFStream);
};
// Writes the given character to the output escaping everything outside of
// printable/space ASCII range. Additionally escapes '\' making escaping
// reversible.
-OStream& operator<<(OStream& os, const AsReversiblyEscapedUC16& c);
+std::ostream& operator<<(std::ostream& os, const AsReversiblyEscapedUC16& c);
// Writes the given character to the output escaping everything outside
// of printable ASCII range.
-OStream& operator<<(OStream& os, const AsUC16& c);
-} } // namespace v8::internal
+std::ostream& operator<<(std::ostream& os, const AsUC16& c);
+
+} // namespace internal
+} // namespace v8
#endif // V8_OSTREAMS_H_
// ----------------------------------------------------------------------------
// Implementation of Parser
-class ParserTraits::Checkpoint
- : public ParserBase<ParserTraits>::CheckpointBase {
- public:
- explicit Checkpoint(ParserBase<ParserTraits>* parser)
- : CheckpointBase(parser), parser_(parser) {
- saved_ast_node_id_gen_ = *parser_->ast_node_id_gen_;
- }
-
- void Restore() {
- CheckpointBase::Restore();
- *parser_->ast_node_id_gen_ = saved_ast_node_id_gen_;
- }
-
- private:
- ParserBase<ParserTraits>* parser_;
- AstNode::IdGen saved_ast_node_id_gen_;
-};
-
-
bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
return identifier == parser_->ast_value_factory()->eval_string() ||
identifier == parser_->ast_value_factory()->arguments_string();
Expression* ParserTraits::NewThrowReferenceError(const char* message, int pos) {
return NewThrowError(
parser_->ast_value_factory()->make_reference_error_string(), message,
- NULL, pos);
+ parser_->ast_value_factory()->empty_string(), pos);
}
const AstRawString* constructor, const char* message,
const AstRawString* arg, int pos) {
Zone* zone = parser_->zone();
- int argc = arg != NULL ? 1 : 0;
const AstRawString* type =
parser_->ast_value_factory()->GetOneByteString(message);
- ZoneList<const AstRawString*>* array =
- new (zone) ZoneList<const AstRawString*>(argc, zone);
- if (arg != NULL) {
- array->Add(arg, zone);
- }
ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(2, zone);
args->Add(parser_->factory()->NewStringLiteral(type, pos), zone);
- args->Add(parser_->factory()->NewStringListLiteral(array, pos), zone);
+ args->Add(parser_->factory()->NewStringLiteral(arg, pos), zone);
CallRuntime* call_constructor =
parser_->factory()->NewCallRuntime(constructor, NULL, args, pos);
return parser_->factory()->NewThrow(call_constructor, pos);
pos);
}
-Expression* ParserTraits::ClassLiteral(
+Expression* ParserTraits::ClassExpression(
const AstRawString* name, Expression* extends, Expression* constructor,
- ZoneList<ObjectLiteral::Property*>* properties, int pos,
- AstNodeFactory<AstConstructionVisitor>* factory) {
- return factory->NewClassLiteral(name, extends, constructor, properties, pos);
+ ZoneList<ObjectLiteral::Property*>* properties, int start_position,
+ int end_position, AstNodeFactory<AstConstructionVisitor>* factory) {
+ return factory->NewClassLiteral(name, extends, constructor, properties,
+ start_position, end_position);
}
Literal* ParserTraits::ExpressionFromLiteral(
Parser::Parser(CompilationInfo* info, ParseInfo* parse_info)
: ParserBase<ParserTraits>(&scanner_, parse_info->stack_limit,
- info->extension(), NULL, info->zone(),
- info->ast_node_id_gen(), this),
+ info->extension(), NULL, info->zone(), this),
scanner_(parse_info->unicode_cache),
reusable_preparser_(NULL),
original_scope_(NULL),
// Initialize parser state.
CompleteParserRecorder recorder;
+ debug_saved_compile_options_ = compile_options();
if (compile_options() == ScriptCompiler::kProduceParserCache) {
log_ = &recorder;
} else if (compile_options() == ScriptCompiler::kConsumeParserCache) {
ParsingModeScope parsing_mode(this, mode);
// Enters 'scope'.
- FunctionState function_state(&function_state_, &scope_, *scope, zone(),
- ast_value_factory(), info->ast_node_id_gen());
+ AstNodeFactory<AstConstructionVisitor> function_factory(
+ ast_value_factory());
+ FunctionState function_state(&function_state_, &scope_, *scope,
+ &function_factory);
scope_->SetStrictMode(info->strict_mode());
ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
zone());
}
original_scope_ = scope;
- FunctionState function_state(&function_state_, &scope_, scope, zone(),
- ast_value_factory(),
- info()->ast_node_id_gen());
+ AstNodeFactory<AstConstructionVisitor> function_factory(
+ ast_value_factory());
+ FunctionState function_state(&function_state_, &scope_, scope,
+ &function_factory);
DCHECK(scope->strict_mode() == SLOPPY || info()->strict_mode() == STRICT);
DCHECK(info()->strict_mode() == shared_info->strict_mode());
scope->SetStrictMode(shared_info->strict_mode());
Expression* value = ParseClassLiteral(name, scanner()->location(),
is_strict_reserved, pos, CHECK_OK);
- Block* block = factory()->NewBlock(NULL, 1, true, pos);
- VariableMode mode = LET;
- VariableProxy* proxy = NewUnresolved(name, mode, Interface::NewValue());
+ VariableProxy* proxy = NewUnresolved(name, LET, Interface::NewValue());
Declaration* declaration =
- factory()->NewVariableDeclaration(proxy, mode, scope_, pos);
+ factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
Declare(declaration, true, CHECK_OK);
+ proxy->var()->set_initializer_position(pos);
Token::Value init_op = Token::INIT_LET;
Assignment* assignment = factory()->NewAssignment(init_op, proxy, value, pos);
- block->AddStatement(
- factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
- zone());
-
+ Statement* assignment_statement =
+ factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
if (names) names->Add(name, zone());
- return block;
+ return assignment_statement;
}
Block* block = factory()->NewBlock(NULL, 1, true, pos);
int nvars = 0; // the number of variables declared
const AstRawString* name = NULL;
+ bool is_for_iteration_variable;
do {
if (fni_ != NULL) fni_->Enter();
// For let/const declarations in harmony mode, we can also immediately
// pre-resolve the proxy because it resides in the same scope as the
// declaration.
+ is_for_iteration_variable =
+ var_context == kForStatement &&
+ (peek() == Token::IN || PeekContextualKeyword(CStrVector("of")));
+ if (is_for_iteration_variable && mode == CONST) {
+ needs_init = false;
+ }
+
Interface* interface =
is_const ? Interface::NewConst() : Interface::NewValue();
VariableProxy* proxy = NewUnresolved(name, mode, interface);
Expression* value = NULL;
int pos = -1;
// Harmony consts have non-optional initializers.
- if (peek() == Token::ASSIGN || mode == CONST) {
+ if (peek() == Token::ASSIGN ||
+ (mode == CONST && !is_for_iteration_variable)) {
Expect(Token::ASSIGN, CHECK_OK);
pos = position();
value = ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);
}
// Record the end position of the initializer.
- if (proxy->var() != NULL) {
+ if (proxy->is_resolved()) {
proxy->var()->set_initializer_position(position());
}
// If there was a single non-const declaration, return it in the output
// parameter for possible use by for/in.
- if (nvars == 1 && !is_const) {
+ if (nvars == 1 && (!is_const || is_for_iteration_variable)) {
*out = name;
}
Expect(Token::LPAREN, CHECK_OK);
for_scope->set_start_position(scanner()->location().beg_pos);
if (peek() != Token::SEMICOLON) {
- if (peek() == Token::VAR || peek() == Token::CONST) {
+ if (peek() == Token::VAR ||
+ (peek() == Token::CONST && strict_mode() == SLOPPY)) {
bool is_const = peek() == Token::CONST;
const AstRawString* name = NULL;
VariableDeclarationProperties decl_props = kHasNoInitializers;
} else {
init = variable_statement;
}
- } else if (peek() == Token::LET && strict_mode() == STRICT) {
- DCHECK(allow_harmony_scoping());
+ } else if ((peek() == Token::LET || peek() == Token::CONST) &&
+ strict_mode() == STRICT) {
+ bool is_const = peek() == Token::CONST;
const AstRawString* name = NULL;
VariableDeclarationProperties decl_props = kHasNoInitializers;
Block* variable_statement =
if (accept_IN && CheckInOrOf(accept_OF, &mode)) {
// Rewrite a for-in statement of the form
//
- // for (let x in e) b
+ // for (let/const x in e) b
//
// into
//
// <let x' be a temporary variable>
// for (x' in e) {
- // let x;
+ // let/const x;
// x = x';
// b;
// }
scope_ = for_scope;
Expect(Token::RPAREN, CHECK_OK);
- VariableProxy* each =
- scope_->NewUnresolved(factory(), name, Interface::NewValue());
+ VariableProxy* each = scope_->NewUnresolved(factory(), name);
Statement* body = ParseStatement(NULL, CHECK_OK);
Block* body_block =
factory()->NewBlock(NULL, 3, false, RelocInfo::kNoPosition);
+ Token::Value init_op = is_const ? Token::INIT_CONST : Token::ASSIGN;
Assignment* assignment = factory()->NewAssignment(
- Token::ASSIGN, each, temp_proxy, RelocInfo::kNoPosition);
+ init_op, each, temp_proxy, RelocInfo::kNoPosition);
Statement* assignment_statement = factory()->NewExpressionStatement(
assignment, RelocInfo::kNoPosition);
body_block->AddStatement(variable_statement, zone());
Scanner::Location lhs_location = scanner()->peek_location();
Expression* expression = ParseExpression(false, CHECK_OK);
ForEachStatement::VisitMode mode;
- bool accept_OF = expression->AsVariableProxy();
+ bool accept_OF = expression->IsVariableProxy();
if (CheckInOrOf(accept_OF, &mode)) {
expression = this->CheckAndRewriteReferenceExpression(
// Too many parentheses around expression:
// (( ... )) => ...
- if (expression->parenthesization_level() > 1) return false;
+ if (expression->is_multi_parenthesized()) return false;
// Case for a single parameter:
// (foo) => ...
BailoutReason dont_optimize_reason = kNoReason;
// Parse function body.
{
- FunctionState function_state(&function_state_, &scope_, scope, zone(),
- ast_value_factory(),
- info()->ast_node_id_gen());
+ AstNodeFactory<AstConstructionVisitor> function_factory(
+ ast_value_factory());
+ FunctionState function_state(&function_state_, &scope_, scope,
+ &function_factory);
scope_->SetScopeName(function_name);
if (is_generator) {
int* materialized_literal_count,
int* expected_property_count,
bool* ok) {
+ // Temporary debugging code for tracking down a mystery crash which should
+ // never happen. The crash happens on the line where we log the function in
+ // the preparse data: log_->LogFunction(...). TODO(marja): remove this once
+ // done.
+ CHECK(materialized_literal_count);
+ CHECK(expected_property_count);
+ CHECK(debug_saved_compile_options_ == compile_options());
+ if (compile_options() == ScriptCompiler::kProduceParserCache) {
+ CHECK(log_);
+ }
+
int function_block_pos = position();
if (compile_options() == ScriptCompiler::kConsumeParserCache) {
// If we have cached data, we use it to skip parsing the function body. The
fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
CompleteParserRecorder recorder;
+ debug_saved_compile_options_ = compile_options();
if (compile_options() == ScriptCompiler::kProduceParserCache) {
log_ = &recorder;
}
// Used by FunctionState and BlockState.
typedef v8::internal::Scope Scope;
typedef v8::internal::Scope* ScopePtr;
+ inline static Scope* ptr_to_scope(ScopePtr scope) { return scope; }
+
typedef Variable GeneratorVariable;
typedef v8::internal::Zone Zone;
typedef AstNodeFactory<AstConstructionVisitor> Factory;
};
- class Checkpoint;
-
explicit ParserTraits(Parser* parser) : parser_(parser) {}
- // Custom operations executed when FunctionStates are created and destructed.
- template <typename FunctionState>
- static void SetUpFunctionState(FunctionState* function_state) {
- function_state->saved_id_gen_ = *function_state->ast_node_id_gen_;
- *function_state->ast_node_id_gen_ =
- AstNode::IdGen(BailoutId::FirstUsable().ToInt());
- }
-
- template <typename FunctionState>
- static void TearDownFunctionState(FunctionState* function_state) {
- if (function_state->outer_function_state_ != NULL) {
- *function_state->ast_node_id_gen_ = function_state->saved_id_gen_;
- }
- }
-
// Helper functions for recursive descent.
bool IsEvalOrArguments(const AstRawString* identifier) const;
V8_INLINE bool IsFutureStrictReserved(const AstRawString* identifier) const;
return string->AsArrayIndex(index);
}
+ bool IsConstructorProperty(ObjectLiteral::Property* property) {
+ return property->key()->raw_value()->EqualsString(
+ ast_value_factory()->constructor_string());
+ }
+
+ static Expression* GetPropertyValue(ObjectLiteral::Property* property) {
+ return property->value();
+ }
+
// Functions for encapsulating the differences between parsing and preparsing;
// operations interleaved with the recursive descent.
static void PushLiteralName(FuncNameInferrer* fni, const AstRawString* id) {
Expression* SuperReference(Scope* scope,
AstNodeFactory<AstConstructionVisitor>* factory,
int pos = RelocInfo::kNoPosition);
- Expression* ClassLiteral(const AstRawString* name, Expression* extends,
- Expression* constructor,
- ZoneList<ObjectLiteral::Property*>* properties,
- int pos,
- AstNodeFactory<AstConstructionVisitor>* factory);
+ Expression* ClassExpression(const AstRawString* name, Expression* extends,
+ Expression* constructor,
+ ZoneList<ObjectLiteral::Property*>* properties,
+ int start_position, int end_position,
+
AstNodeFactory<AstConstructionVisitor>* factory);
Literal* ExpressionFromLiteral(
Token::Value token, int pos, Scanner* scanner,
int use_counts_[v8::Isolate::kUseCounterFeatureCount];
int total_preparse_skipped_;
HistogramTimer* pre_parse_timer_;
+
+ // Temporary; for debugging. See Parser::SkipLazyFunctionBody. TODO(marja):
+ // remove this once done.
+ ScriptCompiler::CompileOptions debug_saved_compile_options_;
};
bool ParserTraits::IsFutureStrictReserved(
const AstRawString* identifier) const {
- return identifier->IsOneByteEqualTo("yield") ||
- parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
+ return parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
#include "src/base/logging.h"
#include "src/compiler.h"
#include "src/globals.h"
#include <cmath>
-#include "include/v8stdint.h"
-
#include "src/allocation.h"
#include "src/base/logging.h"
#include "src/conversions-inl.h"
#include "src/unicode.h"
#include "src/utils.h"
-#if V8_LIBC_MSVCRT && (_MSC_VER < 1800)
-namespace std {
-
-// Usually defined in math.h, but not in MSVC until VS2013+.
-// Abstracted to work
-int isfinite(double value);
-
-} // namespace std
-#endif
-
namespace v8 {
namespace internal {
-class PreParserTraits::Checkpoint
- : public ParserBase<PreParserTraits>::CheckpointBase {
- public:
- explicit Checkpoint(ParserBase<PreParserTraits>* parser)
- : ParserBase<PreParserTraits>::CheckpointBase(parser) {}
-};
-
void PreParserTraits::ReportMessageAt(Scanner::Location location,
const char* message,
const char* arg,
return PreParserIdentifier::FutureStrictReserved();
} else if (scanner->current_token() == Token::LET) {
return PreParserIdentifier::Let();
+ } else if (scanner->current_token() == Token::STATIC) {
+ return PreParserIdentifier::Static();
} else if (scanner->current_token() == Token::YIELD) {
return PreParserIdentifier::Yield();
}
if (scanner->UnescapedLiteralMatches("arguments", 9)) {
return PreParserIdentifier::Arguments();
}
- if (scanner->UnescapedLiteralMatches("prototype", 9)) {
+ if (scanner->LiteralMatches("prototype", 9)) {
return PreParserIdentifier::Prototype();
}
- if (scanner->UnescapedLiteralMatches("constructor", 11)) {
+ if (scanner->LiteralMatches("constructor", 11)) {
return PreParserIdentifier::Constructor();
}
return PreParserIdentifier::Default();
log_ = log;
// Lazy functions always have trivial outer scopes (no with/catch scopes).
PreParserScope top_scope(scope_, GLOBAL_SCOPE);
- FunctionState top_state(&function_state_, &scope_, &top_scope, NULL,
- this->ast_value_factory());
+ PreParserFactory top_factory(NULL);
+ FunctionState top_state(&function_state_, &scope_, &top_scope, &top_factory);
scope_->SetStrictMode(strict_mode);
PreParserScope function_scope(scope_, FUNCTION_SCOPE);
- FunctionState function_state(&function_state_, &scope_, &function_scope, NULL,
- this->ast_value_factory());
+ PreParserFactory function_factory(NULL);
+ FunctionState function_state(&function_state_, &scope_, &function_scope,
+ &function_factory);
function_state.set_is_generator(is_generator);
DCHECK_EQ(Token::LBRACE, scanner()->current_token());
bool ok = true;
// ConstBinding ::
// BindingPattern '=' AssignmentExpression
bool require_initializer = false;
+ bool is_strict_const = false;
if (peek() == Token::VAR) {
Consume(Token::VAR);
} else if (peek() == Token::CONST) {
*ok = false;
return Statement::Default();
}
- require_initializer = true;
+ is_strict_const = true;
+ require_initializer = var_context != kForStatement;
} else {
Scanner::Location location = scanner()->peek_location();
ReportMessageAt(location, "strict_const");
if (nvars > 0) Consume(Token::COMMA);
ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
nvars++;
- if (peek() == Token::ASSIGN || require_initializer) {
+ if (peek() == Token::ASSIGN || require_initializer ||
+ // require initializers for multiple consts.
+ (is_strict_const && peek() == Token::COMMA)) {
Expect(Token::ASSIGN, CHECK_OK);
ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);
if (decl_props != NULL) *decl_props = kHasInitializers;
// identifier.
DCHECK(!expr.AsIdentifier().IsFutureReserved());
DCHECK(strict_mode() == SLOPPY ||
- (!expr.AsIdentifier().IsFutureStrictReserved() &&
- !expr.AsIdentifier().IsYield()));
+ !IsFutureStrictReserved(expr.AsIdentifier()));
Consume(Token::COLON);
return ParseStatement(ok);
// Preparsing is disabled for extensions (because the extension details
if (peek() != Token::SEMICOLON) {
if (peek() == Token::VAR || peek() == Token::CONST ||
(peek() == Token::LET && strict_mode() == STRICT)) {
- bool is_let = peek() == Token::LET;
+ bool is_lexical = peek() == Token::LET ||
+ (peek() == Token::CONST && strict_mode() == STRICT);
int decl_count;
VariableDeclarationProperties decl_props = kHasNoInitializers;
ParseVariableDeclarations(
kForStatement, &decl_props, &decl_count, CHECK_OK);
bool has_initializers = decl_props == kHasInitializers;
- bool accept_IN = decl_count == 1 && !(is_let && has_initializers);
+ bool accept_IN = decl_count == 1 && !(is_lexical && has_initializers);
bool accept_OF = !has_initializers;
if (accept_IN && CheckInOrOf(accept_OF)) {
ParseExpression(true, CHECK_OK);
// Parse function body.
ScopeType outer_scope_type = scope_->type();
PreParserScope function_scope(scope_, FUNCTION_SCOPE);
- FunctionState function_state(&function_state_, &scope_, &function_scope, NULL,
- this->ast_value_factory());
+ PreParserFactory factory(NULL);
+ FunctionState function_state(&function_state_, &scope_, &function_scope,
+ &factory);
function_state.set_is_generator(IsGeneratorFunction(kind));
// FormalParameterList ::
// '(' (Identifier)*[','] ')'
ParserBase(Scanner* scanner, uintptr_t stack_limit, v8::Extension* extension,
ParserRecorder* log, typename Traits::Type::Zone* zone,
- AstNode::IdGen* ast_node_id_gen,
typename Traits::Type::Parser this_object)
: Traits(this_object),
parenthesized_function_(false),
allow_natives_syntax_(false),
allow_arrow_functions_(false),
allow_harmony_object_literals_(false),
- zone_(zone),
- ast_node_id_gen_(ast_node_id_gen) {}
+ zone_(zone) {}
// Getters that indicate whether certain syntactical constructs are
// allowed to be parsed by this instance of the parser.
}
protected:
- friend class Traits::Checkpoint;
-
enum AllowEvalOrArgumentsAsIdentifier {
kAllowEvalOrArguments,
kDontAllowEvalOrArguments
PARSE_EAGERLY
};
- class CheckpointBase;
+ class Checkpoint;
class ObjectLiteralChecker;
// ---------------------------------------------------------------------------
FunctionState(FunctionState** function_state_stack,
typename Traits::Type::Scope** scope_stack,
typename Traits::Type::Scope* scope,
- typename Traits::Type::Zone* zone = NULL,
- AstValueFactory* ast_value_factory = NULL,
- AstNode::IdGen* ast_node_id_gen = NULL);
- FunctionState(FunctionState** function_state_stack,
- typename Traits::Type::Scope** scope_stack,
- typename Traits::Type::Scope** scope,
- typename Traits::Type::Zone* zone = NULL,
- AstValueFactory* ast_value_factory = NULL,
- AstNode::IdGen* ast_node_id_gen = NULL);
+ typename Traits::Type::Factory* factory);
~FunctionState();
int NextMaterializedLiteralIndex() {
return generator_object_variable_;
}
- typename Traits::Type::Factory* factory() { return &factory_; }
+ typename Traits::Type::Factory* factory() { return factory_; }
private:
// Used to assign an index to each literal that needs materialization in
FunctionState* outer_function_state_;
typename Traits::Type::Scope** scope_stack_;
typename Traits::Type::Scope* outer_scope_;
- AstNode::IdGen* ast_node_id_gen_; // Only used by ParserTraits.
- AstNode::IdGen saved_id_gen_; // Ditto.
typename Traits::Type::Zone* extra_param_;
- typename Traits::Type::Factory factory_;
+ typename Traits::Type::Factory* factory_;
friend class ParserTraits;
- friend class CheckpointBase;
+ friend class Checkpoint;
};
// Annoyingly, arrow functions first parse as comma expressions, then when we
// see the => we have to go back and reinterpret the arguments as being formal
// parameters. To do so we need to reset some of the parser state back to
// what it was before the arguments were first seen.
- class CheckpointBase BASE_EMBEDDED {
+ class Checkpoint BASE_EMBEDDED {
public:
- explicit CheckpointBase(ParserBase* parser) {
+ explicit Checkpoint(ParserBase* parser) {
function_state_ = parser->function_state_;
next_materialized_literal_index_ =
function_state_->next_materialized_literal_index_;
void set_stack_overflow() { stack_overflow_ = true; }
Mode mode() const { return mode_; }
typename Traits::Type::Zone* zone() const { return zone_; }
- AstNode::IdGen* ast_node_id_gen() const { return ast_node_id_gen_; }
INLINE(Token::Value peek()) {
if (stack_overflow_) return Token::ILLEGAL;
bool peek_any_identifier() {
Token::Value next = peek();
- return next == Token::IDENTIFIER ||
- next == Token::FUTURE_RESERVED_WORD ||
- next == Token::FUTURE_STRICT_RESERVED_WORD ||
- next == Token::LET ||
- next == Token::YIELD;
+ return next == Token::IDENTIFIER || next == Token::FUTURE_RESERVED_WORD ||
+ next == Token::FUTURE_STRICT_RESERVED_WORD || next == Token::LET ||
+ next == Token::STATIC || next == Token::YIELD;
}
bool CheckContextualKeyword(Vector<const char> keyword) {
- if (peek() == Token::IDENTIFIER &&
- scanner()->is_next_contextual_keyword(keyword)) {
+ if (PeekContextualKeyword(keyword)) {
Consume(Token::IDENTIFIER);
return true;
}
return false;
}
+ bool PeekContextualKeyword(Vector<const char> keyword) {
+ return peek() == Token::IDENTIFIER &&
+ scanner()->is_next_contextual_keyword(keyword);
+ }
+
void ExpectContextualKeyword(Vector<const char> keyword, bool* ok) {
Expect(Token::IDENTIFIER, ok);
if (!*ok) return;
ExpressionT ParseObjectLiteral(bool* ok);
ObjectLiteralPropertyT ParsePropertyDefinition(ObjectLiteralChecker* checker,
bool in_class, bool is_static,
+ bool* has_seen_constructor,
bool* ok);
typename Traits::Type::ExpressionList ParseArguments(bool* ok);
ExpressionT ParseAssignmentExpression(bool accept_IN, bool* ok);
bool allow_harmony_object_literals_;
typename Traits::Type::Zone* zone_; // Only used by Parser.
- AstNode::IdGen* ast_node_id_gen_;
};
static PreParserIdentifier Let() {
return PreParserIdentifier(kLetIdentifier);
}
+ static PreParserIdentifier Static() {
+ return PreParserIdentifier(kStaticIdentifier);
+ }
static PreParserIdentifier Yield() {
return PreParserIdentifier(kYieldIdentifier);
}
return PreParserIdentifier(kConstructorIdentifier);
}
bool IsEval() const { return type_ == kEvalIdentifier; }
- bool IsArguments() const { return type_ == kArgumentsIdentifier; }
+ bool IsArguments(const AstValueFactory* = NULL) const {
+ return type_ == kArgumentsIdentifier;
+ }
+ bool IsLet() const { return type_ == kLetIdentifier; }
+ bool IsStatic() const { return type_ == kStaticIdentifier; }
bool IsYield() const { return type_ == kYieldIdentifier; }
bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
bool IsConstructor() const { return type_ == kConstructorIdentifier; }
}
bool IsFutureReserved() const { return type_ == kFutureReservedIdentifier; }
bool IsFutureStrictReserved() const {
- return type_ == kFutureStrictReservedIdentifier;
+ return type_ == kFutureStrictReservedIdentifier ||
+ type_ == kLetIdentifier || type_ == kStaticIdentifier ||
+ type_ == kYieldIdentifier;
}
bool IsValidStrictVariable() const { return type_ == kUnknownIdentifier; }
+ V8_INLINE bool IsValidArrowParam() const {
+ // A valid identifier can be an arrow function parameter
+ // except for eval, arguments, yield, and reserved keywords.
+ return !(IsEval() || IsArguments() || IsFutureStrictReserved());
+ }
// Allow identifier->name()[->length()] to work. The preparser
// does not need the actual positions/lengths of the identifiers.
kFutureReservedIdentifier,
kFutureStrictReservedIdentifier,
kLetIdentifier,
+ kStaticIdentifier,
kYieldIdentifier,
kEvalIdentifier,
kArgumentsIdentifier,
};
-// Bits 0 and 1 are used to identify the type of expression:
-// If bit 0 is set, it's an identifier.
-// if bit 1 is set, it's a string literal.
-// If neither is set, it's no particular type, and both set isn't
-// use yet.
class PreParserExpression {
public:
static PreParserExpression Default() {
- return PreParserExpression(kUnknownExpression);
+ return PreParserExpression(TypeField::encode(kExpression));
}
static PreParserExpression FromIdentifier(PreParserIdentifier id) {
- return PreParserExpression(kTypeIdentifier |
- (id.type_ << kIdentifierShift));
+ return PreParserExpression(TypeField::encode(kIdentifierExpression) |
+ IdentifierTypeField::encode(id.type_));
}
static PreParserExpression BinaryOperation(PreParserExpression left,
Token::Value op,
PreParserExpression right) {
- int code = ((op == Token::COMMA) && !left.is_parenthesized() &&
- !right.is_parenthesized())
- ? left.ArrowParamListBit() & right.ArrowParamListBit()
- : 0;
- return PreParserExpression(kTypeBinaryOperation | code);
+ bool valid_arrow_param_list =
+ op == Token::COMMA && !left.is_parenthesized() &&
+ !right.is_parenthesized() && left.IsValidArrowParams() &&
+ right.IsValidArrowParams();
+ return PreParserExpression(
+ TypeField::encode(kBinaryOperationExpression) |
+ IsValidArrowParamListField::encode(valid_arrow_param_list));
}
static PreParserExpression EmptyArrowParamList() {
}
static PreParserExpression StringLiteral() {
- return PreParserExpression(kUnknownStringLiteral);
+ return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
+ IsUseStrictField::encode(false));
}
static PreParserExpression UseStrictStringLiteral() {
- return PreParserExpression(kUseStrictString);
+ return PreParserExpression(TypeField::encode(kStringLiteralExpression) |
+ IsUseStrictField::encode(true));
}
static PreParserExpression This() {
- return PreParserExpression(kThisExpression);
+ return PreParserExpression(TypeField::encode(kExpression) |
+ ExpressionTypeField::encode(kThisExpression));
}
static PreParserExpression Super() {
- return PreParserExpression(kSuperExpression);
+ return PreParserExpression(TypeField::encode(kExpression) |
+ ExpressionTypeField::encode(kSuperExpression));
}
static PreParserExpression ThisProperty() {
- return PreParserExpression(kThisPropertyExpression);
+ return PreParserExpression(
+ TypeField::encode(kExpression) |
+ ExpressionTypeField::encode(kThisPropertyExpression));
}
static PreParserExpression Property() {
- return PreParserExpression(kPropertyExpression);
+ return PreParserExpression(
+ TypeField::encode(kExpression) |
+ ExpressionTypeField::encode(kPropertyExpression));
}
static PreParserExpression Call() {
- return PreParserExpression(kCallExpression);
+ return PreParserExpression(TypeField::encode(kExpression) |
+ ExpressionTypeField::encode(kCallExpression));
}
- bool IsIdentifier() const { return (code_ & kTypeMask) == kTypeIdentifier; }
+ bool IsIdentifier() const {
+ return TypeField::decode(code_) == kIdentifierExpression;
+ }
PreParserIdentifier AsIdentifier() const {
DCHECK(IsIdentifier());
- return PreParserIdentifier(
- static_cast<PreParserIdentifier::Type>(code_ >> kIdentifierShift));
+ return PreParserIdentifier(IdentifierTypeField::decode(code_));
}
bool IsStringLiteral() const {
- return (code_ & kTypeMask) == kTypeStringLiteral;
+ return TypeField::decode(code_) == kStringLiteralExpression;
}
bool IsUseStrictLiteral() const {
- return (code_ & kUseStrictString) == kUseStrictString;
+ return TypeField::decode(code_) == kStringLiteralExpression &&
+ IsUseStrictField::decode(code_);
}
- bool IsThis() const { return (code_ & kThisExpression) == kThisExpression; }
+ bool IsThis() const {
+ return TypeField::decode(code_) == kExpression &&
+ ExpressionTypeField::decode(code_) == kThisExpression;
+ }
bool IsThisProperty() const {
- return (code_ & kThisPropertyExpression) == kThisPropertyExpression;
+ return TypeField::decode(code_) == kExpression &&
+ ExpressionTypeField::decode(code_) == kThisPropertyExpression;
}
bool IsProperty() const {
- return (code_ & kPropertyExpression) == kPropertyExpression ||
- (code_ & kThisPropertyExpression) == kThisPropertyExpression;
+ return TypeField::decode(code_) == kExpression &&
+ (ExpressionTypeField::decode(code_) == kPropertyExpression ||
+ ExpressionTypeField::decode(code_) == kThisPropertyExpression);
}
- bool IsCall() const { return (code_ & kCallExpression) == kCallExpression; }
+ bool IsCall() const {
+ return TypeField::decode(code_) == kExpression &&
+ ExpressionTypeField::decode(code_) == kCallExpression;
+ }
bool IsValidReferenceExpression() const {
return IsIdentifier() || IsProperty();
}
bool IsValidArrowParamList() const {
- return (ArrowParamListBit() & kBinaryOperationArrowParamList) != 0 &&
- (code_ & kMultiParenthesizedExpression) == 0;
+ return IsValidArrowParams() &&
+ ParenthesizationField::decode(code_) !=
+ kMultiParenthesizedExpression;
}
// At the moment PreParser doesn't track these expression types.
PreParserExpression AsFunctionLiteral() { return *this; }
bool IsBinaryOperation() const {
- return (code_ & kTypeMask) == kTypeBinaryOperation;
+ return TypeField::decode(code_) == kBinaryOperationExpression;
}
bool is_parenthesized() const {
- return (code_ & kParenthesizedExpression) != 0;
+ return ParenthesizationField::decode(code_) != kNotParenthesized;
}
void increase_parenthesization_level() {
- code_ |= is_parenthesized() ? kMultiParenthesizedExpression
- : kParenthesizedExpression;
+ code_ = ParenthesizationField::update(
+ code_, is_parenthesized() ? kMultiParenthesizedExpression
+ : kParanthesizedExpression);
}
// Dummy implementation for making expression->somefunc() work in both Parser
void set_ast_properties(int* ast_properties) {}
void set_dont_optimize_reason(BailoutReason dont_optimize_reason) {}
- bool operator==(const PreParserExpression& other) const {
- return code_ == other.code_;
- }
- bool operator!=(const PreParserExpression& other) const {
- return code_ != other.code_;
- }
-
private:
- // Least significant 2 bits are used as expression type. The third least
- // significant bit tracks whether an expression is parenthesized. If the
- // expression is an identifier or a string literal, the other bits
- // describe the type/ (see PreParserIdentifier::Type and string literal
- // constants below). For binary operations, the other bits are flags
- // which further describe the contents of the expression.
- enum {
- kUnknownExpression = 0,
- kTypeMask = 1 | 2,
- kParenthesizedExpression = (1 << 2),
- kMultiParenthesizedExpression = (1 << 3),
-
- // Identifiers
- kTypeIdentifier = 1, // Used to detect labels.
- kIdentifierShift = 5,
- kTypeStringLiteral = 2, // Used to detect directive prologue.
- kUnknownStringLiteral = kTypeStringLiteral,
- kUseStrictString = kTypeStringLiteral | 32,
- kStringLiteralMask = kUseStrictString,
-
- // Binary operations. Those are needed to detect certain keywords and
- // duplicated identifier in parameter lists for arrow functions, because
- // they are initially parsed as comma-separated expressions.
- kTypeBinaryOperation = 3,
- kBinaryOperationArrowParamList = (1 << 4),
-
- // Below here applies if neither identifier nor string literal. Reserve the
- // 2 least significant bits for flags.
- kThisExpression = (1 << 4),
- kThisPropertyExpression = (2 << 4),
- kPropertyExpression = (3 << 4),
- kCallExpression = (4 << 4),
- kSuperExpression = (5 << 4)
+ enum Type {
+ kExpression,
+ kIdentifierExpression,
+ kStringLiteralExpression,
+ kBinaryOperationExpression
};
- explicit PreParserExpression(int expression_code) : code_(expression_code) {}
+ enum Parenthesization {
+ kNotParenthesized,
+ kParanthesizedExpression,
+ kMultiParenthesizedExpression
+ };
- V8_INLINE int ArrowParamListBit() const {
- if (IsBinaryOperation()) return code_ & kBinaryOperationArrowParamList;
- if (IsIdentifier()) {
- const PreParserIdentifier ident = AsIdentifier();
- // A valid identifier can be an arrow function parameter list
- // except for eval, arguments, yield, and reserved keywords.
- if (ident.IsEval() || ident.IsArguments() || ident.IsYield() ||
- ident.IsFutureStrictReserved())
- return 0;
- return kBinaryOperationArrowParamList;
- }
- return 0;
+ enum ExpressionType {
+ kThisExpression,
+ kThisPropertyExpression,
+ kPropertyExpression,
+ kCallExpression,
+ kSuperExpression
+ };
+
+ explicit PreParserExpression(uint32_t expression_code)
+ : code_(expression_code) {}
+
+ V8_INLINE bool IsValidArrowParams() const {
+ return IsBinaryOperation()
+ ? IsValidArrowParamListField::decode(code_)
+ : (IsIdentifier() && AsIdentifier().IsValidArrowParam());
}
- int code_;
+ // The first four bits are for the Type and Parenthesization.
+ typedef BitField<Type, 0, 2> TypeField;
+ typedef BitField<Parenthesization, TypeField::kNext, 2> ParenthesizationField;
+
+ // The rest of the bits are interpreted depending on the value
+ // of the Type field, so they can share the storage.
+ typedef BitField<ExpressionType, ParenthesizationField::kNext, 3>
+ ExpressionTypeField;
+ typedef BitField<bool, ParenthesizationField::kNext, 1> IsUseStrictField;
+ typedef BitField<bool, ParenthesizationField::kNext, 1>
+ IsValidArrowParamListField;
+ typedef BitField<PreParserIdentifier::Type, ParenthesizationField::kNext, 10>
+ IdentifierTypeField;
+
+ uint32_t code_;
};
bool IsDeclared(const PreParserIdentifier& identifier) const { return false; }
void DeclareParameter(const PreParserIdentifier& identifier, VariableMode) {}
+ void RecordArgumentsUsage() {}
+ void RecordThisUsage() {}
// Allow scope->Foo() to work.
PreParserScope* operator->() { return this; }
class PreParserFactory {
public:
- PreParserFactory(void*, void*, void*) {}
+ explicit PreParserFactory(void* unused_value_factory) {}
PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
int pos) {
return PreParserExpression::Default();
PreParserExpression extends,
PreParserExpression constructor,
PreParserExpressionList properties,
- int position) {
+ int start_position, int end_position) {
return PreParserExpression::Default();
}
// Used by FunctionState and BlockState.
typedef PreParserScope Scope;
typedef PreParserScope ScopePtr;
+ inline static Scope* ptr_to_scope(ScopePtr& scope) { return &scope; }
// PreParser doesn't need to store generator variables.
typedef void GeneratorVariable;
typedef PreParserFactory Factory;
};
- class Checkpoint;
-
explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
- // Custom operations executed when FunctionStates are created and
- // destructed. (The PreParser doesn't need to do anything.)
- template <typename FunctionState>
- static void SetUpFunctionState(FunctionState* function_state) {}
- template <typename FunctionState>
- static void TearDownFunctionState(FunctionState* function_state) {}
-
// Helper functions for recursive descent.
static bool IsEvalOrArguments(PreParserIdentifier identifier) {
return identifier.IsEvalOrArguments();
}
static bool IsFutureStrictReserved(PreParserIdentifier identifier) {
- return identifier.IsYield() || identifier.IsFutureStrictReserved();
+ return identifier.IsFutureStrictReserved();
}
static bool IsBoilerplateProperty(PreParserExpression property) {
return false;
}
+ static PreParserExpression GetPropertyValue(PreParserExpression property) {
+ return PreParserExpression::Default();
+ }
+
// Functions for encapsulating the differences between parsing and preparsing;
// operations interleaved with the recursive descent.
static void PushLiteralName(FuncNameInferrer* fni, PreParserIdentifier id) {
return PreParserExpression::Super();
}
- static PreParserExpression ClassLiteral(PreParserIdentifier name,
- PreParserExpression extends,
- PreParserExpression constructor,
- PreParserExpressionList properties,
- int position,
- PreParserFactory* factory) {
+ static PreParserExpression ClassExpression(
+ PreParserIdentifier name, PreParserExpression extends,
+ PreParserExpression constructor, PreParserExpressionList properties,
+ int start_position, int end_position, PreParserFactory* factory) {
return PreParserExpression::Default();
}
};
PreParser(Scanner* scanner, ParserRecorder* log, uintptr_t stack_limit)
- : ParserBase<PreParserTraits>(scanner, stack_limit, NULL, log, NULL, NULL,
+ : ParserBase<PreParserTraits>(scanner, stack_limit, NULL, log, NULL,
this) {}
// Pre-parse the program from the character stream; returns true on
// during parsing.
PreParseResult PreParseProgram() {
PreParserScope scope(scope_, GLOBAL_SCOPE);
- FunctionState top_scope(&function_state_, &scope_, &scope);
+ PreParserFactory factory(NULL);
+ FunctionState top_scope(&function_state_, &scope_, &scope, &factory);
bool ok = true;
int start_position = scanner()->peek_location().beg_pos;
ParseSourceElements(Token::EOS, &ok);
ParserBase<Traits>::FunctionState::FunctionState(
FunctionState** function_state_stack,
typename Traits::Type::Scope** scope_stack,
- typename Traits::Type::Scope* scope, typename Traits::Type::Zone* zone,
- AstValueFactory* ast_value_factory, AstNode::IdGen* ast_node_id_gen)
+ typename Traits::Type::Scope* scope,
+ typename Traits::Type::Factory* factory)
: next_materialized_literal_index_(JSFunction::kLiteralsPrefixSize),
next_handler_index_(0),
expected_property_count_(0),
outer_function_state_(*function_state_stack),
scope_stack_(scope_stack),
outer_scope_(*scope_stack),
- ast_node_id_gen_(ast_node_id_gen),
- factory_(zone, ast_value_factory, ast_node_id_gen) {
+ factory_(factory) {
*scope_stack_ = scope;
*function_state_stack = this;
- Traits::SetUpFunctionState(this);
-}
-
-
-template <class Traits>
-ParserBase<Traits>::FunctionState::FunctionState(
- FunctionState** function_state_stack,
- typename Traits::Type::Scope** scope_stack,
- typename Traits::Type::Scope** scope, typename Traits::Type::Zone* zone,
- AstValueFactory* ast_value_factory, AstNode::IdGen* ast_node_id_gen)
- : next_materialized_literal_index_(JSFunction::kLiteralsPrefixSize),
- next_handler_index_(0),
- expected_property_count_(0),
- is_generator_(false),
- generator_object_variable_(NULL),
- function_state_stack_(function_state_stack),
- outer_function_state_(*function_state_stack),
- scope_stack_(scope_stack),
- outer_scope_(*scope_stack),
- ast_node_id_gen_(ast_node_id_gen),
- factory_(zone, ast_value_factory, ast_node_id_gen) {
- *scope_stack_ = *scope;
- *function_state_stack = this;
- Traits::SetUpFunctionState(this);
}
ParserBase<Traits>::FunctionState::~FunctionState() {
*scope_stack_ = outer_scope_;
*function_state_stack_ = outer_function_state_;
- Traits::TearDownFunctionState(this);
}
case Token::FUTURE_RESERVED_WORD:
return ReportMessageAt(source_location, "unexpected_reserved");
case Token::LET:
+ case Token::STATIC:
case Token::YIELD:
case Token::FUTURE_STRICT_RESERVED_WORD:
return ReportMessageAt(source_location, strict_mode() == SLOPPY
ReportMessage("strict_eval_arguments");
*ok = false;
}
+ if (name->IsArguments(this->ast_value_factory()))
+ scope_->RecordArgumentsUsage();
return name;
} else if (strict_mode() == SLOPPY &&
(next == Token::FUTURE_STRICT_RESERVED_WORD ||
- (next == Token::LET) ||
- (next == Token::YIELD && !is_generator()))) {
+ next == Token::LET || next == Token::STATIC ||
+ (next == Token::YIELD && !is_generator()))) {
return this->GetSymbol(scanner());
} else {
this->ReportUnexpectedToken(next);
Token::Value next = Next();
if (next == Token::IDENTIFIER) {
*is_strict_reserved = false;
- } else if (next == Token::FUTURE_STRICT_RESERVED_WORD ||
- next == Token::LET ||
+ } else if (next == Token::FUTURE_STRICT_RESERVED_WORD || next == Token::LET ||
+ next == Token::STATIC ||
(next == Token::YIELD && !this->is_generator())) {
*is_strict_reserved = true;
} else {
*ok = false;
return Traits::EmptyIdentifier();
}
- return this->GetSymbol(scanner());
+
+ IdentifierT name = this->GetSymbol(scanner());
+ if (name->IsArguments(this->ast_value_factory()))
+ scope_->RecordArgumentsUsage();
+ return name;
}
ParserBase<Traits>::ParseIdentifierName(bool* ok) {
Token::Value next = Next();
if (next != Token::IDENTIFIER && next != Token::FUTURE_RESERVED_WORD &&
- next != Token::LET && next != Token::YIELD &&
+ next != Token::LET && next != Token::STATIC && next != Token::YIELD &&
next != Token::FUTURE_STRICT_RESERVED_WORD && !Token::IsKeyword(next)) {
this->ReportUnexpectedToken(next);
*ok = false;
return Traits::EmptyIdentifier();
}
- return this->GetSymbol(scanner());
+
+ IdentifierT name = this->GetSymbol(scanner());
+ if (name->IsArguments(this->ast_value_factory()))
+ scope_->RecordArgumentsUsage();
+ return name;
}
IdentifierT js_pattern = this->GetNextSymbol(scanner());
if (!scanner()->ScanRegExpFlags()) {
Next();
- ReportMessage("invalid_regexp_flags");
+ ReportMessage("malformed_regexp_flags");
*ok = false;
return Traits::EmptyExpression();
}
switch (token) {
case Token::THIS: {
Consume(Token::THIS);
+ scope_->RecordThisUsage();
result = this->ThisExpression(scope_, factory());
break;
}
case Token::IDENTIFIER:
case Token::LET:
+ case Token::STATIC:
case Token::YIELD:
case Token::FUTURE_STRICT_RESERVED_WORD: {
// Using eval or arguments in this context is OK even in strict mode.
template <class Traits>
typename ParserBase<Traits>::ObjectLiteralPropertyT ParserBase<
Traits>::ParsePropertyDefinition(ObjectLiteralChecker* checker,
- bool in_class, bool is_static, bool* ok) {
+ bool in_class, bool is_static,
+ bool* has_seen_constructor, bool* ok) {
+ DCHECK(!in_class || is_static || has_seen_constructor != NULL);
ExpressionT value = this->EmptyExpression();
bool is_get = false;
bool is_set = false;
if (!in_class && !is_generator && peek() == Token::COLON) {
// PropertyDefinition : PropertyName ':' AssignmentExpression
- checker->CheckProperty(name_token, kValueProperty,
- CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ if (checker != NULL) {
+ checker->CheckProperty(name_token, kValueProperty,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ }
Consume(Token::COLON);
value = this->ParseAssignmentExpression(
true, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
*ok = false;
return this->EmptyObjectLiteralProperty();
}
- if (is_generator && in_class && !is_static && this->IsConstructor(name)) {
- ReportMessageAt(scanner()->location(), "constructor_special_method");
- *ok = false;
- return this->EmptyObjectLiteralProperty();
- }
- checker->CheckProperty(name_token, kValueProperty,
- CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
FunctionKind kind = is_generator ? FunctionKind::kConciseGeneratorMethod
: FunctionKind::kConciseMethod;
+ if (in_class && !is_static && this->IsConstructor(name)) {
+ if (is_generator) {
+ ReportMessageAt(scanner()->location(), "constructor_special_method");
+ *ok = false;
+ return this->EmptyObjectLiteralProperty();
+ }
+
+ if (*has_seen_constructor) {
+ ReportMessageAt(scanner()->location(), "duplicate_constructor");
+ *ok = false;
+ return this->EmptyObjectLiteralProperty();
+ }
+
+ *has_seen_constructor = true;
+ kind = FunctionKind::kNormalFunction;
+ }
+
+ if (checker != NULL) {
+ checker->CheckProperty(name_token, kValueProperty,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ }
+
value = this->ParseFunctionLiteral(
name, scanner()->location(),
false, // reserved words are allowed here
} else if (in_class && name_is_static && !is_static) {
// static MethodDefinition
- return ParsePropertyDefinition(checker, true, true, ok);
+ return ParsePropertyDefinition(checker, true, true, NULL, ok);
} else if (is_get || is_set) {
// Accessor
*ok = false;
return this->EmptyObjectLiteralProperty();
} else if (in_class && !is_static && this->IsConstructor(name)) {
- // ES6, spec draft rev 27, treats static get constructor as an error too.
- // https://bugs.ecmascript.org/show_bug.cgi?id=3223
- // TODO(arv): Update when bug is resolved.
ReportMessageAt(scanner()->location(), "constructor_special_method");
*ok = false;
return this->EmptyObjectLiteralProperty();
}
- checker->CheckProperty(name_token,
- is_get ? kGetterProperty : kSetterProperty,
- CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ if (checker != NULL) {
+ checker->CheckProperty(name_token,
+ is_get ? kGetterProperty : kSetterProperty,
+ CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+ }
typename Traits::Type::FunctionLiteral value = this->ParseFunctionLiteral(
name, scanner()->location(),
CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
return factory()->NewObjectLiteralProperty(is_get, value, next_pos,
is_static);
+
+ } else if (!in_class && allow_harmony_object_literals_ &&
+ Token::IsIdentifier(name_token, strict_mode(),
+ this->is_generator())) {
+ value = this->ExpressionFromIdentifier(name, next_pos, scope_, factory());
+
} else {
Token::Value next = Next();
ReportUnexpectedToken(next);
const bool in_class = false;
const bool is_static = false;
- ObjectLiteralPropertyT property =
- this->ParsePropertyDefinition(&checker, in_class, is_static, CHECK_OK);
+ ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
+ &checker, in_class, is_static, NULL, CHECK_OK);
// Mark top-level object literals that contain function literals and
// pretenure the literal so it can be added as a constant function
}
if (fni_ != NULL) fni_->Enter();
- typename Traits::Checkpoint checkpoint(this);
+ ParserBase<Traits>::Checkpoint checkpoint(this);
ExpressionT expression =
this->ParseConditionalExpression(accept_IN, CHECK_OK);
typename ParserBase<Traits>::ExpressionT ParserBase<
Traits>::ParseArrowFunctionLiteral(int start_pos, ExpressionT params_ast,
bool* ok) {
- // TODO(aperez): Change this to use ARROW_SCOPE
- typename Traits::Type::ScopePtr scope =
- this->NewScope(scope_, FUNCTION_SCOPE);
+ typename Traits::Type::ScopePtr scope = this->NewScope(scope_, ARROW_SCOPE);
typename Traits::Type::StatementList body;
typename Traits::Type::AstProperties ast_properties;
BailoutReason dont_optimize_reason = kNoReason;
int handler_count = 0;
{
- FunctionState function_state(&function_state_, &scope_, &scope, zone(),
- this->ast_value_factory(), ast_node_id_gen_);
+ typename Traits::Type::Factory function_factory(this->ast_value_factory());
+ FunctionState function_state(&function_state_, &scope_,
+ Traits::Type::ptr_to_scope(scope),
+ &function_factory);
Scanner::Location dupe_error_loc = Scanner::Location::invalid();
num_parameters = Traits::DeclareArrowParametersFromExpression(
params_ast, scope_, &dupe_error_loc, ok);
return this->EmptyExpression();
}
- // TODO(arv): Implement scopes and name binding in class body only.
- // TODO(arv): Maybe add CLASS_SCOPE?
- typename Traits::Type::ScopePtr extends_scope =
- this->NewScope(scope_, BLOCK_SCOPE);
- FunctionState extends_function_state(
- &function_state_, &scope_, &extends_scope, zone(),
- this->ast_value_factory(), ast_node_id_gen_);
- scope_->SetStrictMode(STRICT);
- scope_->SetScopeName(name);
-
ExpressionT extends = this->EmptyExpression();
if (Check(Token::EXTENDS)) {
+ typename Traits::Type::ScopePtr scope = this->NewScope(scope_, BLOCK_SCOPE);
+ BlockState block_state(&scope_, Traits::Type::ptr_to_scope(scope));
+ scope_->SetStrictMode(STRICT);
extends = this->ParseLeftHandSideExpression(CHECK_OK);
}
- ObjectLiteralChecker checker(this, STRICT);
+ // TODO(arv): Implement scopes and name binding in class body only.
+ typename Traits::Type::ScopePtr scope = this->NewScope(scope_, BLOCK_SCOPE);
+ BlockState block_state(&scope_, Traits::Type::ptr_to_scope(scope));
+ scope_->SetStrictMode(STRICT);
+ scope_->SetScopeName(name);
+
typename Traits::Type::PropertyList properties =
this->NewPropertyList(4, zone_);
- FunctionLiteralT constructor = this->EmptyFunctionLiteral();
+ ExpressionT constructor = this->EmptyExpression();
+ bool has_seen_constructor = false;
Expect(Token::LBRACE, CHECK_OK);
while (peek() != Token::RBRACE) {
if (Check(Token::SEMICOLON)) continue;
if (fni_ != NULL) fni_->Enter();
-
const bool in_class = true;
const bool is_static = false;
- ObjectLiteralPropertyT property =
- this->ParsePropertyDefinition(&checker, in_class, is_static, CHECK_OK);
+ bool old_has_seen_constructor = has_seen_constructor;
+ ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
+ NULL, in_class, is_static, &has_seen_constructor, CHECK_OK);
- properties->Add(property, zone());
+ if (has_seen_constructor != old_has_seen_constructor) {
+ constructor = this->GetPropertyValue(property);
+ } else {
+ properties->Add(property, zone());
+ }
if (fni_ != NULL) {
fni_->Infer();
fni_->Leave();
}
}
+
+ int end_pos = peek_position();
Expect(Token::RBRACE, CHECK_OK);
- return this->ClassLiteral(name, extends, constructor, properties, pos,
- factory());
+ return this->ClassExpression(name, extends, constructor, properties, pos,
+ end_pos + 1, factory());
}
namespace v8 {
namespace internal {
-CodeEntry::CodeEntry(Logger::LogEventsAndTags tag,
- const char* name,
- const char* name_prefix,
- const char* resource_name,
- int line_number,
- int column_number)
- : tag_(tag),
- builtin_id_(Builtins::builtin_count),
+CodeEntry::CodeEntry(Logger::LogEventsAndTags tag, const char* name,
+ const char* name_prefix, const char* resource_name,
+ int line_number, int column_number,
+ JITLineInfoTable* line_info, Address instruction_start)
+ : bit_field_(TagField::encode(tag) |
+ BuiltinIdField::encode(Builtins::builtin_count)),
name_prefix_(name_prefix),
name_(name),
resource_name_(resource_name),
shared_id_(0),
script_id_(v8::UnboundScript::kNoScriptId),
no_frame_ranges_(NULL),
- bailout_reason_(kEmptyBailoutReason) { }
+ bailout_reason_(kEmptyBailoutReason),
+ line_info_(line_info),
+ instruction_start_(instruction_start) {}
bool CodeEntry::is_js_function_tag(Logger::LogEventsAndTags tag) {
entry_(entry),
self_ticks_(0),
children_(CodeEntriesMatch),
- id_(tree->next_node_id()) { }
-
+ id_(tree->next_node_id()),
+ line_ticks_(LineTickMatch) {}
} } // namespace v8::internal
#endif // V8_PROFILE_GENERATOR_INL_H_
}
+JITLineInfoTable::JITLineInfoTable() {}
+
+
+JITLineInfoTable::~JITLineInfoTable() {}
+
+
+void JITLineInfoTable::SetPosition(int pc_offset, int line) {
+ DCHECK(pc_offset >= 0);
+ DCHECK(line > 0); // The 1-based number of the source line.
+ if (GetSourceLineNumber(pc_offset) != line) {
+ pc_offset_map_.insert(std::make_pair(pc_offset, line));
+ }
+}
+
+
+int JITLineInfoTable::GetSourceLineNumber(int pc_offset) const {
+ PcOffsetMap::const_iterator it = pc_offset_map_.lower_bound(pc_offset);
+ if (it == pc_offset_map_.end()) {
+ if (pc_offset_map_.empty()) return v8::CpuProfileNode::kNoLineNumberInfo;
+ return (--pc_offset_map_.end())->second;
+ }
+ return it->second;
+}
+
+
const char* const CodeEntry::kEmptyNamePrefix = "";
const char* const CodeEntry::kEmptyResourceName = "";
const char* const CodeEntry::kEmptyBailoutReason = "";
CodeEntry::~CodeEntry() {
delete no_frame_ranges_;
+ delete line_info_;
}
uint32_t CodeEntry::GetCallUid() const {
- uint32_t hash = ComputeIntegerHash(tag_, v8::internal::kZeroHashSeed);
+ uint32_t hash = ComputeIntegerHash(tag(), v8::internal::kZeroHashSeed);
if (shared_id_ != 0) {
hash ^= ComputeIntegerHash(static_cast<uint32_t>(shared_id_),
v8::internal::kZeroHashSeed);
bool CodeEntry::IsSameAs(CodeEntry* entry) const {
- return this == entry
- || (tag_ == entry->tag_
- && shared_id_ == entry->shared_id_
- && (shared_id_ != 0
- || (name_prefix_ == entry->name_prefix_
- && name_ == entry->name_
- && resource_name_ == entry->resource_name_
- && line_number_ == entry->line_number_)));
+ return this == entry ||
+ (tag() == entry->tag() && shared_id_ == entry->shared_id_ &&
+ (shared_id_ != 0 ||
+ (name_prefix_ == entry->name_prefix_ && name_ == entry->name_ &&
+ resource_name_ == entry->resource_name_ &&
+ line_number_ == entry->line_number_)));
}
void CodeEntry::SetBuiltinId(Builtins::Name id) {
- tag_ = Logger::BUILTIN_TAG;
- builtin_id_ = id;
+ bit_field_ = TagField::update(bit_field_, Logger::BUILTIN_TAG);
+ bit_field_ = BuiltinIdField::update(bit_field_, id);
+}
+
+
+int CodeEntry::GetSourceLine(int pc_offset) const {
+ if (line_info_ && !line_info_->empty()) {
+ return line_info_->GetSourceLineNumber(pc_offset);
+ }
+ return v8::CpuProfileNode::kNoLineNumberInfo;
}
}
+void ProfileNode::IncrementLineTicks(int src_line) {
+ if (src_line == v8::CpuProfileNode::kNoLineNumberInfo) return;
+ // Increment a hit counter of a certain source line.
+ // Add a new source line if not found.
+ HashMap::Entry* e =
+ line_ticks_.Lookup(reinterpret_cast<void*>(src_line), src_line, true);
+ DCHECK(e);
+ e->value = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(e->value) + 1);
+}
+
+
+bool ProfileNode::GetLineTicks(v8::CpuProfileNode::LineTick* entries,
+ unsigned int length) const {
+ if (entries == NULL || length == 0) return false;
+
+ unsigned line_count = line_ticks_.occupancy();
+
+ if (line_count == 0) return true;
+ if (length < line_count) return false;
+
+ v8::CpuProfileNode::LineTick* entry = entries;
+
+ for (HashMap::Entry* p = line_ticks_.Start(); p != NULL;
+ p = line_ticks_.Next(p), entry++) {
+ entry->line =
+ static_cast<unsigned int>(reinterpret_cast<uintptr_t>(p->key));
+ entry->hit_count =
+ static_cast<unsigned int>(reinterpret_cast<uintptr_t>(p->value));
+ }
+
+ return true;
+}
+
+
void ProfileNode::Print(int indent) {
base::OS::Print("%5u %*s %s%s %d #%d %s", self_ticks_, indent, "",
entry_->name_prefix(), entry_->name(), entry_->script_id(),
}
-ProfileNode* ProfileTree::AddPathFromEnd(const Vector<CodeEntry*>& path) {
+ProfileNode* ProfileTree::AddPathFromEnd(const Vector<CodeEntry*>& path,
+ int src_line) {
ProfileNode* node = root_;
for (CodeEntry** entry = path.start() + path.length() - 1;
entry != path.start() - 1;
}
}
node->IncrementSelfTicks();
+ if (src_line != v8::CpuProfileNode::kNoLineNumberInfo) {
+ node->IncrementLineTicks(src_line);
+ }
return node;
}
-void ProfileTree::AddPathFromStart(const Vector<CodeEntry*>& path) {
+void ProfileTree::AddPathFromStart(const Vector<CodeEntry*>& path,
+ int src_line) {
ProfileNode* node = root_;
for (CodeEntry** entry = path.start();
entry != path.start() + path.length();
}
}
node->IncrementSelfTicks();
+ if (src_line != v8::CpuProfileNode::kNoLineNumberInfo) {
+ node->IncrementLineTicks(src_line);
+ }
}
void CpuProfile::AddPath(base::TimeTicks timestamp,
- const Vector<CodeEntry*>& path) {
- ProfileNode* top_frame_node = top_down_.AddPathFromEnd(path);
+ const Vector<CodeEntry*>& path, int src_line) {
+ ProfileNode* top_frame_node = top_down_.AddPathFromEnd(path, src_line);
if (record_samples_) {
timestamps_.Add(timestamp);
samples_.Add(top_frame_node);
void CpuProfilesCollection::AddPathToCurrentProfiles(
- base::TimeTicks timestamp, const Vector<CodeEntry*>& path) {
+ base::TimeTicks timestamp, const Vector<CodeEntry*>& path, int src_line) {
// As starting / stopping profiles is rare relatively to this
// method, we don't bother minimizing the duration of lock holding,
// e.g. copying contents of the list to a local vector.
current_profiles_semaphore_.Wait();
for (int i = 0; i < current_profiles_.length(); ++i) {
- current_profiles_[i]->AddPath(timestamp, path);
+ current_profiles_[i]->AddPath(timestamp, path, src_line);
}
current_profiles_semaphore_.Signal();
}
CodeEntry* CpuProfilesCollection::NewCodeEntry(
- Logger::LogEventsAndTags tag,
- const char* name,
- const char* name_prefix,
- const char* resource_name,
- int line_number,
- int column_number) {
- CodeEntry* code_entry = new CodeEntry(tag,
- name,
- name_prefix,
- resource_name,
- line_number,
- column_number);
+ Logger::LogEventsAndTags tag, const char* name, const char* name_prefix,
+ const char* resource_name, int line_number, int column_number,
+ JITLineInfoTable* line_info, Address instruction_start) {
+ CodeEntry* code_entry =
+ new CodeEntry(tag, name, name_prefix, resource_name, line_number,
+ column_number, line_info, instruction_start);
code_entries_.Add(code_entry);
return code_entry;
}
// entries vector with NULL values.
CodeEntry** entry = entries.start();
memset(entry, 0, entries.length() * sizeof(*entry));
+
+ // The ProfileNode knows nothing about all versions of generated code for
+ // the same JS function. The line number information associated with
+ // the latest version of generated code is used to find a source line number
+ // for a JS function. Then, the detected source line is passed to
+ // ProfileNode to increase the tick count for this source line.
+ int src_line = v8::CpuProfileNode::kNoLineNumberInfo;
+ bool src_line_not_found = true;
+
if (sample.pc != NULL) {
if (sample.has_external_callback && sample.state == EXTERNAL &&
sample.top_frame_type == StackFrame::EXIT) {
// frame. Check for this case and just skip such samples.
if (pc_entry) {
List<OffsetRange>* ranges = pc_entry->no_frame_ranges();
+ int pc_offset =
+ static_cast<int>(sample.pc - pc_entry->instruction_start());
if (ranges) {
- Code* code = Code::cast(HeapObject::FromAddress(start));
- int pc_offset = static_cast<int>(
- sample.pc - code->instruction_start());
for (int i = 0; i < ranges->length(); i++) {
OffsetRange& range = ranges->at(i);
if (range.from <= pc_offset && pc_offset < range.to) {
}
}
}
+ src_line = pc_entry->GetSourceLine(pc_offset);
+ if (src_line == v8::CpuProfileNode::kNoLineNumberInfo) {
+ src_line = pc_entry->line_number();
+ }
+ src_line_not_found = false;
*entry++ = pc_entry;
if (pc_entry->builtin_id() == Builtins::kFunctionCall ||
*stack_end = stack_pos + sample.frames_count;
stack_pos != stack_end;
++stack_pos) {
- *entry++ = code_map_.FindEntry(*stack_pos);
+ Address start = NULL;
+ *entry = code_map_.FindEntry(*stack_pos, &start);
+
+ // Skip unresolved frames (e.g. internal frame) and get source line of
+ // the first JS caller.
+ if (src_line_not_found && *entry) {
+ int pc_offset =
+ static_cast<int>(*stack_pos - (*entry)->instruction_start());
+ src_line = (*entry)->GetSourceLine(pc_offset);
+ if (src_line == v8::CpuProfileNode::kNoLineNumberInfo) {
+ src_line = (*entry)->line_number();
+ }
+ src_line_not_found = false;
+ }
+
+ entry++;
}
}
}
}
- profiles_->AddPathToCurrentProfiles(sample.timestamp, entries);
+ profiles_->AddPathToCurrentProfiles(sample.timestamp, entries, src_line);
}
#ifndef V8_PROFILE_GENERATOR_H_
#define V8_PROFILE_GENERATOR_H_
+#include <map>
#include "include/v8-profiler.h"
#include "src/allocation.h"
#include "src/hashmap.h"
};
+// Provides a mapping from the offsets within generated code to
+// the source line.
+class JITLineInfoTable : public Malloced {
+ public:
+ JITLineInfoTable();
+ ~JITLineInfoTable();
+
+ void SetPosition(int pc_offset, int line);
+ int GetSourceLineNumber(int pc_offset) const;
+
+ bool empty() const { return pc_offset_map_.empty(); }
+
+ private:
+ // pc_offset -> source line
+ typedef std::map<int, int> PcOffsetMap;
+ PcOffsetMap pc_offset_map_;
+ DISALLOW_COPY_AND_ASSIGN(JITLineInfoTable);
+};
+
class CodeEntry {
public:
// CodeEntry doesn't own name strings, just references them.
- inline CodeEntry(Logger::LogEventsAndTags tag,
- const char* name,
+ inline CodeEntry(Logger::LogEventsAndTags tag, const char* name,
const char* name_prefix = CodeEntry::kEmptyNamePrefix,
const char* resource_name = CodeEntry::kEmptyResourceName,
int line_number = v8::CpuProfileNode::kNoLineNumberInfo,
- int column_number = v8::CpuProfileNode::kNoColumnNumberInfo);
+ int column_number = v8::CpuProfileNode::kNoColumnNumberInfo,
+ JITLineInfoTable* line_info = NULL,
+ Address instruction_start = NULL);
~CodeEntry();
- bool is_js_function() const { return is_js_function_tag(tag_); }
+ bool is_js_function() const { return is_js_function_tag(tag()); }
const char* name_prefix() const { return name_prefix_; }
bool has_name_prefix() const { return name_prefix_[0] != '\0'; }
const char* name() const { return name_; }
const char* resource_name() const { return resource_name_; }
int line_number() const { return line_number_; }
int column_number() const { return column_number_; }
+ const JITLineInfoTable* line_info() const { return line_info_; }
void set_shared_id(int shared_id) { shared_id_ = shared_id; }
int script_id() const { return script_id_; }
void set_script_id(int script_id) { script_id_ = script_id; }
}
void SetBuiltinId(Builtins::Name id);
- Builtins::Name builtin_id() const { return builtin_id_; }
+ Builtins::Name builtin_id() const {
+ return BuiltinIdField::decode(bit_field_);
+ }
uint32_t GetCallUid() const;
bool IsSameAs(CodeEntry* entry) const;
+ int GetSourceLine(int pc_offset) const;
+
+ Address instruction_start() const { return instruction_start_; }
+
static const char* const kEmptyNamePrefix;
static const char* const kEmptyResourceName;
static const char* const kEmptyBailoutReason;
private:
- Logger::LogEventsAndTags tag_ : 8;
- Builtins::Name builtin_id_ : 8;
+ class TagField : public BitField<Logger::LogEventsAndTags, 0, 8> {};
+ class BuiltinIdField : public BitField<Builtins::Name, 8, 8> {};
+ Logger::LogEventsAndTags tag() const { return TagField::decode(bit_field_); }
+
+ uint32_t bit_field_;
const char* name_prefix_;
const char* name_;
const char* resource_name_;
int script_id_;
List<OffsetRange>* no_frame_ranges_;
const char* bailout_reason_;
+ JITLineInfoTable* line_info_;
+ Address instruction_start_;
DISALLOW_COPY_AND_ASSIGN(CodeEntry);
};
ProfileNode* FindOrAddChild(CodeEntry* entry);
void IncrementSelfTicks() { ++self_ticks_; }
void IncreaseSelfTicks(unsigned amount) { self_ticks_ += amount; }
+ void IncrementLineTicks(int src_line);
CodeEntry* entry() const { return entry_; }
unsigned self_ticks() const { return self_ticks_; }
const List<ProfileNode*>* children() const { return &children_list_; }
unsigned id() const { return id_; }
+ unsigned int GetHitLineCount() const { return line_ticks_.occupancy(); }
+ bool GetLineTicks(v8::CpuProfileNode::LineTick* entries,
+ unsigned int length) const;
void Print(int indent);
return entry->GetCallUid();
}
+ static bool LineTickMatch(void* a, void* b) { return a == b; }
+
ProfileTree* tree_;
CodeEntry* entry_;
unsigned self_ticks_;
HashMap children_;
List<ProfileNode*> children_list_;
unsigned id_;
+ HashMap line_ticks_;
DISALLOW_COPY_AND_ASSIGN(ProfileNode);
};
ProfileTree();
~ProfileTree();
- ProfileNode* AddPathFromEnd(const Vector<CodeEntry*>& path);
- void AddPathFromStart(const Vector<CodeEntry*>& path);
+ ProfileNode* AddPathFromEnd(
+ const Vector<CodeEntry*>& path,
+ int src_line = v8::CpuProfileNode::kNoLineNumberInfo);
+ void AddPathFromStart(const Vector<CodeEntry*>& path,
+ int src_line = v8::CpuProfileNode::kNoLineNumberInfo);
ProfileNode* root() const { return root_; }
unsigned next_node_id() { return next_node_id_++; }
CpuProfile(const char* title, bool record_samples);
// Add pc -> ... -> main() call path to the profile.
- void AddPath(base::TimeTicks timestamp, const Vector<CodeEntry*>& path);
+ void AddPath(base::TimeTicks timestamp, const Vector<CodeEntry*>& path,
+ int src_line);
void CalculateTotalTicksAndSamplingRate();
const char* title() const { return title_; }
void RemoveProfile(CpuProfile* profile);
CodeEntry* NewCodeEntry(
- Logger::LogEventsAndTags tag,
- const char* name,
+ Logger::LogEventsAndTags tag, const char* name,
const char* name_prefix = CodeEntry::kEmptyNamePrefix,
const char* resource_name = CodeEntry::kEmptyResourceName,
int line_number = v8::CpuProfileNode::kNoLineNumberInfo,
- int column_number = v8::CpuProfileNode::kNoColumnNumberInfo);
+ int column_number = v8::CpuProfileNode::kNoColumnNumberInfo,
+ JITLineInfoTable* line_info = NULL, Address instruction_start = NULL);
// Called from profile generator thread.
- void AddPathToCurrentProfiles(
- base::TimeTicks timestamp, const Vector<CodeEntry*>& path);
+ void AddPathToCurrentProfiles(base::TimeTicks timestamp,
+ const Vector<CodeEntry*>& path, int src_line);
// Limits the number of profiles that can be simultaneously collected.
static const int kMaxSimultaneousProfiles = 100;
var PromiseCatch;
var PromiseThen;
var PromiseHasRejectHandler;
+var PromiseHasUserDefinedRejectHandler;
// mirror-debugger.js currently uses builtins.promiseStatus. It would be nice
// if we could move these property names into the closure below.
var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
-var promiseDebug = GLOBAL_PRIVATE("Promise#debug");
+var promiseHasHandler = %PromiseHasHandlerSymbol();
var lastMicrotaskId = 0;
+
(function() {
var $Promise = function Promise(resolver) {
PromiseReject = function PromiseReject(promise, r) {
// Check promise status to confirm that this reject has an effect.
- // Check promiseDebug property to avoid duplicate event.
- if (DEBUG_IS_ACTIVE &&
- GET_PRIVATE(promise, promiseStatus) == 0 &&
- !HAS_DEFINED_PRIVATE(promise, promiseDebug)) {
- %DebugPromiseRejectEvent(promise, r);
+ // Call runtime for callbacks to the debugger or for unhandled reject.
+ if (GET_PRIVATE(promise, promiseStatus) == 0) {
+ var debug_is_active = DEBUG_IS_ACTIVE;
+ if (debug_is_active || !HAS_DEFINED_PRIVATE(promise, promiseHasHandler)) {
+ %PromiseRejectEvent(promise, r, debug_is_active);
+ }
}
PromiseDone(promise, -1, r, promiseOnReject)
}
}
function PromiseRejected(r) {
+ var promise;
if (this === $Promise) {
// Optimized case, avoid extra closure.
- return PromiseSet(new $Promise(promiseRaw), -1, r);
+ promise = PromiseSet(new $Promise(promiseRaw), -1, r);
+ // The debug event for this would always be an uncaught promise reject,
+ // which is usually simply noise. Do not trigger that debug event.
+ %PromiseRejectEvent(promise, r, false);
} else {
- return new this(function(resolve, reject) { reject(r) });
+ promise = new this(function(resolve, reject) { reject(r) });
}
+ return promise;
}
// Simple chaining.
+1);
break;
case -1: // Rejected
+ if (!HAS_DEFINED_PRIVATE(this, promiseHasHandler)) {
+ // Promise has already been rejected, but had no handler.
+ // Revoke previously triggered reject event.
+ %PromiseRevokeReject(this);
+ }
PromiseEnqueue(GET_PRIVATE(this, promiseValue),
[onReject, deferred],
-1);
break;
}
+ // Mark this promise as having handler.
+ SET_PRIVATE(this, promiseHasHandler, true);
if (DEBUG_IS_ACTIVE) {
%DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
}
// Utility for debugger
- function PromiseHasRejectHandlerRecursive(promise) {
+ function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
var queue = GET_PRIVATE(promise, promiseOnReject);
if (IS_UNDEFINED(queue)) return false;
- // Do a depth first search for a reject handler that's not
- // the default PromiseIdRejectHandler.
for (var i = 0; i < queue.length; i += 2) {
if (queue[i] != PromiseIdRejectHandler) return true;
- if (PromiseHasRejectHandlerRecursive(queue[i + 1].promise)) return true;
+ if (PromiseHasUserDefinedRejectHandlerRecursive(queue[i + 1].promise)) {
+ return true;
+ }
}
return false;
}
- PromiseHasRejectHandler = function PromiseHasRejectHandler() {
- // Mark promise as already having triggered a reject event.
- SET_PRIVATE(this, promiseDebug, true);
- return PromiseHasRejectHandlerRecursive(this);
+ // Return whether the promise will be handled by a user-defined reject
+ // handler somewhere down the promise chain. For this, we do a depth-first
+ // search for a reject handler that's not the default PromiseIdRejectHandler.
+ PromiseHasUserDefinedRejectHandler =
+ function PromiseHasUserDefinedRejectHandler() {
+ return PromiseHasUserDefinedRejectHandlerRecursive(this);
};
// -------------------------------------------------------------------
%CheckIsBootstrapping();
%AddNamedProperty(global, 'Promise', $Promise, DONT_ENUM);
+ %AddNamedProperty(
+ $Promise.prototype, symbolToStringTag, "Promise", DONT_ENUM | READ_ONLY);
InstallFunctions($Promise, DONT_ENUM, [
"defer", PromiseDeferred,
"accept", PromiseResolved,
uint32_t value_;
};
+
+std::ostream& operator<<(std::ostream& os,
+ const PropertyAttributes& attributes);
+std::ostream& operator<<(std::ostream& os, const PropertyDetails& details);
} } // namespace v8::internal
#endif // V8_PROPERTY_DETAILS_H_
}
-OStream& operator<<(OStream& os, const LookupResult& r) {
+std::ostream& operator<<(std::ostream& os, const LookupResult& r) {
if (!r.IsFound()) return os << "Not Found\n";
os << "LookupResult:\n";
}
-OStream& operator<<(OStream& os, const Descriptor& d) {
+std::ostream& operator<<(std::ostream& os,
+ const PropertyAttributes& attributes) {
+ os << "[";
+ os << (((attributes & READ_ONLY) == 0) ? "W" : "_"); // writable
+ os << (((attributes & DONT_ENUM) == 0) ? "E" : "_"); // enumerable
+ os << (((attributes & DONT_DELETE) == 0) ? "C" : "_"); // configurable
+ os << "]";
+ return os;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const PropertyDetails& details) {
+ os << "(";
+ switch (details.type()) {
+ case NORMAL:
+ os << "normal: dictionary_index: " << details.dictionary_index();
+ break;
+ case CONSTANT:
+ os << "constant: p: " << details.pointer();
+ break;
+ case FIELD:
+ os << "field: " << details.representation().Mnemonic()
+ << ", field_index: " << details.field_index()
+ << ", p: " << details.pointer();
+ break;
+ case CALLBACKS:
+ os << "callbacks: p: " << details.pointer();
+ break;
+ }
+ os << ", attrs: " << details.attributes() << ")";
+ return os;
+}
+
+
+std::ostream& operator<<(std::ostream& os, const Descriptor& d) {
return os << "Descriptor " << Brief(*d.GetKey()) << " @ "
- << Brief(*d.GetValue());
+ << Brief(*d.GetValue()) << " " << d.GetDetails();
}
} } // namespace v8::internal
#ifndef V8_PROPERTY_H_
#define V8_PROPERTY_H_
+#include <iosfwd>
+
#include "src/factory.h"
#include "src/field-index.h"
#include "src/field-index-inl.h"
namespace v8 {
namespace internal {
-class OStream;
-
// Abstraction for elements in instance-descriptor arrays.
//
// Each descriptor has a key, property attributes, property type,
};
-OStream& operator<<(OStream& os, const Descriptor& d);
+std::ostream& operator<<(std::ostream& os, const Descriptor& d);
class FieldDescriptor FINAL : public Descriptor {
};
-OStream& operator<<(OStream& os, const LookupResult& r);
+std::ostream& operator<<(std::ostream& os, const LookupResult& r);
} } // namespace v8::internal
#endif // V8_PROPERTY_H_
class Processor: public AstVisitor {
public:
- Processor(Variable* result, Zone* zone, AstNode::IdGen* ast_node_id_gen)
+ Processor(Variable* result, AstValueFactory* ast_value_factory)
: result_(result),
result_assigned_(false),
is_set_(false),
in_try_(false),
- // Passing a null AstValueFactory is fine, because Processor doesn't
- // need to create strings or literals.
- factory_(zone, NULL, ast_node_id_gen) {
- InitializeAstVisitor(zone);
+ factory_(ast_value_factory) {
+ InitializeAstVisitor(ast_value_factory->zone());
}
virtual ~Processor() { }
}
// Node visitors.
-#define DEF_VISIT(type) \
- virtual void Visit##type(type* node);
+#define DEF_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
AST_NODE_LIST(DEF_VISIT)
#undef DEF_VISIT
scope->NewTemporary(info->ast_value_factory()->dot_result_string());
// The name string must be internalized at this point.
DCHECK(!result->name().is_null());
- Processor processor(result, info->zone(), info->ast_node_id_gen());
+ Processor processor(result, info->ast_value_factory());
processor.Process(body);
if (processor.HasStackOverflow()) return false;
// the end position of the function generated for executing the eval code
// coincides with the end of the with scope which is the position of '1'.
int pos = function->end_position();
- VariableProxy* result_proxy = processor.factory()->NewVariableProxy(
- result->raw_name(), false, result->interface(), pos);
- result_proxy->BindTo(result);
+ VariableProxy* result_proxy =
+ processor.factory()->NewVariableProxy(result, pos);
Statement* result_statement =
processor.factory()->NewReturnStatement(result_proxy, pos);
body->Add(result_statement, info->zone());
}
-static void GetICCounts(Code* shared_code, int* ic_with_type_info_count,
- int* ic_generic_count, int* ic_total_count,
- int* type_info_percentage, int* generic_percentage) {
+static void GetICCounts(SharedFunctionInfo* shared,
+ int* ic_with_type_info_count, int* ic_generic_count,
+ int* ic_total_count, int* type_info_percentage,
+ int* generic_percentage) {
+ Code* shared_code = shared->code();
*ic_total_count = 0;
*ic_generic_count = 0;
*ic_with_type_info_count = 0;
*ic_generic_count = info->ic_generic_count();
*ic_total_count = info->ic_total_count();
}
+
+ // Harvest vector-ics as well
+ TypeFeedbackVector* vector = shared->feedback_vector();
+ *ic_with_type_info_count += vector->ic_with_type_info_count();
+ *ic_generic_count += vector->ic_generic_count();
+
if (*ic_total_count > 0) {
*type_info_percentage = 100 * *ic_with_type_info_count / *ic_total_count;
*generic_percentage = 100 * *ic_generic_count / *ic_total_count;
PrintF(" for recompilation, reason: %s", reason);
if (FLAG_type_info_threshold > 0) {
int typeinfo, generic, total, type_percentage, generic_percentage;
- GetICCounts(function->shared()->code(), &typeinfo, &generic, &total,
+ GetICCounts(function->shared(), &typeinfo, &generic, &total,
&type_percentage, &generic_percentage);
PrintF(", ICs with typeinfo: %d/%d (%d%%)", typeinfo, total,
type_percentage);
if (ticks >= kProfilerTicksBeforeOptimization) {
int typeinfo, generic, total, type_percentage, generic_percentage;
- GetICCounts(shared_code, &typeinfo, &generic, &total, &type_percentage,
+ GetICCounts(shared, &typeinfo, &generic, &total, &type_percentage,
&generic_percentage);
if (type_percentage >= FLAG_type_info_threshold &&
generic_percentage <= FLAG_generic_ic_threshold) {
// If no IC was patched since the last tick and this function is very
// small, optimistically optimize it now.
int typeinfo, generic, total, type_percentage, generic_percentage;
- GetICCounts(shared_code, &typeinfo, &generic, &total, &type_percentage,
+ GetICCounts(shared, &typeinfo, &generic, &total, &type_percentage,
&generic_percentage);
if (type_percentage >= FLAG_type_info_threshold &&
generic_percentage <= FLAG_generic_ic_threshold) {
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/bootstrapper.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_CreateApiFunction) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(FunctionTemplateInfo, data, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
+ return *isolate->factory()->CreateApiFunction(data, prototype);
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsTemplate) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, arg, 0);
+ bool result = arg->IsObjectTemplateInfo() || arg->IsFunctionTemplateInfo();
+ return isolate->heap()->ToBoolean(result);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetTemplateField) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(HeapObject, templ, 0);
+ CONVERT_SMI_ARG_CHECKED(index, 1);
+ int offset = index * kPointerSize + HeapObject::kHeaderSize;
+ InstanceType type = templ->map()->instance_type();
+ RUNTIME_ASSERT(type == FUNCTION_TEMPLATE_INFO_TYPE ||
+ type == OBJECT_TEMPLATE_INFO_TYPE);
+ RUNTIME_ASSERT(offset > 0);
+ if (type == FUNCTION_TEMPLATE_INFO_TYPE) {
+ RUNTIME_ASSERT(offset < FunctionTemplateInfo::kSize);
+ } else {
+ RUNTIME_ASSERT(offset < ObjectTemplateInfo::kSize);
+ }
+ return *HeapObject::RawField(templ, offset);
+}
+
+
+// Transform getter or setter into something DefineAccessor can handle.
+static Handle<Object> InstantiateAccessorComponent(Isolate* isolate,
+ Handle<Object> component) {
+ if (component->IsUndefined()) return isolate->factory()->undefined_value();
+ Handle<FunctionTemplateInfo> info =
+ Handle<FunctionTemplateInfo>::cast(component);
+ return Utils::OpenHandle(*Utils::ToLocal(info)->GetFunction());
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineApiAccessorProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 5);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, getter, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, setter, 3);
+ CONVERT_SMI_ARG_CHECKED(attribute, 4);
+ RUNTIME_ASSERT(getter->IsUndefined() || getter->IsFunctionTemplateInfo());
+ RUNTIME_ASSERT(setter->IsUndefined() || setter->IsFunctionTemplateInfo());
+ RUNTIME_ASSERT(PropertyDetails::AttributesField::is_valid(
+ static_cast<PropertyAttributes>(attribute)));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::DefineAccessor(
+ object, name, InstantiateAccessorComponent(isolate, getter),
+ InstantiateAccessorComponent(isolate, setter),
+ static_cast<PropertyAttributes>(attribute)));
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_AddPropertyForTemplate) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 4);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+ CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
+ RUNTIME_ASSERT(
+ (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ // Compute attributes.
+ PropertyAttributes attributes =
+ static_cast<PropertyAttributes>(unchecked_attributes);
+
+#ifdef DEBUG
+ bool duplicate;
+ if (key->IsName()) {
+ LookupIterator it(object, Handle<Name>::cast(key),
+ LookupIterator::OWN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ DCHECK(maybe.has_value);
+ duplicate = it.IsFound();
+ } else {
+ uint32_t index = 0;
+ RUNTIME_ASSERT(key->ToArrayIndex(&index));
+ Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ duplicate = maybe.value;
+ }
+ if (duplicate) {
+ Handle<Object> args[1] = {key};
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewTypeError("duplicate_template_property", HandleVector(args, 1)));
+ }
+#endif
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Runtime::DefineObjectProperty(object, key, value, attributes));
+ return *result;
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_FinishArrayPrototypeSetup) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, prototype, 0);
+ Object* length = prototype->length();
+ RUNTIME_ASSERT(length->IsSmi() && Smi::cast(length)->value() == 0);
+ RUNTIME_ASSERT(prototype->HasFastSmiOrObjectElements());
+ // This is necessary to enable fast checks for absence of elements
+ // on Array.prototype and below.
+ prototype->set_elements(isolate->heap()->empty_fixed_array());
+ return Smi::FromInt(0);
+}
+
+
+static void InstallBuiltin(Isolate* isolate, Handle<JSObject> holder,
+ const char* name, Builtins::Name builtin_name) {
+ Handle<String> key = isolate->factory()->InternalizeUtf8String(name);
+ Handle<Code> code(isolate->builtins()->builtin(builtin_name));
+ Handle<JSFunction> optimized =
+ isolate->factory()->NewFunctionWithoutPrototype(key, code);
+ optimized->shared()->DontAdaptArguments();
+ JSObject::AddProperty(holder, key, optimized, NONE);
+}
+
+
+RUNTIME_FUNCTION(Runtime_SpecialArrayFunctions) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ Handle<JSObject> holder =
+ isolate->factory()->NewJSObject(isolate->object_function());
+
+ InstallBuiltin(isolate, holder, "pop", Builtins::kArrayPop);
+ InstallBuiltin(isolate, holder, "push", Builtins::kArrayPush);
+ InstallBuiltin(isolate, holder, "shift", Builtins::kArrayShift);
+ InstallBuiltin(isolate, holder, "unshift", Builtins::kArrayUnshift);
+ InstallBuiltin(isolate, holder, "slice", Builtins::kArraySlice);
+ InstallBuiltin(isolate, holder, "splice", Builtins::kArraySplice);
+ InstallBuiltin(isolate, holder, "concat", Builtins::kArrayConcat);
+
+ return *holder;
+}
+
+
+RUNTIME_FUNCTION(Runtime_TransitionElementsKind) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Map, map, 1);
+ JSObject::TransitionElementsKind(array, map->elements_kind());
+ return *array;
+}
+
+
+// Push an object unto an array of objects if it is not already in the
+// array. Returns true if the element was pushed on the stack and
+// false otherwise.
+RUNTIME_FUNCTION(Runtime_PushIfAbsent) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, element, 1);
+ RUNTIME_ASSERT(array->HasFastSmiOrObjectElements());
+ int length = Smi::cast(array->length())->value();
+ FixedArray* elements = FixedArray::cast(array->elements());
+ for (int i = 0; i < length; i++) {
+ if (elements->get(i) == *element) return isolate->heap()->false_value();
+ }
+
+ // Strict not needed. Used for cycle detection in Array join implementation.
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetFastElement(array, length, element, SLOPPY, true));
+ return isolate->heap()->true_value();
+}
+
+
+/**
+ * A simple visitor visits every element of Array's.
+ * The backend storage can be a fixed array for fast elements case,
+ * or a dictionary for sparse array. Since Dictionary is a subtype
+ * of FixedArray, the class can be used by both fast and slow cases.
+ * The second parameter of the constructor, fast_elements, specifies
+ * whether the storage is a FixedArray or Dictionary.
+ *
+ * An index limit is used to deal with the situation that a result array
+ * length overflows 32-bit non-negative integer.
+ */
+class ArrayConcatVisitor {
+ public:
+ ArrayConcatVisitor(Isolate* isolate, Handle<FixedArray> storage,
+ bool fast_elements)
+ : isolate_(isolate),
+ storage_(Handle<FixedArray>::cast(
+ isolate->global_handles()->Create(*storage))),
+ index_offset_(0u),
+ bit_field_(FastElementsField::encode(fast_elements) |
+ ExceedsLimitField::encode(false)) {}
+
+ ~ArrayConcatVisitor() { clear_storage(); }
+
+ void visit(uint32_t i, Handle<Object> elm) {
+ if (i > JSObject::kMaxElementCount - index_offset_) {
+ set_exceeds_array_limit(true);
+ return;
+ }
+ uint32_t index = index_offset_ + i;
+
+ if (fast_elements()) {
+ if (index < static_cast<uint32_t>(storage_->length())) {
+ storage_->set(index, *elm);
+ return;
+ }
+ // Our initial estimate of length was foiled, possibly by
+ // getters on the arrays increasing the length of later arrays
+ // during iteration.
+ // This shouldn't happen in anything but pathological cases.
+ SetDictionaryMode();
+ // Fall-through to dictionary mode.
+ }
+ DCHECK(!fast_elements());
+ Handle<SeededNumberDictionary> dict(
+ SeededNumberDictionary::cast(*storage_));
+ Handle<SeededNumberDictionary> result =
+ SeededNumberDictionary::AtNumberPut(dict, index, elm);
+ if (!result.is_identical_to(dict)) {
+ // Dictionary needed to grow.
+ clear_storage();
+ set_storage(*result);
+ }
+ }
+
+ void increase_index_offset(uint32_t delta) {
+ if (JSObject::kMaxElementCount - index_offset_ < delta) {
+ index_offset_ = JSObject::kMaxElementCount;
+ } else {
+ index_offset_ += delta;
+ }
+ // If the initial length estimate was off (see special case in visit()),
+ // but the array blowing the limit didn't contain elements beyond the
+ // provided-for index range, go to dictionary mode now.
+ if (fast_elements() &&
+ index_offset_ >
+ static_cast<uint32_t>(FixedArrayBase::cast(*storage_)->length())) {
+ SetDictionaryMode();
+ }
+ }
+
+ bool exceeds_array_limit() const {
+ return ExceedsLimitField::decode(bit_field_);
+ }
+
+ Handle<JSArray> ToArray() {
+ Handle<JSArray> array = isolate_->factory()->NewJSArray(0);
+ Handle<Object> length =
+ isolate_->factory()->NewNumber(static_cast<double>(index_offset_));
+ Handle<Map> map = JSObject::GetElementsTransitionMap(
+ array, fast_elements() ? FAST_HOLEY_ELEMENTS : DICTIONARY_ELEMENTS);
+ array->set_map(*map);
+ array->set_length(*length);
+ array->set_elements(*storage_);
+ return array;
+ }
+
+ private:
+ // Convert storage to dictionary mode.
+ void SetDictionaryMode() {
+ DCHECK(fast_elements());
+ Handle<FixedArray> current_storage(*storage_);
+ Handle<SeededNumberDictionary> slow_storage(
+ SeededNumberDictionary::New(isolate_, current_storage->length()));
+ uint32_t current_length = static_cast<uint32_t>(current_storage->length());
+ for (uint32_t i = 0; i < current_length; i++) {
+ HandleScope loop_scope(isolate_);
+ Handle<Object> element(current_storage->get(i), isolate_);
+ if (!element->IsTheHole()) {
+ Handle<SeededNumberDictionary> new_storage =
+ SeededNumberDictionary::AtNumberPut(slow_storage, i, element);
+ if (!new_storage.is_identical_to(slow_storage)) {
+ slow_storage = loop_scope.CloseAndEscape(new_storage);
+ }
+ }
+ }
+ clear_storage();
+ set_storage(*slow_storage);
+ set_fast_elements(false);
+ }
+
+ inline void clear_storage() {
+ GlobalHandles::Destroy(Handle<Object>::cast(storage_).location());
+ }
+
+ inline void set_storage(FixedArray* storage) {
+ storage_ =
+ Handle<FixedArray>::cast(isolate_->global_handles()->Create(storage));
+ }
+
+ class FastElementsField : public BitField<bool, 0, 1> {};
+ class ExceedsLimitField : public BitField<bool, 1, 1> {};
+
+ bool fast_elements() const { return FastElementsField::decode(bit_field_); }
+ void set_fast_elements(bool fast) {
+ bit_field_ = FastElementsField::update(bit_field_, fast);
+ }
+ void set_exceeds_array_limit(bool exceeds) {
+ bit_field_ = ExceedsLimitField::update(bit_field_, exceeds);
+ }
+
+ Isolate* isolate_;
+ Handle<FixedArray> storage_; // Always a global handle.
+ // Index after last seen index. Always less than or equal to
+ // JSObject::kMaxElementCount.
+ uint32_t index_offset_;
+ uint32_t bit_field_;
+};
+
+
+static uint32_t EstimateElementCount(Handle<JSArray> array) {
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ int element_count = 0;
+ switch (array->GetElementsKind()) {
+ case FAST_SMI_ELEMENTS:
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case FAST_ELEMENTS:
+ case FAST_HOLEY_ELEMENTS: {
+ // Fast elements can't have lengths that are not representable by
+ // a 32-bit signed integer.
+ DCHECK(static_cast<int32_t>(FixedArray::kMaxLength) >= 0);
+ int fast_length = static_cast<int>(length);
+ Handle<FixedArray> elements(FixedArray::cast(array->elements()));
+ for (int i = 0; i < fast_length; i++) {
+ if (!elements->get(i)->IsTheHole()) element_count++;
+ }
+ break;
+ }
+ case FAST_DOUBLE_ELEMENTS:
+ case FAST_HOLEY_DOUBLE_ELEMENTS: {
+ // Fast elements can't have lengths that are not representable by
+ // a 32-bit signed integer.
+ DCHECK(static_cast<int32_t>(FixedDoubleArray::kMaxLength) >= 0);
+ int fast_length = static_cast<int>(length);
+ if (array->elements()->IsFixedArray()) {
+ DCHECK(FixedArray::cast(array->elements())->length() == 0);
+ break;
+ }
+ Handle<FixedDoubleArray> elements(
+ FixedDoubleArray::cast(array->elements()));
+ for (int i = 0; i < fast_length; i++) {
+ if (!elements->is_the_hole(i)) element_count++;
+ }
+ break;
+ }
+ case DICTIONARY_ELEMENTS: {
+ Handle<SeededNumberDictionary> dictionary(
+ SeededNumberDictionary::cast(array->elements()));
+ int capacity = dictionary->Capacity();
+ for (int i = 0; i < capacity; i++) {
+ Handle<Object> key(dictionary->KeyAt(i), array->GetIsolate());
+ if (dictionary->IsKey(*key)) {
+ element_count++;
+ }
+ }
+ break;
+ }
+ case SLOPPY_ARGUMENTS_ELEMENTS:
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case EXTERNAL_##TYPE##_ELEMENTS: \
+ case TYPE##_ELEMENTS:
+
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
+ // External arrays are always dense.
+ return length;
+ }
+ // As an estimate, we assume that the prototype doesn't contain any
+ // inherited elements.
+ return element_count;
+}
+
+
+template <class ExternalArrayClass, class ElementType>
+static void IterateExternalArrayElements(Isolate* isolate,
+ Handle<JSObject> receiver,
+ bool elements_are_ints,
+ bool elements_are_guaranteed_smis,
+ ArrayConcatVisitor* visitor) {
+ Handle<ExternalArrayClass> array(
+ ExternalArrayClass::cast(receiver->elements()));
+ uint32_t len = static_cast<uint32_t>(array->length());
+
+ DCHECK(visitor != NULL);
+ if (elements_are_ints) {
+ if (elements_are_guaranteed_smis) {
+ for (uint32_t j = 0; j < len; j++) {
+ HandleScope loop_scope(isolate);
+ Handle<Smi> e(Smi::FromInt(static_cast<int>(array->get_scalar(j))),
+ isolate);
+ visitor->visit(j, e);
+ }
+ } else {
+ for (uint32_t j = 0; j < len; j++) {
+ HandleScope loop_scope(isolate);
+ int64_t val = static_cast<int64_t>(array->get_scalar(j));
+ if (Smi::IsValid(static_cast<intptr_t>(val))) {
+ Handle<Smi> e(Smi::FromInt(static_cast<int>(val)), isolate);
+ visitor->visit(j, e);
+ } else {
+ Handle<Object> e =
+ isolate->factory()->NewNumber(static_cast<ElementType>(val));
+ visitor->visit(j, e);
+ }
+ }
+ }
+ } else {
+ for (uint32_t j = 0; j < len; j++) {
+ HandleScope loop_scope(isolate);
+ Handle<Object> e = isolate->factory()->NewNumber(array->get_scalar(j));
+ visitor->visit(j, e);
+ }
+ }
+}
+
+
+// Used for sorting indices in a List<uint32_t>.
+static int compareUInt32(const uint32_t* ap, const uint32_t* bp) {
+ uint32_t a = *ap;
+ uint32_t b = *bp;
+ return (a == b) ? 0 : (a < b) ? -1 : 1;
+}
+
+
+static void CollectElementIndices(Handle<JSObject> object, uint32_t range,
+ List<uint32_t>* indices) {
+ Isolate* isolate = object->GetIsolate();
+ ElementsKind kind = object->GetElementsKind();
+ switch (kind) {
+ case FAST_SMI_ELEMENTS:
+ case FAST_ELEMENTS:
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case FAST_HOLEY_ELEMENTS: {
+ Handle<FixedArray> elements(FixedArray::cast(object->elements()));
+ uint32_t length = static_cast<uint32_t>(elements->length());
+ if (range < length) length = range;
+ for (uint32_t i = 0; i < length; i++) {
+ if (!elements->get(i)->IsTheHole()) {
+ indices->Add(i);
+ }
+ }
+ break;
+ }
+ case FAST_HOLEY_DOUBLE_ELEMENTS:
+ case FAST_DOUBLE_ELEMENTS: {
+ if (object->elements()->IsFixedArray()) {
+ DCHECK(object->elements()->length() == 0);
+ break;
+ }
+ Handle<FixedDoubleArray> elements(
+ FixedDoubleArray::cast(object->elements()));
+ uint32_t length = static_cast<uint32_t>(elements->length());
+ if (range < length) length = range;
+ for (uint32_t i = 0; i < length; i++) {
+ if (!elements->is_the_hole(i)) {
+ indices->Add(i);
+ }
+ }
+ break;
+ }
+ case DICTIONARY_ELEMENTS: {
+ Handle<SeededNumberDictionary> dict(
+ SeededNumberDictionary::cast(object->elements()));
+ uint32_t capacity = dict->Capacity();
+ for (uint32_t j = 0; j < capacity; j++) {
+ HandleScope loop_scope(isolate);
+ Handle<Object> k(dict->KeyAt(j), isolate);
+ if (dict->IsKey(*k)) {
+ DCHECK(k->IsNumber());
+ uint32_t index = static_cast<uint32_t>(k->Number());
+ if (index < range) {
+ indices->Add(index);
+ }
+ }
+ }
+ break;
+ }
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case TYPE##_ELEMENTS: \
+ case EXTERNAL_##TYPE##_ELEMENTS:
+
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
+ {
+ uint32_t length = static_cast<uint32_t>(
+ FixedArrayBase::cast(object->elements())->length());
+ if (range <= length) {
+ length = range;
+ // We will add all indices, so we might as well clear it first
+ // and avoid duplicates.
+ indices->Clear();
+ }
+ for (uint32_t i = 0; i < length; i++) {
+ indices->Add(i);
+ }
+ if (length == range) return; // All indices accounted for already.
+ break;
+ }
+ case SLOPPY_ARGUMENTS_ELEMENTS: {
+ MaybeHandle<Object> length_obj =
+ Object::GetProperty(object, isolate->factory()->length_string());
+ double length_num = length_obj.ToHandleChecked()->Number();
+ uint32_t length = static_cast<uint32_t>(DoubleToInt32(length_num));
+ ElementsAccessor* accessor = object->GetElementsAccessor();
+ for (uint32_t i = 0; i < length; i++) {
+ if (accessor->HasElement(object, object, i)) {
+ indices->Add(i);
+ }
+ }
+ break;
+ }
+ }
+
+ PrototypeIterator iter(isolate, object);
+ if (!iter.IsAtEnd()) {
+ // The prototype will usually have no inherited element indices,
+ // but we have to check.
+ CollectElementIndices(
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), range,
+ indices);
+ }
+}
+
+
+/**
+ * A helper function that visits elements of a JSArray in numerical
+ * order.
+ *
+ * The visitor argument called for each existing element in the array
+ * with the element index and the element's value.
+ * Afterwards it increments the base-index of the visitor by the array
+ * length.
+ * Returns false if any access threw an exception, otherwise true.
+ */
+static bool IterateElements(Isolate* isolate, Handle<JSArray> receiver,
+ ArrayConcatVisitor* visitor) {
+ uint32_t length = static_cast<uint32_t>(receiver->length()->Number());
+ switch (receiver->GetElementsKind()) {
+ case FAST_SMI_ELEMENTS:
+ case FAST_ELEMENTS:
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case FAST_HOLEY_ELEMENTS: {
+ // Run through the elements FixedArray and use HasElement and GetElement
+ // to check the prototype for missing elements.
+ Handle<FixedArray> elements(FixedArray::cast(receiver->elements()));
+ int fast_length = static_cast<int>(length);
+ DCHECK(fast_length <= elements->length());
+ for (int j = 0; j < fast_length; j++) {
+ HandleScope loop_scope(isolate);
+ Handle<Object> element_value(elements->get(j), isolate);
+ if (!element_value->IsTheHole()) {
+ visitor->visit(j, element_value);
+ } else {
+ Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
+ if (!maybe.has_value) return false;
+ if (maybe.value) {
+ // Call GetElement on receiver, not its prototype, or getters won't
+ // have the correct receiver.
+ ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+ isolate, element_value,
+ Object::GetElement(isolate, receiver, j), false);
+ visitor->visit(j, element_value);
+ }
+ }
+ }
+ break;
+ }
+ case FAST_HOLEY_DOUBLE_ELEMENTS:
+ case FAST_DOUBLE_ELEMENTS: {
+ // Empty array is FixedArray but not FixedDoubleArray.
+ if (length == 0) break;
+ // Run through the elements FixedArray and use HasElement and GetElement
+ // to check the prototype for missing elements.
+ if (receiver->elements()->IsFixedArray()) {
+ DCHECK(receiver->elements()->length() == 0);
+ break;
+ }
+ Handle<FixedDoubleArray> elements(
+ FixedDoubleArray::cast(receiver->elements()));
+ int fast_length = static_cast<int>(length);
+ DCHECK(fast_length <= elements->length());
+ for (int j = 0; j < fast_length; j++) {
+ HandleScope loop_scope(isolate);
+ if (!elements->is_the_hole(j)) {
+ double double_value = elements->get_scalar(j);
+ Handle<Object> element_value =
+ isolate->factory()->NewNumber(double_value);
+ visitor->visit(j, element_value);
+ } else {
+ Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
+ if (!maybe.has_value) return false;
+ if (maybe.value) {
+ // Call GetElement on receiver, not its prototype, or getters won't
+ // have the correct receiver.
+ Handle<Object> element_value;
+ ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+ isolate, element_value,
+ Object::GetElement(isolate, receiver, j), false);
+ visitor->visit(j, element_value);
+ }
+ }
+ }
+ break;
+ }
+ case DICTIONARY_ELEMENTS: {
+ Handle<SeededNumberDictionary> dict(receiver->element_dictionary());
+ List<uint32_t> indices(dict->Capacity() / 2);
+ // Collect all indices in the object and the prototypes less
+ // than length. This might introduce duplicates in the indices list.
+ CollectElementIndices(receiver, length, &indices);
+ indices.Sort(&compareUInt32);
+ int j = 0;
+ int n = indices.length();
+ while (j < n) {
+ HandleScope loop_scope(isolate);
+ uint32_t index = indices[j];
+ Handle<Object> element;
+ ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+ isolate, element, Object::GetElement(isolate, receiver, index),
+ false);
+ visitor->visit(index, element);
+ // Skip to next different index (i.e., omit duplicates).
+ do {
+ j++;
+ } while (j < n && indices[j] == index);
+ }
+ break;
+ }
+ case EXTERNAL_UINT8_CLAMPED_ELEMENTS: {
+ Handle<ExternalUint8ClampedArray> pixels(
+ ExternalUint8ClampedArray::cast(receiver->elements()));
+ for (uint32_t j = 0; j < length; j++) {
+ Handle<Smi> e(Smi::FromInt(pixels->get_scalar(j)), isolate);
+ visitor->visit(j, e);
+ }
+ break;
+ }
+ case EXTERNAL_INT8_ELEMENTS: {
+ IterateExternalArrayElements<ExternalInt8Array, int8_t>(
+ isolate, receiver, true, true, visitor);
+ break;
+ }
+ case EXTERNAL_UINT8_ELEMENTS: {
+ IterateExternalArrayElements<ExternalUint8Array, uint8_t>(
+ isolate, receiver, true, true, visitor);
+ break;
+ }
+ case EXTERNAL_INT16_ELEMENTS: {
+ IterateExternalArrayElements<ExternalInt16Array, int16_t>(
+ isolate, receiver, true, true, visitor);
+ break;
+ }
+ case EXTERNAL_UINT16_ELEMENTS: {
+ IterateExternalArrayElements<ExternalUint16Array, uint16_t>(
+ isolate, receiver, true, true, visitor);
+ break;
+ }
+ case EXTERNAL_INT32_ELEMENTS: {
+ IterateExternalArrayElements<ExternalInt32Array, int32_t>(
+ isolate, receiver, true, false, visitor);
+ break;
+ }
+ case EXTERNAL_UINT32_ELEMENTS: {
+ IterateExternalArrayElements<ExternalUint32Array, uint32_t>(
+ isolate, receiver, true, false, visitor);
+ break;
+ }
+ case EXTERNAL_FLOAT32_ELEMENTS: {
+ IterateExternalArrayElements<ExternalFloat32Array, float>(
+ isolate, receiver, false, false, visitor);
+ break;
+ }
+ case EXTERNAL_FLOAT64_ELEMENTS: {
+ IterateExternalArrayElements<ExternalFloat64Array, double>(
+ isolate, receiver, false, false, visitor);
+ break;
+ }
+ default:
+ UNREACHABLE();
+ break;
+ }
+ visitor->increase_index_offset(length);
+ return true;
+}
+
+
+/**
+ * Array::concat implementation.
+ * See ECMAScript 262, 15.4.4.4.
+ * TODO(581): Fix non-compliance for very large concatenations and update to
+ * following the ECMAScript 5 specification.
+ */
+RUNTIME_FUNCTION(Runtime_ArrayConcat) {
+ HandleScope handle_scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, arguments, 0);
+ int argument_count = static_cast<int>(arguments->length()->Number());
+ RUNTIME_ASSERT(arguments->HasFastObjectElements());
+ Handle<FixedArray> elements(FixedArray::cast(arguments->elements()));
+
+ // Pass 1: estimate the length and number of elements of the result.
+ // The actual length can be larger if any of the arguments have getters
+ // that mutate other arguments (but will otherwise be precise).
+ // The number of elements is precise if there are no inherited elements.
+
+ ElementsKind kind = FAST_SMI_ELEMENTS;
+
+ uint32_t estimate_result_length = 0;
+ uint32_t estimate_nof_elements = 0;
+ for (int i = 0; i < argument_count; i++) {
+ HandleScope loop_scope(isolate);
+ Handle<Object> obj(elements->get(i), isolate);
+ uint32_t length_estimate;
+ uint32_t element_estimate;
+ if (obj->IsJSArray()) {
+ Handle<JSArray> array(Handle<JSArray>::cast(obj));
+ length_estimate = static_cast<uint32_t>(array->length()->Number());
+ if (length_estimate != 0) {
+ ElementsKind array_kind =
+ GetPackedElementsKind(array->map()->elements_kind());
+ if (IsMoreGeneralElementsKindTransition(kind, array_kind)) {
+ kind = array_kind;
+ }
+ }
+ element_estimate = EstimateElementCount(array);
+ } else {
+ if (obj->IsHeapObject()) {
+ if (obj->IsNumber()) {
+ if (IsMoreGeneralElementsKindTransition(kind, FAST_DOUBLE_ELEMENTS)) {
+ kind = FAST_DOUBLE_ELEMENTS;
+ }
+ } else if (IsMoreGeneralElementsKindTransition(kind, FAST_ELEMENTS)) {
+ kind = FAST_ELEMENTS;
+ }
+ }
+ length_estimate = 1;
+ element_estimate = 1;
+ }
+ // Avoid overflows by capping at kMaxElementCount.
+ if (JSObject::kMaxElementCount - estimate_result_length < length_estimate) {
+ estimate_result_length = JSObject::kMaxElementCount;
+ } else {
+ estimate_result_length += length_estimate;
+ }
+ if (JSObject::kMaxElementCount - estimate_nof_elements < element_estimate) {
+ estimate_nof_elements = JSObject::kMaxElementCount;
+ } else {
+ estimate_nof_elements += element_estimate;
+ }
+ }
+
+ // If estimated number of elements is more than half of length, a
+ // fixed array (fast case) is more time and space-efficient than a
+ // dictionary.
+ bool fast_case = (estimate_nof_elements * 2) >= estimate_result_length;
+
+ if (fast_case && kind == FAST_DOUBLE_ELEMENTS) {
+ Handle<FixedArrayBase> storage =
+ isolate->factory()->NewFixedDoubleArray(estimate_result_length);
+ int j = 0;
+ bool failure = false;
+ if (estimate_result_length > 0) {
+ Handle<FixedDoubleArray> double_storage =
+ Handle<FixedDoubleArray>::cast(storage);
+ for (int i = 0; i < argument_count; i++) {
+ Handle<Object> obj(elements->get(i), isolate);
+ if (obj->IsSmi()) {
+ double_storage->set(j, Smi::cast(*obj)->value());
+ j++;
+ } else if (obj->IsNumber()) {
+ double_storage->set(j, obj->Number());
+ j++;
+ } else {
+ JSArray* array = JSArray::cast(*obj);
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ switch (array->map()->elements_kind()) {
+ case FAST_HOLEY_DOUBLE_ELEMENTS:
+ case FAST_DOUBLE_ELEMENTS: {
+ // Empty array is FixedArray but not FixedDoubleArray.
+ if (length == 0) break;
+ FixedDoubleArray* elements =
+ FixedDoubleArray::cast(array->elements());
+ for (uint32_t i = 0; i < length; i++) {
+ if (elements->is_the_hole(i)) {
+ // TODO(jkummerow/verwaest): We could be a bit more clever
+ // here: Check if there are no elements/getters on the
+ // prototype chain, and if so, allow creation of a holey
+ // result array.
+ // Same thing below (holey smi case).
+ failure = true;
+ break;
+ }
+ double double_value = elements->get_scalar(i);
+ double_storage->set(j, double_value);
+ j++;
+ }
+ break;
+ }
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case FAST_SMI_ELEMENTS: {
+ FixedArray* elements(FixedArray::cast(array->elements()));
+ for (uint32_t i = 0; i < length; i++) {
+ Object* element = elements->get(i);
+ if (element->IsTheHole()) {
+ failure = true;
+ break;
+ }
+ int32_t int_value = Smi::cast(element)->value();
+ double_storage->set(j, int_value);
+ j++;
+ }
+ break;
+ }
+ case FAST_HOLEY_ELEMENTS:
+ case FAST_ELEMENTS:
+ DCHECK_EQ(0, length);
+ break;
+ default:
+ UNREACHABLE();
+ }
+ }
+ if (failure) break;
+ }
+ }
+ if (!failure) {
+ Handle<JSArray> array = isolate->factory()->NewJSArray(0);
+ Smi* length = Smi::FromInt(j);
+ Handle<Map> map;
+ map = JSObject::GetElementsTransitionMap(array, kind);
+ array->set_map(*map);
+ array->set_length(length);
+ array->set_elements(*storage);
+ return *array;
+ }
+ // In case of failure, fall through.
+ }
+
+ Handle<FixedArray> storage;
+ if (fast_case) {
+ // The backing storage array must have non-existing elements to preserve
+ // holes across concat operations.
+ storage =
+ isolate->factory()->NewFixedArrayWithHoles(estimate_result_length);
+ } else {
+ // TODO(126): move 25% pre-allocation logic into Dictionary::Allocate
+ uint32_t at_least_space_for =
+ estimate_nof_elements + (estimate_nof_elements >> 2);
+ storage = Handle<FixedArray>::cast(
+ SeededNumberDictionary::New(isolate, at_least_space_for));
+ }
+
+ ArrayConcatVisitor visitor(isolate, storage, fast_case);
+
+ for (int i = 0; i < argument_count; i++) {
+ Handle<Object> obj(elements->get(i), isolate);
+ if (obj->IsJSArray()) {
+ Handle<JSArray> array = Handle<JSArray>::cast(obj);
+ if (!IterateElements(isolate, array, &visitor)) {
+ return isolate->heap()->exception();
+ }
+ } else {
+ visitor.visit(0, obj);
+ visitor.increase_index_offset(1);
+ }
+ }
+
+ if (visitor.exceeds_array_limit()) {
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewRangeError("invalid_array_length", HandleVector<Object>(NULL, 0)));
+ }
+ return *visitor.ToArray();
+}
+
+
+// Moves all own elements of an object, that are below a limit, to positions
+// starting at zero. All undefined values are placed after non-undefined values,
+// and are followed by non-existing element. Does not change the length
+// property.
+// Returns the number of non-undefined elements collected.
+// Returns -1 if hole removal is not supported by this method.
+RUNTIME_FUNCTION(Runtime_RemoveArrayHoles) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]);
+ return *JSObject::PrepareElementsForSort(object, limit);
+}
+
+
+// Move contents of argument 0 (an array) to argument 1 (an array)
+RUNTIME_FUNCTION(Runtime_MoveArrayContents) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, from, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, to, 1);
+ JSObject::ValidateElements(from);
+ JSObject::ValidateElements(to);
+
+ Handle<FixedArrayBase> new_elements(from->elements());
+ ElementsKind from_kind = from->GetElementsKind();
+ Handle<Map> new_map = JSObject::GetElementsTransitionMap(to, from_kind);
+ JSObject::SetMapAndElements(to, new_map, new_elements);
+ to->set_length(from->length());
+
+ JSObject::ResetElements(from);
+ from->set_length(Smi::FromInt(0));
+
+ JSObject::ValidateElements(to);
+ return *to;
+}
+
+
+// How many elements does this object/array have?
+RUNTIME_FUNCTION(Runtime_EstimateNumberOfElements) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
+ Handle<FixedArrayBase> elements(array->elements(), isolate);
+ SealHandleScope shs(isolate);
+ if (elements->IsDictionary()) {
+ int result =
+ Handle<SeededNumberDictionary>::cast(elements)->NumberOfElements();
+ return Smi::FromInt(result);
+ } else {
+ DCHECK(array->length()->IsSmi());
+ // For packed elements, we know the exact number of elements
+ int length = elements->length();
+ ElementsKind kind = array->GetElementsKind();
+ if (IsFastPackedElementsKind(kind)) {
+ return Smi::FromInt(length);
+ }
+ // For holey elements, take samples from the buffer checking for holes
+ // to generate the estimate.
+ const int kNumberOfHoleCheckSamples = 97;
+ int increment = (length < kNumberOfHoleCheckSamples)
+ ? 1
+ : static_cast<int>(length / kNumberOfHoleCheckSamples);
+ ElementsAccessor* accessor = array->GetElementsAccessor();
+ int holes = 0;
+ for (int i = 0; i < length; i += increment) {
+ if (!accessor->HasElement(array, array, i, elements)) {
+ ++holes;
+ }
+ }
+ int estimate = static_cast<int>((kNumberOfHoleCheckSamples - holes) /
+ kNumberOfHoleCheckSamples * length);
+ return Smi::FromInt(estimate);
+ }
+}
+
+
+// Returns an array that tells you where in the [0, length) interval an array
+// might have elements. Can either return an array of keys (positive integers
+// or undefined) or a number representing the positive length of an interval
+// starting at index 0.
+// Intervals can span over some keys that are not in the object.
+RUNTIME_FUNCTION(Runtime_GetArrayKeys) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
+ CONVERT_NUMBER_CHECKED(uint32_t, length, Uint32, args[1]);
+ if (array->elements()->IsDictionary()) {
+ Handle<FixedArray> keys = isolate->factory()->empty_fixed_array();
+ for (PrototypeIterator iter(isolate, array,
+ PrototypeIterator::START_AT_RECEIVER);
+ !iter.IsAtEnd(); iter.Advance()) {
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy() ||
+ JSObject::cast(*PrototypeIterator::GetCurrent(iter))
+ ->HasIndexedInterceptor()) {
+ // Bail out if we find a proxy or interceptor, likely not worth
+ // collecting keys in that case.
+ return *isolate->factory()->NewNumberFromUint(length);
+ }
+ Handle<JSObject> current =
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ Handle<FixedArray> current_keys =
+ isolate->factory()->NewFixedArray(current->NumberOfOwnElements(NONE));
+ current->GetOwnElementKeys(*current_keys, NONE);
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, keys, FixedArray::UnionOfKeys(keys, current_keys));
+ }
+ // Erase any keys >= length.
+ // TODO(adamk): Remove this step when the contract of %GetArrayKeys
+ // is changed to let this happen on the JS side.
+ for (int i = 0; i < keys->length(); i++) {
+ if (NumberToUint32(keys->get(i)) >= length) keys->set_undefined(i);
+ }
+ return *isolate->factory()->NewJSArrayWithElements(keys);
+ } else {
+ RUNTIME_ASSERT(array->HasFastSmiOrObjectElements() ||
+ array->HasFastDoubleElements());
+ uint32_t actual_length = static_cast<uint32_t>(array->elements()->length());
+ return *isolate->factory()->NewNumberFromUint(Min(actual_length, length));
+ }
+}
+
+
+static Object* ArrayConstructorCommon(Isolate* isolate,
+ Handle<JSFunction> constructor,
+ Handle<AllocationSite> site,
+ Arguments* caller_args) {
+ Factory* factory = isolate->factory();
+
+ bool holey = false;
+ bool can_use_type_feedback = true;
+ if (caller_args->length() == 1) {
+ Handle<Object> argument_one = caller_args->at<Object>(0);
+ if (argument_one->IsSmi()) {
+ int value = Handle<Smi>::cast(argument_one)->value();
+ if (value < 0 || value >= JSObject::kInitialMaxFastElementArray) {
+ // the array is a dictionary in this case.
+ can_use_type_feedback = false;
+ } else if (value != 0) {
+ holey = true;
+ }
+ } else {
+ // Non-smi length argument produces a dictionary
+ can_use_type_feedback = false;
+ }
+ }
+
+ Handle<JSArray> array;
+ if (!site.is_null() && can_use_type_feedback) {
+ ElementsKind to_kind = site->GetElementsKind();
+ if (holey && !IsFastHoleyElementsKind(to_kind)) {
+ to_kind = GetHoleyElementsKind(to_kind);
+ // Update the allocation site info to reflect the advice alteration.
+ site->SetElementsKind(to_kind);
+ }
+
+ // We should allocate with an initial map that reflects the allocation site
+ // advice. Therefore we use AllocateJSObjectFromMap instead of passing
+ // the constructor.
+ Handle<Map> initial_map(constructor->initial_map(), isolate);
+ if (to_kind != initial_map->elements_kind()) {
+ initial_map = Map::AsElementsKind(initial_map, to_kind);
+ }
+
+ // If we don't care to track arrays of to_kind ElementsKind, then
+ // don't emit a memento for them.
+ Handle<AllocationSite> allocation_site;
+ if (AllocationSite::GetMode(to_kind) == TRACK_ALLOCATION_SITE) {
+ allocation_site = site;
+ }
+
+ array = Handle<JSArray>::cast(factory->NewJSObjectFromMap(
+ initial_map, NOT_TENURED, true, allocation_site));
+ } else {
+ array = Handle<JSArray>::cast(factory->NewJSObject(constructor));
+
+ // We might need to transition to holey
+ ElementsKind kind = constructor->initial_map()->elements_kind();
+ if (holey && !IsFastHoleyElementsKind(kind)) {
+ kind = GetHoleyElementsKind(kind);
+ JSObject::TransitionElementsKind(array, kind);
+ }
+ }
+
+ factory->NewJSArrayStorage(array, 0, 0, DONT_INITIALIZE_ARRAY_ELEMENTS);
+
+ ElementsKind old_kind = array->GetElementsKind();
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, ArrayConstructInitializeElements(array, caller_args));
+ if (!site.is_null() &&
+ (old_kind != array->GetElementsKind() || !can_use_type_feedback)) {
+ // The arguments passed in caused a transition. This kind of complexity
+ // can't be dealt with in the inlined hydrogen array constructor case.
+ // We must mark the allocationsite as un-inlinable.
+ site->SetDoNotInlineCall();
+ }
+ return *array;
+}
+
+
+RUNTIME_FUNCTION(Runtime_ArrayConstructor) {
+ HandleScope scope(isolate);
+ // If we get 2 arguments then they are the stub parameters (constructor, type
+ // info). If we get 4, then the first one is a pointer to the arguments
+ // passed by the caller, and the last one is the length of the arguments
+ // passed to the caller (redundant, but useful to check on the deoptimizer
+ // with an assert).
+ Arguments empty_args(0, NULL);
+ bool no_caller_args = args.length() == 2;
+ DCHECK(no_caller_args || args.length() == 4);
+ int parameters_start = no_caller_args ? 0 : 1;
+ Arguments* caller_args =
+ no_caller_args ? &empty_args : reinterpret_cast<Arguments*>(args[0]);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, parameters_start);
+ CONVERT_ARG_HANDLE_CHECKED(Object, type_info, parameters_start + 1);
+#ifdef DEBUG
+ if (!no_caller_args) {
+ CONVERT_SMI_ARG_CHECKED(arg_count, parameters_start + 2);
+ DCHECK(arg_count == caller_args->length());
+ }
+#endif
+
+ Handle<AllocationSite> site;
+ if (!type_info.is_null() &&
+ *type_info != isolate->heap()->undefined_value()) {
+ site = Handle<AllocationSite>::cast(type_info);
+ DCHECK(!site->SitePointsToLiteral());
+ }
+
+ return ArrayConstructorCommon(isolate, constructor, site, caller_args);
+}
+
+
+RUNTIME_FUNCTION(Runtime_InternalArrayConstructor) {
+ HandleScope scope(isolate);
+ Arguments empty_args(0, NULL);
+ bool no_caller_args = args.length() == 1;
+ DCHECK(no_caller_args || args.length() == 3);
+ int parameters_start = no_caller_args ? 0 : 1;
+ Arguments* caller_args =
+ no_caller_args ? &empty_args : reinterpret_cast<Arguments*>(args[0]);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, parameters_start);
+#ifdef DEBUG
+ if (!no_caller_args) {
+ CONVERT_SMI_ARG_CHECKED(arg_count, parameters_start + 1);
+ DCHECK(arg_count == caller_args->length());
+ }
+#endif
+ return ArrayConstructorCommon(isolate, constructor,
+ Handle<AllocationSite>::null(), caller_args);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NormalizeElements) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
+ RUNTIME_ASSERT(!array->HasExternalArrayElements() &&
+ !array->HasFixedTypedArrayElements());
+ JSObject::NormalizeElements(array);
+ return *array;
+}
+
+
+RUNTIME_FUNCTION(Runtime_HasComplexElements) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
+ for (PrototypeIterator iter(isolate, array,
+ PrototypeIterator::START_AT_RECEIVER);
+ !iter.IsAtEnd(); iter.Advance()) {
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
+ return isolate->heap()->true_value();
+ }
+ Handle<JSObject> current =
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ if (current->HasIndexedInterceptor()) {
+ return isolate->heap()->true_value();
+ }
+ if (!current->HasDictionaryElements()) continue;
+ if (current->element_dictionary()->HasComplexElements()) {
+ return isolate->heap()->true_value();
+ }
+ }
+ return isolate->heap()->false_value();
+}
+
+
+// TODO(dcarney): remove this function when TurboFan supports it.
+// Takes the object to be iterated over and the result of GetPropertyNamesFast
+// Returns pair (cache_array, cache_type).
+RUNTIME_FUNCTION_RETURN_PAIR(Runtime_ForInInit) {
+ SealHandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ // This simulates CONVERT_ARG_HANDLE_CHECKED for calls returning pairs.
+ // Not worth creating a macro atm as this function should be removed.
+ if (!args[0]->IsJSReceiver() || !args[1]->IsObject()) {
+ Object* error = isolate->ThrowIllegalOperation();
+ return MakePair(error, isolate->heap()->undefined_value());
+ }
+ Handle<JSReceiver> object = args.at<JSReceiver>(0);
+ Handle<Object> cache_type = args.at<Object>(1);
+ if (cache_type->IsMap()) {
+ // Enum cache case.
+ if (Map::EnumLengthBits::decode(Map::cast(*cache_type)->bit_field3()) ==
+ 0) {
+ // 0 length enum.
+ // Can't handle this case in the graph builder,
+ // so transform it into the empty fixed array case.
+ return MakePair(isolate->heap()->empty_fixed_array(), Smi::FromInt(1));
+ }
+ return MakePair(object->map()->instance_descriptors()->GetEnumCache(),
+ *cache_type);
+ } else {
+ // FixedArray case.
+ Smi* new_cache_type = Smi::FromInt(object->IsJSProxy() ? 0 : 1);
+ return MakePair(*Handle<FixedArray>::cast(cache_type), new_cache_type);
+ }
+}
+
+
+// TODO(dcarney): remove this function when TurboFan supports it.
+RUNTIME_FUNCTION(Runtime_ForInCacheArrayLength) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, cache_type, 0);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, array, 1);
+ int length = 0;
+ if (cache_type->IsMap()) {
+ length = Map::cast(*cache_type)->EnumLength();
+ } else {
+ DCHECK(cache_type->IsSmi());
+ length = array->length();
+ }
+ return Smi::FromInt(length);
+}
+
+
+// TODO(dcarney): remove this function when TurboFan supports it.
+// Takes (the object to be iterated over,
+// cache_array from ForInInit,
+// cache_type from ForInInit,
+// the current index)
+// Returns pair (array[index], needs_filtering).
+RUNTIME_FUNCTION_RETURN_PAIR(Runtime_ForInNext) {
+ SealHandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ int32_t index;
+ // This simulates CONVERT_ARG_HANDLE_CHECKED for calls returning pairs.
+ // Not worth creating a macro atm as this function should be removed.
+ if (!args[0]->IsJSReceiver() || !args[1]->IsFixedArray() ||
+ !args[2]->IsObject() || !args[3]->ToInt32(&index)) {
+ Object* error = isolate->ThrowIllegalOperation();
+ return MakePair(error, isolate->heap()->undefined_value());
+ }
+ Handle<JSReceiver> object = args.at<JSReceiver>(0);
+ Handle<FixedArray> array = args.at<FixedArray>(1);
+ Handle<Object> cache_type = args.at<Object>(2);
+ // Figure out first if a slow check is needed for this object.
+ bool slow_check_needed = false;
+ if (cache_type->IsMap()) {
+ if (object->map() != Map::cast(*cache_type)) {
+ // Object transitioned. Need slow check.
+ slow_check_needed = true;
+ }
+ } else {
+ // No slow check needed for proxies.
+ slow_check_needed = Smi::cast(*cache_type)->value() == 1;
+ }
+ return MakePair(array->get(index),
+ isolate->heap()->ToBoolean(slow_check_needed));
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsArray) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSArray());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_HasCachedArrayIndex) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ return isolate->heap()->false_value();
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_GetCachedArrayIndex) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_FastOneByteArrayJoin) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ return isolate->heap()->undefined_value();
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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 <stdlib.h>
+#include <limits>
+
+#include "src/v8.h"
+
+#include "src/isolate-inl.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+
+namespace v8 {
+namespace internal {
+
+
+RUNTIME_FUNCTION(Runtime_ThrowNonMethodError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewReferenceError("non_method", HandleVector<Object>(NULL, 0)));
+}
+
+
+static Object* ThrowUnsupportedSuper(Isolate* isolate) {
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewReferenceError("unsupported_super", HandleVector<Object>(NULL, 0)));
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowUnsupportedSuperError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ return ThrowUnsupportedSuper(isolate);
+}
+
+
+RUNTIME_FUNCTION(Runtime_ToMethod) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ Handle<JSFunction> clone = JSFunction::CloneClosure(fun);
+ Handle<Symbol> home_object_symbol(isolate->heap()->home_object_symbol());
+ JSObject::SetOwnPropertyIgnoreAttributes(clone, home_object_symbol,
+ home_object, DONT_ENUM).Assert();
+ return *clone;
+}
+
+
+RUNTIME_FUNCTION(Runtime_HomeObjectSymbol) {
+ DCHECK(args.length() == 0);
+ return isolate->heap()->home_object_symbol();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineClass) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 6);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, super_class, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, constructor, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Script, script, 3);
+ CONVERT_SMI_ARG_CHECKED(start_position, 4);
+ CONVERT_SMI_ARG_CHECKED(end_position, 5);
+
+ Handle<Object> prototype_parent;
+ Handle<Object> constructor_parent;
+
+ if (super_class->IsTheHole()) {
+ prototype_parent = isolate->initial_object_prototype();
+ } else {
+ if (super_class->IsNull()) {
+ prototype_parent = isolate->factory()->null_value();
+ } else if (super_class->IsSpecFunction()) {
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, prototype_parent,
+ Runtime::GetObjectProperty(isolate, super_class,
+ isolate->factory()->prototype_string()));
+ if (!prototype_parent->IsNull() && !prototype_parent->IsSpecObject()) {
+ Handle<Object> args[1] = {prototype_parent};
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError("prototype_parent_not_an_object",
+ HandleVector(args, 1)));
+ }
+ constructor_parent = super_class;
+ } else {
+ // TODO(arv): Should be IsConstructor.
+ Handle<Object> args[1] = {super_class};
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewTypeError("extends_value_not_a_function", HandleVector(args, 1)));
+ }
+ }
+
+ Handle<Map> map =
+ isolate->factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
+ map->set_prototype(*prototype_parent);
+ Handle<JSObject> prototype = isolate->factory()->NewJSObjectFromMap(map);
+
+ Handle<String> name_string = name->IsString()
+ ? Handle<String>::cast(name)
+ : isolate->factory()->empty_string();
+
+ Handle<JSFunction> ctor;
+ if (constructor->IsSpecFunction()) {
+ ctor = Handle<JSFunction>::cast(constructor);
+ JSFunction::SetPrototype(ctor, prototype);
+ PropertyAttributes attribs =
+ static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::SetOwnPropertyIgnoreAttributes(
+ ctor, isolate->factory()->prototype_string(), prototype, attribs));
+ } else {
+ // TODO(arv): This should not use an empty function but a function that
+ // calls super.
+ Handle<Code> code(isolate->builtins()->builtin(Builtins::kEmptyFunction));
+ ctor = isolate->factory()->NewFunction(name_string, code, prototype, true);
+ }
+
+ Handle<Symbol> home_object_symbol(isolate->heap()->home_object_symbol());
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ ctor, home_object_symbol, prototype, DONT_ENUM));
+
+ if (!constructor_parent.is_null()) {
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetPrototype(ctor, constructor_parent, false));
+ }
+
+ JSObject::AddProperty(prototype, isolate->factory()->constructor_string(),
+ ctor, DONT_ENUM);
+
+ // Install private properties that are used to construct the FunctionToString.
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ Object::SetProperty(ctor, isolate->factory()->class_script_symbol(),
+ script, STRICT));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, Object::SetProperty(
+ ctor, isolate->factory()->class_start_position_symbol(),
+ handle(Smi::FromInt(start_position), isolate), STRICT));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ Object::SetProperty(ctor, isolate->factory()->class_end_position_symbol(),
+ handle(Smi::FromInt(end_position), isolate), STRICT));
+
+ return *ctor;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineClassMethod) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 2);
+
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ function, isolate->factory()->home_object_symbol(), object,
+ DONT_ENUM));
+
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnElement(object, index, function, STRICT));
+ }
+
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Runtime::ToName(isolate, key));
+ if (name->AsArrayIndex(&index)) {
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnElement(object, index, function, STRICT));
+ } else {
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::SetOwnPropertyIgnoreAttributes(object, name, function, NONE));
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineClassGetter) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, getter, 2);
+
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Runtime::ToName(isolate, key));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::SetOwnPropertyIgnoreAttributes(
+ getter, isolate->factory()->home_object_symbol(), object, DONT_ENUM));
+
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::DefineAccessor(object, name, getter,
+ isolate->factory()->null_value(), NONE));
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DefineClassSetter) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, setter, 2);
+
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Runtime::ToName(isolate, key));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::SetOwnPropertyIgnoreAttributes(
+ setter, isolate->factory()->home_object_symbol(), object, DONT_ENUM));
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate,
+ JSObject::DefineAccessor(object, name, isolate->factory()->null_value(),
+ setter, NONE));
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_ClassGetSourceCode) {
+ HandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+
+ Handle<Object> script;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, script,
+ Object::GetProperty(fun, isolate->factory()->class_script_symbol()));
+ if (!script->IsScript()) {
+ return isolate->heap()->undefined_value();
+ }
+
+ Handle<Symbol> start_position_symbol(
+ isolate->heap()->class_start_position_symbol());
+ Handle<Object> start_position;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, start_position, Object::GetProperty(fun, start_position_symbol));
+
+ Handle<Symbol> end_position_symbol(
+ isolate->heap()->class_end_position_symbol());
+ Handle<Object> end_position;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, end_position, Object::GetProperty(fun, end_position_symbol));
+
+ if (!start_position->IsSmi() || !end_position->IsSmi() ||
+ !Handle<Script>::cast(script)->HasValidSource()) {
+ return isolate->ThrowIllegalOperation();
+ }
+
+ Handle<String> source(String::cast(Handle<Script>::cast(script)->source()));
+ return *isolate->factory()->NewSubString(
+ source, Handle<Smi>::cast(start_position)->value(),
+ Handle<Smi>::cast(end_position)->value());
+}
+
+
+static Object* LoadFromSuper(Isolate* isolate, Handle<Object> receiver,
+ Handle<JSObject> home_object, Handle<Name> name) {
+ if (home_object->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(home_object, name, v8::ACCESS_GET)) {
+ isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_GET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ }
+
+ PrototypeIterator iter(isolate, home_object);
+ Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
+ if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+
+ LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Object::GetProperty(&it));
+ return *result;
+}
+
+
+static Object* LoadElementFromSuper(Isolate* isolate, Handle<Object> receiver,
+ Handle<JSObject> home_object,
+ uint32_t index) {
+ if (home_object->IsAccessCheckNeeded() &&
+ !isolate->MayIndexedAccess(home_object, index, v8::ACCESS_GET)) {
+ isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_GET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ }
+
+ PrototypeIterator iter(isolate, home_object);
+ Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
+ if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::GetElementWithReceiver(isolate, proto, receiver, index));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_LoadFromSuper) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
+
+ return LoadFromSuper(isolate, receiver, home_object, name);
+}
+
+
+RUNTIME_FUNCTION(Runtime_LoadKeyedFromSuper) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 2);
+
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ return LoadElementFromSuper(isolate, receiver, home_object, index);
+ }
+
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Runtime::ToName(isolate, key));
+ if (name->AsArrayIndex(&index)) {
+ return LoadElementFromSuper(isolate, receiver, home_object, index);
+ }
+ return LoadFromSuper(isolate, receiver, home_object, name);
+}
+
+
+static Object* StoreToSuper(Isolate* isolate, Handle<JSObject> home_object,
+ Handle<Object> receiver, Handle<Name> name,
+ Handle<Object> value, StrictMode strict_mode) {
+ if (home_object->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(home_object, name, v8::ACCESS_SET)) {
+ isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_SET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ }
+
+ PrototypeIterator iter(isolate, home_object);
+ Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
+ if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+
+ LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::SetProperty(&it, value, strict_mode,
+ Object::CERTAINLY_NOT_STORE_FROM_KEYED,
+ Object::SUPER_PROPERTY));
+ return *result;
+}
+
+
+static Object* StoreElementToSuper(Isolate* isolate,
+ Handle<JSObject> home_object,
+ Handle<Object> receiver, uint32_t index,
+ Handle<Object> value,
+ StrictMode strict_mode) {
+ if (home_object->IsAccessCheckNeeded() &&
+ !isolate->MayIndexedAccess(home_object, index, v8::ACCESS_SET)) {
+ isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_SET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ }
+
+ PrototypeIterator iter(isolate, home_object);
+ Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
+ if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::SetElementWithReceiver(isolate, proto, receiver, index, value,
+ strict_mode));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreToSuper_Strict) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 3);
+
+ return StoreToSuper(isolate, home_object, receiver, name, value, STRICT);
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreToSuper_Sloppy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 3);
+
+ return StoreToSuper(isolate, home_object, receiver, name, value, SLOPPY);
+}
+
+
+static Object* StoreKeyedToSuper(Isolate* isolate, Handle<JSObject> home_object,
+ Handle<Object> receiver, Handle<Object> key,
+ Handle<Object> value, StrictMode strict_mode) {
+ uint32_t index;
+
+ if (key->ToArrayIndex(&index)) {
+ return StoreElementToSuper(isolate, home_object, receiver, index, value,
+ strict_mode);
+ }
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Runtime::ToName(isolate, key));
+ if (name->AsArrayIndex(&index)) {
+ return StoreElementToSuper(isolate, home_object, receiver, index, value,
+ strict_mode);
+ }
+ return StoreToSuper(isolate, home_object, receiver, name, value, strict_mode);
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreKeyedToSuper_Strict) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 3);
+
+ return StoreKeyedToSuper(isolate, home_object, receiver, key, value, STRICT);
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreKeyedToSuper_Sloppy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 3);
+
+ return StoreKeyedToSuper(isolate, home_object, receiver, key, value, SLOPPY);
+}
+}
+} // namespace v8::internal
#include "src/v8.h"
#include "src/arguments.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
}
+RUNTIME_FUNCTION(Runtime_SetIteratorClone) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSSetIterator, holder, 0);
+
+ Handle<JSSetIterator> result = isolate->factory()->NewJSSetIterator();
+ result->set_table(holder->table());
+ result->set_index(Smi::FromInt(Smi::cast(holder->index())->value()));
+ result->set_kind(Smi::FromInt(Smi::cast(holder->kind())->value()));
+
+ return *result;
+}
+
+
RUNTIME_FUNCTION(Runtime_SetIteratorNext) {
SealHandleScope shs(isolate);
DCHECK(args.length() == 2);
}
+RUNTIME_FUNCTION(Runtime_MapIteratorClone) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSMapIterator, holder, 0);
+
+ Handle<JSMapIterator> result = isolate->factory()->NewJSMapIterator();
+ result->set_table(holder->table());
+ result->set_index(Smi::FromInt(Smi::cast(holder->index())->value()));
+ result->set_kind(Smi::FromInt(Smi::cast(holder->kind())->value()));
+
+ return *result;
+}
+
+
RUNTIME_FUNCTION(Runtime_GetWeakMapEntries) {
HandleScope scope(isolate);
DCHECK(args.length() == 1);
Handle<ObjectHashTable> new_table =
ObjectHashTable::Remove(table, key, &was_present);
weak_collection->set_table(*new_table);
+ if (*table != *new_table) {
+ // Zap the old table since we didn't record slots for its elements.
+ table->FillWithHoles(0, table->length());
+ }
return isolate->heap()->ToBoolean(was_present);
}
RUNTIME_ASSERT(table->IsKey(*key));
Handle<ObjectHashTable> new_table = ObjectHashTable::Put(table, key, value);
weak_collection->set_table(*new_table);
+ if (*table != *new_table) {
+ // Zap the old table since we didn't record slots for its elements.
+ table->FillWithHoles(0, table->length());
+ }
return *weak_collection;
}
#include "src/deoptimizer.h"
#include "src/frames.h"
#include "src/full-codegen.h"
-#include "src/isolate.h"
#include "src/isolate-inl.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
#include "src/v8threads.h"
-#include "src/vm-state.h"
#include "src/vm-state-inl.h"
namespace v8 {
ParseRestriction restriction = function_literal_only
? ONLY_SINGLE_FUNCTION_LITERAL
: NO_PARSE_RESTRICTION;
+ Handle<SharedFunctionInfo> outer_info(context->closure()->shared(), isolate);
Handle<JSFunction> fun;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, fun,
- Compiler::GetFunctionFromEval(source, context, SLOPPY, restriction,
- RelocInfo::kNoPosition));
+ Compiler::GetFunctionFromEval(source, outer_info, context, SLOPPY,
+ restriction, RelocInfo::kNoPosition));
return *fun;
}
static ObjectPair CompileGlobalEval(Isolate* isolate, Handle<String> source,
+ Handle<SharedFunctionInfo> outer_info,
Handle<Object> receiver,
StrictMode strict_mode,
int scope_position) {
Handle<JSFunction> compiled;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, compiled,
- Compiler::GetFunctionFromEval(source, context, strict_mode, restriction,
- scope_position),
+ Compiler::GetFunctionFromEval(source, outer_info, context, strict_mode,
+ restriction, scope_position),
MakePair(isolate->heap()->exception(), NULL));
return MakePair(*compiled, *receiver);
}
RUNTIME_FUNCTION_RETURN_PAIR(Runtime_ResolvePossiblyDirectEval) {
HandleScope scope(isolate);
- DCHECK(args.length() == 5);
+ DCHECK(args.length() == 6);
Handle<Object> callee = args.at<Object>(0);
return MakePair(*callee, isolate->heap()->undefined_value());
}
- DCHECK(args[3]->IsSmi());
- DCHECK(args.smi_at(3) == SLOPPY || args.smi_at(3) == STRICT);
- StrictMode strict_mode = static_cast<StrictMode>(args.smi_at(3));
DCHECK(args[4]->IsSmi());
- return CompileGlobalEval(isolate, args.at<String>(1), args.at<Object>(2),
- strict_mode, args.smi_at(4));
+ DCHECK(args.smi_at(4) == SLOPPY || args.smi_at(4) == STRICT);
+ StrictMode strict_mode = static_cast<StrictMode>(args.smi_at(4));
+ DCHECK(args[5]->IsSmi());
+ Handle<SharedFunctionInfo> outer_info(args.at<JSFunction>(2)->shared(),
+ isolate);
+ return CompileGlobalEval(isolate, args.at<String>(1), outer_info,
+ args.at<Object>(3), strict_mode, args.smi_at(5));
}
}
} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/date.h"
+#include "src/dateparser-inl.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_DateMakeDay) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_SMI_ARG_CHECKED(year, 0);
+ CONVERT_SMI_ARG_CHECKED(month, 1);
+
+ int days = isolate->date_cache()->DaysFromYearMonth(year, month);
+ RUNTIME_ASSERT(Smi::IsValid(days));
+ return Smi::FromInt(days);
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateSetValue) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSDate, date, 0);
+ CONVERT_DOUBLE_ARG_CHECKED(time, 1);
+ CONVERT_SMI_ARG_CHECKED(is_utc, 2);
+
+ DateCache* date_cache = isolate->date_cache();
+
+ Handle<Object> value;
+ ;
+ bool is_value_nan = false;
+ if (std::isnan(time)) {
+ value = isolate->factory()->nan_value();
+ is_value_nan = true;
+ } else if (!is_utc && (time < -DateCache::kMaxTimeBeforeUTCInMs ||
+ time > DateCache::kMaxTimeBeforeUTCInMs)) {
+ value = isolate->factory()->nan_value();
+ is_value_nan = true;
+ } else {
+ time = is_utc ? time : date_cache->ToUTC(static_cast<int64_t>(time));
+ if (time < -DateCache::kMaxTimeInMs || time > DateCache::kMaxTimeInMs) {
+ value = isolate->factory()->nan_value();
+ is_value_nan = true;
+ } else {
+ value = isolate->factory()->NewNumber(DoubleToInteger(time));
+ }
+ }
+ date->SetValue(*value, is_value_nan);
+ return *value;
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowNotDateError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError("not_date_object", HandleVector<Object>(NULL, 0)));
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateCurrentTime) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ if (FLAG_log_timer_events) LOG(isolate, CurrentTimeEvent());
+
+ // According to ECMA-262, section 15.9.1, page 117, the precision of
+ // the number in a Date object representing a particular instant in
+ // time is milliseconds. Therefore, we floor the result of getting
+ // the OS time.
+ double millis;
+ if (FLAG_verify_predictable) {
+ millis = 1388534400000.0; // Jan 1 2014 00:00:00 GMT+0000
+ millis += Floor(isolate->heap()->synthetic_time());
+ } else {
+ millis = Floor(base::OS::TimeCurrentMillis());
+ }
+ return *isolate->factory()->NewNumber(millis);
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateParseString) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(String, str, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, output, 1);
+
+ RUNTIME_ASSERT(output->HasFastElements());
+ JSObject::EnsureCanContainHeapObjectElements(output);
+ RUNTIME_ASSERT(output->HasFastObjectElements());
+ Handle<FixedArray> output_array(FixedArray::cast(output->elements()));
+ RUNTIME_ASSERT(output_array->length() >= DateParser::OUTPUT_SIZE);
+
+ str = String::Flatten(str);
+ DisallowHeapAllocation no_gc;
+
+ bool result;
+ String::FlatContent str_content = str->GetFlatContent();
+ if (str_content.IsOneByte()) {
+ result = DateParser::Parse(str_content.ToOneByteVector(), *output_array,
+ isolate->unicode_cache());
+ } else {
+ DCHECK(str_content.IsTwoByte());
+ result = DateParser::Parse(str_content.ToUC16Vector(), *output_array,
+ isolate->unicode_cache());
+ }
+
+ if (result) {
+ return *output;
+ } else {
+ return isolate->heap()->null_value();
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateLocalTimezone) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_DOUBLE_ARG_CHECKED(x, 0);
+ RUNTIME_ASSERT(x >= -DateCache::kMaxTimeBeforeUTCInMs &&
+ x <= DateCache::kMaxTimeBeforeUTCInMs);
+ const char* zone =
+ isolate->date_cache()->LocalTimezone(static_cast<int64_t>(x));
+ Handle<String> result =
+ isolate->factory()->NewStringFromUtf8(CStrVector(zone)).ToHandleChecked();
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateToUTC) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_DOUBLE_ARG_CHECKED(x, 0);
+ RUNTIME_ASSERT(x >= -DateCache::kMaxTimeBeforeUTCInMs &&
+ x <= DateCache::kMaxTimeBeforeUTCInMs);
+ int64_t time = isolate->date_cache()->ToUTC(static_cast<int64_t>(x));
+
+ return *isolate->factory()->NewNumber(static_cast<double>(time));
+}
+
+
+RUNTIME_FUNCTION(Runtime_DateCacheVersion) {
+ HandleScope hs(isolate);
+ DCHECK(args.length() == 0);
+ if (!isolate->eternal_handles()->Exists(EternalHandles::DATE_CACHE_VERSION)) {
+ Handle<FixedArray> date_cache_version =
+ isolate->factory()->NewFixedArray(1, TENURED);
+ date_cache_version->set(0, Smi::FromInt(0));
+ isolate->eternal_handles()->CreateSingleton(
+ isolate, *date_cache_version, EternalHandles::DATE_CACHE_VERSION);
+ }
+ Handle<FixedArray> date_cache_version =
+ Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
+ EternalHandles::DATE_CACHE_VERSION));
+ // Return result as a JS array.
+ Handle<JSObject> result =
+ isolate->factory()->NewJSObject(isolate->array_function());
+ JSArray::SetContent(Handle<JSArray>::cast(result), date_cache_version);
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_DateField) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ CONVERT_SMI_ARG_CHECKED(index, 1);
+ if (!obj->IsJSDate()) {
+ HandleScope scope(isolate);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewTypeError("not_date_object", HandleVector<Object>(NULL, 0)));
+ }
+ JSDate* date = JSDate::cast(obj);
+ if (index == 0) return date->value();
+ return JSDate::GetField(date, Smi::FromInt(index));
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/accessors.h"
+#include "src/arguments.h"
+#include "src/debug.h"
+#include "src/deoptimizer.h"
+#include "src/isolate-inl.h"
+#include "src/parser.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_DebugBreak) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ isolate->debug()->HandleDebugBreak();
+ return isolate->heap()->undefined_value();
+}
+
+
+// Helper functions for wrapping and unwrapping stack frame ids.
+static Smi* WrapFrameId(StackFrame::Id id) {
+ DCHECK(IsAligned(OffsetFrom(id), static_cast<intptr_t>(4)));
+ return Smi::FromInt(id >> 2);
+}
+
+
+static StackFrame::Id UnwrapFrameId(int wrapped) {
+ return static_cast<StackFrame::Id>(wrapped << 2);
+}
+
+
+// Adds a JavaScript function as a debug event listener.
+// args[0]: debug event listener function to set or null or undefined for
+// clearing the event listener function
+// args[1]: object supplied during callback
+RUNTIME_FUNCTION(Runtime_SetDebugEventListener) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ RUNTIME_ASSERT(args[0]->IsJSFunction() || args[0]->IsUndefined() ||
+ args[0]->IsNull());
+ CONVERT_ARG_HANDLE_CHECKED(Object, callback, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, data, 1);
+ isolate->debug()->SetEventListener(callback, data);
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_Break) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ isolate->stack_guard()->RequestDebugBreak();
+ return isolate->heap()->undefined_value();
+}
+
+
+static Handle<Object> DebugGetProperty(LookupIterator* it,
+ bool* has_caught = NULL) {
+ for (; it->IsFound(); it->Next()) {
+ switch (it->state()) {
+ case LookupIterator::NOT_FOUND:
+ case LookupIterator::TRANSITION:
+ UNREACHABLE();
+ case LookupIterator::ACCESS_CHECK:
+ // Ignore access checks.
+ break;
+ case LookupIterator::INTERCEPTOR:
+ case LookupIterator::JSPROXY:
+ return it->isolate()->factory()->undefined_value();
+ case LookupIterator::ACCESSOR: {
+ Handle<Object> accessors = it->GetAccessors();
+ if (!accessors->IsAccessorInfo()) {
+ return it->isolate()->factory()->undefined_value();
+ }
+ MaybeHandle<Object> maybe_result = JSObject::GetPropertyWithAccessor(
+ it->GetReceiver(), it->name(), it->GetHolder<JSObject>(),
+ accessors);
+ Handle<Object> result;
+ if (!maybe_result.ToHandle(&result)) {
+ result = handle(it->isolate()->pending_exception(), it->isolate());
+ it->isolate()->clear_pending_exception();
+ if (has_caught != NULL) *has_caught = true;
+ }
+ return result;
+ }
+
+ case LookupIterator::DATA:
+ return it->GetDataValue();
+ }
+ }
+
+ return it->isolate()->factory()->undefined_value();
+}
+
+
+// Get debugger related details for an object property, in the following format:
+// 0: Property value
+// 1: Property details
+// 2: Property value is exception
+// 3: Getter function if defined
+// 4: Setter function if defined
+// Items 2-4 are only filled if the property has either a getter or a setter.
+RUNTIME_FUNCTION(Runtime_DebugGetPropertyDetails) {
+ HandleScope scope(isolate);
+
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+
+ // Make sure to set the current context to the context before the debugger was
+ // entered (if the debugger is entered). The reason for switching context here
+ // is that for some property lookups (accessors and interceptors) callbacks
+ // into the embedding application can occour, and the embedding application
+ // could have the assumption that its own native context is the current
+ // context and not some internal debugger context.
+ SaveContext save(isolate);
+ if (isolate->debug()->in_debug_scope()) {
+ isolate->set_context(*isolate->debug()->debugger_entry()->GetContext());
+ }
+
+ // Check if the name is trivially convertible to an index and get the element
+ // if so.
+ uint32_t index;
+ if (name->AsArrayIndex(&index)) {
+ Handle<FixedArray> details = isolate->factory()->NewFixedArray(2);
+ Handle<Object> element_or_char;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, element_or_char,
+ Runtime::GetElementOrCharAt(isolate, obj, index));
+ details->set(0, *element_or_char);
+ details->set(1,
+ PropertyDetails(NONE, NORMAL, Representation::None()).AsSmi());
+ return *isolate->factory()->NewJSArrayWithElements(details);
+ }
+
+ LookupIterator it(obj, name, LookupIterator::HIDDEN);
+ bool has_caught = false;
+ Handle<Object> value = DebugGetProperty(&it, &has_caught);
+ if (!it.IsFound()) return isolate->heap()->undefined_value();
+
+ Handle<Object> maybe_pair;
+ if (it.state() == LookupIterator::ACCESSOR) {
+ maybe_pair = it.GetAccessors();
+ }
+
+ // If the callback object is a fixed array then it contains JavaScript
+ // getter and/or setter.
+ bool has_js_accessors = !maybe_pair.is_null() && maybe_pair->IsAccessorPair();
+ Handle<FixedArray> details =
+ isolate->factory()->NewFixedArray(has_js_accessors ? 6 : 3);
+ details->set(0, *value);
+ // TODO(verwaest): Get rid of this random way of handling interceptors.
+ PropertyDetails d = it.state() == LookupIterator::INTERCEPTOR
+ ? PropertyDetails(NONE, NORMAL, 0)
+ : it.property_details();
+ details->set(1, d.AsSmi());
+ details->set(
+ 2, isolate->heap()->ToBoolean(it.state() == LookupIterator::INTERCEPTOR));
+ if (has_js_accessors) {
+ AccessorPair* accessors = AccessorPair::cast(*maybe_pair);
+ details->set(3, isolate->heap()->ToBoolean(has_caught));
+ details->set(4, accessors->GetComponent(ACCESSOR_GETTER));
+ details->set(5, accessors->GetComponent(ACCESSOR_SETTER));
+ }
+
+ return *isolate->factory()->NewJSArrayWithElements(details);
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugGetProperty) {
+ HandleScope scope(isolate);
+
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+
+ LookupIterator it(obj, name);
+ return *DebugGetProperty(&it);
+}
+
+
+// Return the property type calculated from the property details.
+// args[0]: smi with property details.
+RUNTIME_FUNCTION(Runtime_DebugPropertyTypeFromDetails) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
+ return Smi::FromInt(static_cast<int>(details.type()));
+}
+
+
+// Return the property attribute calculated from the property details.
+// args[0]: smi with property details.
+RUNTIME_FUNCTION(Runtime_DebugPropertyAttributesFromDetails) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
+ return Smi::FromInt(static_cast<int>(details.attributes()));
+}
+
+
+// Return the property insertion index calculated from the property details.
+// args[0]: smi with property details.
+RUNTIME_FUNCTION(Runtime_DebugPropertyIndexFromDetails) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
+ // TODO(verwaest): Depends on the type of details.
+ return Smi::FromInt(details.dictionary_index());
+}
+
+
+// Return property value from named interceptor.
+// args[0]: object
+// args[1]: property name
+RUNTIME_FUNCTION(Runtime_DebugNamedInterceptorPropertyValue) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ RUNTIME_ASSERT(obj->HasNamedInterceptor());
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+ JSObject::GetProperty(obj, name));
+ return *result;
+}
+
+
+// Return element value from indexed interceptor.
+// args[0]: object
+// args[1]: index
+RUNTIME_FUNCTION(Runtime_DebugIndexedInterceptorElementValue) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ RUNTIME_ASSERT(obj->HasIndexedInterceptor());
+ CONVERT_NUMBER_CHECKED(uint32_t, index, Uint32, args[1]);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSObject::GetElementWithInterceptor(obj, obj, index));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CheckExecutionState) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+ return isolate->heap()->true_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetFrameCount) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ // Count all frames which are relevant to debugging stack trace.
+ int n = 0;
+ StackFrame::Id id = isolate->debug()->break_frame_id();
+ if (id == StackFrame::NO_ID) {
+ // If there is no JavaScript stack frame count is 0.
+ return Smi::FromInt(0);
+ }
+
+ for (JavaScriptFrameIterator it(isolate, id); !it.done(); it.Advance()) {
+ List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+ it.frame()->Summarize(&frames);
+ for (int i = frames.length() - 1; i >= 0; i--) {
+ // Omit functions from native scripts.
+ if (!frames[i].function()->IsFromNativeScript()) n++;
+ }
+ }
+ return Smi::FromInt(n);
+}
+
+
+class FrameInspector {
+ public:
+ FrameInspector(JavaScriptFrame* frame, int inlined_jsframe_index,
+ Isolate* isolate)
+ : frame_(frame), deoptimized_frame_(NULL), isolate_(isolate) {
+ // Calculate the deoptimized frame.
+ if (frame->is_optimized()) {
+ deoptimized_frame_ = Deoptimizer::DebuggerInspectableFrame(
+ frame, inlined_jsframe_index, isolate);
+ }
+ has_adapted_arguments_ = frame_->has_adapted_arguments();
+ is_bottommost_ = inlined_jsframe_index == 0;
+ is_optimized_ = frame_->is_optimized();
+ }
+
+ ~FrameInspector() {
+ // Get rid of the calculated deoptimized frame if any.
+ if (deoptimized_frame_ != NULL) {
+ Deoptimizer::DeleteDebuggerInspectableFrame(deoptimized_frame_, isolate_);
+ }
+ }
+
+ int GetParametersCount() {
+ return is_optimized_ ? deoptimized_frame_->parameters_count()
+ : frame_->ComputeParametersCount();
+ }
+ int expression_count() { return deoptimized_frame_->expression_count(); }
+ Object* GetFunction() {
+ return is_optimized_ ? deoptimized_frame_->GetFunction()
+ : frame_->function();
+ }
+ Object* GetParameter(int index) {
+ return is_optimized_ ? deoptimized_frame_->GetParameter(index)
+ : frame_->GetParameter(index);
+ }
+ Object* GetExpression(int index) {
+ return is_optimized_ ? deoptimized_frame_->GetExpression(index)
+ : frame_->GetExpression(index);
+ }
+ int GetSourcePosition() {
+ return is_optimized_ ? deoptimized_frame_->GetSourcePosition()
+ : frame_->LookupCode()->SourcePosition(frame_->pc());
+ }
+ bool IsConstructor() {
+ return is_optimized_ && !is_bottommost_
+ ? deoptimized_frame_->HasConstructStub()
+ : frame_->IsConstructor();
+ }
+ Object* GetContext() {
+ return is_optimized_ ? deoptimized_frame_->GetContext() : frame_->context();
+ }
+
+ // To inspect all the provided arguments the frame might need to be
+ // replaced with the arguments frame.
+ void SetArgumentsFrame(JavaScriptFrame* frame) {
+ DCHECK(has_adapted_arguments_);
+ frame_ = frame;
+ is_optimized_ = frame_->is_optimized();
+ DCHECK(!is_optimized_);
+ }
+
+ private:
+ JavaScriptFrame* frame_;
+ DeoptimizedFrameInfo* deoptimized_frame_;
+ Isolate* isolate_;
+ bool is_optimized_;
+ bool is_bottommost_;
+ bool has_adapted_arguments_;
+
+ DISALLOW_COPY_AND_ASSIGN(FrameInspector);
+};
+
+
+static const int kFrameDetailsFrameIdIndex = 0;
+static const int kFrameDetailsReceiverIndex = 1;
+static const int kFrameDetailsFunctionIndex = 2;
+static const int kFrameDetailsArgumentCountIndex = 3;
+static const int kFrameDetailsLocalCountIndex = 4;
+static const int kFrameDetailsSourcePositionIndex = 5;
+static const int kFrameDetailsConstructCallIndex = 6;
+static const int kFrameDetailsAtReturnIndex = 7;
+static const int kFrameDetailsFlagsIndex = 8;
+static const int kFrameDetailsFirstDynamicIndex = 9;
+
+
+static SaveContext* FindSavedContextForFrame(Isolate* isolate,
+ JavaScriptFrame* frame) {
+ SaveContext* save = isolate->save_context();
+ while (save != NULL && !save->IsBelowFrame(frame)) {
+ save = save->prev();
+ }
+ DCHECK(save != NULL);
+ return save;
+}
+
+
+// Advances the iterator to the frame that matches the index and returns the
+// inlined frame index, or -1 if not found. Skips native JS functions.
+int Runtime::FindIndexedNonNativeFrame(JavaScriptFrameIterator* it, int index) {
+ int count = -1;
+ for (; !it->done(); it->Advance()) {
+ List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+ it->frame()->Summarize(&frames);
+ for (int i = frames.length() - 1; i >= 0; i--) {
+ // Omit functions from native scripts.
+ if (frames[i].function()->IsFromNativeScript()) continue;
+ if (++count == index) return i;
+ }
+ }
+ return -1;
+}
+
+
+// Return an array with frame details
+// args[0]: number: break id
+// args[1]: number: frame index
+//
+// The array returned contains the following information:
+// 0: Frame id
+// 1: Receiver
+// 2: Function
+// 3: Argument count
+// 4: Local count
+// 5: Source position
+// 6: Constructor call
+// 7: Is at return
+// 8: Flags
+// Arguments name, value
+// Locals name, value
+// Return value if any
+RUNTIME_FUNCTION(Runtime_GetFrameDetails) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
+ Heap* heap = isolate->heap();
+
+ // Find the relevant frame with the requested index.
+ StackFrame::Id id = isolate->debug()->break_frame_id();
+ if (id == StackFrame::NO_ID) {
+ // If there are no JavaScript stack frames return undefined.
+ return heap->undefined_value();
+ }
+
+ JavaScriptFrameIterator it(isolate, id);
+ // Inlined frame index in optimized frame, starting from outer function.
+ int inlined_jsframe_index = Runtime::FindIndexedNonNativeFrame(&it, index);
+ if (inlined_jsframe_index == -1) return heap->undefined_value();
+
+ FrameInspector frame_inspector(it.frame(), inlined_jsframe_index, isolate);
+ bool is_optimized = it.frame()->is_optimized();
+
+ // Traverse the saved contexts chain to find the active context for the
+ // selected frame.
+ SaveContext* save = FindSavedContextForFrame(isolate, it.frame());
+
+ // Get the frame id.
+ Handle<Object> frame_id(WrapFrameId(it.frame()->id()), isolate);
+
+ // Find source position in unoptimized code.
+ int position = frame_inspector.GetSourcePosition();
+
+ // Check for constructor frame.
+ bool constructor = frame_inspector.IsConstructor();
+
+ // Get scope info and read from it for local variable information.
+ Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
+ Handle<SharedFunctionInfo> shared(function->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+ DCHECK(*scope_info != ScopeInfo::Empty(isolate));
+
+ // Get the locals names and values into a temporary array.
+ int local_count = scope_info->LocalCount();
+ for (int slot = 0; slot < scope_info->LocalCount(); ++slot) {
+ // Hide compiler-introduced temporary variables, whether on the stack or on
+ // the context.
+ if (scope_info->LocalIsSynthetic(slot)) local_count--;
+ }
+
+ Handle<FixedArray> locals =
+ isolate->factory()->NewFixedArray(local_count * 2);
+
+ // Fill in the values of the locals.
+ int local = 0;
+ int i = 0;
+ for (; i < scope_info->StackLocalCount(); ++i) {
+ // Use the value from the stack.
+ if (scope_info->LocalIsSynthetic(i)) continue;
+ locals->set(local * 2, scope_info->LocalName(i));
+ locals->set(local * 2 + 1, frame_inspector.GetExpression(i));
+ local++;
+ }
+ if (local < local_count) {
+ // Get the context containing declarations.
+ Handle<Context> context(
+ Context::cast(frame_inspector.GetContext())->declaration_context());
+ for (; i < scope_info->LocalCount(); ++i) {
+ if (scope_info->LocalIsSynthetic(i)) continue;
+ Handle<String> name(scope_info->LocalName(i));
+ VariableMode mode;
+ InitializationFlag init_flag;
+ MaybeAssignedFlag maybe_assigned_flag;
+ locals->set(local * 2, *name);
+ int context_slot_index = ScopeInfo::ContextSlotIndex(
+ scope_info, name, &mode, &init_flag, &maybe_assigned_flag);
+ Object* value = context->get(context_slot_index);
+ locals->set(local * 2 + 1, value);
+ local++;
+ }
+ }
+
+ // Check whether this frame is positioned at return. If not top
+ // frame or if the frame is optimized it cannot be at a return.
+ bool at_return = false;
+ if (!is_optimized && index == 0) {
+ at_return = isolate->debug()->IsBreakAtReturn(it.frame());
+ }
+
+ // If positioned just before return find the value to be returned and add it
+ // to the frame information.
+ Handle<Object> return_value = isolate->factory()->undefined_value();
+ if (at_return) {
+ StackFrameIterator it2(isolate);
+ Address internal_frame_sp = NULL;
+ while (!it2.done()) {
+ if (it2.frame()->is_internal()) {
+ internal_frame_sp = it2.frame()->sp();
+ } else {
+ if (it2.frame()->is_java_script()) {
+ if (it2.frame()->id() == it.frame()->id()) {
+ // The internal frame just before the JavaScript frame contains the
+ // value to return on top. A debug break at return will create an
+ // internal frame to store the return value (eax/rax/r0) before
+ // entering the debug break exit frame.
+ if (internal_frame_sp != NULL) {
+ return_value =
+ Handle<Object>(Memory::Object_at(internal_frame_sp), isolate);
+ break;
+ }
+ }
+ }
+
+ // Indicate that the previous frame was not an internal frame.
+ internal_frame_sp = NULL;
+ }
+ it2.Advance();
+ }
+ }
+
+ // Now advance to the arguments adapter frame (if any). It contains all
+ // the provided parameters whereas the function frame always have the number
+ // of arguments matching the functions parameters. The rest of the
+ // information (except for what is collected above) is the same.
+ if ((inlined_jsframe_index == 0) && it.frame()->has_adapted_arguments()) {
+ it.AdvanceToArgumentsFrame();
+ frame_inspector.SetArgumentsFrame(it.frame());
+ }
+
+ // Find the number of arguments to fill. At least fill the number of
+ // parameters for the function and fill more if more parameters are provided.
+ int argument_count = scope_info->ParameterCount();
+ if (argument_count < frame_inspector.GetParametersCount()) {
+ argument_count = frame_inspector.GetParametersCount();
+ }
+
+ // Calculate the size of the result.
+ int details_size = kFrameDetailsFirstDynamicIndex +
+ 2 * (argument_count + local_count) + (at_return ? 1 : 0);
+ Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);
+
+ // Add the frame id.
+ details->set(kFrameDetailsFrameIdIndex, *frame_id);
+
+ // Add the function (same as in function frame).
+ details->set(kFrameDetailsFunctionIndex, frame_inspector.GetFunction());
+
+ // Add the arguments count.
+ details->set(kFrameDetailsArgumentCountIndex, Smi::FromInt(argument_count));
+
+ // Add the locals count
+ details->set(kFrameDetailsLocalCountIndex, Smi::FromInt(local_count));
+
+ // Add the source position.
+ if (position != RelocInfo::kNoPosition) {
+ details->set(kFrameDetailsSourcePositionIndex, Smi::FromInt(position));
+ } else {
+ details->set(kFrameDetailsSourcePositionIndex, heap->undefined_value());
+ }
+
+ // Add the constructor information.
+ details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(constructor));
+
+ // Add the at return information.
+ details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(at_return));
+
+ // Add flags to indicate information on whether this frame is
+ // bit 0: invoked in the debugger context.
+ // bit 1: optimized frame.
+ // bit 2: inlined in optimized frame
+ int flags = 0;
+ if (*save->context() == *isolate->debug()->debug_context()) {
+ flags |= 1 << 0;
+ }
+ if (is_optimized) {
+ flags |= 1 << 1;
+ flags |= inlined_jsframe_index << 2;
+ }
+ details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));
+
+ // Fill the dynamic part.
+ int details_index = kFrameDetailsFirstDynamicIndex;
+
+ // Add arguments name and value.
+ for (int i = 0; i < argument_count; i++) {
+ // Name of the argument.
+ if (i < scope_info->ParameterCount()) {
+ details->set(details_index++, scope_info->ParameterName(i));
+ } else {
+ details->set(details_index++, heap->undefined_value());
+ }
+
+ // Parameter value.
+ if (i < frame_inspector.GetParametersCount()) {
+ // Get the value from the stack.
+ details->set(details_index++, frame_inspector.GetParameter(i));
+ } else {
+ details->set(details_index++, heap->undefined_value());
+ }
+ }
+
+ // Add locals name and value from the temporary copy from the function frame.
+ for (int i = 0; i < local_count * 2; i++) {
+ details->set(details_index++, locals->get(i));
+ }
+
+ // Add the value being returned.
+ if (at_return) {
+ details->set(details_index++, *return_value);
+ }
+
+ // Add the receiver (same as in function frame).
+ // THIS MUST BE DONE LAST SINCE WE MIGHT ADVANCE
+ // THE FRAME ITERATOR TO WRAP THE RECEIVER.
+ Handle<Object> receiver(it.frame()->receiver(), isolate);
+ if (!receiver->IsJSObject() && shared->strict_mode() == SLOPPY &&
+ !function->IsBuiltin()) {
+ // If the receiver is not a JSObject and the function is not a
+ // builtin or strict-mode we have hit an optimization where a
+ // value object is not converted into a wrapped JS objects. To
+ // hide this optimization from the debugger, we wrap the receiver
+ // by creating correct wrapper object based on the calling frame's
+ // native context.
+ it.Advance();
+ if (receiver->IsUndefined()) {
+ receiver = handle(function->global_proxy());
+ } else {
+ Context* context = Context::cast(it.frame()->context());
+ Handle<Context> native_context(Context::cast(context->native_context()));
+ if (!Object::ToObject(isolate, receiver, native_context)
+ .ToHandle(&receiver)) {
+ // This only happens if the receiver is forcibly set in %_CallFunction.
+ return heap->undefined_value();
+ }
+ }
+ }
+ details->set(kFrameDetailsReceiverIndex, *receiver);
+
+ DCHECK_EQ(details_size, details_index);
+ return *isolate->factory()->NewJSArrayWithElements(details);
+}
+
+
+static bool ParameterIsShadowedByContextLocal(Handle<ScopeInfo> info,
+ Handle<String> parameter_name) {
+ VariableMode mode;
+ InitializationFlag init_flag;
+ MaybeAssignedFlag maybe_assigned_flag;
+ return ScopeInfo::ContextSlotIndex(info, parameter_name, &mode, &init_flag,
+ &maybe_assigned_flag) != -1;
+}
+
+
+// Create a plain JSObject which materializes the local scope for the specified
+// frame.
+MUST_USE_RESULT
+static MaybeHandle<JSObject> MaterializeStackLocalsWithFrameInspector(
+ Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function,
+ FrameInspector* frame_inspector) {
+ Handle<SharedFunctionInfo> shared(function->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ // First fill all parameters.
+ for (int i = 0; i < scope_info->ParameterCount(); ++i) {
+ // Do not materialize the parameter if it is shadowed by a context local.
+ Handle<String> name(scope_info->ParameterName(i));
+ if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
+
+ HandleScope scope(isolate);
+ Handle<Object> value(i < frame_inspector->GetParametersCount()
+ ? frame_inspector->GetParameter(i)
+ : isolate->heap()->undefined_value(),
+ isolate);
+ DCHECK(!value->IsTheHole());
+
+ RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
+ isolate, target, name, value, SLOPPY),
+ JSObject);
+ }
+
+ // Second fill all stack locals.
+ for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
+ if (scope_info->LocalIsSynthetic(i)) continue;
+ Handle<String> name(scope_info->StackLocalName(i));
+ Handle<Object> value(frame_inspector->GetExpression(i), isolate);
+ if (value->IsTheHole()) continue;
+
+ RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
+ isolate, target, name, value, SLOPPY),
+ JSObject);
+ }
+
+ return target;
+}
+
+
+static void UpdateStackLocalsFromMaterializedObject(Isolate* isolate,
+ Handle<JSObject> target,
+ Handle<JSFunction> function,
+ JavaScriptFrame* frame,
+ int inlined_jsframe_index) {
+ if (inlined_jsframe_index != 0 || frame->is_optimized()) {
+ // Optimized frames are not supported.
+ // TODO(yangguo): make sure all code deoptimized when debugger is active
+ // and assert that this cannot happen.
+ return;
+ }
+
+ Handle<SharedFunctionInfo> shared(function->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ // Parameters.
+ for (int i = 0; i < scope_info->ParameterCount(); ++i) {
+ // Shadowed parameters were not materialized.
+ Handle<String> name(scope_info->ParameterName(i));
+ if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
+
+ DCHECK(!frame->GetParameter(i)->IsTheHole());
+ HandleScope scope(isolate);
+ Handle<Object> value =
+ Object::GetPropertyOrElement(target, name).ToHandleChecked();
+ frame->SetParameterValue(i, *value);
+ }
+
+ // Stack locals.
+ for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
+ if (scope_info->LocalIsSynthetic(i)) continue;
+ if (frame->GetExpression(i)->IsTheHole()) continue;
+ HandleScope scope(isolate);
+ Handle<Object> value = Object::GetPropertyOrElement(
+ target, handle(scope_info->StackLocalName(i),
+ isolate)).ToHandleChecked();
+ frame->SetExpression(i, *value);
+ }
+}
+
+
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalContext(
+ Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function,
+ JavaScriptFrame* frame) {
+ HandleScope scope(isolate);
+ Handle<SharedFunctionInfo> shared(function->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ if (!scope_info->HasContext()) return target;
+
+ // Third fill all context locals.
+ Handle<Context> frame_context(Context::cast(frame->context()));
+ Handle<Context> function_context(frame_context->declaration_context());
+ if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, function_context,
+ target)) {
+ return MaybeHandle<JSObject>();
+ }
+
+ // Finally copy any properties from the function context extension.
+ // These will be variables introduced by eval.
+ if (function_context->closure() == *function) {
+ if (function_context->has_extension() &&
+ !function_context->IsNativeContext()) {
+ Handle<JSObject> ext(JSObject::cast(function_context->extension()));
+ Handle<FixedArray> keys;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, keys, JSReceiver::GetKeys(ext, JSReceiver::INCLUDE_PROTOS),
+ JSObject);
+
+ for (int i = 0; i < keys->length(); i++) {
+ // Names of variables introduced by eval are strings.
+ DCHECK(keys->get(i)->IsString());
+ Handle<String> key(String::cast(keys->get(i)));
+ Handle<Object> value;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, Object::GetPropertyOrElement(ext, key), JSObject);
+ RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
+ isolate, target, key, value, SLOPPY),
+ JSObject);
+ }
+ }
+ }
+
+ return target;
+}
+
+
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalScope(
+ Isolate* isolate, JavaScriptFrame* frame, int inlined_jsframe_index) {
+ FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
+ Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
+
+ Handle<JSObject> local_scope =
+ isolate->factory()->NewJSObject(isolate->object_function());
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, local_scope,
+ MaterializeStackLocalsWithFrameInspector(isolate, local_scope, function,
+ &frame_inspector),
+ JSObject);
+
+ return MaterializeLocalContext(isolate, local_scope, function, frame);
+}
+
+
+// Set the context local variable value.
+static bool SetContextLocalValue(Isolate* isolate, Handle<ScopeInfo> scope_info,
+ Handle<Context> context,
+ Handle<String> variable_name,
+ Handle<Object> new_value) {
+ for (int i = 0; i < scope_info->ContextLocalCount(); i++) {
+ Handle<String> next_name(scope_info->ContextLocalName(i));
+ if (String::Equals(variable_name, next_name)) {
+ VariableMode mode;
+ InitializationFlag init_flag;
+ MaybeAssignedFlag maybe_assigned_flag;
+ int context_index = ScopeInfo::ContextSlotIndex(
+ scope_info, next_name, &mode, &init_flag, &maybe_assigned_flag);
+ context->set(context_index, *new_value);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+static bool SetLocalVariableValue(Isolate* isolate, JavaScriptFrame* frame,
+ int inlined_jsframe_index,
+ Handle<String> variable_name,
+ Handle<Object> new_value) {
+ if (inlined_jsframe_index != 0 || frame->is_optimized()) {
+ // Optimized frames are not supported.
+ return false;
+ }
+
+ Handle<JSFunction> function(frame->function());
+ Handle<SharedFunctionInfo> shared(function->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ bool default_result = false;
+
+ // Parameters.
+ for (int i = 0; i < scope_info->ParameterCount(); ++i) {
+ HandleScope scope(isolate);
+ if (String::Equals(handle(scope_info->ParameterName(i)), variable_name)) {
+ frame->SetParameterValue(i, *new_value);
+ // Argument might be shadowed in heap context, don't stop here.
+ default_result = true;
+ }
+ }
+
+ // Stack locals.
+ for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
+ HandleScope scope(isolate);
+ if (String::Equals(handle(scope_info->StackLocalName(i)), variable_name)) {
+ frame->SetExpression(i, *new_value);
+ return true;
+ }
+ }
+
+ if (scope_info->HasContext()) {
+ // Context locals.
+ Handle<Context> frame_context(Context::cast(frame->context()));
+ Handle<Context> function_context(frame_context->declaration_context());
+ if (SetContextLocalValue(isolate, scope_info, function_context,
+ variable_name, new_value)) {
+ return true;
+ }
+
+ // Function context extension. These are variables introduced by eval.
+ if (function_context->closure() == *function) {
+ if (function_context->has_extension() &&
+ !function_context->IsNativeContext()) {
+ Handle<JSObject> ext(JSObject::cast(function_context->extension()));
+
+ Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
+ DCHECK(maybe.has_value);
+ if (maybe.value) {
+ // We don't expect this to do anything except replacing
+ // property value.
+ Runtime::SetObjectProperty(isolate, ext, variable_name, new_value,
+ SLOPPY).Assert();
+ return true;
+ }
+ }
+ }
+ }
+
+ return default_result;
+}
+
+
+// Create a plain JSObject which materializes the closure content for the
+// context.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeClosure(
+ Isolate* isolate, Handle<Context> context) {
+ DCHECK(context->IsFunctionContext());
+
+ Handle<SharedFunctionInfo> shared(context->closure()->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ // Allocate and initialize a JSObject with all the content of this function
+ // closure.
+ Handle<JSObject> closure_scope =
+ isolate->factory()->NewJSObject(isolate->object_function());
+
+ // Fill all context locals to the context extension.
+ if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
+ closure_scope)) {
+ return MaybeHandle<JSObject>();
+ }
+
+ // Finally copy any properties from the function context extension. This will
+ // be variables introduced by eval.
+ if (context->has_extension()) {
+ Handle<JSObject> ext(JSObject::cast(context->extension()));
+ Handle<FixedArray> keys;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, keys, JSReceiver::GetKeys(ext, JSReceiver::INCLUDE_PROTOS),
+ JSObject);
+
+ for (int i = 0; i < keys->length(); i++) {
+ HandleScope scope(isolate);
+ // Names of variables introduced by eval are strings.
+ DCHECK(keys->get(i)->IsString());
+ Handle<String> key(String::cast(keys->get(i)));
+ Handle<Object> value;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, Object::GetPropertyOrElement(ext, key), JSObject);
+ RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
+ closure_scope, key, value, NONE),
+ JSObject);
+ }
+ }
+
+ return closure_scope;
+}
+
+
+// This method copies structure of MaterializeClosure method above.
+static bool SetClosureVariableValue(Isolate* isolate, Handle<Context> context,
+ Handle<String> variable_name,
+ Handle<Object> new_value) {
+ DCHECK(context->IsFunctionContext());
+
+ Handle<SharedFunctionInfo> shared(context->closure()->shared());
+ Handle<ScopeInfo> scope_info(shared->scope_info());
+
+ // Context locals to the context extension.
+ if (SetContextLocalValue(isolate, scope_info, context, variable_name,
+ new_value)) {
+ return true;
+ }
+
+ // Properties from the function context extension. This will
+ // be variables introduced by eval.
+ if (context->has_extension()) {
+ Handle<JSObject> ext(JSObject::cast(context->extension()));
+ Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
+ DCHECK(maybe.has_value);
+ if (maybe.value) {
+ // We don't expect this to do anything except replacing property value.
+ Runtime::DefineObjectProperty(ext, variable_name, new_value, NONE)
+ .Assert();
+ return true;
+ }
+ }
+
+ return false;
+}
+
+
+// Create a plain JSObject which materializes the scope for the specified
+// catch context.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeCatchScope(
+ Isolate* isolate, Handle<Context> context) {
+ DCHECK(context->IsCatchContext());
+ Handle<String> name(String::cast(context->extension()));
+ Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX),
+ isolate);
+ Handle<JSObject> catch_scope =
+ isolate->factory()->NewJSObject(isolate->object_function());
+ RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
+ catch_scope, name, thrown_object, NONE),
+ JSObject);
+ return catch_scope;
+}
+
+
+static bool SetCatchVariableValue(Isolate* isolate, Handle<Context> context,
+ Handle<String> variable_name,
+ Handle<Object> new_value) {
+ DCHECK(context->IsCatchContext());
+ Handle<String> name(String::cast(context->extension()));
+ if (!String::Equals(name, variable_name)) {
+ return false;
+ }
+ context->set(Context::THROWN_OBJECT_INDEX, *new_value);
+ return true;
+}
+
+
+// Create a plain JSObject which materializes the block scope for the specified
+// block context.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeBlockScope(
+ Isolate* isolate, Handle<Context> context) {
+ DCHECK(context->IsBlockContext());
+ Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+
+ // Allocate and initialize a JSObject with all the arguments, stack locals
+ // heap locals and extension properties of the debugged function.
+ Handle<JSObject> block_scope =
+ isolate->factory()->NewJSObject(isolate->object_function());
+
+ // Fill all context locals.
+ if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
+ block_scope)) {
+ return MaybeHandle<JSObject>();
+ }
+
+ return block_scope;
+}
+
+
+// Create a plain JSObject which materializes the module scope for the specified
+// module context.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeModuleScope(
+ Isolate* isolate, Handle<Context> context) {
+ DCHECK(context->IsModuleContext());
+ Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+
+ // Allocate and initialize a JSObject with all the members of the debugged
+ // module.
+ Handle<JSObject> module_scope =
+ isolate->factory()->NewJSObject(isolate->object_function());
+
+ // Fill all context locals.
+ if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
+ module_scope)) {
+ return MaybeHandle<JSObject>();
+ }
+
+ return module_scope;
+}
+
+
+// Iterate over the actual scopes visible from a stack frame or from a closure.
+// The iteration proceeds from the innermost visible nested scope outwards.
+// All scopes are backed by an actual context except the local scope,
+// which is inserted "artificially" in the context chain.
+class ScopeIterator {
+ public:
+ enum ScopeType {
+ ScopeTypeGlobal = 0,
+ ScopeTypeLocal,
+ ScopeTypeWith,
+ ScopeTypeClosure,
+ ScopeTypeCatch,
+ ScopeTypeBlock,
+ ScopeTypeModule
+ };
+
+ ScopeIterator(Isolate* isolate, JavaScriptFrame* frame,
+ int inlined_jsframe_index, bool ignore_nested_scopes = false)
+ : isolate_(isolate),
+ frame_(frame),
+ inlined_jsframe_index_(inlined_jsframe_index),
+ function_(frame->function()),
+ context_(Context::cast(frame->context())),
+ nested_scope_chain_(4),
+ failed_(false) {
+ // Catch the case when the debugger stops in an internal function.
+ Handle<SharedFunctionInfo> shared_info(function_->shared());
+ Handle<ScopeInfo> scope_info(shared_info->scope_info());
+ if (shared_info->script() == isolate->heap()->undefined_value()) {
+ while (context_->closure() == *function_) {
+ context_ = Handle<Context>(context_->previous(), isolate_);
+ }
+ return;
+ }
+
+ // Get the debug info (create it if it does not exist).
+ if (!isolate->debug()->EnsureDebugInfo(shared_info, function_)) {
+ // Return if ensuring debug info failed.
+ return;
+ }
+
+ // Currently it takes too much time to find nested scopes due to script
+ // parsing. Sometimes we want to run the ScopeIterator as fast as possible
+ // (for example, while collecting async call stacks on every
+ // addEventListener call), even if we drop some nested scopes.
+ // Later we may optimize getting the nested scopes (cache the result?)
+ // and include nested scopes into the "fast" iteration case as well.
+ if (!ignore_nested_scopes) {
+ Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared_info);
+
+ // Find the break point where execution has stopped.
+ BreakLocationIterator break_location_iterator(debug_info,
+ ALL_BREAK_LOCATIONS);
+ // pc points to the instruction after the current one, possibly a break
+ // location as well. So the "- 1" to exclude it from the search.
+ break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
+
+ // Within the return sequence at the moment it is not possible to
+ // get a source position which is consistent with the current scope chain.
+ // Thus all nested with, catch and block contexts are skipped and we only
+ // provide the function scope.
+ ignore_nested_scopes = break_location_iterator.IsExit();
+ }
+
+ if (ignore_nested_scopes) {
+ if (scope_info->HasContext()) {
+ context_ = Handle<Context>(context_->declaration_context(), isolate_);
+ } else {
+ while (context_->closure() == *function_) {
+ context_ = Handle<Context>(context_->previous(), isolate_);
+ }
+ }
+ if (scope_info->scope_type() == FUNCTION_SCOPE ||
+ scope_info->scope_type() == ARROW_SCOPE) {
+ nested_scope_chain_.Add(scope_info);
+ }
+ } else {
+ // Reparse the code and analyze the scopes.
+ Handle<Script> script(Script::cast(shared_info->script()));
+ Scope* scope = NULL;
+
+ // Check whether we are in global, eval or function code.
+ Handle<ScopeInfo> scope_info(shared_info->scope_info());
+ if (scope_info->scope_type() != FUNCTION_SCOPE &&
+ scope_info->scope_type() != ARROW_SCOPE) {
+ // Global or eval code.
+ CompilationInfoWithZone info(script);
+ if (scope_info->scope_type() == GLOBAL_SCOPE) {
+ info.MarkAsGlobal();
+ } else {
+ DCHECK(scope_info->scope_type() == EVAL_SCOPE);
+ info.MarkAsEval();
+ info.SetContext(Handle<Context>(function_->context()));
+ }
+ if (Parser::Parse(&info) && Scope::Analyze(&info)) {
+ scope = info.function()->scope();
+ }
+ RetrieveScopeChain(scope, shared_info);
+ } else {
+ // Function code
+ CompilationInfoWithZone info(shared_info);
+ if (Parser::Parse(&info) && Scope::Analyze(&info)) {
+ scope = info.function()->scope();
+ }
+ RetrieveScopeChain(scope, shared_info);
+ }
+ }
+ }
+
+ ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
+ : isolate_(isolate),
+ frame_(NULL),
+ inlined_jsframe_index_(0),
+ function_(function),
+ context_(function->context()),
+ failed_(false) {
+ if (function->IsBuiltin()) {
+ context_ = Handle<Context>();
+ }
+ }
+
+ // More scopes?
+ bool Done() {
+ DCHECK(!failed_);
+ return context_.is_null();
+ }
+
+ bool Failed() { return failed_; }
+
+ // Move to the next scope.
+ void Next() {
+ DCHECK(!failed_);
+ ScopeType scope_type = Type();
+ if (scope_type == ScopeTypeGlobal) {
+ // The global scope is always the last in the chain.
+ DCHECK(context_->IsNativeContext());
+ context_ = Handle<Context>();
+ return;
+ }
+ if (nested_scope_chain_.is_empty()) {
+ context_ = Handle<Context>(context_->previous(), isolate_);
+ } else {
+ if (nested_scope_chain_.last()->HasContext()) {
+ DCHECK(context_->previous() != NULL);
+ context_ = Handle<Context>(context_->previous(), isolate_);
+ }
+ nested_scope_chain_.RemoveLast();
+ }
+ }
+
+ // Return the type of the current scope.
+ ScopeType Type() {
+ DCHECK(!failed_);
+ if (!nested_scope_chain_.is_empty()) {
+ Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
+ switch (scope_info->scope_type()) {
+ case FUNCTION_SCOPE:
+ case ARROW_SCOPE:
+ DCHECK(context_->IsFunctionContext() || !scope_info->HasContext());
+ return ScopeTypeLocal;
+ case MODULE_SCOPE:
+ DCHECK(context_->IsModuleContext());
+ return ScopeTypeModule;
+ case GLOBAL_SCOPE:
+ DCHECK(context_->IsNativeContext());
+ return ScopeTypeGlobal;
+ case WITH_SCOPE:
+ DCHECK(context_->IsWithContext());
+ return ScopeTypeWith;
+ case CATCH_SCOPE:
+ DCHECK(context_->IsCatchContext());
+ return ScopeTypeCatch;
+ case BLOCK_SCOPE:
+ DCHECK(!scope_info->HasContext() || context_->IsBlockContext());
+ return ScopeTypeBlock;
+ case EVAL_SCOPE:
+ UNREACHABLE();
+ }
+ }
+ if (context_->IsNativeContext()) {
+ DCHECK(context_->global_object()->IsGlobalObject());
+ return ScopeTypeGlobal;
+ }
+ if (context_->IsFunctionContext()) {
+ return ScopeTypeClosure;
+ }
+ if (context_->IsCatchContext()) {
+ return ScopeTypeCatch;
+ }
+ if (context_->IsBlockContext()) {
+ return ScopeTypeBlock;
+ }
+ if (context_->IsModuleContext()) {
+ return ScopeTypeModule;
+ }
+ DCHECK(context_->IsWithContext());
+ return ScopeTypeWith;
+ }
+
+ // Return the JavaScript object with the content of the current scope.
+ MaybeHandle<JSObject> ScopeObject() {
+ DCHECK(!failed_);
+ switch (Type()) {
+ case ScopeIterator::ScopeTypeGlobal:
+ return Handle<JSObject>(CurrentContext()->global_object());
+ case ScopeIterator::ScopeTypeLocal:
+ // Materialize the content of the local scope into a JSObject.
+ DCHECK(nested_scope_chain_.length() == 1);
+ return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
+ case ScopeIterator::ScopeTypeWith:
+ // Return the with object.
+ return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
+ case ScopeIterator::ScopeTypeCatch:
+ return MaterializeCatchScope(isolate_, CurrentContext());
+ case ScopeIterator::ScopeTypeClosure:
+ // Materialize the content of the closure scope into a JSObject.
+ return MaterializeClosure(isolate_, CurrentContext());
+ case ScopeIterator::ScopeTypeBlock:
+ return MaterializeBlockScope(isolate_, CurrentContext());
+ case ScopeIterator::ScopeTypeModule:
+ return MaterializeModuleScope(isolate_, CurrentContext());
+ }
+ UNREACHABLE();
+ return Handle<JSObject>();
+ }
+
+ bool SetVariableValue(Handle<String> variable_name,
+ Handle<Object> new_value) {
+ DCHECK(!failed_);
+ switch (Type()) {
+ case ScopeIterator::ScopeTypeGlobal:
+ break;
+ case ScopeIterator::ScopeTypeLocal:
+ return SetLocalVariableValue(isolate_, frame_, inlined_jsframe_index_,
+ variable_name, new_value);
+ case ScopeIterator::ScopeTypeWith:
+ break;
+ case ScopeIterator::ScopeTypeCatch:
+ return SetCatchVariableValue(isolate_, CurrentContext(), variable_name,
+ new_value);
+ case ScopeIterator::ScopeTypeClosure:
+ return SetClosureVariableValue(isolate_, CurrentContext(),
+ variable_name, new_value);
+ case ScopeIterator::ScopeTypeBlock:
+ // TODO(2399): should we implement it?
+ break;
+ case ScopeIterator::ScopeTypeModule:
+ // TODO(2399): should we implement it?
+ break;
+ }
+ return false;
+ }
+
+ Handle<ScopeInfo> CurrentScopeInfo() {
+ DCHECK(!failed_);
+ if (!nested_scope_chain_.is_empty()) {
+ return nested_scope_chain_.last();
+ } else if (context_->IsBlockContext()) {
+ return Handle<ScopeInfo>(ScopeInfo::cast(context_->extension()));
+ } else if (context_->IsFunctionContext()) {
+ return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
+ }
+ return Handle<ScopeInfo>::null();
+ }
+
+ // Return the context for this scope. For the local context there might not
+ // be an actual context.
+ Handle<Context> CurrentContext() {
+ DCHECK(!failed_);
+ if (Type() == ScopeTypeGlobal || nested_scope_chain_.is_empty()) {
+ return context_;
+ } else if (nested_scope_chain_.last()->HasContext()) {
+ return context_;
+ } else {
+ return Handle<Context>();
+ }
+ }
+
+#ifdef DEBUG
+ // Debug print of the content of the current scope.
+ void DebugPrint() {
+ OFStream os(stdout);
+ DCHECK(!failed_);
+ switch (Type()) {
+ case ScopeIterator::ScopeTypeGlobal:
+ os << "Global:\n";
+ CurrentContext()->Print(os);
+ break;
+
+ case ScopeIterator::ScopeTypeLocal: {
+ os << "Local:\n";
+ function_->shared()->scope_info()->Print();
+ if (!CurrentContext().is_null()) {
+ CurrentContext()->Print(os);
+ if (CurrentContext()->has_extension()) {
+ Handle<Object> extension(CurrentContext()->extension(), isolate_);
+ if (extension->IsJSContextExtensionObject()) {
+ extension->Print(os);
+ }
+ }
+ }
+ break;
+ }
+
+ case ScopeIterator::ScopeTypeWith:
+ os << "With:\n";
+ CurrentContext()->extension()->Print(os);
+ break;
+
+ case ScopeIterator::ScopeTypeCatch:
+ os << "Catch:\n";
+ CurrentContext()->extension()->Print(os);
+ CurrentContext()->get(Context::THROWN_OBJECT_INDEX)->Print(os);
+ break;
+
+ case ScopeIterator::ScopeTypeClosure:
+ os << "Closure:\n";
+ CurrentContext()->Print(os);
+ if (CurrentContext()->has_extension()) {
+ Handle<Object> extension(CurrentContext()->extension(), isolate_);
+ if (extension->IsJSContextExtensionObject()) {
+ extension->Print(os);
+ }
+ }
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ PrintF("\n");
+ }
+#endif
+
+ private:
+ Isolate* isolate_;
+ JavaScriptFrame* frame_;
+ int inlined_jsframe_index_;
+ Handle<JSFunction> function_;
+ Handle<Context> context_;
+ List<Handle<ScopeInfo> > nested_scope_chain_;
+ bool failed_;
+
+ void RetrieveScopeChain(Scope* scope,
+ Handle<SharedFunctionInfo> shared_info) {
+ if (scope != NULL) {
+ int source_position = shared_info->code()->SourcePosition(frame_->pc());
+ scope->GetNestedScopeChain(&nested_scope_chain_, source_position);
+ } else {
+ // A failed reparse indicates that the preparser has diverged from the
+ // parser or that the preparse data given to the initial parse has been
+ // faulty. We fail in debug mode but in release mode we only provide the
+ // information we get from the context chain but nothing about
+ // completely stack allocated scopes or stack allocated locals.
+ // Or it could be due to stack overflow.
+ DCHECK(isolate_->has_pending_exception());
+ failed_ = true;
+ }
+ }
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ScopeIterator);
+};
+
+
+RUNTIME_FUNCTION(Runtime_GetScopeCount) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator it(isolate, id);
+ JavaScriptFrame* frame = it.frame();
+
+ // Count the visible scopes.
+ int n = 0;
+ for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
+ n++;
+ }
+
+ return Smi::FromInt(n);
+}
+
+
+// Returns the list of step-in positions (text offset) in a function of the
+// stack frame in a range from the current debug break position to the end
+// of the corresponding statement.
+RUNTIME_FUNCTION(Runtime_GetStepInPositions) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator frame_it(isolate, id);
+ RUNTIME_ASSERT(!frame_it.done());
+
+ JavaScriptFrame* frame = frame_it.frame();
+
+ Handle<JSFunction> fun = Handle<JSFunction>(frame->function());
+ Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>(fun->shared());
+
+ if (!isolate->debug()->EnsureDebugInfo(shared, fun)) {
+ return isolate->heap()->undefined_value();
+ }
+
+ Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared);
+
+ int len = 0;
+ Handle<JSArray> array(isolate->factory()->NewJSArray(10));
+ // Find the break point where execution has stopped.
+ BreakLocationIterator break_location_iterator(debug_info,
+ ALL_BREAK_LOCATIONS);
+
+ break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
+ int current_statement_pos = break_location_iterator.statement_position();
+
+ while (!break_location_iterator.Done()) {
+ bool accept;
+ if (break_location_iterator.pc() > frame->pc()) {
+ accept = true;
+ } else {
+ StackFrame::Id break_frame_id = isolate->debug()->break_frame_id();
+ // The break point is near our pc. Could be a step-in possibility,
+ // that is currently taken by active debugger call.
+ if (break_frame_id == StackFrame::NO_ID) {
+ // We are not stepping.
+ accept = false;
+ } else {
+ JavaScriptFrameIterator additional_frame_it(isolate, break_frame_id);
+ // If our frame is a top frame and we are stepping, we can do step-in
+ // at this place.
+ accept = additional_frame_it.frame()->id() == id;
+ }
+ }
+ if (accept) {
+ if (break_location_iterator.IsStepInLocation(isolate)) {
+ Smi* position_value = Smi::FromInt(break_location_iterator.position());
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetElement(
+ array, len, Handle<Object>(position_value, isolate),
+ NONE, SLOPPY));
+ len++;
+ }
+ }
+ // Advance iterator.
+ break_location_iterator.Next();
+ if (current_statement_pos != break_location_iterator.statement_position()) {
+ break;
+ }
+ }
+ return *array;
+}
+
+
+static const int kScopeDetailsTypeIndex = 0;
+static const int kScopeDetailsObjectIndex = 1;
+static const int kScopeDetailsSize = 2;
+
+
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeScopeDetails(
+ Isolate* isolate, ScopeIterator* it) {
+ // Calculate the size of the result.
+ int details_size = kScopeDetailsSize;
+ Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);
+
+ // Fill in scope details.
+ details->set(kScopeDetailsTypeIndex, Smi::FromInt(it->Type()));
+ Handle<JSObject> scope_object;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, scope_object, it->ScopeObject(),
+ JSObject);
+ details->set(kScopeDetailsObjectIndex, *scope_object);
+
+ return isolate->factory()->NewJSArrayWithElements(details);
+}
+
+
+// Return an array with scope details
+// args[0]: number: break id
+// args[1]: number: frame index
+// args[2]: number: inlined frame index
+// args[3]: number: scope index
+//
+// The array returned contains the following information:
+// 0: Scope type
+// 1: Scope object
+RUNTIME_FUNCTION(Runtime_GetScopeDetails) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+ CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator frame_it(isolate, id);
+ JavaScriptFrame* frame = frame_it.frame();
+
+ // Find the requested scope.
+ int n = 0;
+ ScopeIterator it(isolate, frame, inlined_jsframe_index);
+ for (; !it.Done() && n < index; it.Next()) {
+ n++;
+ }
+ if (it.Done()) {
+ return isolate->heap()->undefined_value();
+ }
+ Handle<JSObject> details;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
+ MaterializeScopeDetails(isolate, &it));
+ return *details;
+}
+
+
+// Return an array of scope details
+// args[0]: number: break id
+// args[1]: number: frame index
+// args[2]: number: inlined frame index
+// args[3]: boolean: ignore nested scopes
+//
+// The array returned contains arrays with the following information:
+// 0: Scope type
+// 1: Scope object
+RUNTIME_FUNCTION(Runtime_GetAllScopesDetails) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3 || args.length() == 4);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+ CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
+
+ bool ignore_nested_scopes = false;
+ if (args.length() == 4) {
+ CONVERT_BOOLEAN_ARG_CHECKED(flag, 3);
+ ignore_nested_scopes = flag;
+ }
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator frame_it(isolate, id);
+ JavaScriptFrame* frame = frame_it.frame();
+
+ List<Handle<JSObject> > result(4);
+ ScopeIterator it(isolate, frame, inlined_jsframe_index, ignore_nested_scopes);
+ for (; !it.Done(); it.Next()) {
+ Handle<JSObject> details;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
+ MaterializeScopeDetails(isolate, &it));
+ result.Add(details);
+ }
+
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
+ for (int i = 0; i < result.length(); ++i) {
+ array->set(i, *result[i]);
+ }
+ return *isolate->factory()->NewJSArrayWithElements(array);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetFunctionScopeCount) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ // Check arguments.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+
+ // Count the visible scopes.
+ int n = 0;
+ for (ScopeIterator it(isolate, fun); !it.Done(); it.Next()) {
+ n++;
+ }
+
+ return Smi::FromInt(n);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetFunctionScopeDetails) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ // Check arguments.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
+
+ // Find the requested scope.
+ int n = 0;
+ ScopeIterator it(isolate, fun);
+ for (; !it.Done() && n < index; it.Next()) {
+ n++;
+ }
+ if (it.Done()) {
+ return isolate->heap()->undefined_value();
+ }
+
+ Handle<JSObject> details;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
+ MaterializeScopeDetails(isolate, &it));
+ return *details;
+}
+
+
+static bool SetScopeVariableValue(ScopeIterator* it, int index,
+ Handle<String> variable_name,
+ Handle<Object> new_value) {
+ for (int n = 0; !it->Done() && n < index; it->Next()) {
+ n++;
+ }
+ if (it->Done()) {
+ return false;
+ }
+ return it->SetVariableValue(variable_name, new_value);
+}
+
+
+// Change variable value in closure or local scope
+// args[0]: number or JsFunction: break id or function
+// args[1]: number: frame index (when arg[0] is break id)
+// args[2]: number: inlined frame index (when arg[0] is break id)
+// args[3]: number: scope index
+// args[4]: string: variable name
+// args[5]: object: new value
+//
+// Return true if success and false otherwise
+RUNTIME_FUNCTION(Runtime_SetScopeVariableValue) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 6);
+
+ // Check arguments.
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);
+ CONVERT_ARG_HANDLE_CHECKED(String, variable_name, 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, new_value, 5);
+
+ bool res;
+ if (args[0]->IsNumber()) {
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+ CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator frame_it(isolate, id);
+ JavaScriptFrame* frame = frame_it.frame();
+
+ ScopeIterator it(isolate, frame, inlined_jsframe_index);
+ res = SetScopeVariableValue(&it, index, variable_name, new_value);
+ } else {
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+ ScopeIterator it(isolate, fun);
+ res = SetScopeVariableValue(&it, index, variable_name, new_value);
+ }
+
+ return isolate->heap()->ToBoolean(res);
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugPrintScopes) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+
+#ifdef DEBUG
+ // Print the scopes for the top frame.
+ StackFrameLocator locator(isolate);
+ JavaScriptFrame* frame = locator.FindJavaScriptFrame(0);
+ for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
+ it.DebugPrint();
+ }
+#endif
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetThreadCount) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ // Count all archived V8 threads.
+ int n = 0;
+ for (ThreadState* thread = isolate->thread_manager()->FirstThreadStateInUse();
+ thread != NULL; thread = thread->Next()) {
+ n++;
+ }
+
+ // Total number of threads is current thread and archived threads.
+ return Smi::FromInt(n + 1);
+}
+
+
+static const int kThreadDetailsCurrentThreadIndex = 0;
+static const int kThreadDetailsThreadIdIndex = 1;
+static const int kThreadDetailsSize = 2;
+
+// Return an array with thread details
+// args[0]: number: break id
+// args[1]: number: thread index
+//
+// The array returned contains the following information:
+// 0: Is current thread?
+// 1: Thread id
+RUNTIME_FUNCTION(Runtime_GetThreadDetails) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
+
+ // Allocate array for result.
+ Handle<FixedArray> details =
+ isolate->factory()->NewFixedArray(kThreadDetailsSize);
+
+ // Thread index 0 is current thread.
+ if (index == 0) {
+ // Fill the details.
+ details->set(kThreadDetailsCurrentThreadIndex,
+ isolate->heap()->true_value());
+ details->set(kThreadDetailsThreadIdIndex,
+ Smi::FromInt(ThreadId::Current().ToInteger()));
+ } else {
+ // Find the thread with the requested index.
+ int n = 1;
+ ThreadState* thread = isolate->thread_manager()->FirstThreadStateInUse();
+ while (index != n && thread != NULL) {
+ thread = thread->Next();
+ n++;
+ }
+ if (thread == NULL) {
+ return isolate->heap()->undefined_value();
+ }
+
+ // Fill the details.
+ details->set(kThreadDetailsCurrentThreadIndex,
+ isolate->heap()->false_value());
+ details->set(kThreadDetailsThreadIdIndex,
+ Smi::FromInt(thread->id().ToInteger()));
+ }
+
+ // Convert to JS array and return.
+ return *isolate->factory()->NewJSArrayWithElements(details);
+}
+
+
+// Sets the disable break state
+// args[0]: disable break state
+RUNTIME_FUNCTION(Runtime_SetDisableBreak) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 0);
+ isolate->debug()->set_disable_break(disable_break);
+ return isolate->heap()->undefined_value();
+}
+
+
+static bool IsPositionAlignmentCodeCorrect(int alignment) {
+ return alignment == STATEMENT_ALIGNED || alignment == BREAK_POSITION_ALIGNED;
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetBreakLocations) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+ CONVERT_NUMBER_CHECKED(int32_t, statement_aligned_code, Int32, args[1]);
+
+ if (!IsPositionAlignmentCodeCorrect(statement_aligned_code)) {
+ return isolate->ThrowIllegalOperation();
+ }
+ BreakPositionAlignment alignment =
+ static_cast<BreakPositionAlignment>(statement_aligned_code);
+
+ Handle<SharedFunctionInfo> shared(fun->shared());
+ // Find the number of break points
+ Handle<Object> break_locations =
+ Debug::GetSourceBreakLocations(shared, alignment);
+ if (break_locations->IsUndefined()) return isolate->heap()->undefined_value();
+ // Return array as JS array
+ return *isolate->factory()->NewJSArrayWithElements(
+ Handle<FixedArray>::cast(break_locations));
+}
+
+
+// Set a break point in a function.
+// args[0]: function
+// args[1]: number: break source position (within the function source)
+// args[2]: number: break point object
+RUNTIME_FUNCTION(Runtime_SetFunctionBreakPoint) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
+ RUNTIME_ASSERT(source_position >= function->shared()->start_position() &&
+ source_position <= function->shared()->end_position());
+ CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 2);
+
+ // Set break point.
+ RUNTIME_ASSERT(isolate->debug()->SetBreakPoint(
+ function, break_point_object_arg, &source_position));
+
+ return Smi::FromInt(source_position);
+}
+
+
+// Changes the state of a break point in a script and returns source position
+// where break point was set. NOTE: Regarding performance see the NOTE for
+// GetScriptFromScriptData.
+// args[0]: script to set break point in
+// args[1]: number: break source position (within the script source)
+// args[2]: number, breakpoint position alignment
+// args[3]: number: break point object
+RUNTIME_FUNCTION(Runtime_SetScriptBreakPoint) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(JSValue, wrapper, 0);
+ CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
+ RUNTIME_ASSERT(source_position >= 0);
+ CONVERT_NUMBER_CHECKED(int32_t, statement_aligned_code, Int32, args[2]);
+ CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 3);
+
+ if (!IsPositionAlignmentCodeCorrect(statement_aligned_code)) {
+ return isolate->ThrowIllegalOperation();
+ }
+ BreakPositionAlignment alignment =
+ static_cast<BreakPositionAlignment>(statement_aligned_code);
+
+ // Get the script from the script wrapper.
+ RUNTIME_ASSERT(wrapper->value()->IsScript());
+ Handle<Script> script(Script::cast(wrapper->value()));
+
+ // Set break point.
+ if (!isolate->debug()->SetBreakPointForScript(script, break_point_object_arg,
+ &source_position, alignment)) {
+ return isolate->heap()->undefined_value();
+ }
+
+ return Smi::FromInt(source_position);
+}
+
+
+// Clear a break point
+// args[0]: number: break point object
+RUNTIME_FUNCTION(Runtime_ClearBreakPoint) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 0);
+
+ // Clear break point.
+ isolate->debug()->ClearBreakPoint(break_point_object_arg);
+
+ return isolate->heap()->undefined_value();
+}
+
+
+// Change the state of break on exceptions.
+// args[0]: Enum value indicating whether to affect caught/uncaught exceptions.
+// args[1]: Boolean indicating on/off.
+RUNTIME_FUNCTION(Runtime_ChangeBreakOnException) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(uint32_t, type_arg, Uint32, args[0]);
+ CONVERT_BOOLEAN_ARG_CHECKED(enable, 1);
+
+ // If the number doesn't match an enum value, the ChangeBreakOnException
+ // function will default to affecting caught exceptions.
+ ExceptionBreakType type = static_cast<ExceptionBreakType>(type_arg);
+ // Update break point state.
+ isolate->debug()->ChangeBreakOnException(type, enable);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Returns the state of break on exceptions
+// args[0]: boolean indicating uncaught exceptions
+RUNTIME_FUNCTION(Runtime_IsBreakOnException) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_NUMBER_CHECKED(uint32_t, type_arg, Uint32, args[0]);
+
+ ExceptionBreakType type = static_cast<ExceptionBreakType>(type_arg);
+ bool result = isolate->debug()->IsBreakOnException(type);
+ return Smi::FromInt(result);
+}
+
+
+// Prepare for stepping
+// args[0]: break id for checking execution state
+// args[1]: step action from the enumeration StepAction
+// args[2]: number of times to perform the step, for step out it is the number
+// of frames to step down.
+RUNTIME_FUNCTION(Runtime_PrepareStep) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ if (!args[1]->IsNumber() || !args[2]->IsNumber()) {
+ return isolate->Throw(isolate->heap()->illegal_argument_string());
+ }
+
+ CONVERT_NUMBER_CHECKED(int, wrapped_frame_id, Int32, args[3]);
+
+ StackFrame::Id frame_id;
+ if (wrapped_frame_id == 0) {
+ frame_id = StackFrame::NO_ID;
+ } else {
+ frame_id = UnwrapFrameId(wrapped_frame_id);
+ }
+
+ // Get the step action and check validity.
+ StepAction step_action = static_cast<StepAction>(NumberToInt32(args[1]));
+ if (step_action != StepIn && step_action != StepNext &&
+ step_action != StepOut && step_action != StepInMin &&
+ step_action != StepMin && step_action != StepFrame) {
+ return isolate->Throw(isolate->heap()->illegal_argument_string());
+ }
+
+ if (frame_id != StackFrame::NO_ID && step_action != StepNext &&
+ step_action != StepMin && step_action != StepOut) {
+ return isolate->ThrowIllegalOperation();
+ }
+
+ // Get the number of steps.
+ int step_count = NumberToInt32(args[2]);
+ if (step_count < 1) {
+ return isolate->Throw(isolate->heap()->illegal_argument_string());
+ }
+
+ // Clear all current stepping setup.
+ isolate->debug()->ClearStepping();
+
+ // Prepare step.
+ isolate->debug()->PrepareStep(static_cast<StepAction>(step_action),
+ step_count, frame_id);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Clear all stepping set by PrepareStep.
+RUNTIME_FUNCTION(Runtime_ClearStepping) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ isolate->debug()->ClearStepping();
+ return isolate->heap()->undefined_value();
+}
+
+
+// Helper function to find or create the arguments object for
+// Runtime_DebugEvaluate.
+MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeArgumentsObject(
+ Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function) {
+ // Do not materialize the arguments object for eval or top-level code.
+ // Skip if "arguments" is already taken.
+ if (!function->shared()->is_function()) return target;
+ Maybe<bool> maybe = JSReceiver::HasOwnProperty(
+ target, isolate->factory()->arguments_string());
+ if (!maybe.has_value) return MaybeHandle<JSObject>();
+ if (maybe.value) return target;
+
+ // FunctionGetArguments can't throw an exception.
+ Handle<JSObject> arguments =
+ Handle<JSObject>::cast(Accessors::FunctionGetArguments(function));
+ Handle<String> arguments_str = isolate->factory()->arguments_string();
+ RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
+ target, arguments_str, arguments, NONE),
+ JSObject);
+ return target;
+}
+
+
+// Compile and evaluate source for the given context.
+static MaybeHandle<Object> DebugEvaluate(Isolate* isolate,
+ Handle<SharedFunctionInfo> outer_info,
+ Handle<Context> context,
+ Handle<Object> context_extension,
+ Handle<Object> receiver,
+ Handle<String> source) {
+ if (context_extension->IsJSObject()) {
+ Handle<JSObject> extension = Handle<JSObject>::cast(context_extension);
+ Handle<JSFunction> closure(context->closure(), isolate);
+ context = isolate->factory()->NewWithContext(closure, context, extension);
+ }
+
+ Handle<JSFunction> eval_fun;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, eval_fun,
+ Compiler::GetFunctionFromEval(
+ source, outer_info, context, SLOPPY,
+ NO_PARSE_RESTRICTION, RelocInfo::kNoPosition),
+ Object);
+
+ Handle<Object> result;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, result, Execution::Call(isolate, eval_fun, receiver, 0, NULL),
+ Object);
+
+ // Skip the global proxy as it has no properties and always delegates to the
+ // real global object.
+ if (result->IsJSGlobalProxy()) {
+ PrototypeIterator iter(isolate, result);
+ // TODO(verwaest): This will crash when the global proxy is detached.
+ result = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ }
+
+ // Clear the oneshot breakpoints so that the debugger does not step further.
+ isolate->debug()->ClearStepping();
+ return result;
+}
+
+
+static Handle<JSObject> NewJSObjectWithNullProto(Isolate* isolate) {
+ Handle<JSObject> result =
+ isolate->factory()->NewJSObject(isolate->object_function());
+ Handle<Map> new_map = Map::Copy(Handle<Map>(result->map()));
+ new_map->set_prototype(*isolate->factory()->null_value());
+ JSObject::MigrateToMap(result, new_map);
+ return result;
+}
+
+
+// Evaluate a piece of JavaScript in the context of a stack frame for
+// debugging. Things that need special attention are:
+// - Parameters and stack-allocated locals need to be materialized. Altered
+// values need to be written back to the stack afterwards.
+// - The arguments object needs to materialized.
+RUNTIME_FUNCTION(Runtime_DebugEvaluate) {
+ HandleScope scope(isolate);
+
+ // Check the execution state and decode arguments frame and source to be
+ // evaluated.
+ DCHECK(args.length() == 6);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
+ CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
+ CONVERT_ARG_HANDLE_CHECKED(String, source, 3);
+ CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 4);
+ CONVERT_ARG_HANDLE_CHECKED(Object, context_extension, 5);
+
+ // Handle the processing of break.
+ DisableBreak disable_break_scope(isolate->debug(), disable_break);
+
+ // Get the frame where the debugging is performed.
+ StackFrame::Id id = UnwrapFrameId(wrapped_id);
+ JavaScriptFrameIterator it(isolate, id);
+ JavaScriptFrame* frame = it.frame();
+ FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
+ Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
+ Handle<SharedFunctionInfo> outer_info(function->shared());
+
+ // Traverse the saved contexts chain to find the active context for the
+ // selected frame.
+ SaveContext* save = FindSavedContextForFrame(isolate, frame);
+
+ SaveContext savex(isolate);
+ isolate->set_context(*(save->context()));
+
+ // Materialize stack locals and the arguments object.
+ Handle<JSObject> materialized = NewJSObjectWithNullProto(isolate);
+
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, materialized,
+ MaterializeStackLocalsWithFrameInspector(isolate, materialized, function,
+ &frame_inspector));
+
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, materialized,
+ MaterializeArgumentsObject(isolate, materialized, function));
+
+ // At this point, the lookup chain may look like this:
+ // [inner context] -> [function stack]+[function context] -> [outer context]
+ // The function stack is not an actual context, it complements the function
+ // context. In order to have the same lookup chain when debug-evaluating,
+ // we materialize the stack and insert it into the context chain as a
+ // with-context before the function context.
+ // [inner context] -> [with context] -> [function context] -> [outer context]
+ // Ordering the with-context before the function context forces a dynamic
+ // lookup instead of a static lookup that could fail as the scope info is
+ // outdated and may expect variables to still be stack-allocated.
+ // Afterwards, we write changes to the with-context back to the stack
+ // and remove it from the context chain.
+ // This could cause lookup failures if debug-evaluate creates a closure that
+ // uses this temporary context chain.
+
+ Handle<Context> eval_context(Context::cast(frame_inspector.GetContext()));
+ DCHECK(!eval_context.is_null());
+ Handle<Context> function_context = eval_context;
+ Handle<Context> outer_context(function->context(), isolate);
+ Handle<Context> inner_context;
+ // We iterate to find the function's context. If the function has no
+ // context-allocated variables, we iterate until we hit the outer context.
+ while (!function_context->IsFunctionContext() &&
+ !function_context.is_identical_to(outer_context)) {
+ inner_context = function_context;
+ function_context = Handle<Context>(function_context->previous(), isolate);
+ }
+
+ Handle<Context> materialized_context = isolate->factory()->NewWithContext(
+ function, function_context, materialized);
+
+ if (inner_context.is_null()) {
+ // No inner context. The with-context is now inner-most.
+ eval_context = materialized_context;
+ } else {
+ inner_context->set_previous(*materialized_context);
+ }
+
+ Handle<Object> receiver(frame->receiver(), isolate);
+ MaybeHandle<Object> maybe_result = DebugEvaluate(
+ isolate, outer_info, eval_context, context_extension, receiver, source);
+
+ // Remove with-context if it was inserted in between.
+ if (!inner_context.is_null()) inner_context->set_previous(*function_context);
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, maybe_result);
+
+ // Write back potential changes to materialized stack locals to the stack.
+ UpdateStackLocalsFromMaterializedObject(isolate, materialized, function,
+ frame, inlined_jsframe_index);
+
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugEvaluateGlobal) {
+ HandleScope scope(isolate);
+
+ // Check the execution state and decode arguments frame and source to be
+ // evaluated.
+ DCHECK(args.length() == 4);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
+ CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, context_extension, 3);
+
+ // Handle the processing of break.
+ DisableBreak disable_break_scope(isolate->debug(), disable_break);
+
+ // Enter the top context from before the debugger was invoked.
+ SaveContext save(isolate);
+ SaveContext* top = &save;
+ while (top != NULL && *top->context() == *isolate->debug()->debug_context()) {
+ top = top->prev();
+ }
+ if (top != NULL) {
+ isolate->set_context(*top->context());
+ }
+
+ // Get the native context now set to the top context from before the
+ // debugger was invoked.
+ Handle<Context> context = isolate->native_context();
+ Handle<JSObject> receiver(context->global_proxy());
+ Handle<SharedFunctionInfo> outer_info(context->closure()->shared(), isolate);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, DebugEvaluate(isolate, outer_info, context,
+ context_extension, receiver, source));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugGetLoadedScripts) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+
+ // Fill the script objects.
+ Handle<FixedArray> instances = isolate->debug()->GetLoadedScripts();
+
+ // Convert the script objects to proper JS objects.
+ for (int i = 0; i < instances->length(); i++) {
+ Handle<Script> script = Handle<Script>(Script::cast(instances->get(i)));
+ // Get the script wrapper in a local handle before calling GetScriptWrapper,
+ // because using
+ // instances->set(i, *GetScriptWrapper(script))
+ // is unsafe as GetScriptWrapper might call GC and the C++ compiler might
+ // already have dereferenced the instances handle.
+ Handle<JSObject> wrapper = Script::GetWrapper(script);
+ instances->set(i, *wrapper);
+ }
+
+ // Return result as a JS array.
+ Handle<JSObject> result =
+ isolate->factory()->NewJSObject(isolate->array_function());
+ JSArray::SetContent(Handle<JSArray>::cast(result), instances);
+ return *result;
+}
+
+
+// Helper function used by Runtime_DebugReferencedBy below.
+static int DebugReferencedBy(HeapIterator* iterator, JSObject* target,
+ Object* instance_filter, int max_references,
+ FixedArray* instances, int instances_size,
+ JSFunction* arguments_function) {
+ Isolate* isolate = target->GetIsolate();
+ SealHandleScope shs(isolate);
+ DisallowHeapAllocation no_allocation;
+
+ // Iterate the heap.
+ int count = 0;
+ JSObject* last = NULL;
+ HeapObject* heap_obj = NULL;
+ while (((heap_obj = iterator->next()) != NULL) &&
+ (max_references == 0 || count < max_references)) {
+ // Only look at all JSObjects.
+ if (heap_obj->IsJSObject()) {
+ // Skip context extension objects and argument arrays as these are
+ // checked in the context of functions using them.
+ JSObject* obj = JSObject::cast(heap_obj);
+ if (obj->IsJSContextExtensionObject() ||
+ obj->map()->constructor() == arguments_function) {
+ continue;
+ }
+
+ // Check if the JS object has a reference to the object looked for.
+ if (obj->ReferencesObject(target)) {
+ // Check instance filter if supplied. This is normally used to avoid
+ // references from mirror objects (see Runtime_IsInPrototypeChain).
+ if (!instance_filter->IsUndefined()) {
+ for (PrototypeIterator iter(isolate, obj); !iter.IsAtEnd();
+ iter.Advance()) {
+ if (iter.GetCurrent() == instance_filter) {
+ obj = NULL; // Don't add this object.
+ break;
+ }
+ }
+ }
+
+ if (obj != NULL) {
+ // Valid reference found add to instance array if supplied an update
+ // count.
+ if (instances != NULL && count < instances_size) {
+ instances->set(count, obj);
+ }
+ last = obj;
+ count++;
+ }
+ }
+ }
+ }
+
+ // Check for circular reference only. This can happen when the object is only
+ // referenced from mirrors and has a circular reference in which case the
+ // object is not really alive and would have been garbage collected if not
+ // referenced from the mirror.
+ if (count == 1 && last == target) {
+ count = 0;
+ }
+
+ // Return the number of referencing objects found.
+ return count;
+}
+
+
+// Scan the heap for objects with direct references to an object
+// args[0]: the object to find references to
+// args[1]: constructor function for instances to exclude (Mirror)
+// args[2]: the the maximum number of objects to return
+RUNTIME_FUNCTION(Runtime_DebugReferencedBy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+
+ // Check parameters.
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, target, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, instance_filter, 1);
+ RUNTIME_ASSERT(instance_filter->IsUndefined() ||
+ instance_filter->IsJSObject());
+ CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[2]);
+ RUNTIME_ASSERT(max_references >= 0);
+
+
+ // Get the constructor function for context extension and arguments array.
+ Handle<JSFunction> arguments_function(
+ JSFunction::cast(isolate->sloppy_arguments_map()->constructor()));
+
+ // Get the number of referencing objects.
+ int count;
+ // First perform a full GC in order to avoid dead objects and to make the heap
+ // iterable.
+ Heap* heap = isolate->heap();
+ heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "%DebugConstructedBy");
+ {
+ HeapIterator heap_iterator(heap);
+ count = DebugReferencedBy(&heap_iterator, *target, *instance_filter,
+ max_references, NULL, 0, *arguments_function);
+ }
+
+ // Allocate an array to hold the result.
+ Handle<FixedArray> instances = isolate->factory()->NewFixedArray(count);
+
+ // Fill the referencing objects.
+ {
+ HeapIterator heap_iterator(heap);
+ count = DebugReferencedBy(&heap_iterator, *target, *instance_filter,
+ max_references, *instances, count,
+ *arguments_function);
+ }
+
+ // Return result as JS array.
+ Handle<JSFunction> constructor = isolate->array_function();
+
+ Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
+ JSArray::SetContent(Handle<JSArray>::cast(result), instances);
+ return *result;
+}
+
+
+// Helper function used by Runtime_DebugConstructedBy below.
+static int DebugConstructedBy(HeapIterator* iterator, JSFunction* constructor,
+ int max_references, FixedArray* instances,
+ int instances_size) {
+ DisallowHeapAllocation no_allocation;
+
+ // Iterate the heap.
+ int count = 0;
+ HeapObject* heap_obj = NULL;
+ while (((heap_obj = iterator->next()) != NULL) &&
+ (max_references == 0 || count < max_references)) {
+ // Only look at all JSObjects.
+ if (heap_obj->IsJSObject()) {
+ JSObject* obj = JSObject::cast(heap_obj);
+ if (obj->map()->constructor() == constructor) {
+ // Valid reference found add to instance array if supplied an update
+ // count.
+ if (instances != NULL && count < instances_size) {
+ instances->set(count, obj);
+ }
+ count++;
+ }
+ }
+ }
+
+ // Return the number of referencing objects found.
+ return count;
+}
+
+
+// Scan the heap for objects constructed by a specific function.
+// args[0]: the constructor to find instances of
+// args[1]: the the maximum number of objects to return
+RUNTIME_FUNCTION(Runtime_DebugConstructedBy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+
+ // Check parameters.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 0);
+ CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[1]);
+ RUNTIME_ASSERT(max_references >= 0);
+
+ // Get the number of referencing objects.
+ int count;
+ // First perform a full GC in order to avoid dead objects and to make the heap
+ // iterable.
+ Heap* heap = isolate->heap();
+ heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "%DebugConstructedBy");
+ {
+ HeapIterator heap_iterator(heap);
+ count = DebugConstructedBy(&heap_iterator, *constructor, max_references,
+ NULL, 0);
+ }
+
+ // Allocate an array to hold the result.
+ Handle<FixedArray> instances = isolate->factory()->NewFixedArray(count);
+
+ // Fill the referencing objects.
+ {
+ HeapIterator heap_iterator2(heap);
+ count = DebugConstructedBy(&heap_iterator2, *constructor, max_references,
+ *instances, count);
+ }
+
+ // Return result as JS array.
+ Handle<JSFunction> array_function = isolate->array_function();
+ Handle<JSObject> result = isolate->factory()->NewJSObject(array_function);
+ JSArray::SetContent(Handle<JSArray>::cast(result), instances);
+ return *result;
+}
+
+
+// Find the effective prototype object as returned by __proto__.
+// args[0]: the object to find the prototype for.
+RUNTIME_FUNCTION(Runtime_DebugGetPrototype) {
+ HandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ return *Object::GetPrototypeSkipHiddenPrototypes(isolate, obj);
+}
+
+
+// Patches script source (should be called upon BeforeCompile event).
+RUNTIME_FUNCTION(Runtime_DebugSetScriptSource) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSValue, script_wrapper, 0);
+ CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
+
+ RUNTIME_ASSERT(script_wrapper->value()->IsScript());
+ Handle<Script> script(Script::cast(script_wrapper->value()));
+
+ int compilation_state = script->compilation_state();
+ RUNTIME_ASSERT(compilation_state == Script::COMPILATION_STATE_INITIAL);
+ script->set_source(*source);
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugDisassembleFunction) {
+ HandleScope scope(isolate);
+#ifdef DEBUG
+ DCHECK(args.length() == 1);
+ // Get the function and make sure it is compiled.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, func, 0);
+ if (!Compiler::EnsureCompiled(func, KEEP_EXCEPTION)) {
+ return isolate->heap()->exception();
+ }
+ OFStream os(stdout);
+ func->code()->Print(os);
+ os << std::endl;
+#endif // DEBUG
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugDisassembleConstructor) {
+ HandleScope scope(isolate);
+#ifdef DEBUG
+ DCHECK(args.length() == 1);
+ // Get the function and make sure it is compiled.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, func, 0);
+ if (!Compiler::EnsureCompiled(func, KEEP_EXCEPTION)) {
+ return isolate->heap()->exception();
+ }
+ OFStream os(stdout);
+ func->shared()->construct_stub()->Print(os);
+ os << std::endl;
+#endif // DEBUG
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetInferredName) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return f->shared()->inferred_name();
+}
+
+
+// A testing entry. Returns statement position which is the closest to
+// source_position.
+RUNTIME_FUNCTION(Runtime_GetFunctionCodePositionFromSource) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
+
+ Handle<Code> code(function->code(), isolate);
+
+ if (code->kind() != Code::FUNCTION &&
+ code->kind() != Code::OPTIMIZED_FUNCTION) {
+ return isolate->heap()->undefined_value();
+ }
+
+ RelocIterator it(*code, RelocInfo::ModeMask(RelocInfo::STATEMENT_POSITION));
+ int closest_pc = 0;
+ int distance = kMaxInt;
+ while (!it.done()) {
+ int statement_position = static_cast<int>(it.rinfo()->data());
+ // Check if this break point is closer that what was previously found.
+ if (source_position <= statement_position &&
+ statement_position - source_position < distance) {
+ closest_pc =
+ static_cast<int>(it.rinfo()->pc() - code->instruction_start());
+ distance = statement_position - source_position;
+ // Check whether we can't get any closer.
+ if (distance == 0) break;
+ }
+ it.next();
+ }
+
+ return Smi::FromInt(closest_pc);
+}
+
+
+// Calls specified function with or without entering the debugger.
+// This is used in unit tests to run code as if debugger is entered or simply
+// to have a stack with C++ frame in the middle.
+RUNTIME_FUNCTION(Runtime_ExecuteInDebugContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ CONVERT_BOOLEAN_ARG_CHECKED(without_debugger, 1);
+
+ MaybeHandle<Object> maybe_result;
+ if (without_debugger) {
+ maybe_result = Execution::Call(isolate, function,
+ handle(function->global_proxy()), 0, NULL);
+ } else {
+ DebugScope debug_scope(isolate->debug());
+ maybe_result = Execution::Call(isolate, function,
+ handle(function->global_proxy()), 0, NULL);
+ }
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, maybe_result);
+ return *result;
+}
+
+
+// Performs a GC.
+// Presently, it only does a full GC.
+RUNTIME_FUNCTION(Runtime_CollectGarbage) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags, "%CollectGarbage");
+ return isolate->heap()->undefined_value();
+}
+
+
+// Gets the current heap usage.
+RUNTIME_FUNCTION(Runtime_GetHeapUsage) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ int usage = static_cast<int>(isolate->heap()->SizeOfObjects());
+ if (!Smi::IsValid(usage)) {
+ return *isolate->factory()->NewNumberFromInt(usage);
+ }
+ return Smi::FromInt(usage);
+}
+
+
+// Finds the script object from the script data. NOTE: This operation uses
+// heap traversal to find the function generated for the source position
+// for the requested break point. For lazily compiled functions several heap
+// traversals might be required rendering this operation as a rather slow
+// operation. However for setting break points which is normally done through
+// some kind of user interaction the performance is not crucial.
+RUNTIME_FUNCTION(Runtime_GetScript) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(String, script_name, 0);
+
+ Handle<Script> found;
+ Heap* heap = isolate->heap();
+ {
+ HeapIterator iterator(heap);
+ HeapObject* obj = NULL;
+ while ((obj = iterator.next()) != NULL) {
+ if (!obj->IsScript()) continue;
+ Script* script = Script::cast(obj);
+ if (!script->name()->IsString()) continue;
+ String* name = String::cast(script->name());
+ if (name->Equals(*script_name)) {
+ found = Handle<Script>(script, isolate);
+ break;
+ }
+ }
+ }
+
+ if (found.is_null()) return heap->undefined_value();
+ return *Script::GetWrapper(found);
+}
+
+
+// Check whether debugger and is about to step into the callback that is passed
+// to a built-in function such as Array.forEach.
+RUNTIME_FUNCTION(Runtime_DebugCallbackSupportsStepping) {
+ DCHECK(args.length() == 1);
+ if (!isolate->debug()->is_active() || !isolate->debug()->StepInActive()) {
+ return isolate->heap()->false_value();
+ }
+ CONVERT_ARG_CHECKED(Object, callback, 0);
+ // We do not step into the callback if it's a builtin or not even a function.
+ return isolate->heap()->ToBoolean(callback->IsJSFunction() &&
+ !JSFunction::cast(callback)->IsBuiltin());
+}
+
+
+// Set one shot breakpoints for the callback function that is passed to a
+// built-in function such as Array.forEach to enable stepping into the callback.
+RUNTIME_FUNCTION(Runtime_DebugPrepareStepInIfStepping) {
+ DCHECK(args.length() == 1);
+ Debug* debug = isolate->debug();
+ if (!debug->IsStepping()) return isolate->heap()->undefined_value();
+
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ RUNTIME_ASSERT(object->IsJSFunction() || object->IsJSGeneratorObject());
+ Handle<JSFunction> fun;
+ if (object->IsJSFunction()) {
+ fun = Handle<JSFunction>::cast(object);
+ } else {
+ fun = Handle<JSFunction>(
+ Handle<JSGeneratorObject>::cast(object)->function(), isolate);
+ }
+ // When leaving the function, step out has been activated, but not performed
+ // if we do not leave the builtin. To be able to step into the function
+ // again, we need to clear the step out at this point.
+ debug->ClearStepOut();
+ debug->FloodWithOneShot(fun);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugPushPromise) {
+ DCHECK(args.length() == 1);
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
+ isolate->PushPromise(promise);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugPopPromise) {
+ DCHECK(args.length() == 0);
+ SealHandleScope shs(isolate);
+ isolate->PopPromise();
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugPromiseEvent) {
+ DCHECK(args.length() == 1);
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, data, 0);
+ isolate->debug()->OnPromiseEvent(data);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DebugAsyncTaskEvent) {
+ DCHECK(args.length() == 1);
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, data, 0);
+ isolate->debug()->OnAsyncTaskEvent(data);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_DebugIsActive) {
+ SealHandleScope shs(isolate);
+ return Smi::FromInt(isolate->debug()->is_active());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_DebugBreakInOptimizedCode) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/accessors.h"
+#include "src/arguments.h"
+#include "src/compiler.h"
+#include "src/deoptimizer.h"
+#include "src/frames.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_IsSloppyModeFunction) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSReceiver, callable, 0);
+ if (!callable->IsJSFunction()) {
+ HandleScope scope(isolate);
+ Handle<Object> delegate;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, delegate, Execution::TryGetFunctionDelegate(
+ isolate, Handle<JSReceiver>(callable)));
+ callable = JSFunction::cast(*delegate);
+ }
+ JSFunction* function = JSFunction::cast(callable);
+ SharedFunctionInfo* shared = function->shared();
+ return isolate->heap()->ToBoolean(shared->strict_mode() == SLOPPY);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetDefaultReceiver) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSReceiver, callable, 0);
+
+ if (!callable->IsJSFunction()) {
+ HandleScope scope(isolate);
+ Handle<Object> delegate;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, delegate, Execution::TryGetFunctionDelegate(
+ isolate, Handle<JSReceiver>(callable)));
+ callable = JSFunction::cast(*delegate);
+ }
+ JSFunction* function = JSFunction::cast(callable);
+
+ SharedFunctionInfo* shared = function->shared();
+ if (shared->native() || shared->strict_mode() == STRICT) {
+ return isolate->heap()->undefined_value();
+ }
+ // Returns undefined for strict or native functions, or
+ // the associated global receiver for "normal" functions.
+
+ return function->global_proxy();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetName) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return f->shared()->name();
+}
+
+
+static Handle<String> NameToFunctionName(Handle<Name> name) {
+ Handle<String> stringName(name->GetHeap()->empty_string());
+
+ // TODO(caitp): Follow proper rules in section 9.2.11 (SetFunctionName)
+ if (name->IsSymbol()) {
+ Handle<Object> description(Handle<Symbol>::cast(name)->name(),
+ name->GetIsolate());
+ if (description->IsString()) {
+ stringName = Handle<String>::cast(description);
+ }
+ } else {
+ stringName = Handle<String>::cast(name);
+ }
+
+ return stringName;
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionSetName) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, f, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+
+ f->shared()->set_name(*NameToFunctionName(name));
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionNameShouldPrintAsAnonymous) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(
+ f->shared()->name_should_print_as_anonymous());
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionMarkNameShouldPrintAsAnonymous) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ f->shared()->set_name_should_print_as_anonymous(true);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionIsArrow) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(f->shared()->is_arrow());
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionIsConciseMethod) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(f->shared()->is_concise_method());
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionRemovePrototype) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ RUNTIME_ASSERT(f->RemovePrototype());
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetScript) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, fun, 0);
+ Handle<Object> script = Handle<Object>(fun->shared()->script(), isolate);
+ if (!script->IsScript()) return isolate->heap()->undefined_value();
+
+ return *Script::GetWrapper(Handle<Script>::cast(script));
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetSourceCode) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, f, 0);
+ Handle<SharedFunctionInfo> shared(f->shared());
+ return *shared->GetSourceCode();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetScriptSourcePosition) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, fun, 0);
+ int pos = fun->shared()->start_position();
+ return Smi::FromInt(pos);
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionGetPositionForOffset) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_CHECKED(Code, code, 0);
+ CONVERT_NUMBER_CHECKED(int, offset, Int32, args[1]);
+
+ RUNTIME_ASSERT(0 <= offset && offset < code->Size());
+
+ Address pc = code->address() + offset;
+ return Smi::FromInt(code->SourcePosition(pc));
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionSetInstanceClassName) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_CHECKED(JSFunction, fun, 0);
+ CONVERT_ARG_CHECKED(String, name, 1);
+ fun->SetInstanceClassName(name);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionSetLength) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_CHECKED(JSFunction, fun, 0);
+ CONVERT_SMI_ARG_CHECKED(length, 1);
+ RUNTIME_ASSERT((length & 0xC0000000) == 0xC0000000 ||
+ (length & 0xC0000000) == 0x0);
+ fun->shared()->set_length(length);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionSetPrototype) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
+ RUNTIME_ASSERT(fun->should_have_prototype());
+ RETURN_FAILURE_ON_EXCEPTION(isolate,
+ Accessors::FunctionSetPrototype(fun, value));
+ return args[0]; // return TOS
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionIsAPIFunction) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(f->shared()->IsApiFunction());
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionIsBuiltin) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(f->IsBuiltin());
+}
+
+
+RUNTIME_FUNCTION(Runtime_SetCode) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, source, 1);
+
+ Handle<SharedFunctionInfo> target_shared(target->shared());
+ Handle<SharedFunctionInfo> source_shared(source->shared());
+ RUNTIME_ASSERT(!source_shared->bound());
+
+ if (!Compiler::EnsureCompiled(source, KEEP_EXCEPTION)) {
+ return isolate->heap()->exception();
+ }
+
+ // Mark both, the source and the target, as un-flushable because the
+ // shared unoptimized code makes them impossible to enqueue in a list.
+ DCHECK(target_shared->code()->gc_metadata() == NULL);
+ DCHECK(source_shared->code()->gc_metadata() == NULL);
+ target_shared->set_dont_flush(true);
+ source_shared->set_dont_flush(true);
+
+ // Set the code, scope info, formal parameter count, and the length
+ // of the target shared function info.
+ target_shared->ReplaceCode(source_shared->code());
+ target_shared->set_scope_info(source_shared->scope_info());
+ target_shared->set_length(source_shared->length());
+ target_shared->set_feedback_vector(source_shared->feedback_vector());
+ target_shared->set_formal_parameter_count(
+ source_shared->formal_parameter_count());
+ target_shared->set_script(source_shared->script());
+ target_shared->set_start_position_and_type(
+ source_shared->start_position_and_type());
+ target_shared->set_end_position(source_shared->end_position());
+ bool was_native = target_shared->native();
+ target_shared->set_compiler_hints(source_shared->compiler_hints());
+ target_shared->set_native(was_native);
+ target_shared->set_profiler_ticks(source_shared->profiler_ticks());
+
+ // Set the code of the target function.
+ target->ReplaceCode(source_shared->code());
+ DCHECK(target->next_function_link()->IsUndefined());
+
+ // Make sure we get a fresh copy of the literal vector to avoid cross
+ // context contamination.
+ Handle<Context> context(source->context());
+ int number_of_literals = source->NumberOfLiterals();
+ Handle<FixedArray> literals =
+ isolate->factory()->NewFixedArray(number_of_literals, TENURED);
+ if (number_of_literals > 0) {
+ literals->set(JSFunction::kLiteralNativeContextIndex,
+ context->native_context());
+ }
+ target->set_context(*context);
+ target->set_literals(*literals);
+
+ if (isolate->logger()->is_logging_code_events() ||
+ isolate->cpu_profiler()->is_profiling()) {
+ isolate->logger()->LogExistingFunction(source_shared,
+ Handle<Code>(source_shared->code()));
+ }
+
+ return *target;
+}
+
+
+// Set the native flag on the function.
+// This is used to decide if we should transform null and undefined
+// into the global object when doing call and apply.
+RUNTIME_FUNCTION(Runtime_SetNativeFlag) {
+ SealHandleScope shs(isolate);
+ RUNTIME_ASSERT(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(Object, object, 0);
+
+ if (object->IsJSFunction()) {
+ JSFunction* func = JSFunction::cast(object);
+ func->shared()->set_native(true);
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_SetInlineBuiltinFlag) {
+ SealHandleScope shs(isolate);
+ RUNTIME_ASSERT(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+
+ if (object->IsJSFunction()) {
+ JSFunction* func = JSFunction::cast(*object);
+ func->shared()->set_inline_builtin(true);
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+// Find the arguments of the JavaScript function invocation that called
+// into C++ code. Collect these in a newly allocated array of handles (possibly
+// prefixed by a number of empty handles).
+static SmartArrayPointer<Handle<Object> > GetCallerArguments(Isolate* isolate,
+ int prefix_argc,
+ int* total_argc) {
+ // Find frame containing arguments passed to the caller.
+ JavaScriptFrameIterator it(isolate);
+ JavaScriptFrame* frame = it.frame();
+ List<JSFunction*> functions(2);
+ frame->GetFunctions(&functions);
+ if (functions.length() > 1) {
+ int inlined_jsframe_index = functions.length() - 1;
+ JSFunction* inlined_function = functions[inlined_jsframe_index];
+ SlotRefValueBuilder slot_refs(
+ frame, inlined_jsframe_index,
+ inlined_function->shared()->formal_parameter_count());
+
+ int args_count = slot_refs.args_length();
+
+ *total_argc = prefix_argc + args_count;
+ SmartArrayPointer<Handle<Object> > param_data(
+ NewArray<Handle<Object> >(*total_argc));
+ slot_refs.Prepare(isolate);
+ for (int i = 0; i < args_count; i++) {
+ Handle<Object> val = slot_refs.GetNext(isolate, 0);
+ param_data[prefix_argc + i] = val;
+ }
+ slot_refs.Finish(isolate);
+
+ return param_data;
+ } else {
+ it.AdvanceToArgumentsFrame();
+ frame = it.frame();
+ int args_count = frame->ComputeParametersCount();
+
+ *total_argc = prefix_argc + args_count;
+ SmartArrayPointer<Handle<Object> > param_data(
+ NewArray<Handle<Object> >(*total_argc));
+ for (int i = 0; i < args_count; i++) {
+ Handle<Object> val = Handle<Object>(frame->GetParameter(i), isolate);
+ param_data[prefix_argc + i] = val;
+ }
+ return param_data;
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionBindArguments) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, bound_function, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, bindee, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, this_object, 2);
+ CONVERT_NUMBER_ARG_HANDLE_CHECKED(new_length, 3);
+
+ // TODO(lrn): Create bound function in C++ code from premade shared info.
+ bound_function->shared()->set_bound(true);
+ // Get all arguments of calling function (Function.prototype.bind).
+ int argc = 0;
+ SmartArrayPointer<Handle<Object> > arguments =
+ GetCallerArguments(isolate, 0, &argc);
+ // Don't count the this-arg.
+ if (argc > 0) {
+ RUNTIME_ASSERT(arguments[0].is_identical_to(this_object));
+ argc--;
+ } else {
+ RUNTIME_ASSERT(this_object->IsUndefined());
+ }
+ // Initialize array of bindings (function, this, and any existing arguments
+ // if the function was already bound).
+ Handle<FixedArray> new_bindings;
+ int i;
+ if (bindee->IsJSFunction() && JSFunction::cast(*bindee)->shared()->bound()) {
+ Handle<FixedArray> old_bindings(
+ JSFunction::cast(*bindee)->function_bindings());
+ RUNTIME_ASSERT(old_bindings->length() > JSFunction::kBoundFunctionIndex);
+ new_bindings =
+ isolate->factory()->NewFixedArray(old_bindings->length() + argc);
+ bindee = Handle<Object>(old_bindings->get(JSFunction::kBoundFunctionIndex),
+ isolate);
+ i = 0;
+ for (int n = old_bindings->length(); i < n; i++) {
+ new_bindings->set(i, old_bindings->get(i));
+ }
+ } else {
+ int array_size = JSFunction::kBoundArgumentsStartIndex + argc;
+ new_bindings = isolate->factory()->NewFixedArray(array_size);
+ new_bindings->set(JSFunction::kBoundFunctionIndex, *bindee);
+ new_bindings->set(JSFunction::kBoundThisIndex, *this_object);
+ i = 2;
+ }
+ // Copy arguments, skipping the first which is "this_arg".
+ for (int j = 0; j < argc; j++, i++) {
+ new_bindings->set(i, *arguments[j + 1]);
+ }
+ new_bindings->set_map_no_write_barrier(
+ isolate->heap()->fixed_cow_array_map());
+ bound_function->set_function_bindings(*new_bindings);
+
+ // Update length. Have to remove the prototype first so that map migration
+ // is happy about the number of fields.
+ RUNTIME_ASSERT(bound_function->RemovePrototype());
+ Handle<Map> bound_function_map(
+ isolate->native_context()->bound_function_map());
+ JSObject::MigrateToMap(bound_function, bound_function_map);
+ Handle<String> length_string = isolate->factory()->length_string();
+ PropertyAttributes attr =
+ static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY);
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ bound_function, length_string, new_length, attr));
+ return *bound_function;
+}
+
+
+RUNTIME_FUNCTION(Runtime_BoundFunctionGetBindings) {
+ HandleScope handles(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, callable, 0);
+ if (callable->IsJSFunction()) {
+ Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
+ if (function->shared()->bound()) {
+ Handle<FixedArray> bindings(function->function_bindings());
+ RUNTIME_ASSERT(bindings->map() == isolate->heap()->fixed_cow_array_map());
+ return *isolate->factory()->NewJSArrayWithElements(bindings);
+ }
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewObjectFromBound) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ // First argument is a function to use as a constructor.
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ RUNTIME_ASSERT(function->shared()->bound());
+
+ // The argument is a bound function. Extract its bound arguments
+ // and callable.
+ Handle<FixedArray> bound_args =
+ Handle<FixedArray>(FixedArray::cast(function->function_bindings()));
+ int bound_argc = bound_args->length() - JSFunction::kBoundArgumentsStartIndex;
+ Handle<Object> bound_function(
+ JSReceiver::cast(bound_args->get(JSFunction::kBoundFunctionIndex)),
+ isolate);
+ DCHECK(!bound_function->IsJSFunction() ||
+ !Handle<JSFunction>::cast(bound_function)->shared()->bound());
+
+ int total_argc = 0;
+ SmartArrayPointer<Handle<Object> > param_data =
+ GetCallerArguments(isolate, bound_argc, &total_argc);
+ for (int i = 0; i < bound_argc; i++) {
+ param_data[i] = Handle<Object>(
+ bound_args->get(JSFunction::kBoundArgumentsStartIndex + i), isolate);
+ }
+
+ if (!bound_function->IsJSFunction()) {
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, bound_function,
+ Execution::TryGetConstructorDelegate(isolate, bound_function));
+ }
+ DCHECK(bound_function->IsJSFunction());
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, Execution::New(Handle<JSFunction>::cast(bound_function),
+ total_argc, param_data.get()));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_Call) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() >= 2);
+ int argc = args.length() - 2;
+ CONVERT_ARG_CHECKED(JSReceiver, fun, argc + 1);
+ Object* receiver = args[0];
+
+ // If there are too many arguments, allocate argv via malloc.
+ const int argv_small_size = 10;
+ Handle<Object> argv_small_buffer[argv_small_size];
+ SmartArrayPointer<Handle<Object> > argv_large_buffer;
+ Handle<Object>* argv = argv_small_buffer;
+ if (argc > argv_small_size) {
+ argv = new Handle<Object>[argc];
+ if (argv == NULL) return isolate->StackOverflow();
+ argv_large_buffer = SmartArrayPointer<Handle<Object> >(argv);
+ }
+
+ for (int i = 0; i < argc; ++i) {
+ argv[i] = Handle<Object>(args[1 + i], isolate);
+ }
+
+ Handle<JSReceiver> hfun(fun);
+ Handle<Object> hreceiver(receiver, isolate);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Execution::Call(isolate, hfun, hreceiver, argc, argv, true));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_Apply) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 5);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, fun, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, arguments, 2);
+ CONVERT_INT32_ARG_CHECKED(offset, 3);
+ CONVERT_INT32_ARG_CHECKED(argc, 4);
+ RUNTIME_ASSERT(offset >= 0);
+ // Loose upper bound to allow fuzzing. We'll most likely run out of
+ // stack space before hitting this limit.
+ static int kMaxArgc = 1000000;
+ RUNTIME_ASSERT(argc >= 0 && argc <= kMaxArgc);
+
+ // If there are too many arguments, allocate argv via malloc.
+ const int argv_small_size = 10;
+ Handle<Object> argv_small_buffer[argv_small_size];
+ SmartArrayPointer<Handle<Object> > argv_large_buffer;
+ Handle<Object>* argv = argv_small_buffer;
+ if (argc > argv_small_size) {
+ argv = new Handle<Object>[argc];
+ if (argv == NULL) return isolate->StackOverflow();
+ argv_large_buffer = SmartArrayPointer<Handle<Object> >(argv);
+ }
+
+ for (int i = 0; i < argc; ++i) {
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, argv[i], Object::GetElement(isolate, arguments, offset + i));
+ }
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Execution::Call(isolate, fun, receiver, argc, argv, true));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetFunctionDelegate) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ RUNTIME_ASSERT(!object->IsJSFunction());
+ return *Execution::GetFunctionDelegate(isolate, object);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetConstructorDelegate) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ RUNTIME_ASSERT(!object->IsJSFunction());
+ return *Execution::GetConstructorDelegate(isolate, object);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_CallFunction) {
+ SealHandleScope shs(isolate);
+ return __RT_impl_Runtime_Call(args, isolate);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsConstructCall) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ JavaScriptFrameIterator it(isolate);
+ JavaScriptFrame* frame = it.frame();
+ return isolate->heap()->ToBoolean(frame->IsConstructor());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsFunction) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSFunction());
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/frames-inl.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_CreateJSGeneratorObject) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+
+ JavaScriptFrameIterator it(isolate);
+ JavaScriptFrame* frame = it.frame();
+ Handle<JSFunction> function(frame->function());
+ RUNTIME_ASSERT(function->shared()->is_generator());
+
+ Handle<JSGeneratorObject> generator;
+ if (frame->IsConstructor()) {
+ generator = handle(JSGeneratorObject::cast(frame->receiver()));
+ } else {
+ generator = isolate->factory()->NewJSGeneratorObject(function);
+ }
+ generator->set_function(*function);
+ generator->set_context(Context::cast(frame->context()));
+ generator->set_receiver(frame->receiver());
+ generator->set_continuation(0);
+ generator->set_operand_stack(isolate->heap()->empty_fixed_array());
+ generator->set_stack_handler_index(-1);
+
+ return *generator;
+}
+
+
+RUNTIME_FUNCTION(Runtime_SuspendJSGeneratorObject) {
+ HandleScope handle_scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator_object, 0);
+
+ JavaScriptFrameIterator stack_iterator(isolate);
+ JavaScriptFrame* frame = stack_iterator.frame();
+ RUNTIME_ASSERT(frame->function()->shared()->is_generator());
+ DCHECK_EQ(frame->function(), generator_object->function());
+
+ // The caller should have saved the context and continuation already.
+ DCHECK_EQ(generator_object->context(), Context::cast(frame->context()));
+ DCHECK_LT(0, generator_object->continuation());
+
+ // We expect there to be at least two values on the operand stack: the return
+ // value of the yield expression, and the argument to this runtime call.
+ // Neither of those should be saved.
+ int operands_count = frame->ComputeOperandsCount();
+ DCHECK_GE(operands_count, 2);
+ operands_count -= 2;
+
+ if (operands_count == 0) {
+ // Although it's semantically harmless to call this function with an
+ // operands_count of zero, it is also unnecessary.
+ DCHECK_EQ(generator_object->operand_stack(),
+ isolate->heap()->empty_fixed_array());
+ DCHECK_EQ(generator_object->stack_handler_index(), -1);
+ // If there are no operands on the stack, there shouldn't be a handler
+ // active either.
+ DCHECK(!frame->HasHandler());
+ } else {
+ int stack_handler_index = -1;
+ Handle<FixedArray> operand_stack =
+ isolate->factory()->NewFixedArray(operands_count);
+ frame->SaveOperandStack(*operand_stack, &stack_handler_index);
+ generator_object->set_operand_stack(*operand_stack);
+ generator_object->set_stack_handler_index(stack_handler_index);
+ }
+
+ return isolate->heap()->undefined_value();
+}
+
+
+// Note that this function is the slow path for resuming generators. It is only
+// called if the suspended activation had operands on the stack, stack handlers
+// needing rewinding, or if the resume should throw an exception. The fast path
+// is handled directly in FullCodeGenerator::EmitGeneratorResume(), which is
+// inlined into GeneratorNext and GeneratorThrow. EmitGeneratorResumeResume is
+// called in any case, as it needs to reconstruct the stack frame and make space
+// for arguments and operands.
+RUNTIME_FUNCTION(Runtime_ResumeJSGeneratorObject) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_CHECKED(JSGeneratorObject, generator_object, 0);
+ CONVERT_ARG_CHECKED(Object, value, 1);
+ CONVERT_SMI_ARG_CHECKED(resume_mode_int, 2);
+ JavaScriptFrameIterator stack_iterator(isolate);
+ JavaScriptFrame* frame = stack_iterator.frame();
+
+ DCHECK_EQ(frame->function(), generator_object->function());
+ DCHECK(frame->function()->is_compiled());
+
+ STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
+ STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
+
+ Address pc = generator_object->function()->code()->instruction_start();
+ int offset = generator_object->continuation();
+ DCHECK(offset > 0);
+ frame->set_pc(pc + offset);
+ if (FLAG_enable_ool_constant_pool) {
+ frame->set_constant_pool(
+ generator_object->function()->code()->constant_pool());
+ }
+ generator_object->set_continuation(JSGeneratorObject::kGeneratorExecuting);
+
+ FixedArray* operand_stack = generator_object->operand_stack();
+ int operands_count = operand_stack->length();
+ if (operands_count != 0) {
+ frame->RestoreOperandStack(operand_stack,
+ generator_object->stack_handler_index());
+ generator_object->set_operand_stack(isolate->heap()->empty_fixed_array());
+ generator_object->set_stack_handler_index(-1);
+ }
+
+ JSGeneratorObject::ResumeMode resume_mode =
+ static_cast<JSGeneratorObject::ResumeMode>(resume_mode_int);
+ switch (resume_mode) {
+ case JSGeneratorObject::NEXT:
+ return value;
+ case JSGeneratorObject::THROW:
+ return isolate->Throw(value);
+ }
+
+ UNREACHABLE();
+ return isolate->ThrowIllegalOperation();
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowGeneratorStateError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+ int continuation = generator->continuation();
+ const char* message = continuation == JSGeneratorObject::kGeneratorClosed
+ ? "generator_finished"
+ : "generator_running";
+ Vector<Handle<Object> > argv = HandleVector<Object>(NULL, 0);
+ THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewError(message, argv));
+}
+
+
+// Returns function of generator activation.
+RUNTIME_FUNCTION(Runtime_GeneratorGetFunction) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+
+ return generator->function();
+}
+
+
+// Returns context of generator activation.
+RUNTIME_FUNCTION(Runtime_GeneratorGetContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+
+ return generator->context();
+}
+
+
+// Returns receiver of generator activation.
+RUNTIME_FUNCTION(Runtime_GeneratorGetReceiver) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+
+ return generator->receiver();
+}
+
+
+// Returns generator continuation as a PC offset, or the magic -1 or 0 values.
+RUNTIME_FUNCTION(Runtime_GeneratorGetContinuation) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+
+ return Smi::FromInt(generator->continuation());
+}
+
+
+RUNTIME_FUNCTION(Runtime_GeneratorGetSourcePosition) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+
+ if (generator->is_suspended()) {
+ Handle<Code> code(generator->function()->code(), isolate);
+ int offset = generator->continuation();
+
+ RUNTIME_ASSERT(0 <= offset && offset < code->Size());
+ Address pc = code->address() + offset;
+
+ return Smi::FromInt(code->SourcePosition(pc));
+ }
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_FunctionIsGenerator) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunction, f, 0);
+ return isolate->heap()->ToBoolean(f->shared()->is_generator());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_GeneratorNext) {
+ UNREACHABLE(); // Optimization disabled in SetUpGenerators().
+ return NULL;
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_GeneratorThrow) {
+ UNREACHABLE(); // Optimization disabled in SetUpGenerators().
+ return NULL;
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/i18n.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
#include "unicode/brkiter.h"
if (!input->IsJSObject()) return isolate->heap()->false_value();
Handle<JSObject> obj = Handle<JSObject>::cast(input);
- Handle<String> marker = isolate->factory()->intl_initialized_marker_string();
- Handle<Object> tag(obj->GetHiddenProperty(marker), isolate);
- return isolate->heap()->ToBoolean(!tag->IsTheHole());
+ Handle<Symbol> marker = isolate->factory()->intl_initialized_marker_symbol();
+ Handle<Object> tag = JSObject::GetDataProperty(obj, marker);
+ return isolate->heap()->ToBoolean(!tag->IsUndefined());
}
if (!input->IsJSObject()) return isolate->heap()->false_value();
Handle<JSObject> obj = Handle<JSObject>::cast(input);
- Handle<String> marker = isolate->factory()->intl_initialized_marker_string();
- Handle<Object> tag(obj->GetHiddenProperty(marker), isolate);
+ Handle<Symbol> marker = isolate->factory()->intl_initialized_marker_symbol();
+ Handle<Object> tag = JSObject::GetDataProperty(obj, marker);
return isolate->heap()->ToBoolean(tag->IsString() &&
String::cast(*tag)->Equals(*expected_type));
}
CONVERT_ARG_HANDLE_CHECKED(String, type, 1);
CONVERT_ARG_HANDLE_CHECKED(JSObject, impl, 2);
- Handle<String> marker = isolate->factory()->intl_initialized_marker_string();
- JSObject::SetHiddenProperty(input, marker, type);
+ Handle<Symbol> marker = isolate->factory()->intl_initialized_marker_symbol();
+ JSObject::SetProperty(input, marker, type, STRICT).Assert();
- marker = isolate->factory()->intl_impl_object_string();
- JSObject::SetHiddenProperty(input, marker, impl);
+ marker = isolate->factory()->intl_impl_object_symbol();
+ JSObject::SetProperty(input, marker, impl, STRICT).Assert();
return isolate->heap()->undefined_value();
}
Handle<JSObject> obj = Handle<JSObject>::cast(input);
- Handle<String> marker = isolate->factory()->intl_impl_object_string();
- Handle<Object> impl(obj->GetHiddenProperty(marker), isolate);
+ Handle<Symbol> marker = isolate->factory()->intl_impl_object_symbol();
+
+ Handle<Object> impl = JSObject::GetDataProperty(obj, marker);
if (impl->IsTheHole()) {
Vector<Handle<Object> > arguments = HandleVector(&obj, 1);
THROW_NEW_ERROR_RETURN_FAILURE(isolate,
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/bootstrapper.h"
+#include "src/debug.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_CheckIsBootstrapping) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ RUNTIME_ASSERT(isolate->bootstrapper()->IsActive());
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_Throw) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ return isolate->Throw(args[0]);
+}
+
+
+RUNTIME_FUNCTION(Runtime_ReThrow) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ return isolate->ReThrow(args[0]);
+}
+
+
+RUNTIME_FUNCTION(Runtime_PromoteScheduledException) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ return isolate->PromoteScheduledException();
+}
+
+
+RUNTIME_FUNCTION(Runtime_ThrowReferenceError) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewReferenceError("not_defined", HandleVector(&name, 1)));
+}
+
+
+RUNTIME_FUNCTION(Runtime_PromiseRejectEvent) {
+ DCHECK(args.length() == 3);
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
+ CONVERT_BOOLEAN_ARG_CHECKED(debug_event, 2);
+ if (debug_event) isolate->debug()->OnPromiseReject(promise, value);
+ Handle<Symbol> key = isolate->factory()->promise_has_handler_symbol();
+ // Do not report if we actually have a handler.
+ if (JSObject::GetDataProperty(promise, key)->IsUndefined()) {
+ isolate->ReportPromiseReject(promise, value,
+ v8::kPromiseRejectWithNoHandler);
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_PromiseRevokeReject) {
+ DCHECK(args.length() == 1);
+ HandleScope scope(isolate);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
+ Handle<Symbol> key = isolate->factory()->promise_has_handler_symbol();
+ // At this point, no revocation has been issued before
+ RUNTIME_ASSERT(JSObject::GetDataProperty(promise, key)->IsUndefined());
+ isolate->ReportPromiseReject(promise, Handle<Object>(),
+ v8::kPromiseHandlerAddedAfterReject);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_PromiseHasHandlerSymbol) {
+ DCHECK(args.length() == 0);
+ return isolate->heap()->promise_has_handler_symbol();
+}
+
+
+RUNTIME_FUNCTION(Runtime_StackGuard) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+
+ // First check if this is a real stack overflow.
+ StackLimitCheck check(isolate);
+ if (check.JsHasOverflowed()) {
+ return isolate->StackOverflow();
+ }
+
+ return isolate->stack_guard()->HandleInterrupts();
+}
+
+
+RUNTIME_FUNCTION(Runtime_Interrupt) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ return isolate->stack_guard()->HandleInterrupts();
+}
+
+
+RUNTIME_FUNCTION(Runtime_AllocateInNewSpace) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_SMI_ARG_CHECKED(size, 0);
+ RUNTIME_ASSERT(IsAligned(size, kPointerSize));
+ RUNTIME_ASSERT(size > 0);
+ RUNTIME_ASSERT(size <= Page::kMaxRegularHeapObjectSize);
+ return *isolate->factory()->NewFillerObject(size, false, NEW_SPACE);
+}
+
+
+RUNTIME_FUNCTION(Runtime_AllocateInTargetSpace) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_SMI_ARG_CHECKED(size, 0);
+ CONVERT_SMI_ARG_CHECKED(flags, 1);
+ RUNTIME_ASSERT(IsAligned(size, kPointerSize));
+ RUNTIME_ASSERT(size > 0);
+ RUNTIME_ASSERT(size <= Page::kMaxRegularHeapObjectSize);
+ bool double_align = AllocateDoubleAlignFlag::decode(flags);
+ AllocationSpace space = AllocateTargetSpace::decode(flags);
+ return *isolate->factory()->NewFillerObject(size, double_align, space);
+}
+
+
+// Collect the raw data for a stack trace. Returns an array of 4
+// element segments each containing a receiver, function, code and
+// native code offset.
+RUNTIME_FUNCTION(Runtime_CollectStackTrace) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, error_object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, caller, 1);
+
+ if (!isolate->bootstrapper()->IsActive()) {
+ // Optionally capture a more detailed stack trace for the message.
+ isolate->CaptureAndSetDetailedStackTrace(error_object);
+ // Capture a simple stack trace for the stack property.
+ isolate->CaptureAndSetSimpleStackTrace(error_object, caller);
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetFromCache) {
+ SealHandleScope shs(isolate);
+ // This is only called from codegen, so checks might be more lax.
+ CONVERT_ARG_CHECKED(JSFunctionResultCache, cache, 0);
+ CONVERT_ARG_CHECKED(Object, key, 1);
+
+ {
+ DisallowHeapAllocation no_alloc;
+
+ int finger_index = cache->finger_index();
+ Object* o = cache->get(finger_index);
+ if (o == key) {
+ // The fastest case: hit the same place again.
+ return cache->get(finger_index + 1);
+ }
+
+ for (int i = finger_index - 2; i >= JSFunctionResultCache::kEntriesIndex;
+ i -= 2) {
+ o = cache->get(i);
+ if (o == key) {
+ cache->set_finger_index(i);
+ return cache->get(i + 1);
+ }
+ }
+
+ int size = cache->size();
+ DCHECK(size <= cache->length());
+
+ for (int i = size - 2; i > finger_index; i -= 2) {
+ o = cache->get(i);
+ if (o == key) {
+ cache->set_finger_index(i);
+ return cache->get(i + 1);
+ }
+ }
+ }
+
+ // There is no value in the cache. Invoke the function and cache result.
+ HandleScope scope(isolate);
+
+ Handle<JSFunctionResultCache> cache_handle(cache);
+ Handle<Object> key_handle(key, isolate);
+ Handle<Object> value;
+ {
+ Handle<JSFunction> factory(JSFunction::cast(
+ cache_handle->get(JSFunctionResultCache::kFactoryIndex)));
+ // TODO(antonm): consider passing a receiver when constructing a cache.
+ Handle<JSObject> receiver(isolate->global_proxy());
+ // This handle is nor shared, nor used later, so it's safe.
+ Handle<Object> argv[] = {key_handle};
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value,
+ Execution::Call(isolate, factory, receiver, arraysize(argv), argv));
+ }
+
+#ifdef VERIFY_HEAP
+ if (FLAG_verify_heap) {
+ cache_handle->JSFunctionResultCacheVerify();
+ }
+#endif
+
+ // Function invocation may have cleared the cache. Reread all the data.
+ int finger_index = cache_handle->finger_index();
+ int size = cache_handle->size();
+
+ // If we have spare room, put new data into it, otherwise evict post finger
+ // entry which is likely to be the least recently used.
+ int index = -1;
+ if (size < cache_handle->length()) {
+ cache_handle->set_size(size + JSFunctionResultCache::kEntrySize);
+ index = size;
+ } else {
+ index = finger_index + JSFunctionResultCache::kEntrySize;
+ if (index == cache_handle->length()) {
+ index = JSFunctionResultCache::kEntriesIndex;
+ }
+ }
+
+ DCHECK(index % 2 == 0);
+ DCHECK(index >= JSFunctionResultCache::kEntriesIndex);
+ DCHECK(index < cache_handle->length());
+
+ cache_handle->set(index, *key_handle);
+ cache_handle->set(index + 1, *value);
+ cache_handle->set_finger_index(index);
+
+#ifdef VERIFY_HEAP
+ if (FLAG_verify_heap) {
+ cache_handle->JSFunctionResultCacheVerify();
+ }
+#endif
+
+ return *value;
+}
+
+
+RUNTIME_FUNCTION(Runtime_MessageGetStartPosition) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
+ return Smi::FromInt(message->start_position());
+}
+
+
+RUNTIME_FUNCTION(Runtime_MessageGetScript) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
+ return message->script();
+}
+
+
+RUNTIME_FUNCTION(Runtime_IS_VAR) {
+ UNREACHABLE(); // implemented as macro in the parser
+ return NULL;
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_GetFromCache) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_SMI_ARG_CHECKED(id, 0);
+ args[0] = isolate->native_context()->jsfunction_result_caches()->get(id);
+ return __RT_impl_Runtime_GetFromCache(args, isolate);
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/json-parser.h"
#include "src/json-stringifier.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
namespace v8 {
--- /dev/null
+// 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/v8.h"
+
+#include "src/allocation-site-scopes.h"
+#include "src/arguments.h"
+#include "src/ast.h"
+#include "src/parser.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+static Handle<Map> ComputeObjectLiteralMap(
+ Handle<Context> context, Handle<FixedArray> constant_properties,
+ bool* is_result_from_cache) {
+ Isolate* isolate = context->GetIsolate();
+ int properties_length = constant_properties->length();
+ int number_of_properties = properties_length / 2;
+ // Check that there are only internal strings and array indices among keys.
+ int number_of_string_keys = 0;
+ for (int p = 0; p != properties_length; p += 2) {
+ Object* key = constant_properties->get(p);
+ uint32_t element_index = 0;
+ if (key->IsInternalizedString()) {
+ number_of_string_keys++;
+ } else if (key->ToArrayIndex(&element_index)) {
+ // An index key does not require space in the property backing store.
+ number_of_properties--;
+ } else {
+ // Bail out as a non-internalized-string non-index key makes caching
+ // impossible.
+ // DCHECK to make sure that the if condition after the loop is false.
+ DCHECK(number_of_string_keys != number_of_properties);
+ break;
+ }
+ }
+ // If we only have internalized strings and array indices among keys then we
+ // can use the map cache in the native context.
+ const int kMaxKeys = 10;
+ if ((number_of_string_keys == number_of_properties) &&
+ (number_of_string_keys < kMaxKeys)) {
+ // Create the fixed array with the key.
+ Handle<FixedArray> keys =
+ isolate->factory()->NewFixedArray(number_of_string_keys);
+ if (number_of_string_keys > 0) {
+ int index = 0;
+ for (int p = 0; p < properties_length; p += 2) {
+ Object* key = constant_properties->get(p);
+ if (key->IsInternalizedString()) {
+ keys->set(index++, key);
+ }
+ }
+ DCHECK(index == number_of_string_keys);
+ }
+ *is_result_from_cache = true;
+ return isolate->factory()->ObjectLiteralMapFromCache(context, keys);
+ }
+ *is_result_from_cache = false;
+ return Map::Create(isolate, number_of_properties);
+}
+
+
+MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
+ Isolate* isolate, Handle<FixedArray> literals,
+ Handle<FixedArray> constant_properties);
+
+
+MUST_USE_RESULT static MaybeHandle<Object> CreateObjectLiteralBoilerplate(
+ Isolate* isolate, Handle<FixedArray> literals,
+ Handle<FixedArray> constant_properties, bool should_have_fast_elements,
+ bool has_function_literal) {
+ // Get the native context from the literals array. This is the
+ // context in which the function was created and we use the object
+ // function from this context to create the object literal. We do
+ // not use the object function from the current native context
+ // because this might be the object function from another context
+ // which we should not have access to.
+ Handle<Context> context =
+ Handle<Context>(JSFunction::NativeContextFromLiterals(*literals));
+
+ // In case we have function literals, we want the object to be in
+ // slow properties mode for now. We don't go in the map cache because
+ // maps with constant functions can't be shared if the functions are
+ // not the same (which is the common case).
+ bool is_result_from_cache = false;
+ Handle<Map> map = has_function_literal
+ ? Handle<Map>(context->object_function()->initial_map())
+ : ComputeObjectLiteralMap(context, constant_properties,
+ &is_result_from_cache);
+
+ PretenureFlag pretenure_flag =
+ isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
+
+ Handle<JSObject> boilerplate =
+ isolate->factory()->NewJSObjectFromMap(map, pretenure_flag);
+
+ // Normalize the elements of the boilerplate to save space if needed.
+ if (!should_have_fast_elements) JSObject::NormalizeElements(boilerplate);
+
+ // Add the constant properties to the boilerplate.
+ int length = constant_properties->length();
+ bool should_transform =
+ !is_result_from_cache && boilerplate->HasFastProperties();
+ bool should_normalize = should_transform || has_function_literal;
+ if (should_normalize) {
+ // TODO(verwaest): We might not want to ever normalize here.
+ JSObject::NormalizeProperties(boilerplate, KEEP_INOBJECT_PROPERTIES,
+ length / 2);
+ }
+ // TODO(verwaest): Support tracking representations in the boilerplate.
+ for (int index = 0; index < length; index += 2) {
+ Handle<Object> key(constant_properties->get(index + 0), isolate);
+ Handle<Object> value(constant_properties->get(index + 1), isolate);
+ if (value->IsFixedArray()) {
+ // The value contains the constant_properties of a
+ // simple object or array literal.
+ Handle<FixedArray> array = Handle<FixedArray>::cast(value);
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, CreateLiteralBoilerplate(isolate, literals, array),
+ Object);
+ }
+ MaybeHandle<Object> maybe_result;
+ uint32_t element_index = 0;
+ if (key->IsInternalizedString()) {
+ if (Handle<String>::cast(key)->AsArrayIndex(&element_index)) {
+ // Array index as string (uint32).
+ if (value->IsUninitialized()) value = handle(Smi::FromInt(0), isolate);
+ maybe_result =
+ JSObject::SetOwnElement(boilerplate, element_index, value, SLOPPY);
+ } else {
+ Handle<String> name(String::cast(*key));
+ DCHECK(!name->AsArrayIndex(&element_index));
+ maybe_result = JSObject::SetOwnPropertyIgnoreAttributes(
+ boilerplate, name, value, NONE);
+ }
+ } else if (key->ToArrayIndex(&element_index)) {
+ // Array index (uint32).
+ if (value->IsUninitialized()) value = handle(Smi::FromInt(0), isolate);
+ maybe_result =
+ JSObject::SetOwnElement(boilerplate, element_index, value, SLOPPY);
+ } else {
+ // Non-uint32 number.
+ DCHECK(key->IsNumber());
+ double num = key->Number();
+ char arr[100];
+ Vector<char> buffer(arr, arraysize(arr));
+ const char* str = DoubleToCString(num, buffer);
+ Handle<String> name = isolate->factory()->NewStringFromAsciiChecked(str);
+ maybe_result = JSObject::SetOwnPropertyIgnoreAttributes(boilerplate, name,
+ value, NONE);
+ }
+ // If setting the property on the boilerplate throws an
+ // exception, the exception is converted to an empty handle in
+ // the handle based operations. In that case, we need to
+ // convert back to an exception.
+ RETURN_ON_EXCEPTION(isolate, maybe_result, Object);
+ }
+
+ // Transform to fast properties if necessary. For object literals with
+ // containing function literals we defer this operation until after all
+ // computed properties have been assigned so that we can generate
+ // constant function properties.
+ if (should_transform && !has_function_literal) {
+ JSObject::MigrateSlowToFast(boilerplate,
+ boilerplate->map()->unused_property_fields());
+ }
+
+ return boilerplate;
+}
+
+
+MaybeHandle<Object> Runtime::CreateArrayLiteralBoilerplate(
+ Isolate* isolate, Handle<FixedArray> literals,
+ Handle<FixedArray> elements) {
+ // Create the JSArray.
+ Handle<JSFunction> constructor(
+ JSFunction::NativeContextFromLiterals(*literals)->array_function());
+
+ PretenureFlag pretenure_flag =
+ isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
+
+ Handle<JSArray> object = Handle<JSArray>::cast(
+ isolate->factory()->NewJSObject(constructor, pretenure_flag));
+
+ ElementsKind constant_elements_kind =
+ static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
+ Handle<FixedArrayBase> constant_elements_values(
+ FixedArrayBase::cast(elements->get(1)));
+
+ {
+ DisallowHeapAllocation no_gc;
+ DCHECK(IsFastElementsKind(constant_elements_kind));
+ Context* native_context = isolate->context()->native_context();
+ Object* maps_array = native_context->js_array_maps();
+ DCHECK(!maps_array->IsUndefined());
+ Object* map = FixedArray::cast(maps_array)->get(constant_elements_kind);
+ object->set_map(Map::cast(map));
+ }
+
+ Handle<FixedArrayBase> copied_elements_values;
+ if (IsFastDoubleElementsKind(constant_elements_kind)) {
+ copied_elements_values = isolate->factory()->CopyFixedDoubleArray(
+ Handle<FixedDoubleArray>::cast(constant_elements_values));
+ } else {
+ DCHECK(IsFastSmiOrObjectElementsKind(constant_elements_kind));
+ const bool is_cow = (constant_elements_values->map() ==
+ isolate->heap()->fixed_cow_array_map());
+ if (is_cow) {
+ copied_elements_values = constant_elements_values;
+#if DEBUG
+ Handle<FixedArray> fixed_array_values =
+ Handle<FixedArray>::cast(copied_elements_values);
+ for (int i = 0; i < fixed_array_values->length(); i++) {
+ DCHECK(!fixed_array_values->get(i)->IsFixedArray());
+ }
+#endif
+ } else {
+ Handle<FixedArray> fixed_array_values =
+ Handle<FixedArray>::cast(constant_elements_values);
+ Handle<FixedArray> fixed_array_values_copy =
+ isolate->factory()->CopyFixedArray(fixed_array_values);
+ copied_elements_values = fixed_array_values_copy;
+ for (int i = 0; i < fixed_array_values->length(); i++) {
+ if (fixed_array_values->get(i)->IsFixedArray()) {
+ // The value contains the constant_properties of a
+ // simple object or array literal.
+ Handle<FixedArray> fa(FixedArray::cast(fixed_array_values->get(i)));
+ Handle<Object> result;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, result, CreateLiteralBoilerplate(isolate, literals, fa),
+ Object);
+ fixed_array_values_copy->set(i, *result);
+ }
+ }
+ }
+ }
+ object->set_elements(*copied_elements_values);
+ object->set_length(Smi::FromInt(copied_elements_values->length()));
+
+ JSObject::ValidateElements(object);
+ return object;
+}
+
+
+MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
+ Isolate* isolate, Handle<FixedArray> literals, Handle<FixedArray> array) {
+ Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
+ const bool kHasNoFunctionLiteral = false;
+ switch (CompileTimeValue::GetLiteralType(array)) {
+ case CompileTimeValue::OBJECT_LITERAL_FAST_ELEMENTS:
+ return CreateObjectLiteralBoilerplate(isolate, literals, elements, true,
+ kHasNoFunctionLiteral);
+ case CompileTimeValue::OBJECT_LITERAL_SLOW_ELEMENTS:
+ return CreateObjectLiteralBoilerplate(isolate, literals, elements, false,
+ kHasNoFunctionLiteral);
+ case CompileTimeValue::ARRAY_LITERAL:
+ return Runtime::CreateArrayLiteralBoilerplate(isolate, literals,
+ elements);
+ default:
+ UNREACHABLE();
+ return MaybeHandle<Object>();
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreateObjectLiteral) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
+ CONVERT_SMI_ARG_CHECKED(literals_index, 1);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, constant_properties, 2);
+ CONVERT_SMI_ARG_CHECKED(flags, 3);
+ bool should_have_fast_elements = (flags & ObjectLiteral::kFastElements) != 0;
+ bool has_function_literal = (flags & ObjectLiteral::kHasFunction) != 0;
+
+ RUNTIME_ASSERT(literals_index >= 0 && literals_index < literals->length());
+
+ // Check if boilerplate exists. If not, create it first.
+ Handle<Object> literal_site(literals->get(literals_index), isolate);
+ Handle<AllocationSite> site;
+ Handle<JSObject> boilerplate;
+ if (*literal_site == isolate->heap()->undefined_value()) {
+ Handle<Object> raw_boilerplate;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, raw_boilerplate,
+ CreateObjectLiteralBoilerplate(isolate, literals, constant_properties,
+ should_have_fast_elements,
+ has_function_literal));
+ boilerplate = Handle<JSObject>::cast(raw_boilerplate);
+
+ AllocationSiteCreationContext creation_context(isolate);
+ site = creation_context.EnterNewScope();
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::DeepWalk(boilerplate, &creation_context));
+ creation_context.ExitScope(site, boilerplate);
+
+ // Update the functions literal and return the boilerplate.
+ literals->set(literals_index, *site);
+ } else {
+ site = Handle<AllocationSite>::cast(literal_site);
+ boilerplate =
+ Handle<JSObject>(JSObject::cast(site->transition_info()), isolate);
+ }
+
+ AllocationSiteUsageContext usage_context(isolate, site, true);
+ usage_context.EnterNewScope();
+ MaybeHandle<Object> maybe_copy =
+ JSObject::DeepCopy(boilerplate, &usage_context);
+ usage_context.ExitScope(site, boilerplate);
+ Handle<Object> copy;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, copy, maybe_copy);
+ return *copy;
+}
+
+
+MUST_USE_RESULT static MaybeHandle<AllocationSite> GetLiteralAllocationSite(
+ Isolate* isolate, Handle<FixedArray> literals, int literals_index,
+ Handle<FixedArray> elements) {
+ // Check if boilerplate exists. If not, create it first.
+ Handle<Object> literal_site(literals->get(literals_index), isolate);
+ Handle<AllocationSite> site;
+ if (*literal_site == isolate->heap()->undefined_value()) {
+ DCHECK(*elements != isolate->heap()->empty_fixed_array());
+ Handle<Object> boilerplate;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, boilerplate,
+ Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements),
+ AllocationSite);
+
+ AllocationSiteCreationContext creation_context(isolate);
+ site = creation_context.EnterNewScope();
+ if (JSObject::DeepWalk(Handle<JSObject>::cast(boilerplate),
+ &creation_context).is_null()) {
+ return Handle<AllocationSite>::null();
+ }
+ creation_context.ExitScope(site, Handle<JSObject>::cast(boilerplate));
+
+ literals->set(literals_index, *site);
+ } else {
+ site = Handle<AllocationSite>::cast(literal_site);
+ }
+
+ return site;
+}
+
+
+static MaybeHandle<JSObject> CreateArrayLiteralImpl(Isolate* isolate,
+ Handle<FixedArray> literals,
+ int literals_index,
+ Handle<FixedArray> elements,
+ int flags) {
+ RUNTIME_ASSERT_HANDLIFIED(
+ literals_index >= 0 && literals_index < literals->length(), JSObject);
+ Handle<AllocationSite> site;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, site,
+ GetLiteralAllocationSite(isolate, literals, literals_index, elements),
+ JSObject);
+
+ bool enable_mementos = (flags & ArrayLiteral::kDisableMementos) == 0;
+ Handle<JSObject> boilerplate(JSObject::cast(site->transition_info()));
+ AllocationSiteUsageContext usage_context(isolate, site, enable_mementos);
+ usage_context.EnterNewScope();
+ JSObject::DeepCopyHints hints = (flags & ArrayLiteral::kShallowElements) == 0
+ ? JSObject::kNoHints
+ : JSObject::kObjectIsShallow;
+ MaybeHandle<JSObject> copy =
+ JSObject::DeepCopy(boilerplate, &usage_context, hints);
+ usage_context.ExitScope(site, boilerplate);
+ return copy;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreateArrayLiteral) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
+ CONVERT_SMI_ARG_CHECKED(literals_index, 1);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
+ CONVERT_SMI_ARG_CHECKED(flags, 3);
+
+ Handle<JSObject> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, CreateArrayLiteralImpl(isolate, literals, literals_index,
+ elements, flags));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreateArrayLiteralStubBailout) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
+ CONVERT_SMI_ARG_CHECKED(literals_index, 1);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
+
+ Handle<JSObject> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ CreateArrayLiteralImpl(isolate, literals, literals_index, elements,
+ ArrayLiteral::kShallowElements));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreArrayLiteralElement) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 5);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_SMI_ARG_CHECKED(store_index, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 3);
+ CONVERT_SMI_ARG_CHECKED(literal_index, 4);
+
+ Object* raw_literal_cell = literals->get(literal_index);
+ JSArray* boilerplate = NULL;
+ if (raw_literal_cell->IsAllocationSite()) {
+ AllocationSite* site = AllocationSite::cast(raw_literal_cell);
+ boilerplate = JSArray::cast(site->transition_info());
+ } else {
+ boilerplate = JSArray::cast(raw_literal_cell);
+ }
+ Handle<JSArray> boilerplate_object(boilerplate);
+ ElementsKind elements_kind = object->GetElementsKind();
+ DCHECK(IsFastElementsKind(elements_kind));
+ // Smis should never trigger transitions.
+ DCHECK(!value->IsSmi());
+
+ if (value->IsNumber()) {
+ DCHECK(IsFastSmiElementsKind(elements_kind));
+ ElementsKind transitioned_kind = IsFastHoleyElementsKind(elements_kind)
+ ? FAST_HOLEY_DOUBLE_ELEMENTS
+ : FAST_DOUBLE_ELEMENTS;
+ if (IsMoreGeneralElementsKindTransition(
+ boilerplate_object->GetElementsKind(), transitioned_kind)) {
+ JSObject::TransitionElementsKind(boilerplate_object, transitioned_kind);
+ }
+ JSObject::TransitionElementsKind(object, transitioned_kind);
+ DCHECK(IsFastDoubleElementsKind(object->GetElementsKind()));
+ FixedDoubleArray* double_array = FixedDoubleArray::cast(object->elements());
+ HeapNumber* number = HeapNumber::cast(*value);
+ double_array->set(store_index, number->Number());
+ } else {
+ if (!IsFastObjectElementsKind(elements_kind)) {
+ ElementsKind transitioned_kind = IsFastHoleyElementsKind(elements_kind)
+ ? FAST_HOLEY_ELEMENTS
+ : FAST_ELEMENTS;
+ JSObject::TransitionElementsKind(object, transitioned_kind);
+ ElementsKind boilerplate_elements_kind =
+ boilerplate_object->GetElementsKind();
+ if (IsMoreGeneralElementsKindTransition(boilerplate_elements_kind,
+ transitioned_kind)) {
+ JSObject::TransitionElementsKind(boilerplate_object, transitioned_kind);
+ }
+ }
+ FixedArray* object_array = FixedArray::cast(object->elements());
+ object_array->set(store_index, *value);
+ }
+ return *object;
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/debug.h"
+#include "src/liveedit.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+
+static int FindSharedFunctionInfosForScript(HeapIterator* iterator,
+ Script* script,
+ FixedArray* buffer) {
+ DisallowHeapAllocation no_allocation;
+ int counter = 0;
+ int buffer_size = buffer->length();
+ for (HeapObject* obj = iterator->next(); obj != NULL;
+ obj = iterator->next()) {
+ DCHECK(obj != NULL);
+ if (!obj->IsSharedFunctionInfo()) {
+ continue;
+ }
+ SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
+ if (shared->script() != script) {
+ continue;
+ }
+ if (counter < buffer_size) {
+ buffer->set(counter, shared);
+ }
+ counter++;
+ }
+ return counter;
+}
+
+
+// For a script finds all SharedFunctionInfo's in the heap that points
+// to this script. Returns JSArray of SharedFunctionInfo wrapped
+// in OpaqueReferences.
+RUNTIME_FUNCTION(Runtime_LiveEditFindSharedFunctionInfosForScript) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSValue, script_value, 0);
+
+ RUNTIME_ASSERT(script_value->value()->IsScript());
+ Handle<Script> script = Handle<Script>(Script::cast(script_value->value()));
+
+ const int kBufferSize = 32;
+
+ Handle<FixedArray> array;
+ array = isolate->factory()->NewFixedArray(kBufferSize);
+ int number;
+ Heap* heap = isolate->heap();
+ {
+ HeapIterator heap_iterator(heap);
+ Script* scr = *script;
+ FixedArray* arr = *array;
+ number = FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
+ }
+ if (number > kBufferSize) {
+ array = isolate->factory()->NewFixedArray(number);
+ HeapIterator heap_iterator(heap);
+ Script* scr = *script;
+ FixedArray* arr = *array;
+ FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
+ }
+
+ Handle<JSArray> result = isolate->factory()->NewJSArrayWithElements(array);
+ result->set_length(Smi::FromInt(number));
+
+ LiveEdit::WrapSharedFunctionInfos(result);
+
+ return *result;
+}
+
+
+// For a script calculates compilation information about all its functions.
+// The script source is explicitly specified by the second argument.
+// The source of the actual script is not used, however it is important that
+// all generated code keeps references to this particular instance of script.
+// Returns a JSArray of compilation infos. The array is ordered so that
+// each function with all its descendant is always stored in a continues range
+// with the function itself going first. The root function is a script function.
+RUNTIME_FUNCTION(Runtime_LiveEditGatherCompileInfo) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(JSValue, script, 0);
+ CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
+
+ RUNTIME_ASSERT(script->value()->IsScript());
+ Handle<Script> script_handle = Handle<Script>(Script::cast(script->value()));
+
+ Handle<JSArray> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, LiveEdit::GatherCompileInfo(script_handle, source));
+ return *result;
+}
+
+
+// Changes the source of the script to a new_source.
+// If old_script_name is provided (i.e. is a String), also creates a copy of
+// the script with its original source and sends notification to debugger.
+RUNTIME_FUNCTION(Runtime_LiveEditReplaceScript) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_CHECKED(JSValue, original_script_value, 0);
+ CONVERT_ARG_HANDLE_CHECKED(String, new_source, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, old_script_name, 2);
+
+ RUNTIME_ASSERT(original_script_value->value()->IsScript());
+ Handle<Script> original_script(Script::cast(original_script_value->value()));
+
+ Handle<Object> old_script = LiveEdit::ChangeScriptSource(
+ original_script, new_source, old_script_name);
+
+ if (old_script->IsScript()) {
+ Handle<Script> script_handle = Handle<Script>::cast(old_script);
+ return *Script::GetWrapper(script_handle);
+ } else {
+ return isolate->heap()->null_value();
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_LiveEditFunctionSourceUpdated) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_info, 0);
+ RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_info));
+
+ LiveEdit::FunctionSourceUpdated(shared_info);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Replaces code of SharedFunctionInfo with a new one.
+RUNTIME_FUNCTION(Runtime_LiveEditReplaceFunctionCode) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, new_compile_info, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_info, 1);
+ RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_info));
+
+ LiveEdit::ReplaceFunctionCode(new_compile_info, shared_info);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Connects SharedFunctionInfo to another script.
+RUNTIME_FUNCTION(Runtime_LiveEditFunctionSetScript) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, script_object, 1);
+
+ if (function_object->IsJSValue()) {
+ Handle<JSValue> function_wrapper = Handle<JSValue>::cast(function_object);
+ if (script_object->IsJSValue()) {
+ RUNTIME_ASSERT(JSValue::cast(*script_object)->value()->IsScript());
+ Script* script = Script::cast(JSValue::cast(*script_object)->value());
+ script_object = Handle<Object>(script, isolate);
+ }
+ RUNTIME_ASSERT(function_wrapper->value()->IsSharedFunctionInfo());
+ LiveEdit::SetFunctionScript(function_wrapper, script_object);
+ } else {
+ // Just ignore this. We may not have a SharedFunctionInfo for some functions
+ // and we check it in this function.
+ }
+
+ return isolate->heap()->undefined_value();
+}
+
+
+// In a code of a parent function replaces original function as embedded object
+// with a substitution one.
+RUNTIME_FUNCTION(Runtime_LiveEditReplaceRefToNestedFunction) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 3);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSValue, parent_wrapper, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSValue, orig_wrapper, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSValue, subst_wrapper, 2);
+ RUNTIME_ASSERT(parent_wrapper->value()->IsSharedFunctionInfo());
+ RUNTIME_ASSERT(orig_wrapper->value()->IsSharedFunctionInfo());
+ RUNTIME_ASSERT(subst_wrapper->value()->IsSharedFunctionInfo());
+
+ LiveEdit::ReplaceRefToNestedFunction(parent_wrapper, orig_wrapper,
+ subst_wrapper);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Updates positions of a shared function info (first parameter) according
+// to script source change. Text change is described in second parameter as
+// array of groups of 3 numbers:
+// (change_begin, change_end, change_end_new_position).
+// Each group describes a change in text; groups are sorted by change_begin.
+RUNTIME_FUNCTION(Runtime_LiveEditPatchFunctionPositions) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_array, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, position_change_array, 1);
+ RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_array))
+
+ LiveEdit::PatchFunctionPositions(shared_array, position_change_array);
+ return isolate->heap()->undefined_value();
+}
+
+
+// For array of SharedFunctionInfo's (each wrapped in JSValue)
+// checks that none of them have activations on stacks (of any thread).
+// Returns array of the same length with corresponding results of
+// LiveEdit::FunctionPatchabilityStatus type.
+RUNTIME_FUNCTION(Runtime_LiveEditCheckAndDropActivations) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_array, 0);
+ CONVERT_BOOLEAN_ARG_CHECKED(do_drop, 1);
+ RUNTIME_ASSERT(shared_array->length()->IsSmi());
+ RUNTIME_ASSERT(shared_array->HasFastElements())
+ int array_length = Smi::cast(shared_array->length())->value();
+ for (int i = 0; i < array_length; i++) {
+ Handle<Object> element =
+ Object::GetElement(isolate, shared_array, i).ToHandleChecked();
+ RUNTIME_ASSERT(
+ element->IsJSValue() &&
+ Handle<JSValue>::cast(element)->value()->IsSharedFunctionInfo());
+ }
+
+ return *LiveEdit::CheckAndDropActivations(shared_array, do_drop);
+}
+
+
+// Compares 2 strings line-by-line, then token-wise and returns diff in form
+// of JSArray of triplets (pos1, pos1_end, pos2_end) describing list
+// of diff chunks.
+RUNTIME_FUNCTION(Runtime_LiveEditCompareStrings) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(String, s1, 0);
+ CONVERT_ARG_HANDLE_CHECKED(String, s2, 1);
+
+ return *LiveEdit::CompareStrings(s1, s2);
+}
+
+
+// Restarts a call frame and completely drops all frames above.
+// Returns true if successful. Otherwise returns undefined or an error message.
+RUNTIME_FUNCTION(Runtime_LiveEditRestartFrame) {
+ HandleScope scope(isolate);
+ CHECK(isolate->debug()->live_edit_enabled());
+ DCHECK(args.length() == 2);
+ CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
+ RUNTIME_ASSERT(isolate->debug()->CheckExecutionState(break_id));
+
+ CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
+ Heap* heap = isolate->heap();
+
+ // Find the relevant frame with the requested index.
+ StackFrame::Id id = isolate->debug()->break_frame_id();
+ if (id == StackFrame::NO_ID) {
+ // If there are no JavaScript stack frames return undefined.
+ return heap->undefined_value();
+ }
+
+ JavaScriptFrameIterator it(isolate, id);
+ int inlined_jsframe_index = Runtime::FindIndexedNonNativeFrame(&it, index);
+ if (inlined_jsframe_index == -1) return heap->undefined_value();
+ // We don't really care what the inlined frame index is, since we are
+ // throwing away the entire frame anyways.
+ const char* error_message = LiveEdit::RestartFrame(it.frame());
+ if (error_message) {
+ return *(isolate->factory()->InternalizeUtf8String(error_message));
+ }
+ return heap->true_value();
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/assembler.h"
#include "src/codegen.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
-#include "third_party/fdlibm/fdlibm.h"
+#include "src/third_party/fdlibm/fdlibm.h"
namespace v8 {
DCHECK(args.length() == 1);
CONVERT_DOUBLE_ARG_CHECKED(x, 0);
Factory* factory = isolate->factory();
- double y[2];
+ double y[2] = {0.0, 0.0};
int n = fdlibm::rempio2(x, y);
Handle<FixedArray> array = factory->NewFixedArray(3);
Handle<HeapNumber> y0 = factory->NewHeapNumber(y[0]);
#include "src/v8.h"
#include "src/arguments.h"
+#include "src/base/bits.h"
+#include "src/bootstrapper.h"
#include "src/codegen.h"
-#include "src/misc-intrinsics.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
}
return *isolate->factory()->NewNumber(
- StringToDouble(isolate->unicode_cache(), *subject, flags));
+ StringToDouble(isolate->unicode_cache(), subject, flags));
}
DCHECK(args.length() == 1);
CONVERT_ARG_HANDLE_CHECKED(String, subject, 0);
- subject = String::Flatten(subject);
- double value = StringToDouble(isolate->unicode_cache(), *subject,
+ double value = StringToDouble(isolate->unicode_cache(), subject,
ALLOW_TRAILING_JUNK, base::OS::nan_value());
return *isolate->factory()->NewNumber(value);
// integer comes first in the lexicographic order.
// From http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
- int x_log2 = IntegerLog2(x_scaled);
+ int x_log2 = 31 - base::bits::CountLeadingZeros32(x_scaled);
int x_log10 = ((x_log2 + 1) * 1233) >> 12;
x_log10 -= x_scaled < kPowersOf10[x_log10];
- int y_log2 = IntegerLog2(y_scaled);
+ int y_log2 = 31 - base::bits::CountLeadingZeros32(y_scaled);
int y_log10 = ((y_log2 + 1) * 1233) >> 12;
y_log10 -= y_scaled < kPowersOf10[y_log10];
}
+RUNTIME_FUNCTION(Runtime_GetRootNaN) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ RUNTIME_ASSERT(isolate->bootstrapper()->IsActive());
+ return isolate->heap()->nan_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_MaxSmi) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ return Smi::FromInt(Smi::kMaxValue);
+}
+
+
RUNTIME_FUNCTION(RuntimeReference_NumberToString) {
SealHandleScope shs(isolate);
return __RT_impl_Runtime_NumberToStringRT(args, isolate);
}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsSmi) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsSmi());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsNonNegativeSmi) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsSmi() &&
+ Smi::cast(obj)->value() >= 0);
+}
}
} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/bootstrapper.h"
+#include "src/debug.h"
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+// Returns a single character string where first character equals
+// string->Get(index).
+static Handle<Object> GetCharAt(Handle<String> string, uint32_t index) {
+ if (index < static_cast<uint32_t>(string->length())) {
+ Factory* factory = string->GetIsolate()->factory();
+ return factory->LookupSingleCharacterStringFromCode(
+ String::Flatten(string)->Get(index));
+ }
+ return Execution::CharAt(string, index);
+}
+
+
+MaybeHandle<Object> Runtime::GetElementOrCharAt(Isolate* isolate,
+ Handle<Object> object,
+ uint32_t index) {
+ // Handle [] indexing on Strings
+ if (object->IsString()) {
+ Handle<Object> result = GetCharAt(Handle<String>::cast(object), index);
+ if (!result->IsUndefined()) return result;
+ }
+
+ // Handle [] indexing on String objects
+ if (object->IsStringObjectWithCharacterAt(index)) {
+ Handle<JSValue> js_value = Handle<JSValue>::cast(object);
+ Handle<Object> result =
+ GetCharAt(Handle<String>(String::cast(js_value->value())), index);
+ if (!result->IsUndefined()) return result;
+ }
+
+ Handle<Object> result;
+ if (object->IsString() || object->IsNumber() || object->IsBoolean()) {
+ PrototypeIterator iter(isolate, object);
+ return Object::GetElement(isolate, PrototypeIterator::GetCurrent(iter),
+ index);
+ } else {
+ return Object::GetElement(isolate, object, index);
+ }
+}
+
+
+MaybeHandle<Name> Runtime::ToName(Isolate* isolate, Handle<Object> key) {
+ if (key->IsName()) {
+ return Handle<Name>::cast(key);
+ } else {
+ Handle<Object> converted;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
+ Execution::ToString(isolate, key), Name);
+ return Handle<Name>::cast(converted);
+ }
+}
+
+
+MaybeHandle<Object> Runtime::GetObjectProperty(Isolate* isolate,
+ Handle<Object> object,
+ Handle<Object> key) {
+ if (object->IsUndefined() || object->IsNull()) {
+ Handle<Object> args[2] = {key, object};
+ THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_load",
+ HandleVector(args, 2)),
+ Object);
+ }
+
+ // Check if the given key is an array index.
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ return GetElementOrCharAt(isolate, object, index);
+ }
+
+ // Convert the key to a name - possibly by calling back into JavaScript.
+ Handle<Name> name;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, name, ToName(isolate, key), Object);
+
+ // Check if the name is trivially convertible to an index and get
+ // the element if so.
+ if (name->AsArrayIndex(&index)) {
+ return GetElementOrCharAt(isolate, object, index);
+ } else {
+ return Object::GetProperty(object, name);
+ }
+}
+
+
+MaybeHandle<Object> Runtime::SetObjectProperty(Isolate* isolate,
+ Handle<Object> object,
+ Handle<Object> key,
+ Handle<Object> value,
+ StrictMode strict_mode) {
+ if (object->IsUndefined() || object->IsNull()) {
+ Handle<Object> args[2] = {key, object};
+ THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_store",
+ HandleVector(args, 2)),
+ Object);
+ }
+
+ if (object->IsJSProxy()) {
+ Handle<Object> name_object;
+ if (key->IsSymbol()) {
+ name_object = key;
+ } else {
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, name_object,
+ Execution::ToString(isolate, key), Object);
+ }
+ Handle<Name> name = Handle<Name>::cast(name_object);
+ return Object::SetProperty(Handle<JSProxy>::cast(object), name, value,
+ strict_mode);
+ }
+
+ // Check if the given key is an array index.
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ // TODO(verwaest): Support non-JSObject receivers.
+ if (!object->IsJSObject()) return value;
+ Handle<JSObject> js_object = Handle<JSObject>::cast(object);
+
+ // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
+ // of a string using [] notation. We need to support this too in
+ // JavaScript.
+ // In the case of a String object we just need to redirect the assignment to
+ // the underlying string if the index is in range. Since the underlying
+ // string does nothing with the assignment then we can ignore such
+ // assignments.
+ if (js_object->IsStringObjectWithCharacterAt(index)) {
+ return value;
+ }
+
+ JSObject::ValidateElements(js_object);
+ if (js_object->HasExternalArrayElements() ||
+ js_object->HasFixedTypedArrayElements()) {
+ if (!value->IsNumber() && !value->IsUndefined()) {
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, value,
+ Execution::ToNumber(isolate, value), Object);
+ }
+ }
+
+ MaybeHandle<Object> result = JSObject::SetElement(
+ js_object, index, value, NONE, strict_mode, true, SET_PROPERTY);
+ JSObject::ValidateElements(js_object);
+
+ return result.is_null() ? result : value;
+ }
+
+ if (key->IsName()) {
+ Handle<Name> name = Handle<Name>::cast(key);
+ if (name->AsArrayIndex(&index)) {
+ // TODO(verwaest): Support non-JSObject receivers.
+ if (!object->IsJSObject()) return value;
+ Handle<JSObject> js_object = Handle<JSObject>::cast(object);
+ if (js_object->HasExternalArrayElements()) {
+ if (!value->IsNumber() && !value->IsUndefined()) {
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, Execution::ToNumber(isolate, value), Object);
+ }
+ }
+ return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
+ true, SET_PROPERTY);
+ } else {
+ if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
+ return Object::SetProperty(object, name, value, strict_mode);
+ }
+ }
+
+ // Call-back into JavaScript to convert the key to a string.
+ Handle<Object> converted;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
+ Execution::ToString(isolate, key), Object);
+ Handle<String> name = Handle<String>::cast(converted);
+
+ if (name->AsArrayIndex(&index)) {
+ // TODO(verwaest): Support non-JSObject receivers.
+ if (!object->IsJSObject()) return value;
+ Handle<JSObject> js_object = Handle<JSObject>::cast(object);
+ return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
+ true, SET_PROPERTY);
+ }
+ return Object::SetProperty(object, name, value, strict_mode);
+}
+
+
+MaybeHandle<Object> Runtime::DefineObjectProperty(Handle<JSObject> js_object,
+ Handle<Object> key,
+ Handle<Object> value,
+ PropertyAttributes attr) {
+ Isolate* isolate = js_object->GetIsolate();
+ // Check if the given key is an array index.
+ uint32_t index;
+ if (key->ToArrayIndex(&index)) {
+ // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
+ // of a string using [] notation. We need to support this too in
+ // JavaScript.
+ // In the case of a String object we just need to redirect the assignment to
+ // the underlying string if the index is in range. Since the underlying
+ // string does nothing with the assignment then we can ignore such
+ // assignments.
+ if (js_object->IsStringObjectWithCharacterAt(index)) {
+ return value;
+ }
+
+ return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
+ DEFINE_PROPERTY);
+ }
+
+ if (key->IsName()) {
+ Handle<Name> name = Handle<Name>::cast(key);
+ if (name->AsArrayIndex(&index)) {
+ return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
+ DEFINE_PROPERTY);
+ } else {
+ if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
+ return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
+ attr);
+ }
+ }
+
+ // Call-back into JavaScript to convert the key to a string.
+ Handle<Object> converted;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
+ Execution::ToString(isolate, key), Object);
+ Handle<String> name = Handle<String>::cast(converted);
+
+ if (name->AsArrayIndex(&index)) {
+ return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
+ DEFINE_PROPERTY);
+ } else {
+ return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
+ attr);
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetPrototype) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);
+ // We don't expect access checks to be needed on JSProxy objects.
+ DCHECK(!obj->IsAccessCheckNeeded() || obj->IsJSObject());
+ PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
+ do {
+ if (PrototypeIterator::GetCurrent(iter)->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
+ isolate->factory()->proto_string(), v8::ACCESS_GET)) {
+ isolate->ReportFailedAccessCheck(
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
+ v8::ACCESS_GET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return isolate->heap()->undefined_value();
+ }
+ iter.AdvanceIgnoringProxies();
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
+ return *PrototypeIterator::GetCurrent(iter);
+ }
+ } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
+ return *PrototypeIterator::GetCurrent(iter);
+}
+
+
+RUNTIME_FUNCTION(Runtime_InternalSetPrototype) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
+ DCHECK(!obj->IsAccessCheckNeeded());
+ DCHECK(!obj->map()->is_observed());
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSObject::SetPrototype(obj, prototype, false));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_SetPrototype) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
+ if (obj->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(obj, isolate->factory()->proto_string(),
+ v8::ACCESS_SET)) {
+ isolate->ReportFailedAccessCheck(obj, v8::ACCESS_SET);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return isolate->heap()->undefined_value();
+ }
+ if (obj->map()->is_observed()) {
+ Handle<Object> old_value =
+ Object::GetPrototypeSkipHiddenPrototypes(isolate, obj);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSObject::SetPrototype(obj, prototype, true));
+
+ Handle<Object> new_value =
+ Object::GetPrototypeSkipHiddenPrototypes(isolate, obj);
+ if (!new_value->SameValue(*old_value)) {
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::EnqueueChangeRecord(
+ obj, "setPrototype", isolate->factory()->proto_string(),
+ old_value));
+ }
+ return *result;
+ }
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSObject::SetPrototype(obj, prototype, true));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsInPrototypeChain) {
+ HandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ // See ECMA-262, section 15.3.5.3, page 88 (steps 5 - 8).
+ CONVERT_ARG_HANDLE_CHECKED(Object, O, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, V, 1);
+ PrototypeIterator iter(isolate, V, PrototypeIterator::START_AT_RECEIVER);
+ while (true) {
+ iter.AdvanceIgnoringProxies();
+ if (iter.IsAtEnd()) return isolate->heap()->false_value();
+ if (iter.IsAtEnd(O)) return isolate->heap()->true_value();
+ }
+}
+
+
+// Enumerator used as indices into the array returned from GetOwnProperty
+enum PropertyDescriptorIndices {
+ IS_ACCESSOR_INDEX,
+ VALUE_INDEX,
+ GETTER_INDEX,
+ SETTER_INDEX,
+ WRITABLE_INDEX,
+ ENUMERABLE_INDEX,
+ CONFIGURABLE_INDEX,
+ DESCRIPTOR_SIZE
+};
+
+
+MUST_USE_RESULT static MaybeHandle<Object> GetOwnProperty(Isolate* isolate,
+ Handle<JSObject> obj,
+ Handle<Name> name) {
+ Heap* heap = isolate->heap();
+ Factory* factory = isolate->factory();
+
+ PropertyAttributes attrs;
+ uint32_t index = 0;
+ Handle<Object> value;
+ MaybeHandle<AccessorPair> maybe_accessors;
+ // TODO(verwaest): Unify once indexed properties can be handled by the
+ // LookupIterator.
+ if (name->AsArrayIndex(&index)) {
+ // Get attributes.
+ Maybe<PropertyAttributes> maybe =
+ JSReceiver::GetOwnElementAttribute(obj, index);
+ if (!maybe.has_value) return MaybeHandle<Object>();
+ attrs = maybe.value;
+ if (attrs == ABSENT) return factory->undefined_value();
+
+ // Get AccessorPair if present.
+ maybe_accessors = JSObject::GetOwnElementAccessorPair(obj, index);
+
+ // Get value if not an AccessorPair.
+ if (maybe_accessors.is_null()) {
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, Runtime::GetElementOrCharAt(isolate, obj, index),
+ Object);
+ }
+ } else {
+ // Get attributes.
+ LookupIterator it(obj, name, LookupIterator::HIDDEN);
+ Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(&it);
+ if (!maybe.has_value) return MaybeHandle<Object>();
+ attrs = maybe.value;
+ if (attrs == ABSENT) return factory->undefined_value();
+
+ // Get AccessorPair if present.
+ if (it.state() == LookupIterator::ACCESSOR &&
+ it.GetAccessors()->IsAccessorPair()) {
+ maybe_accessors = Handle<AccessorPair>::cast(it.GetAccessors());
+ }
+
+ // Get value if not an AccessorPair.
+ if (maybe_accessors.is_null()) {
+ ASSIGN_RETURN_ON_EXCEPTION(isolate, value, Object::GetProperty(&it),
+ Object);
+ }
+ }
+ DCHECK(!isolate->has_pending_exception());
+ Handle<FixedArray> elms = factory->NewFixedArray(DESCRIPTOR_SIZE);
+ elms->set(ENUMERABLE_INDEX, heap->ToBoolean((attrs & DONT_ENUM) == 0));
+ elms->set(CONFIGURABLE_INDEX, heap->ToBoolean((attrs & DONT_DELETE) == 0));
+ elms->set(IS_ACCESSOR_INDEX, heap->ToBoolean(!maybe_accessors.is_null()));
+
+ Handle<AccessorPair> accessors;
+ if (maybe_accessors.ToHandle(&accessors)) {
+ Handle<Object> getter(accessors->GetComponent(ACCESSOR_GETTER), isolate);
+ Handle<Object> setter(accessors->GetComponent(ACCESSOR_SETTER), isolate);
+ elms->set(GETTER_INDEX, *getter);
+ elms->set(SETTER_INDEX, *setter);
+ } else {
+ elms->set(WRITABLE_INDEX, heap->ToBoolean((attrs & READ_ONLY) == 0));
+ elms->set(VALUE_INDEX, *value);
+ }
+
+ return factory->NewJSArrayWithElements(elms);
+}
+
+
+// Returns an array with the property description:
+// if args[1] is not a property on args[0]
+// returns undefined
+// if args[1] is a data property on args[0]
+// [false, value, Writeable, Enumerable, Configurable]
+// if args[1] is an accessor on args[0]
+// [true, GetFunction, SetFunction, Enumerable, Configurable]
+RUNTIME_FUNCTION(Runtime_GetOwnProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+ GetOwnProperty(isolate, obj, name));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_PreventExtensions) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+ JSObject::PreventExtensions(obj));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsExtensible) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSObject, obj, 0);
+ if (obj->IsJSGlobalProxy()) {
+ PrototypeIterator iter(isolate, obj);
+ if (iter.IsAtEnd()) return isolate->heap()->false_value();
+ DCHECK(iter.GetCurrent()->IsJSGlobalObject());
+ obj = JSObject::cast(iter.GetCurrent());
+ }
+ return isolate->heap()->ToBoolean(obj->map()->is_extensible());
+}
+
+
+RUNTIME_FUNCTION(Runtime_DisableAccessChecks) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(HeapObject, object, 0);
+ Handle<Map> old_map(object->map());
+ bool needs_access_checks = old_map->is_access_check_needed();
+ if (needs_access_checks) {
+ // Copy map so it won't interfere constructor's initial map.
+ Handle<Map> new_map = Map::Copy(old_map);
+ new_map->set_is_access_check_needed(false);
+ JSObject::MigrateToMap(Handle<JSObject>::cast(object), new_map);
+ }
+ return isolate->heap()->ToBoolean(needs_access_checks);
+}
+
+
+RUNTIME_FUNCTION(Runtime_EnableAccessChecks) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ Handle<Map> old_map(object->map());
+ RUNTIME_ASSERT(!old_map->is_access_check_needed());
+ // Copy map so it won't interfere constructor's initial map.
+ Handle<Map> new_map = Map::Copy(old_map);
+ new_map->set_is_access_check_needed(true);
+ JSObject::MigrateToMap(object, new_map);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_OptimizeObjectForAddingMultipleProperties) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_SMI_ARG_CHECKED(properties, 1);
+ // Conservative upper limit to prevent fuzz tests from going OOM.
+ RUNTIME_ASSERT(properties <= 100000);
+ if (object->HasFastProperties() && !object->IsJSGlobalProxy()) {
+ JSObject::NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, properties);
+ }
+ return *object;
+}
+
+
+RUNTIME_FUNCTION(Runtime_ObjectFreeze) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+
+ // %ObjectFreeze is a fast path and these cases are handled elsewhere.
+ RUNTIME_ASSERT(!object->HasSloppyArgumentsElements() &&
+ !object->map()->is_observed() && !object->IsJSProxy());
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, JSObject::Freeze(object));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, Runtime::GetObjectProperty(isolate, object, key));
+ return *result;
+}
+
+
+MUST_USE_RESULT static MaybeHandle<Object> TransitionElements(
+ Handle<Object> object, ElementsKind to_kind, Isolate* isolate) {
+ HandleScope scope(isolate);
+ if (!object->IsJSObject()) {
+ isolate->ThrowIllegalOperation();
+ return MaybeHandle<Object>();
+ }
+ ElementsKind from_kind =
+ Handle<JSObject>::cast(object)->map()->elements_kind();
+ if (Map::IsValidElementsTransition(from_kind, to_kind)) {
+ JSObject::TransitionElementsKind(Handle<JSObject>::cast(object), to_kind);
+ return object;
+ }
+ isolate->ThrowIllegalOperation();
+ return MaybeHandle<Object>();
+}
+
+
+// KeyedGetProperty is called from KeyedLoadIC::GenerateGeneric.
+RUNTIME_FUNCTION(Runtime_KeyedGetProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(Object, receiver_obj, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key_obj, 1);
+
+ // Fast cases for getting named properties of the receiver JSObject
+ // itself.
+ //
+ // The global proxy objects has to be excluded since LookupOwn on
+ // the global proxy object can return a valid result even though the
+ // global proxy object never has properties. This is the case
+ // because the global proxy object forwards everything to its hidden
+ // prototype including own lookups.
+ //
+ // Additionally, we need to make sure that we do not cache results
+ // for objects that require access checks.
+ if (receiver_obj->IsJSObject()) {
+ if (!receiver_obj->IsJSGlobalProxy() &&
+ !receiver_obj->IsAccessCheckNeeded() && key_obj->IsName()) {
+ DisallowHeapAllocation no_allocation;
+ Handle<JSObject> receiver = Handle<JSObject>::cast(receiver_obj);
+ Handle<Name> key = Handle<Name>::cast(key_obj);
+ if (receiver->HasFastProperties()) {
+ // Attempt to use lookup cache.
+ Handle<Map> receiver_map(receiver->map(), isolate);
+ KeyedLookupCache* keyed_lookup_cache = isolate->keyed_lookup_cache();
+ int index = keyed_lookup_cache->Lookup(receiver_map, key);
+ if (index != -1) {
+ // Doubles are not cached, so raw read the value.
+ return receiver->RawFastPropertyAt(
+ FieldIndex::ForKeyedLookupCacheIndex(*receiver_map, index));
+ }
+ // Lookup cache miss. Perform lookup and update the cache if
+ // appropriate.
+ LookupIterator it(receiver, key, LookupIterator::OWN);
+ if (it.state() == LookupIterator::DATA &&
+ it.property_details().type() == FIELD) {
+ FieldIndex field_index = it.GetFieldIndex();
+ // Do not track double fields in the keyed lookup cache. Reading
+ // double values requires boxing.
+ if (!it.representation().IsDouble()) {
+ keyed_lookup_cache->Update(receiver_map, key,
+ field_index.GetKeyedLookupCacheIndex());
+ }
+ AllowHeapAllocation allow_allocation;
+ return *JSObject::FastPropertyAt(receiver, it.representation(),
+ field_index);
+ }
+ } else {
+ // Attempt dictionary lookup.
+ NameDictionary* dictionary = receiver->property_dictionary();
+ int entry = dictionary->FindEntry(key);
+ if ((entry != NameDictionary::kNotFound) &&
+ (dictionary->DetailsAt(entry).type() == NORMAL)) {
+ Object* value = dictionary->ValueAt(entry);
+ if (!receiver->IsGlobalObject()) return value;
+ value = PropertyCell::cast(value)->value();
+ if (!value->IsTheHole()) return value;
+ // If value is the hole (meaning, absent) do the general lookup.
+ }
+ }
+ } else if (key_obj->IsSmi()) {
+ // JSObject without a name key. If the key is a Smi, check for a
+ // definite out-of-bounds access to elements, which is a strong indicator
+ // that subsequent accesses will also call the runtime. Proactively
+ // transition elements to FAST_*_ELEMENTS to avoid excessive boxing of
+ // doubles for those future calls in the case that the elements would
+ // become FAST_DOUBLE_ELEMENTS.
+ Handle<JSObject> js_object = Handle<JSObject>::cast(receiver_obj);
+ ElementsKind elements_kind = js_object->GetElementsKind();
+ if (IsFastDoubleElementsKind(elements_kind)) {
+ Handle<Smi> key = Handle<Smi>::cast(key_obj);
+ if (key->value() >= js_object->elements()->length()) {
+ if (IsFastHoleyElementsKind(elements_kind)) {
+ elements_kind = FAST_HOLEY_ELEMENTS;
+ } else {
+ elements_kind = FAST_ELEMENTS;
+ }
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, TransitionElements(js_object, elements_kind, isolate));
+ }
+ } else {
+ DCHECK(IsFastSmiOrObjectElementsKind(elements_kind) ||
+ !IsFastElementsKind(elements_kind));
+ }
+ }
+ } else if (receiver_obj->IsString() && key_obj->IsSmi()) {
+ // Fast case for string indexing using [] with a smi index.
+ Handle<String> str = Handle<String>::cast(receiver_obj);
+ int index = args.smi_at(1);
+ if (index >= 0 && index < str->length()) {
+ return *GetCharAt(str, index);
+ }
+ }
+
+ // Fall back to GetObjectProperty.
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Runtime::GetObjectProperty(isolate, receiver_obj, key_obj));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_AddNamedProperty) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 4);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+ CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
+ RUNTIME_ASSERT(
+ (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ // Compute attributes.
+ PropertyAttributes attributes =
+ static_cast<PropertyAttributes>(unchecked_attributes);
+
+#ifdef DEBUG
+ uint32_t index = 0;
+ DCHECK(!key->ToArrayIndex(&index));
+ LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ RUNTIME_ASSERT(!it.IsFound());
+#endif
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ JSObject::SetOwnPropertyIgnoreAttributes(object, key, value, attributes));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_SetProperty) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 4);
+
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+ CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_arg, 3);
+ StrictMode strict_mode = strict_mode_arg;
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Runtime::SetObjectProperty(isolate, object, key, value, strict_mode));
+ return *result;
+}
+
+
+// Adds an element to an array.
+// This is used to create an indexed data property into an array.
+RUNTIME_FUNCTION(Runtime_AddElement) {
+ HandleScope scope(isolate);
+ RUNTIME_ASSERT(args.length() == 4);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+ CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
+ RUNTIME_ASSERT(
+ (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ // Compute attributes.
+ PropertyAttributes attributes =
+ static_cast<PropertyAttributes>(unchecked_attributes);
+
+ uint32_t index = 0;
+ key->ToArrayIndex(&index);
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSObject::SetElement(object, index, value, attributes,
+ SLOPPY, false, DEFINE_PROPERTY));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeleteProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+ CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 2);
+ JSReceiver::DeleteMode delete_mode = strict_mode == STRICT
+ ? JSReceiver::STRICT_DELETION
+ : JSReceiver::NORMAL_DELETION;
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, JSReceiver::DeleteProperty(object, key, delete_mode));
+ return *result;
+}
+
+
+static Object* HasOwnPropertyImplementation(Isolate* isolate,
+ Handle<JSObject> object,
+ Handle<Name> key) {
+ Maybe<bool> maybe = JSReceiver::HasOwnProperty(object, key);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ if (maybe.value) return isolate->heap()->true_value();
+ // Handle hidden prototypes. If there's a hidden prototype above this thing
+ // then we have to check it for properties, because they are supposed to
+ // look like they are on this object.
+ PrototypeIterator iter(isolate, object);
+ if (!iter.IsAtEnd() &&
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter))
+ ->map()
+ ->is_hidden_prototype()) {
+ // TODO(verwaest): The recursion is not necessary for keys that are array
+ // indices. Removing this.
+ return HasOwnPropertyImplementation(
+ isolate, Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
+ key);
+ }
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return isolate->heap()->false_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_HasOwnProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0)
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+
+ uint32_t index;
+ const bool key_is_array_index = key->AsArrayIndex(&index);
+
+ // Only JS objects can have properties.
+ if (object->IsJSObject()) {
+ Handle<JSObject> js_obj = Handle<JSObject>::cast(object);
+ // Fast case: either the key is a real named property or it is not
+ // an array index and there are no interceptors or hidden
+ // prototypes.
+ Maybe<bool> maybe = JSObject::HasRealNamedProperty(js_obj, key);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ DCHECK(!isolate->has_pending_exception());
+ if (maybe.value) {
+ return isolate->heap()->true_value();
+ }
+ Map* map = js_obj->map();
+ if (!key_is_array_index && !map->has_named_interceptor() &&
+ !HeapObject::cast(map->prototype())->map()->is_hidden_prototype()) {
+ return isolate->heap()->false_value();
+ }
+ // Slow case.
+ return HasOwnPropertyImplementation(isolate, Handle<JSObject>(js_obj),
+ Handle<Name>(key));
+ } else if (object->IsString() && key_is_array_index) {
+ // Well, there is one exception: Handle [] on strings.
+ Handle<String> string = Handle<String>::cast(object);
+ if (index < static_cast<uint32_t>(string->length())) {
+ return isolate->heap()->true_value();
+ }
+ }
+ return isolate->heap()->false_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_HasProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+
+ Maybe<bool> maybe = JSReceiver::HasProperty(receiver, key);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ return isolate->heap()->ToBoolean(maybe.value);
+}
+
+
+RUNTIME_FUNCTION(Runtime_HasElement) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
+ CONVERT_SMI_ARG_CHECKED(index, 1);
+
+ Maybe<bool> maybe = JSReceiver::HasElement(receiver, index);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ return isolate->heap()->ToBoolean(maybe.value);
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsPropertyEnumerable) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+
+ Maybe<PropertyAttributes> maybe =
+ JSReceiver::GetOwnPropertyAttributes(object, key);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ if (maybe.value == ABSENT) maybe.value = DONT_ENUM;
+ return isolate->heap()->ToBoolean((maybe.value & DONT_ENUM) == 0);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetPropertyNames) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0);
+ Handle<JSArray> result;
+
+ isolate->counters()->for_in()->Increment();
+ Handle<FixedArray> elements;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, elements,
+ JSReceiver::GetKeys(object, JSReceiver::INCLUDE_PROTOS));
+ return *isolate->factory()->NewJSArrayWithElements(elements);
+}
+
+
+// Returns either a FixedArray as Runtime_GetPropertyNames,
+// or, if the given object has an enum cache that contains
+// all enumerable properties of the object and its prototypes
+// have none, the map of the object. This is used to speed up
+// the check for deletions during a for-in.
+RUNTIME_FUNCTION(Runtime_GetPropertyNamesFast) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_CHECKED(JSReceiver, raw_object, 0);
+
+ if (raw_object->IsSimpleEnum()) return raw_object->map();
+
+ HandleScope scope(isolate);
+ Handle<JSReceiver> object(raw_object);
+ Handle<FixedArray> content;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, content,
+ JSReceiver::GetKeys(object, JSReceiver::INCLUDE_PROTOS));
+
+ // Test again, since cache may have been built by preceding call.
+ if (object->IsSimpleEnum()) return object->map();
+
+ return *content;
+}
+
+
+// Find the length of the prototype chain that is to be handled as one. If a
+// prototype object is hidden it is to be viewed as part of the the object it
+// is prototype for.
+static int OwnPrototypeChainLength(JSObject* obj) {
+ int count = 1;
+ for (PrototypeIterator iter(obj->GetIsolate(), obj);
+ !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN); iter.Advance()) {
+ count++;
+ }
+ return count;
+}
+
+
+// Return the names of the own named properties.
+// args[0]: object
+// args[1]: PropertyAttributes as int
+RUNTIME_FUNCTION(Runtime_GetOwnPropertyNames) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ if (!args[0]->IsJSObject()) {
+ return isolate->heap()->undefined_value();
+ }
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ CONVERT_SMI_ARG_CHECKED(filter_value, 1);
+ PropertyAttributes filter = static_cast<PropertyAttributes>(filter_value);
+
+ // Skip the global proxy as it has no properties and always delegates to the
+ // real global object.
+ if (obj->IsJSGlobalProxy()) {
+ // Only collect names if access is permitted.
+ if (obj->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(obj, isolate->factory()->undefined_value(),
+ v8::ACCESS_KEYS)) {
+ isolate->ReportFailedAccessCheck(obj, v8::ACCESS_KEYS);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return *isolate->factory()->NewJSArray(0);
+ }
+ PrototypeIterator iter(isolate, obj);
+ obj = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ }
+
+ // Find the number of objects making up this.
+ int length = OwnPrototypeChainLength(*obj);
+
+ // Find the number of own properties for each of the objects.
+ ScopedVector<int> own_property_count(length);
+ int total_property_count = 0;
+ {
+ PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
+ for (int i = 0; i < length; i++) {
+ DCHECK(!iter.IsAtEnd());
+ Handle<JSObject> jsproto =
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ // Only collect names if access is permitted.
+ if (jsproto->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(jsproto,
+ isolate->factory()->undefined_value(),
+ v8::ACCESS_KEYS)) {
+ isolate->ReportFailedAccessCheck(jsproto, v8::ACCESS_KEYS);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return *isolate->factory()->NewJSArray(0);
+ }
+ int n;
+ n = jsproto->NumberOfOwnProperties(filter);
+ own_property_count[i] = n;
+ total_property_count += n;
+ iter.Advance();
+ }
+ }
+
+ // Allocate an array with storage for all the property names.
+ Handle<FixedArray> names =
+ isolate->factory()->NewFixedArray(total_property_count);
+
+ // Get the property names.
+ int next_copy_index = 0;
+ int hidden_strings = 0;
+ {
+ PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
+ for (int i = 0; i < length; i++) {
+ DCHECK(!iter.IsAtEnd());
+ Handle<JSObject> jsproto =
+ Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ jsproto->GetOwnPropertyNames(*names, next_copy_index, filter);
+ if (i > 0) {
+ // Names from hidden prototypes may already have been added
+ // for inherited function template instances. Count the duplicates
+ // and stub them out; the final copy pass at the end ignores holes.
+ for (int j = next_copy_index;
+ j < next_copy_index + own_property_count[i]; j++) {
+ Object* name_from_hidden_proto = names->get(j);
+ for (int k = 0; k < next_copy_index; k++) {
+ if (names->get(k) != isolate->heap()->hidden_string()) {
+ Object* name = names->get(k);
+ if (name_from_hidden_proto == name) {
+ names->set(j, isolate->heap()->hidden_string());
+ hidden_strings++;
+ break;
+ }
+ }
+ }
+ }
+ }
+ next_copy_index += own_property_count[i];
+
+ // Hidden properties only show up if the filter does not skip strings.
+ if ((filter & STRING) == 0 && JSObject::HasHiddenProperties(jsproto)) {
+ hidden_strings++;
+ }
+ iter.Advance();
+ }
+ }
+
+ // Filter out name of hidden properties object and
+ // hidden prototype duplicates.
+ if (hidden_strings > 0) {
+ Handle<FixedArray> old_names = names;
+ names = isolate->factory()->NewFixedArray(names->length() - hidden_strings);
+ int dest_pos = 0;
+ for (int i = 0; i < total_property_count; i++) {
+ Object* name = old_names->get(i);
+ if (name == isolate->heap()->hidden_string()) {
+ hidden_strings--;
+ continue;
+ }
+ names->set(dest_pos++, name);
+ }
+ DCHECK_EQ(0, hidden_strings);
+ }
+
+ return *isolate->factory()->NewJSArrayWithElements(names);
+}
+
+
+// Return the names of the own indexed properties.
+// args[0]: object
+RUNTIME_FUNCTION(Runtime_GetOwnElementNames) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ if (!args[0]->IsJSObject()) {
+ return isolate->heap()->undefined_value();
+ }
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+
+ int n = obj->NumberOfOwnElements(static_cast<PropertyAttributes>(NONE));
+ Handle<FixedArray> names = isolate->factory()->NewFixedArray(n);
+ obj->GetOwnElementKeys(*names, static_cast<PropertyAttributes>(NONE));
+ return *isolate->factory()->NewJSArrayWithElements(names);
+}
+
+
+// Return information on whether an object has a named or indexed interceptor.
+// args[0]: object
+RUNTIME_FUNCTION(Runtime_GetInterceptorInfo) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ if (!args[0]->IsJSObject()) {
+ return Smi::FromInt(0);
+ }
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+
+ int result = 0;
+ if (obj->HasNamedInterceptor()) result |= 2;
+ if (obj->HasIndexedInterceptor()) result |= 1;
+
+ return Smi::FromInt(result);
+}
+
+
+// Return property names from named interceptor.
+// args[0]: object
+RUNTIME_FUNCTION(Runtime_GetNamedInterceptorPropertyNames) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+
+ if (obj->HasNamedInterceptor()) {
+ Handle<JSObject> result;
+ if (JSObject::GetKeysForNamedInterceptor(obj, obj).ToHandle(&result)) {
+ return *result;
+ }
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+// Return element names from indexed interceptor.
+// args[0]: object
+RUNTIME_FUNCTION(Runtime_GetIndexedInterceptorElementNames) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+
+ if (obj->HasIndexedInterceptor()) {
+ Handle<JSObject> result;
+ if (JSObject::GetKeysForIndexedInterceptor(obj, obj).ToHandle(&result)) {
+ return *result;
+ }
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_OwnKeys) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSObject, raw_object, 0);
+ Handle<JSObject> object(raw_object);
+
+ if (object->IsJSGlobalProxy()) {
+ // Do access checks before going to the global object.
+ if (object->IsAccessCheckNeeded() &&
+ !isolate->MayNamedAccess(object, isolate->factory()->undefined_value(),
+ v8::ACCESS_KEYS)) {
+ isolate->ReportFailedAccessCheck(object, v8::ACCESS_KEYS);
+ RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
+ return *isolate->factory()->NewJSArray(0);
+ }
+
+ PrototypeIterator iter(isolate, object);
+ // If proxy is detached we simply return an empty array.
+ if (iter.IsAtEnd()) return *isolate->factory()->NewJSArray(0);
+ object = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+ }
+
+ Handle<FixedArray> contents;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, contents, JSReceiver::GetKeys(object, JSReceiver::OWN_ONLY));
+
+ // Some fast paths through GetKeysInFixedArrayFor reuse a cached
+ // property array and since the result is mutable we have to create
+ // a fresh clone on each invocation.
+ int length = contents->length();
+ Handle<FixedArray> copy = isolate->factory()->NewFixedArray(length);
+ for (int i = 0; i < length; i++) {
+ Object* entry = contents->get(i);
+ if (entry->IsString()) {
+ copy->set(i, entry);
+ } else {
+ DCHECK(entry->IsNumber());
+ HandleScope scope(isolate);
+ Handle<Object> entry_handle(entry, isolate);
+ Handle<Object> entry_str =
+ isolate->factory()->NumberToString(entry_handle);
+ copy->set(i, *entry_str);
+ }
+ }
+ return *isolate->factory()->NewJSArrayWithElements(copy);
+}
+
+
+RUNTIME_FUNCTION(Runtime_ToFastProperties) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ if (object->IsJSObject() && !object->IsGlobalObject()) {
+ JSObject::MigrateSlowToFast(Handle<JSObject>::cast(object), 0);
+ }
+ return *object;
+}
+
+
+RUNTIME_FUNCTION(Runtime_ToBool) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, object, 0);
+
+ return isolate->heap()->ToBoolean(object->BooleanValue());
+}
+
+
+// Returns the type string of a value; see ECMA-262, 11.4.3 (p 47).
+// Possible optimizations: put the type string into the oddballs.
+RUNTIME_FUNCTION(Runtime_Typeof) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ if (obj->IsNumber()) return isolate->heap()->number_string();
+ HeapObject* heap_obj = HeapObject::cast(obj);
+
+ // typeof an undetectable object is 'undefined'
+ if (heap_obj->map()->is_undetectable()) {
+ return isolate->heap()->undefined_string();
+ }
+
+ InstanceType instance_type = heap_obj->map()->instance_type();
+ if (instance_type < FIRST_NONSTRING_TYPE) {
+ return isolate->heap()->string_string();
+ }
+
+ switch (instance_type) {
+ case ODDBALL_TYPE:
+ if (heap_obj->IsTrue() || heap_obj->IsFalse()) {
+ return isolate->heap()->boolean_string();
+ }
+ if (heap_obj->IsNull()) {
+ return isolate->heap()->object_string();
+ }
+ DCHECK(heap_obj->IsUndefined());
+ return isolate->heap()->undefined_string();
+ case SYMBOL_TYPE:
+ return isolate->heap()->symbol_string();
+ case JS_FUNCTION_TYPE:
+ case JS_FUNCTION_PROXY_TYPE:
+ return isolate->heap()->function_string();
+ default:
+ // For any kind of object not handled above, the spec rule for
+ // host objects gives that it is okay to return "object"
+ return isolate->heap()->object_string();
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_Booleanize) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(Object, value_raw, 0);
+ CONVERT_SMI_ARG_CHECKED(token_raw, 1);
+ intptr_t value = reinterpret_cast<intptr_t>(value_raw);
+ Token::Value token = static_cast<Token::Value>(token_raw);
+ switch (token) {
+ case Token::EQ:
+ case Token::EQ_STRICT:
+ return isolate->heap()->ToBoolean(value == 0);
+ case Token::NE:
+ case Token::NE_STRICT:
+ return isolate->heap()->ToBoolean(value != 0);
+ case Token::LT:
+ return isolate->heap()->ToBoolean(value < 0);
+ case Token::GT:
+ return isolate->heap()->ToBoolean(value > 0);
+ case Token::LTE:
+ return isolate->heap()->ToBoolean(value <= 0);
+ case Token::GTE:
+ return isolate->heap()->ToBoolean(value >= 0);
+ default:
+ // This should only happen during natives fuzzing.
+ return isolate->heap()->undefined_value();
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewStringWrapper) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(String, value, 0);
+ return *Object::ToObject(isolate, value).ToHandleChecked();
+}
+
+
+RUNTIME_FUNCTION(Runtime_AllocateHeapNumber) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ return *isolate->factory()->NewHeapNumber(0);
+}
+
+
+static Object* Runtime_NewObjectHelper(Isolate* isolate,
+ Handle<Object> constructor,
+ Handle<AllocationSite> site) {
+ // If the constructor isn't a proper function we throw a type error.
+ if (!constructor->IsJSFunction()) {
+ Vector<Handle<Object> > arguments = HandleVector(&constructor, 1);
+ THROW_NEW_ERROR_RETURN_FAILURE(isolate,
+ NewTypeError("not_constructor", arguments));
+ }
+
+ Handle<JSFunction> function = Handle<JSFunction>::cast(constructor);
+
+ // If function should not have prototype, construction is not allowed. In this
+ // case generated code bailouts here, since function has no initial_map.
+ if (!function->should_have_prototype() && !function->shared()->bound()) {
+ Vector<Handle<Object> > arguments = HandleVector(&constructor, 1);
+ THROW_NEW_ERROR_RETURN_FAILURE(isolate,
+ NewTypeError("not_constructor", arguments));
+ }
+
+ Debug* debug = isolate->debug();
+ // Handle stepping into constructors if step into is active.
+ if (debug->StepInActive()) {
+ debug->HandleStepIn(function, Handle<Object>::null(), 0, true);
+ }
+
+ if (function->has_initial_map()) {
+ if (function->initial_map()->instance_type() == JS_FUNCTION_TYPE) {
+ // The 'Function' function ignores the receiver object when
+ // called using 'new' and creates a new JSFunction object that
+ // is returned. The receiver object is only used for error
+ // reporting if an error occurs when constructing the new
+ // JSFunction. Factory::NewJSObject() should not be used to
+ // allocate JSFunctions since it does not properly initialize
+ // the shared part of the function. Since the receiver is
+ // ignored anyway, we use the global object as the receiver
+ // instead of a new JSFunction object. This way, errors are
+ // reported the same way whether or not 'Function' is called
+ // using 'new'.
+ return isolate->global_proxy();
+ }
+ }
+
+ // The function should be compiled for the optimization hints to be
+ // available.
+ Compiler::EnsureCompiled(function, CLEAR_EXCEPTION);
+
+ Handle<JSObject> result;
+ if (site.is_null()) {
+ result = isolate->factory()->NewJSObject(function);
+ } else {
+ result = isolate->factory()->NewJSObjectWithMemento(function, site);
+ }
+
+ isolate->counters()->constructed_objects()->Increment();
+ isolate->counters()->constructed_objects_runtime()->Increment();
+
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewObject) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, constructor, 0);
+ return Runtime_NewObjectHelper(isolate, constructor,
+ Handle<AllocationSite>::null());
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewObjectWithAllocationSite) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, constructor, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, feedback, 0);
+ Handle<AllocationSite> site;
+ if (feedback->IsAllocationSite()) {
+ // The feedback can be an AllocationSite or undefined.
+ site = Handle<AllocationSite>::cast(feedback);
+ }
+ return Runtime_NewObjectHelper(isolate, constructor, site);
+}
+
+
+RUNTIME_FUNCTION(Runtime_FinalizeInstanceSize) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ function->CompleteInobjectSlackTracking();
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GlobalProxy) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, global, 0);
+ if (!global->IsJSGlobalObject()) return isolate->heap()->null_value();
+ return JSGlobalObject::cast(global)->global_proxy();
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsAttachedGlobal) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, global, 0);
+ if (!global->IsJSGlobalObject()) return isolate->heap()->false_value();
+ return isolate->heap()->ToBoolean(
+ !JSGlobalObject::cast(global)->IsDetached());
+}
+
+
+RUNTIME_FUNCTION(Runtime_LookupAccessor) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+ CONVERT_SMI_ARG_CHECKED(flag, 2);
+ AccessorComponent component = flag == 0 ? ACCESSOR_GETTER : ACCESSOR_SETTER;
+ if (!receiver->IsJSObject()) return isolate->heap()->undefined_value();
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ JSObject::GetAccessor(Handle<JSObject>::cast(receiver), name, component));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_LoadMutableDouble) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Smi, index, 1);
+ RUNTIME_ASSERT((index->value() & 1) == 1);
+ FieldIndex field_index =
+ FieldIndex::ForLoadByFieldIndex(object->map(), index->value());
+ if (field_index.is_inobject()) {
+ RUNTIME_ASSERT(field_index.property_index() <
+ object->map()->inobject_properties());
+ } else {
+ RUNTIME_ASSERT(field_index.outobject_array_index() <
+ object->properties()->length());
+ }
+ Handle<Object> raw_value(object->RawFastPropertyAt(field_index), isolate);
+ RUNTIME_ASSERT(raw_value->IsMutableHeapNumber());
+ return *Object::WrapForRead(isolate, raw_value, Representation::Double());
+}
+
+
+RUNTIME_FUNCTION(Runtime_TryMigrateInstance) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
+ if (!object->IsJSObject()) return Smi::FromInt(0);
+ Handle<JSObject> js_object = Handle<JSObject>::cast(object);
+ if (!js_object->map()->is_deprecated()) return Smi::FromInt(0);
+ // This call must not cause lazy deopts, because it's called from deferred
+ // code where we can't handle lazy deopts for lack of a suitable bailout
+ // ID. So we just try migration and signal failure if necessary,
+ // which will also trigger a deopt.
+ if (!JSObject::TryMigrateInstance(js_object)) return Smi::FromInt(0);
+ return *object;
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsJSGlobalProxy) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSGlobalProxy());
+}
+
+
+static bool IsValidAccessor(Handle<Object> obj) {
+ return obj->IsUndefined() || obj->IsSpecFunction() || obj->IsNull();
+}
+
+
+// Implements part of 8.12.9 DefineOwnProperty.
+// There are 3 cases that lead here:
+// Step 4b - define a new accessor property.
+// Steps 9c & 12 - replace an existing data property with an accessor property.
+// Step 12 - update an existing accessor property with an accessor or generic
+// descriptor.
+RUNTIME_FUNCTION(Runtime_DefineAccessorPropertyUnchecked) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 5);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
+ RUNTIME_ASSERT(!obj->IsNull());
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, getter, 2);
+ RUNTIME_ASSERT(IsValidAccessor(getter));
+ CONVERT_ARG_HANDLE_CHECKED(Object, setter, 3);
+ RUNTIME_ASSERT(IsValidAccessor(setter));
+ CONVERT_SMI_ARG_CHECKED(unchecked, 4);
+ RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
+
+ bool fast = obj->HasFastProperties();
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::DefineAccessor(obj, name, getter, setter, attr));
+ if (fast) JSObject::MigrateSlowToFast(obj, 0);
+ return isolate->heap()->undefined_value();
+}
+
+
+// Implements part of 8.12.9 DefineOwnProperty.
+// There are 3 cases that lead here:
+// Step 4a - define a new data property.
+// Steps 9b & 12 - replace an existing accessor property with a data property.
+// Step 12 - update an existing data property with a data or generic
+// descriptor.
+RUNTIME_FUNCTION(Runtime_DefineDataPropertyUnchecked) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, js_object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, obj_value, 2);
+ CONVERT_SMI_ARG_CHECKED(unchecked, 3);
+ RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
+
+ LookupIterator it(js_object, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
+ if (it.IsFound() && it.state() == LookupIterator::ACCESS_CHECK) {
+ if (!isolate->MayNamedAccess(js_object, name, v8::ACCESS_SET)) {
+ return isolate->heap()->undefined_value();
+ }
+ it.Next();
+ }
+
+ // Take special care when attributes are different and there is already
+ // a property.
+ if (it.state() == LookupIterator::ACCESSOR) {
+ // Use IgnoreAttributes version since a readonly property may be
+ // overridden and SetProperty does not allow this.
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ JSObject::SetOwnPropertyIgnoreAttributes(
+ js_object, name, obj_value, attr, JSObject::DONT_FORCE_FIELD));
+ return *result;
+ }
+
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Runtime::DefineObjectProperty(js_object, name, obj_value, attr));
+ return *result;
+}
+
+
+// Return property without being observable by accessors or interceptors.
+RUNTIME_FUNCTION(Runtime_GetDataProperty) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+ return *JSObject::GetDataProperty(object, key);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_ValueOf) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ if (!obj->IsJSValue()) return obj;
+ return JSValue::cast(obj)->value();
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_SetValueOf) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ CONVERT_ARG_CHECKED(Object, value, 1);
+ if (!obj->IsJSValue()) return value;
+ JSValue::cast(obj)->set_value(value);
+ return value;
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_ObjectEquals) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_CHECKED(Object, obj1, 0);
+ CONVERT_ARG_CHECKED(Object, obj2, 1);
+ return isolate->heap()->ToBoolean(obj1 == obj2);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsObject) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ if (!obj->IsHeapObject()) return isolate->heap()->false_value();
+ if (obj->IsNull()) return isolate->heap()->true_value();
+ if (obj->IsUndetectableObject()) return isolate->heap()->false_value();
+ Map* map = HeapObject::cast(obj)->map();
+ bool is_non_callable_spec_object =
+ map->instance_type() >= FIRST_NONCALLABLE_SPEC_OBJECT_TYPE &&
+ map->instance_type() <= LAST_NONCALLABLE_SPEC_OBJECT_TYPE;
+ return isolate->heap()->ToBoolean(is_non_callable_spec_object);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsUndetectableObject) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsUndetectableObject());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsSpecObject) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsSpecObject());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_ClassOf) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ if (!obj->IsJSReceiver()) return isolate->heap()->null_value();
+ return JSReceiver::cast(obj)->class_name();
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_IsObserved) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+
+ if (!args[0]->IsJSReceiver()) return isolate->heap()->false_value();
+ CONVERT_ARG_CHECKED(JSReceiver, obj, 0);
+ DCHECK(!obj->IsJSGlobalProxy() || !obj->map()->is_observed());
+ return isolate->heap()->ToBoolean(obj->map()->is_observed());
+}
+
+
+RUNTIME_FUNCTION(Runtime_SetIsObserved) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, obj, 0);
+ RUNTIME_ASSERT(!obj->IsJSGlobalProxy());
+ if (obj->IsJSProxy()) return isolate->heap()->undefined_value();
+ RUNTIME_ASSERT(!obj->map()->is_observed());
+
+ DCHECK(obj->IsJSObject());
+ JSObject::SetObserved(Handle<JSObject>::cast(obj));
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_EnqueueMicrotask) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, microtask, 0);
+ isolate->EnqueueMicrotask(microtask);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_RunMicrotasks) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ isolate->RunMicrotasks();
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeliverObservationChangeRecords) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, callback, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, argument, 1);
+ v8::TryCatch catcher;
+ // We should send a message on uncaught exception thrown during
+ // Object.observe delivery while not interrupting further delivery, thus
+ // we make a call inside a verbose TryCatch.
+ catcher.SetVerbose(true);
+ Handle<Object> argv[] = {argument};
+ USE(Execution::Call(isolate, callback, isolate->factory()->undefined_value(),
+ arraysize(argv), argv));
+ if (isolate->has_pending_exception()) {
+ isolate->ReportPendingMessages();
+ isolate->clear_pending_exception();
+ isolate->set_external_caught_exception(false);
+ }
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetObservationState) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ return isolate->heap()->observation_state();
+}
+
+
+static bool ContextsHaveSameOrigin(Handle<Context> context1,
+ Handle<Context> context2) {
+ return context1->security_token() == context2->security_token();
+}
+
+
+RUNTIME_FUNCTION(Runtime_ObserverObjectAndRecordHaveSameOrigin) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, observer, 0);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, record, 2);
+
+ Handle<Context> observer_context(observer->context()->native_context());
+ Handle<Context> object_context(object->GetCreationContext());
+ Handle<Context> record_context(record->GetCreationContext());
+
+ return isolate->heap()->ToBoolean(
+ ContextsHaveSameOrigin(object_context, observer_context) &&
+ ContextsHaveSameOrigin(object_context, record_context));
+}
+
+
+RUNTIME_FUNCTION(Runtime_ObjectWasCreatedInCurrentOrigin) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+
+ Handle<Context> creation_context(object->GetCreationContext(), isolate);
+ return isolate->heap()->ToBoolean(
+ ContextsHaveSameOrigin(creation_context, isolate->native_context()));
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetObjectContextObjectObserve) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+
+ Handle<Context> context(object->GetCreationContext(), isolate);
+ return context->native_object_observe();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetObjectContextObjectGetNotifier) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+
+ Handle<Context> context(object->GetCreationContext(), isolate);
+ return context->native_object_get_notifier();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetObjectContextNotifierPerformChange) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSObject, object_info, 0);
+
+ Handle<Context> context(object_info->GetCreationContext(), isolate);
+ return context->native_object_notifier_perform_change();
+}
+}
+} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_CreateJSProxy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, handler, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
+ if (!prototype->IsJSReceiver()) prototype = isolate->factory()->null_value();
+ return *isolate->factory()->NewJSProxy(handler, prototype);
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreateJSFunctionProxy) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+ CONVERT_ARG_HANDLE_CHECKED(JSReceiver, handler, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, call_trap, 1);
+ RUNTIME_ASSERT(call_trap->IsJSFunction() || call_trap->IsJSFunctionProxy());
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, construct_trap, 2);
+ CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 3);
+ if (!prototype->IsJSReceiver()) prototype = isolate->factory()->null_value();
+ return *isolate->factory()->NewJSFunctionProxy(handler, call_trap,
+ construct_trap, prototype);
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsJSProxy) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSProxy());
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsJSFunctionProxy) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSFunctionProxy());
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetHandler) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSProxy, proxy, 0);
+ return proxy->handler();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetCallTrap) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunctionProxy, proxy, 0);
+ return proxy->call_trap();
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetConstructTrap) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(JSFunctionProxy, proxy, 0);
+ return proxy->construct_trap();
+}
+
+
+RUNTIME_FUNCTION(Runtime_Fix) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSProxy, proxy, 0);
+ JSProxy::Fix(proxy);
+ return isolate->heap()->undefined_value();
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/jsregexp-inl.h"
#include "src/jsregexp.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
#include "src/runtime/string-builder.h"
#include "src/string-search.h"
}
-// Perform string match of pattern on subject, starting at start index.
-// Caller must ensure that 0 <= start_index <= sub->length(),
-// and should check that pat->length() + start_index <= sub->length().
-int Runtime::StringMatch(Isolate* isolate, Handle<String> sub,
- Handle<String> pat, int start_index) {
- DCHECK(0 <= start_index);
- DCHECK(start_index <= sub->length());
-
- int pattern_length = pat->length();
- if (pattern_length == 0) return start_index;
-
- int subject_length = sub->length();
- if (start_index + pattern_length > subject_length) return -1;
-
- sub = String::Flatten(sub);
- pat = String::Flatten(pat);
-
- DisallowHeapAllocation no_gc; // ensure vectors stay valid
- // Extract flattened substrings of cons strings before getting encoding.
- String::FlatContent seq_sub = sub->GetFlatContent();
- String::FlatContent seq_pat = pat->GetFlatContent();
-
- // dispatch on type of strings
- if (seq_pat.IsOneByte()) {
- Vector<const uint8_t> pat_vector = seq_pat.ToOneByteVector();
- if (seq_sub.IsOneByte()) {
- return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
- start_index);
- }
- return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
- start_index);
- }
- Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
- if (seq_sub.IsOneByte()) {
- return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
- start_index);
- }
- return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector, start_index);
+RUNTIME_FUNCTION(RuntimeReference_IsRegExp) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSRegExp());
}
}
} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/accessors.h"
+#include "src/arguments.h"
+#include "src/frames-inl.h"
+#include "src/runtime/runtime-utils.h"
+#include "src/scopeinfo.h"
+#include "src/scopes.h"
+
+namespace v8 {
+namespace internal {
+
+static Object* ThrowRedeclarationError(Isolate* isolate, Handle<String> name) {
+ HandleScope scope(isolate);
+ Handle<Object> args[1] = {name};
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError("var_redeclaration", HandleVector(args, 1)));
+}
+
+
+// May throw a RedeclarationError.
+static Object* DeclareGlobals(Isolate* isolate, Handle<GlobalObject> global,
+ Handle<String> name, Handle<Object> value,
+ PropertyAttributes attr, bool is_var,
+ bool is_const, bool is_function) {
+ // Do the lookup own properties only, see ES5 erratum.
+ LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ if (!maybe.has_value) return isolate->heap()->exception();
+
+ if (it.IsFound()) {
+ PropertyAttributes old_attributes = maybe.value;
+ // The name was declared before; check for conflicting re-declarations.
+ if (is_const) return ThrowRedeclarationError(isolate, name);
+
+ // Skip var re-declarations.
+ if (is_var) return isolate->heap()->undefined_value();
+
+ DCHECK(is_function);
+ if ((old_attributes & DONT_DELETE) != 0) {
+ // Only allow reconfiguring globals to functions in user code (no
+ // natives, which are marked as read-only).
+ DCHECK((attr & READ_ONLY) == 0);
+
+ // Check whether we can reconfigure the existing property into a
+ // function.
+ PropertyDetails old_details = it.property_details();
+ // TODO(verwaest): CALLBACKS invalidly includes ExecutableAccessInfo,
+ // which are actually data properties, not accessor properties.
+ if (old_details.IsReadOnly() || old_details.IsDontEnum() ||
+ old_details.type() == CALLBACKS) {
+ return ThrowRedeclarationError(isolate, name);
+ }
+ // If the existing property is not configurable, keep its attributes. Do
+ attr = old_attributes;
+ }
+ }
+
+ // Define or redefine own property.
+ RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ global, name, value, attr));
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ Handle<GlobalObject> global(isolate->global_object());
+
+ CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, pairs, 1);
+ CONVERT_SMI_ARG_CHECKED(flags, 2);
+
+ // Traverse the name/value pairs and set the properties.
+ int length = pairs->length();
+ for (int i = 0; i < length; i += 2) {
+ HandleScope scope(isolate);
+ Handle<String> name(String::cast(pairs->get(i)));
+ Handle<Object> initial_value(pairs->get(i + 1), isolate);
+
+ // We have to declare a global const property. To capture we only
+ // assign to it when evaluating the assignment for "const x =
+ // <expr>" the initial value is the hole.
+ bool is_var = initial_value->IsUndefined();
+ bool is_const = initial_value->IsTheHole();
+ bool is_function = initial_value->IsSharedFunctionInfo();
+ DCHECK(is_var + is_const + is_function == 1);
+
+ Handle<Object> value;
+ if (is_function) {
+ // Copy the function and update its context. Use it as value.
+ Handle<SharedFunctionInfo> shared =
+ Handle<SharedFunctionInfo>::cast(initial_value);
+ Handle<JSFunction> function =
+ isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
+ TENURED);
+ value = function;
+ } else {
+ value = isolate->factory()->undefined_value();
+ }
+
+ // Compute the property attributes. According to ECMA-262,
+ // the property must be non-configurable except in eval.
+ bool is_native = DeclareGlobalsNativeFlag::decode(flags);
+ bool is_eval = DeclareGlobalsEvalFlag::decode(flags);
+ int attr = NONE;
+ if (is_const) attr |= READ_ONLY;
+ if (is_function && is_native) attr |= READ_ONLY;
+ if (!is_const && !is_eval) attr |= DONT_DELETE;
+
+ Object* result = DeclareGlobals(isolate, global, name, value,
+ static_cast<PropertyAttributes>(attr),
+ is_var, is_const, is_function);
+ if (isolate->has_pending_exception()) return result;
+ }
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_InitializeVarGlobal) {
+ HandleScope scope(isolate);
+ // args[0] == name
+ // args[1] == language_mode
+ // args[2] == value (optional)
+
+ // Determine if we need to assign to the variable if it already
+ // exists (based on the number of arguments).
+ RUNTIME_ASSERT(args.length() == 3);
+
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
+ CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
+
+ Handle<GlobalObject> global(isolate->context()->global_object());
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result, Object::SetProperty(global, name, value, strict_mode));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_InitializeConstGlobal) {
+ HandleScope handle_scope(isolate);
+ // All constants are declared with an initial value. The name
+ // of the constant is the first argument and the initial value
+ // is the second.
+ RUNTIME_ASSERT(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
+
+ Handle<GlobalObject> global = isolate->global_object();
+
+ // Lookup the property as own on the global object.
+ LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ DCHECK(maybe.has_value);
+ PropertyAttributes old_attributes = maybe.value;
+
+ PropertyAttributes attr =
+ static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
+ // Set the value if the property is either missing, or the property attributes
+ // allow setting the value without invoking an accessor.
+ if (it.IsFound()) {
+ // Ignore if we can't reconfigure the value.
+ if ((old_attributes & DONT_DELETE) != 0) {
+ if ((old_attributes & READ_ONLY) != 0 ||
+ it.state() == LookupIterator::ACCESSOR) {
+ return *value;
+ }
+ attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
+ }
+ }
+
+ RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ global, name, value, attr));
+
+ return *value;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeclareLookupSlot) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+
+ // Declarations are always made in a function, native, or global context. In
+ // the case of eval code, the context passed is the context of the caller,
+ // which may be some nested context and not the declaration context.
+ CONVERT_ARG_HANDLE_CHECKED(Context, context_arg, 0);
+ Handle<Context> context(context_arg->declaration_context());
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 1);
+ CONVERT_SMI_ARG_CHECKED(attr_arg, 2);
+ PropertyAttributes attr = static_cast<PropertyAttributes>(attr_arg);
+ RUNTIME_ASSERT(attr == READ_ONLY || attr == NONE);
+ CONVERT_ARG_HANDLE_CHECKED(Object, initial_value, 3);
+
+ // TODO(verwaest): Unify the encoding indicating "var" with DeclareGlobals.
+ bool is_var = *initial_value == NULL;
+ bool is_const = initial_value->IsTheHole();
+ bool is_function = initial_value->IsJSFunction();
+ DCHECK(is_var + is_const + is_function == 1);
+
+ int index;
+ PropertyAttributes attributes;
+ ContextLookupFlags flags = DONT_FOLLOW_CHAINS;
+ BindingFlags binding_flags;
+ Handle<Object> holder =
+ context->Lookup(name, flags, &index, &attributes, &binding_flags);
+
+ Handle<JSObject> object;
+ Handle<Object> value =
+ is_function ? initial_value
+ : Handle<Object>::cast(isolate->factory()->undefined_value());
+
+ // TODO(verwaest): This case should probably not be covered by this function,
+ // but by DeclareGlobals instead.
+ if ((attributes != ABSENT && holder->IsJSGlobalObject()) ||
+ (context_arg->has_extension() &&
+ context_arg->extension()->IsJSGlobalObject())) {
+ return DeclareGlobals(isolate, Handle<JSGlobalObject>::cast(holder), name,
+ value, attr, is_var, is_const, is_function);
+ }
+
+ if (attributes != ABSENT) {
+ // The name was declared before; check for conflicting re-declarations.
+ if (is_const || (attributes & READ_ONLY) != 0) {
+ return ThrowRedeclarationError(isolate, name);
+ }
+
+ // Skip var re-declarations.
+ if (is_var) return isolate->heap()->undefined_value();
+
+ DCHECK(is_function);
+ if (index >= 0) {
+ DCHECK(holder.is_identical_to(context));
+ context->set(index, *initial_value);
+ return isolate->heap()->undefined_value();
+ }
+
+ object = Handle<JSObject>::cast(holder);
+
+ } else if (context->has_extension()) {
+ object = handle(JSObject::cast(context->extension()));
+ DCHECK(object->IsJSContextExtensionObject() || object->IsJSGlobalObject());
+ } else {
+ DCHECK(context->IsFunctionContext());
+ object =
+ isolate->factory()->NewJSObject(isolate->context_extension_function());
+ context->set_extension(*object);
+ }
+
+ RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ object, name, value, attr));
+
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_InitializeLegacyConstLookupSlot) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
+ DCHECK(!value->IsTheHole());
+ // Initializations are always done in a function or native context.
+ CONVERT_ARG_HANDLE_CHECKED(Context, context_arg, 1);
+ Handle<Context> context(context_arg->declaration_context());
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 2);
+
+ int index;
+ PropertyAttributes attributes;
+ ContextLookupFlags flags = DONT_FOLLOW_CHAINS;
+ BindingFlags binding_flags;
+ Handle<Object> holder =
+ context->Lookup(name, flags, &index, &attributes, &binding_flags);
+
+ if (index >= 0) {
+ DCHECK(holder->IsContext());
+ // Property was found in a context. Perform the assignment if the constant
+ // was uninitialized.
+ Handle<Context> context = Handle<Context>::cast(holder);
+ DCHECK((attributes & READ_ONLY) != 0);
+ if (context->get(index)->IsTheHole()) context->set(index, *value);
+ return *value;
+ }
+
+ PropertyAttributes attr =
+ static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
+
+ // Strict mode handling not needed (legacy const is disallowed in strict
+ // mode).
+
+ // The declared const was configurable, and may have been deleted in the
+ // meanwhile. If so, re-introduce the variable in the context extension.
+ DCHECK(context_arg->has_extension());
+ if (attributes == ABSENT) {
+ holder = handle(context_arg->extension(), isolate);
+ } else {
+ // For JSContextExtensionObjects, the initializer can be run multiple times
+ // if in a for loop: for (var i = 0; i < 2; i++) { const x = i; }. Only the
+ // first assignment should go through. For JSGlobalObjects, additionally any
+ // code can run in between that modifies the declared property.
+ DCHECK(holder->IsJSGlobalObject() || holder->IsJSContextExtensionObject());
+
+ LookupIterator it(holder, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ if (!maybe.has_value) return isolate->heap()->exception();
+ PropertyAttributes old_attributes = maybe.value;
+
+ // Ignore if we can't reconfigure the value.
+ if ((old_attributes & DONT_DELETE) != 0) {
+ if ((old_attributes & READ_ONLY) != 0 ||
+ it.state() == LookupIterator::ACCESSOR) {
+ return *value;
+ }
+ attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
+ }
+ }
+
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, JSObject::SetOwnPropertyIgnoreAttributes(
+ Handle<JSObject>::cast(holder), name, value, attr));
+
+ return *value;
+}
+
+
+static Handle<JSObject> NewSloppyArguments(Isolate* isolate,
+ Handle<JSFunction> callee,
+ Object** parameters,
+ int argument_count) {
+ Handle<JSObject> result =
+ isolate->factory()->NewArgumentsObject(callee, argument_count);
+
+ // Allocate the elements if needed.
+ int parameter_count = callee->shared()->formal_parameter_count();
+ if (argument_count > 0) {
+ if (parameter_count > 0) {
+ int mapped_count = Min(argument_count, parameter_count);
+ Handle<FixedArray> parameter_map =
+ isolate->factory()->NewFixedArray(mapped_count + 2, NOT_TENURED);
+ parameter_map->set_map(isolate->heap()->sloppy_arguments_elements_map());
+
+ Handle<Map> map = Map::Copy(handle(result->map()));
+ map->set_elements_kind(SLOPPY_ARGUMENTS_ELEMENTS);
+
+ result->set_map(*map);
+ result->set_elements(*parameter_map);
+
+ // Store the context and the arguments array at the beginning of the
+ // parameter map.
+ Handle<Context> context(isolate->context());
+ Handle<FixedArray> arguments =
+ isolate->factory()->NewFixedArray(argument_count, NOT_TENURED);
+ parameter_map->set(0, *context);
+ parameter_map->set(1, *arguments);
+
+ // Loop over the actual parameters backwards.
+ int index = argument_count - 1;
+ while (index >= mapped_count) {
+ // These go directly in the arguments array and have no
+ // corresponding slot in the parameter map.
+ arguments->set(index, *(parameters - index - 1));
+ --index;
+ }
+
+ Handle<ScopeInfo> scope_info(callee->shared()->scope_info());
+ while (index >= 0) {
+ // Detect duplicate names to the right in the parameter list.
+ Handle<String> name(scope_info->ParameterName(index));
+ int context_local_count = scope_info->ContextLocalCount();
+ bool duplicate = false;
+ for (int j = index + 1; j < parameter_count; ++j) {
+ if (scope_info->ParameterName(j) == *name) {
+ duplicate = true;
+ break;
+ }
+ }
+
+ if (duplicate) {
+ // This goes directly in the arguments array with a hole in the
+ // parameter map.
+ arguments->set(index, *(parameters - index - 1));
+ parameter_map->set_the_hole(index + 2);
+ } else {
+ // The context index goes in the parameter map with a hole in the
+ // arguments array.
+ int context_index = -1;
+ for (int j = 0; j < context_local_count; ++j) {
+ if (scope_info->ContextLocalName(j) == *name) {
+ context_index = j;
+ break;
+ }
+ }
+ DCHECK(context_index >= 0);
+ arguments->set_the_hole(index);
+ parameter_map->set(
+ index + 2,
+ Smi::FromInt(Context::MIN_CONTEXT_SLOTS + context_index));
+ }
+
+ --index;
+ }
+ } else {
+ // If there is no aliasing, the arguments object elements are not
+ // special in any way.
+ Handle<FixedArray> elements =
+ isolate->factory()->NewFixedArray(argument_count, NOT_TENURED);
+ result->set_elements(*elements);
+ for (int i = 0; i < argument_count; ++i) {
+ elements->set(i, *(parameters - i - 1));
+ }
+ }
+ }
+ return result;
+}
+
+
+static Handle<JSObject> NewStrictArguments(Isolate* isolate,
+ Handle<JSFunction> callee,
+ Object** parameters,
+ int argument_count) {
+ Handle<JSObject> result =
+ isolate->factory()->NewArgumentsObject(callee, argument_count);
+
+ if (argument_count > 0) {
+ Handle<FixedArray> array =
+ isolate->factory()->NewUninitializedFixedArray(argument_count);
+ DisallowHeapAllocation no_gc;
+ WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
+ for (int i = 0; i < argument_count; i++) {
+ array->set(i, *--parameters, mode);
+ }
+ result->set_elements(*array);
+ }
+ return result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewArguments) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
+ JavaScriptFrameIterator it(isolate);
+
+ // Find the frame that holds the actual arguments passed to the function.
+ it.AdvanceToArgumentsFrame();
+ JavaScriptFrame* frame = it.frame();
+
+ // Determine parameter location on the stack and dispatch on language mode.
+ int argument_count = frame->GetArgumentsLength();
+ Object** parameters = reinterpret_cast<Object**>(frame->GetParameterSlot(-1));
+ return callee->shared()->strict_mode() == STRICT
+ ? *NewStrictArguments(isolate, callee, parameters, argument_count)
+ : *NewSloppyArguments(isolate, callee, parameters, argument_count);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewSloppyArguments) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
+ Object** parameters = reinterpret_cast<Object**>(args[1]);
+ CONVERT_SMI_ARG_CHECKED(argument_count, 2);
+ return *NewSloppyArguments(isolate, callee, parameters, argument_count);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewStrictArguments) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0)
+ Object** parameters = reinterpret_cast<Object**>(args[1]);
+ CONVERT_SMI_ARG_CHECKED(argument_count, 2);
+ return *NewStrictArguments(isolate, callee, parameters, argument_count);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewClosureFromStubFailure) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 0);
+ Handle<Context> context(isolate->context());
+ PretenureFlag pretenure_flag = NOT_TENURED;
+ return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
+ pretenure_flag);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewClosure) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
+ CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 1);
+ CONVERT_BOOLEAN_ARG_CHECKED(pretenure, 2);
+
+ // The caller ensures that we pretenure closures that are assigned
+ // directly to properties.
+ PretenureFlag pretenure_flag = pretenure ? TENURED : NOT_TENURED;
+ return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
+ pretenure_flag);
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewGlobalContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+ CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
+ Handle<Context> result =
+ isolate->factory()->NewGlobalContext(function, scope_info);
+
+ DCHECK(function->context() == isolate->context());
+ DCHECK(function->context()->global_object() == result->global_object());
+ result->global_object()->set_global_context(*result);
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+
+ CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
+
+ DCHECK(function->context() == isolate->context());
+ int length = function->shared()->scope_info()->ContextLength();
+ return *isolate->factory()->NewFunctionContext(length, function);
+}
+
+
+RUNTIME_FUNCTION(Runtime_PushWithContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ Handle<JSReceiver> extension_object;
+ if (args[0]->IsJSReceiver()) {
+ extension_object = args.at<JSReceiver>(0);
+ } else {
+ // Try to convert the object to a proper JavaScript object.
+ MaybeHandle<JSReceiver> maybe_object =
+ Object::ToObject(isolate, args.at<Object>(0));
+ if (!maybe_object.ToHandle(&extension_object)) {
+ Handle<Object> handle = args.at<Object>(0);
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError("with_expression", HandleVector(&handle, 1)));
+ }
+ }
+
+ Handle<JSFunction> function;
+ if (args[1]->IsSmi()) {
+ // A smi sentinel indicates a context nested inside global code rather
+ // than some function. There is a canonical empty function that can be
+ // gotten from the native context.
+ function = handle(isolate->native_context()->closure());
+ } else {
+ function = args.at<JSFunction>(1);
+ }
+
+ Handle<Context> current(isolate->context());
+ Handle<Context> context =
+ isolate->factory()->NewWithContext(function, current, extension_object);
+ isolate->set_context(*context);
+ return *context;
+}
+
+
+RUNTIME_FUNCTION(Runtime_PushCatchContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 3);
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Object, thrown_object, 1);
+ Handle<JSFunction> function;
+ if (args[2]->IsSmi()) {
+ // A smi sentinel indicates a context nested inside global code rather
+ // than some function. There is a canonical empty function that can be
+ // gotten from the native context.
+ function = handle(isolate->native_context()->closure());
+ } else {
+ function = args.at<JSFunction>(2);
+ }
+ Handle<Context> current(isolate->context());
+ Handle<Context> context = isolate->factory()->NewCatchContext(
+ function, current, name, thrown_object);
+ isolate->set_context(*context);
+ return *context;
+}
+
+
+RUNTIME_FUNCTION(Runtime_PushBlockContext) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
+ Handle<JSFunction> function;
+ if (args[1]->IsSmi()) {
+ // A smi sentinel indicates a context nested inside global code rather
+ // than some function. There is a canonical empty function that can be
+ // gotten from the native context.
+ function = handle(isolate->native_context()->closure());
+ } else {
+ function = args.at<JSFunction>(1);
+ }
+ Handle<Context> current(isolate->context());
+ Handle<Context> context =
+ isolate->factory()->NewBlockContext(function, current, scope_info);
+ isolate->set_context(*context);
+ return *context;
+}
+
+
+RUNTIME_FUNCTION(Runtime_IsJSModule) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ return isolate->heap()->ToBoolean(obj->IsJSModule());
+}
+
+
+RUNTIME_FUNCTION(Runtime_PushModuleContext) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 2);
+ CONVERT_SMI_ARG_CHECKED(index, 0);
+
+ if (!args[1]->IsScopeInfo()) {
+ // Module already initialized. Find hosting context and retrieve context.
+ Context* host = Context::cast(isolate->context())->global_context();
+ Context* context = Context::cast(host->get(index));
+ DCHECK(context->previous() == isolate->context());
+ isolate->set_context(context);
+ return context;
+ }
+
+ CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
+
+ // Allocate module context.
+ HandleScope scope(isolate);
+ Factory* factory = isolate->factory();
+ Handle<Context> context = factory->NewModuleContext(scope_info);
+ Handle<JSModule> module = factory->NewJSModule(context, scope_info);
+ context->set_module(*module);
+ Context* previous = isolate->context();
+ context->set_previous(previous);
+ context->set_closure(previous->closure());
+ context->set_global_object(previous->global_object());
+ isolate->set_context(*context);
+
+ // Find hosting scope and initialize internal variable holding module there.
+ previous->global_context()->set(index, *context);
+
+ return *context;
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeclareModules) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(FixedArray, descriptions, 0);
+ Context* host_context = isolate->context();
+
+ for (int i = 0; i < descriptions->length(); ++i) {
+ Handle<ModuleInfo> description(ModuleInfo::cast(descriptions->get(i)));
+ int host_index = description->host_index();
+ Handle<Context> context(Context::cast(host_context->get(host_index)));
+ Handle<JSModule> module(context->module());
+
+ for (int j = 0; j < description->length(); ++j) {
+ Handle<String> name(description->name(j));
+ VariableMode mode = description->mode(j);
+ int index = description->index(j);
+ switch (mode) {
+ case VAR:
+ case LET:
+ case CONST:
+ case CONST_LEGACY: {
+ PropertyAttributes attr =
+ IsImmutableVariableMode(mode) ? FROZEN : SEALED;
+ Handle<AccessorInfo> info =
+ Accessors::MakeModuleExport(name, index, attr);
+ Handle<Object> result =
+ JSObject::SetAccessor(module, info).ToHandleChecked();
+ DCHECK(!result->IsUndefined());
+ USE(result);
+ break;
+ }
+ case MODULE: {
+ Object* referenced_context = Context::cast(host_context)->get(index);
+ Handle<JSModule> value(Context::cast(referenced_context)->module());
+ JSObject::SetOwnPropertyIgnoreAttributes(module, name, value, FROZEN)
+ .Assert();
+ break;
+ }
+ case INTERNAL:
+ case TEMPORARY:
+ case DYNAMIC:
+ case DYNAMIC_GLOBAL:
+ case DYNAMIC_LOCAL:
+ UNREACHABLE();
+ }
+ }
+
+ JSObject::PreventExtensions(module).Assert();
+ }
+
+ DCHECK(!isolate->has_pending_exception());
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_DeleteLookupSlot) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 2);
+
+ CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 1);
+
+ int index;
+ PropertyAttributes attributes;
+ ContextLookupFlags flags = FOLLOW_CHAINS;
+ BindingFlags binding_flags;
+ Handle<Object> holder =
+ context->Lookup(name, flags, &index, &attributes, &binding_flags);
+
+ // If the slot was not found the result is true.
+ if (holder.is_null()) {
+ return isolate->heap()->true_value();
+ }
+
+ // If the slot was found in a context, it should be DONT_DELETE.
+ if (holder->IsContext()) {
+ return isolate->heap()->false_value();
+ }
+
+ // The slot was found in a JSObject, either a context extension object,
+ // the global object, or the subject of a with. Try to delete it
+ // (respecting DONT_DELETE).
+ Handle<JSObject> object = Handle<JSObject>::cast(holder);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+ JSReceiver::DeleteProperty(object, name));
+ return *result;
+}
+
+
+static Object* ComputeReceiverForNonGlobal(Isolate* isolate, JSObject* holder) {
+ DCHECK(!holder->IsGlobalObject());
+ Context* top = isolate->context();
+ // Get the context extension function.
+ JSFunction* context_extension_function =
+ top->native_context()->context_extension_function();
+ // If the holder isn't a context extension object, we just return it
+ // as the receiver. This allows arguments objects to be used as
+ // receivers, but only if they are put in the context scope chain
+ // explicitly via a with-statement.
+ Object* constructor = holder->map()->constructor();
+ if (constructor != context_extension_function) return holder;
+ // Fall back to using the global object as the implicit receiver if
+ // the property turns out to be a local variable allocated in a
+ // context extension object - introduced via eval.
+ return isolate->heap()->undefined_value();
+}
+
+
+static ObjectPair LoadLookupSlotHelper(Arguments args, Isolate* isolate,
+ bool throw_error) {
+ HandleScope scope(isolate);
+ DCHECK_EQ(2, args.length());
+
+ if (!args[0]->IsContext() || !args[1]->IsString()) {
+ return MakePair(isolate->ThrowIllegalOperation(), NULL);
+ }
+ Handle<Context> context = args.at<Context>(0);
+ Handle<String> name = args.at<String>(1);
+
+ int index;
+ PropertyAttributes attributes;
+ ContextLookupFlags flags = FOLLOW_CHAINS;
+ BindingFlags binding_flags;
+ Handle<Object> holder =
+ context->Lookup(name, flags, &index, &attributes, &binding_flags);
+ if (isolate->has_pending_exception()) {
+ return MakePair(isolate->heap()->exception(), NULL);
+ }
+
+ // If the index is non-negative, the slot has been found in a context.
+ if (index >= 0) {
+ DCHECK(holder->IsContext());
+ // If the "property" we were looking for is a local variable, the
+ // receiver is the global object; see ECMA-262, 3rd., 10.1.6 and 10.2.3.
+ Handle<Object> receiver = isolate->factory()->undefined_value();
+ Object* value = Context::cast(*holder)->get(index);
+ // Check for uninitialized bindings.
+ switch (binding_flags) {
+ case MUTABLE_CHECK_INITIALIZED:
+ case IMMUTABLE_CHECK_INITIALIZED_HARMONY:
+ if (value->IsTheHole()) {
+ Handle<Object> error;
+ MaybeHandle<Object> maybe_error =
+ isolate->factory()->NewReferenceError("not_defined",
+ HandleVector(&name, 1));
+ if (maybe_error.ToHandle(&error)) isolate->Throw(*error);
+ return MakePair(isolate->heap()->exception(), NULL);
+ }
+ // FALLTHROUGH
+ case MUTABLE_IS_INITIALIZED:
+ case IMMUTABLE_IS_INITIALIZED:
+ case IMMUTABLE_IS_INITIALIZED_HARMONY:
+ DCHECK(!value->IsTheHole());
+ return MakePair(value, *receiver);
+ case IMMUTABLE_CHECK_INITIALIZED:
+ if (value->IsTheHole()) {
+ DCHECK((attributes & READ_ONLY) != 0);
+ value = isolate->heap()->undefined_value();
+ }
+ return MakePair(value, *receiver);
+ case MISSING_BINDING:
+ UNREACHABLE();
+ return MakePair(NULL, NULL);
+ }
+ }
+
+ // Otherwise, if the slot was found the holder is a context extension
+ // object, subject of a with, or a global object. We read the named
+ // property from it.
+ if (!holder.is_null()) {
+ Handle<JSReceiver> object = Handle<JSReceiver>::cast(holder);
+#ifdef DEBUG
+ if (!object->IsJSProxy()) {
+ Maybe<bool> maybe = JSReceiver::HasProperty(object, name);
+ DCHECK(maybe.has_value);
+ DCHECK(maybe.value);
+ }
+#endif
+ // GetProperty below can cause GC.
+ Handle<Object> receiver_handle(
+ object->IsGlobalObject()
+ ? Object::cast(isolate->heap()->undefined_value())
+ : object->IsJSProxy() ? static_cast<Object*>(*object)
+ : ComputeReceiverForNonGlobal(
+ isolate, JSObject::cast(*object)),
+ isolate);
+
+ // No need to unhole the value here. This is taken care of by the
+ // GetProperty function.
+ Handle<Object> value;
+ ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+ isolate, value, Object::GetProperty(object, name),
+ MakePair(isolate->heap()->exception(), NULL));
+ return MakePair(*value, *receiver_handle);
+ }
+
+ if (throw_error) {
+ // The property doesn't exist - throw exception.
+ Handle<Object> error;
+ MaybeHandle<Object> maybe_error = isolate->factory()->NewReferenceError(
+ "not_defined", HandleVector(&name, 1));
+ if (maybe_error.ToHandle(&error)) isolate->Throw(*error);
+ return MakePair(isolate->heap()->exception(), NULL);
+ } else {
+ // The property doesn't exist - return undefined.
+ return MakePair(isolate->heap()->undefined_value(),
+ isolate->heap()->undefined_value());
+ }
+}
+
+
+RUNTIME_FUNCTION_RETURN_PAIR(Runtime_LoadLookupSlot) {
+ return LoadLookupSlotHelper(args, isolate, true);
+}
+
+
+RUNTIME_FUNCTION_RETURN_PAIR(Runtime_LoadLookupSlotNoReferenceError) {
+ return LoadLookupSlotHelper(args, isolate, false);
+}
+
+
+RUNTIME_FUNCTION(Runtime_StoreLookupSlot) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 4);
+
+ CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
+ CONVERT_ARG_HANDLE_CHECKED(Context, context, 1);
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 2);
+ CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 3);
+
+ int index;
+ PropertyAttributes attributes;
+ ContextLookupFlags flags = FOLLOW_CHAINS;
+ BindingFlags binding_flags;
+ Handle<Object> holder =
+ context->Lookup(name, flags, &index, &attributes, &binding_flags);
+ // In case of JSProxy, an exception might have been thrown.
+ if (isolate->has_pending_exception()) return isolate->heap()->exception();
+
+ // The property was found in a context slot.
+ if (index >= 0) {
+ if ((attributes & READ_ONLY) == 0) {
+ Handle<Context>::cast(holder)->set(index, *value);
+ } else if (strict_mode == STRICT) {
+ // Setting read only property in strict mode.
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate,
+ NewTypeError("strict_cannot_assign", HandleVector(&name, 1)));
+ }
+ return *value;
+ }
+
+ // Slow case: The property is not in a context slot. It is either in a
+ // context extension object, a property of the subject of a with, or a
+ // property of the global object.
+ Handle<JSReceiver> object;
+ if (attributes != ABSENT) {
+ // The property exists on the holder.
+ object = Handle<JSReceiver>::cast(holder);
+ } else if (strict_mode == STRICT) {
+ // If absent in strict mode: throw.
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewReferenceError("not_defined", HandleVector(&name, 1)));
+ } else {
+ // If absent in sloppy mode: add the property to the global object.
+ object = Handle<JSReceiver>(context->global_object());
+ }
+
+ RETURN_FAILURE_ON_EXCEPTION(
+ isolate, Object::SetProperty(object, name, value, strict_mode));
+
+ return *value;
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetArgumentsProperty) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, raw_key, 0);
+
+ // Compute the frame holding the arguments.
+ JavaScriptFrameIterator it(isolate);
+ it.AdvanceToArgumentsFrame();
+ JavaScriptFrame* frame = it.frame();
+
+ // Get the actual number of provided arguments.
+ const uint32_t n = frame->ComputeParametersCount();
+
+ // Try to convert the key to an index. If successful and within
+ // index return the the argument from the frame.
+ uint32_t index;
+ if (raw_key->ToArrayIndex(&index) && index < n) {
+ return frame->GetParameter(index);
+ }
+
+ HandleScope scope(isolate);
+ if (raw_key->IsSymbol()) {
+ Handle<Symbol> symbol = Handle<Symbol>::cast(raw_key);
+ if (symbol->Equals(isolate->native_context()->iterator_symbol())) {
+ return isolate->native_context()->array_values_iterator();
+ }
+ // Lookup in the initial Object.prototype object.
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::GetProperty(isolate->initial_object_prototype(),
+ Handle<Symbol>::cast(raw_key)));
+ return *result;
+ }
+
+ // Convert the key to a string.
+ Handle<Object> converted;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, converted,
+ Execution::ToString(isolate, raw_key));
+ Handle<String> key = Handle<String>::cast(converted);
+
+ // Try to convert the string key into an array index.
+ if (key->AsArrayIndex(&index)) {
+ if (index < n) {
+ return frame->GetParameter(index);
+ } else {
+ Handle<Object> initial_prototype(isolate->initial_object_prototype());
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::GetElement(isolate, initial_prototype, index));
+ return *result;
+ }
+ }
+
+ // Handle special arguments properties.
+ if (String::Equals(isolate->factory()->length_string(), key)) {
+ return Smi::FromInt(n);
+ }
+ if (String::Equals(isolate->factory()->callee_string(), key)) {
+ JSFunction* function = frame->function();
+ if (function->shared()->strict_mode() == STRICT) {
+ THROW_NEW_ERROR_RETURN_FAILURE(
+ isolate, NewTypeError("strict_arguments_callee",
+ HandleVector<Object>(NULL, 0)));
+ }
+ return function;
+ }
+
+ // Lookup in the initial Object.prototype object.
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, result,
+ Object::GetProperty(isolate->initial_object_prototype(), key));
+ return *result;
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_ArgumentsLength) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ JavaScriptFrameIterator it(isolate);
+ JavaScriptFrame* frame = it.frame();
+ return Smi::FromInt(frame->GetArgumentsLength());
+}
+
+
+RUNTIME_FUNCTION(RuntimeReference_Arguments) {
+ SealHandleScope shs(isolate);
+ return __RT_impl_Runtime_GetArgumentsProperty(args, isolate);
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/jsregexp-inl.h"
#include "src/jsregexp.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
#include "src/runtime/string-builder.h"
#include "src/string-search.h"
namespace internal {
+// Perform string match of pattern on subject, starting at start index.
+// Caller must ensure that 0 <= start_index <= sub->length(),
+// and should check that pat->length() + start_index <= sub->length().
+int StringMatch(Isolate* isolate, Handle<String> sub, Handle<String> pat,
+ int start_index) {
+ DCHECK(0 <= start_index);
+ DCHECK(start_index <= sub->length());
+
+ int pattern_length = pat->length();
+ if (pattern_length == 0) return start_index;
+
+ int subject_length = sub->length();
+ if (start_index + pattern_length > subject_length) return -1;
+
+ sub = String::Flatten(sub);
+ pat = String::Flatten(pat);
+
+ DisallowHeapAllocation no_gc; // ensure vectors stay valid
+ // Extract flattened substrings of cons strings before getting encoding.
+ String::FlatContent seq_sub = sub->GetFlatContent();
+ String::FlatContent seq_pat = pat->GetFlatContent();
+
+ // dispatch on type of strings
+ if (seq_pat.IsOneByte()) {
+ Vector<const uint8_t> pat_vector = seq_pat.ToOneByteVector();
+ if (seq_sub.IsOneByte()) {
+ return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+ start_index);
+ }
+ return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector,
+ start_index);
+ }
+ Vector<const uc16> pat_vector = seq_pat.ToUC16Vector();
+ if (seq_sub.IsOneByte()) {
+ return SearchString(isolate, seq_sub.ToOneByteVector(), pat_vector,
+ start_index);
+ }
+ return SearchString(isolate, seq_sub.ToUC16Vector(), pat_vector, start_index);
+}
+
+
// This may return an empty MaybeHandle if an exception is thrown or
// we abort due to reaching the recursion limit.
MaybeHandle<String> StringReplaceOneCharWithString(
return subject;
} else {
- int index = Runtime::StringMatch(isolate, subject, search, 0);
+ int index = StringMatch(isolate, subject, search, 0);
if (index == -1) return subject;
*found = true;
Handle<String> first = isolate->factory()->NewSubString(subject, 0, index);
if (!index->ToArrayIndex(&start_index)) return Smi::FromInt(-1);
RUNTIME_ASSERT(start_index <= static_cast<uint32_t>(sub->length()));
- int position = Runtime::StringMatch(isolate, sub, pat, start_index);
+ int position = StringMatch(isolate, sub, pat, start_index);
return Smi::FromInt(position);
}
// Convert all characters to upper case, assuming that they will fit
// in the buffer
- Access<ConsStringIteratorOp> op(isolate->runtime_state()->string_iterator());
- StringCharacterStream stream(string, op.value());
+ StringCharacterStream stream(string);
unibrow::uchar chars[Converter::kMaxWidth];
// We can assume that the string is not empty
uc32 current = stream.GetNext();
SealHandleScope shs(isolate);
return __RT_impl_Runtime_StringAdd(args, isolate);
}
+
+
+RUNTIME_FUNCTION(RuntimeReference_IsStringWrapperSafeForDefaultValueOf) {
+ UNIMPLEMENTED();
+ return NULL;
+}
}
} // namespace v8::internal
--- /dev/null
+// 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/v8.h"
+
+#include "src/arguments.h"
+#include "src/runtime/runtime-utils.h"
+
+namespace v8 {
+namespace internal {
+
+RUNTIME_FUNCTION(Runtime_CreateSymbol) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
+ Handle<Symbol> symbol = isolate->factory()->NewSymbol();
+ if (name->IsString()) symbol->set_name(*name);
+ return *symbol;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreatePrivateSymbol) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
+ Handle<Symbol> symbol = isolate->factory()->NewPrivateSymbol();
+ if (name->IsString()) symbol->set_name(*name);
+ return *symbol;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreatePrivateOwnSymbol) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
+ RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
+ Handle<Symbol> symbol = isolate->factory()->NewPrivateOwnSymbol();
+ if (name->IsString()) symbol->set_name(*name);
+ return *symbol;
+}
+
+
+RUNTIME_FUNCTION(Runtime_CreateGlobalPrivateOwnSymbol) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
+ Handle<JSObject> registry = isolate->GetSymbolRegistry();
+ Handle<String> part = isolate->factory()->private_intern_string();
+ Handle<Object> privates;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, privates, Object::GetPropertyOrElement(registry, part));
+ Handle<Object> symbol;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, symbol, Object::GetPropertyOrElement(privates, name));
+ if (!symbol->IsSymbol()) {
+ DCHECK(symbol->IsUndefined());
+ symbol = isolate->factory()->NewPrivateSymbol();
+ Handle<Symbol>::cast(symbol)->set_name(*name);
+ Handle<Symbol>::cast(symbol)->set_is_own(true);
+ JSObject::SetProperty(Handle<JSObject>::cast(privates), name, symbol,
+ STRICT).Assert();
+ }
+ return *symbol;
+}
+
+
+RUNTIME_FUNCTION(Runtime_NewSymbolWrapper) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_HANDLE_CHECKED(Symbol, symbol, 0);
+ return *Object::ToObject(isolate, symbol).ToHandleChecked();
+}
+
+
+RUNTIME_FUNCTION(Runtime_SymbolDescription) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Symbol, symbol, 0);
+ return symbol->name();
+}
+
+
+RUNTIME_FUNCTION(Runtime_SymbolRegistry) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+ return *isolate->GetSymbolRegistry();
+}
+
+
+RUNTIME_FUNCTION(Runtime_SymbolIsPrivate) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Symbol, symbol, 0);
+ return isolate->heap()->ToBoolean(symbol->is_private());
+}
+}
+} // namespace v8::internal
#include "src/arguments.h"
#include "src/deoptimizer.h"
#include "src/full-codegen.h"
-#include "src/runtime/runtime.h"
+#include "src/natives.h"
#include "src/runtime/runtime-utils.h"
namespace v8 {
// ShortPrint is available in release mode. Print is not.
os << Brief(args[0]);
#endif
- os << endl;
+ os << std::endl;
return args[0]; // return TOS
}
DCHECK(args.length() == 1);
CONVERT_ARG_CHECKED(String, string, 0);
- ConsStringIteratorOp op;
- StringCharacterStream stream(string, &op);
+ StringCharacterStream stream(string);
while (stream.HasMore()) {
uint16_t character = stream.GetNext();
PrintF("%c", character);
RUNTIME_FUNCTION(Runtime_SystemBreak) {
- SealHandleScope shs(isolate);
+ // The code below doesn't create handles, but when breaking here in GDB
+ // having a handle scope might be useful.
+ HandleScope scope(isolate);
DCHECK(args.length() == 0);
base::OS::DebugBreak();
return isolate->heap()->undefined_value();
}
+RUNTIME_FUNCTION(Runtime_NativeScriptsCount) {
+ DCHECK(args.length() == 0);
+ return Smi::FromInt(Natives::GetBuiltinsCount());
+}
+
+
+// Returns V8 version as a string.
+RUNTIME_FUNCTION(Runtime_GetV8Version) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 0);
+
+ const char* version_string = v8::V8::GetVersion();
+
+ return *isolate->factory()->NewStringFromAsciiChecked(version_string);
+}
+
+
+static int StackSize(Isolate* isolate) {
+ int n = 0;
+ for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) n++;
+ return n;
+}
+
+
+static void PrintTransition(Isolate* isolate, Object* result) {
+ // indentation
+ {
+ const int nmax = 80;
+ int n = StackSize(isolate);
+ if (n <= nmax)
+ PrintF("%4d:%*s", n, n, "");
+ else
+ PrintF("%4d:%*s", n, nmax, "...");
+ }
+
+ if (result == NULL) {
+ JavaScriptFrame::PrintTop(isolate, stdout, true, false);
+ PrintF(" {\n");
+ } else {
+ // function result
+ PrintF("} -> ");
+ result->ShortPrint();
+ PrintF("\n");
+ }
+}
+
+
+RUNTIME_FUNCTION(Runtime_TraceEnter) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 0);
+ PrintTransition(isolate, NULL);
+ return isolate->heap()->undefined_value();
+}
+
+
+RUNTIME_FUNCTION(Runtime_TraceExit) {
+ SealHandleScope shs(isolate);
+ DCHECK(args.length() == 1);
+ CONVERT_ARG_CHECKED(Object, obj, 0);
+ PrintTransition(isolate, obj);
+ return obj; // return TOS
+}
+
+
RUNTIME_FUNCTION(Runtime_HaveSameMap) {
SealHandleScope shs(isolate);
DCHECK(args.length() == 2);
ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION(FastProperties)
#undef ELEMENTS_KIND_CHECK_RUNTIME_FUNCTION
+
+
+#define TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION(Type, type, TYPE, ctype, size) \
+ RUNTIME_FUNCTION(Runtime_HasExternal##Type##Elements) { \
+ CONVERT_ARG_CHECKED(JSObject, obj, 0); \
+ return isolate->heap()->ToBoolean(obj->HasExternal##Type##Elements()); \
+ }
+
+TYPED_ARRAYS(TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION)
+
+#undef TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
+
+
+#define FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION(Type, type, TYPE, ctype, s) \
+ RUNTIME_FUNCTION(Runtime_HasFixed##Type##Elements) { \
+ CONVERT_ARG_CHECKED(JSObject, obj, 0); \
+ return isolate->heap()->ToBoolean(obj->HasFixed##Type##Elements()); \
+ }
+
+TYPED_ARRAYS(FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION)
+
+#undef FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
}
} // namespace v8::internal
array_buffer->set_backing_store(data);
array_buffer->set_flag(Smi::FromInt(0));
array_buffer->set_is_external(is_external);
+ array_buffer->set_is_neuterable(true);
Handle<Object> byte_length =
isolate->factory()->NewNumberFromSize(allocated_length);
}
+RUNTIME_FUNCTION(Runtime_IsTypedArray) {
+ HandleScope scope(isolate);
+ DCHECK(args.length() == 1);
+ return isolate->heap()->ToBoolean(args[0]->IsJSTypedArray());
+}
+
+
RUNTIME_FUNCTION(Runtime_DataViewInitialize) {
HandleScope scope(isolate);
DCHECK(args.length() == 4);
#include "src/arguments.h"
#include "src/conversions.h"
-#include "src/runtime/runtime.h"
#include "src/runtime/runtime-utils.h"
#include "src/string-search.h"
#include "src/utils.h"
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_RUNTIME_UTILS_H_
-#define V8_RUNTIME_UTILS_H_
+#ifndef V8_RUNTIME_RUNTIME_UTILS_H_
+#define V8_RUNTIME_RUNTIME_UTILS_H_
namespace v8 {
#endif
}
#endif
+
}
} // namespace v8::internal
-#endif // V8_RUNTIME_UTILS_H_
+#endif // V8_RUNTIME_RUNTIME_UTILS_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <stdlib.h>
-#include <limits>
-
-#include "src/v8.h"
-
-#include "src/accessors.h"
-#include "src/allocation-site-scopes.h"
-#include "src/api.h"
-#include "src/arguments.h"
-#include "src/bailout-reason.h"
-#include "src/base/cpu.h"
-#include "src/base/platform/platform.h"
-#include "src/bootstrapper.h"
-#include "src/codegen.h"
-#include "src/compilation-cache.h"
-#include "src/compiler.h"
-#include "src/conversions.h"
-#include "src/cpu-profiler.h"
-#include "src/date.h"
-#include "src/dateparser-inl.h"
-#include "src/debug.h"
-#include "src/deoptimizer.h"
-#include "src/execution.h"
-#include "src/full-codegen.h"
-#include "src/global-handles.h"
-#include "src/isolate-inl.h"
-#include "src/liveedit.h"
-#include "src/misc-intrinsics.h"
-#include "src/parser.h"
-#include "src/prototype.h"
-#include "src/runtime/runtime.h"
-#include "src/runtime/runtime-utils.h"
-#include "src/runtime-profiler.h"
-#include "src/scopeinfo.h"
-#include "src/smart-pointers.h"
-#include "src/utils.h"
-#include "src/v8threads.h"
-#include "src/vm-state-inl.h"
-
-
-namespace v8 {
-namespace internal {
-
-// Header of runtime functions.
-#define F(name, number_of_args, result_size) \
- Object* Runtime_##name(int args_length, Object** args_object, \
- Isolate* isolate);
-
-#define P(name, number_of_args, result_size) \
- ObjectPair Runtime_##name(int args_length, Object** args_object, \
- Isolate* isolate);
-
-#define I(name, number_of_args, result_size) \
- Object* RuntimeReference_##name(int args_length, Object** args_object, \
- Isolate* isolate);
-
-RUNTIME_FUNCTION_LIST_RETURN_OBJECT(F)
-RUNTIME_FUNCTION_LIST_RETURN_PAIR(P)
-INLINE_OPTIMIZED_FUNCTION_LIST(F)
-INLINE_FUNCTION_LIST(I)
-
-#undef I
-#undef F
-#undef P
-
-
-static Handle<Map> ComputeObjectLiteralMap(
- Handle<Context> context, Handle<FixedArray> constant_properties,
- bool* is_result_from_cache) {
- Isolate* isolate = context->GetIsolate();
- int properties_length = constant_properties->length();
- int number_of_properties = properties_length / 2;
- // Check that there are only internal strings and array indices among keys.
- int number_of_string_keys = 0;
- for (int p = 0; p != properties_length; p += 2) {
- Object* key = constant_properties->get(p);
- uint32_t element_index = 0;
- if (key->IsInternalizedString()) {
- number_of_string_keys++;
- } else if (key->ToArrayIndex(&element_index)) {
- // An index key does not require space in the property backing store.
- number_of_properties--;
- } else {
- // Bail out as a non-internalized-string non-index key makes caching
- // impossible.
- // DCHECK to make sure that the if condition after the loop is false.
- DCHECK(number_of_string_keys != number_of_properties);
- break;
- }
- }
- // If we only have internalized strings and array indices among keys then we
- // can use the map cache in the native context.
- const int kMaxKeys = 10;
- if ((number_of_string_keys == number_of_properties) &&
- (number_of_string_keys < kMaxKeys)) {
- // Create the fixed array with the key.
- Handle<FixedArray> keys =
- isolate->factory()->NewFixedArray(number_of_string_keys);
- if (number_of_string_keys > 0) {
- int index = 0;
- for (int p = 0; p < properties_length; p += 2) {
- Object* key = constant_properties->get(p);
- if (key->IsInternalizedString()) {
- keys->set(index++, key);
- }
- }
- DCHECK(index == number_of_string_keys);
- }
- *is_result_from_cache = true;
- return isolate->factory()->ObjectLiteralMapFromCache(context, keys);
- }
- *is_result_from_cache = false;
- return Map::Create(isolate, number_of_properties);
-}
-
-
-MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
- Isolate* isolate, Handle<FixedArray> literals,
- Handle<FixedArray> constant_properties);
-
-
-MUST_USE_RESULT static MaybeHandle<Object> CreateObjectLiteralBoilerplate(
- Isolate* isolate, Handle<FixedArray> literals,
- Handle<FixedArray> constant_properties, bool should_have_fast_elements,
- bool has_function_literal) {
- // Get the native context from the literals array. This is the
- // context in which the function was created and we use the object
- // function from this context to create the object literal. We do
- // not use the object function from the current native context
- // because this might be the object function from another context
- // which we should not have access to.
- Handle<Context> context =
- Handle<Context>(JSFunction::NativeContextFromLiterals(*literals));
-
- // In case we have function literals, we want the object to be in
- // slow properties mode for now. We don't go in the map cache because
- // maps with constant functions can't be shared if the functions are
- // not the same (which is the common case).
- bool is_result_from_cache = false;
- Handle<Map> map = has_function_literal
- ? Handle<Map>(context->object_function()->initial_map())
- : ComputeObjectLiteralMap(context, constant_properties,
- &is_result_from_cache);
-
- PretenureFlag pretenure_flag =
- isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
-
- Handle<JSObject> boilerplate =
- isolate->factory()->NewJSObjectFromMap(map, pretenure_flag);
-
- // Normalize the elements of the boilerplate to save space if needed.
- if (!should_have_fast_elements) JSObject::NormalizeElements(boilerplate);
-
- // Add the constant properties to the boilerplate.
- int length = constant_properties->length();
- bool should_transform =
- !is_result_from_cache && boilerplate->HasFastProperties();
- bool should_normalize = should_transform || has_function_literal;
- if (should_normalize) {
- // TODO(verwaest): We might not want to ever normalize here.
- JSObject::NormalizeProperties(boilerplate, KEEP_INOBJECT_PROPERTIES,
- length / 2);
- }
- // TODO(verwaest): Support tracking representations in the boilerplate.
- for (int index = 0; index < length; index += 2) {
- Handle<Object> key(constant_properties->get(index + 0), isolate);
- Handle<Object> value(constant_properties->get(index + 1), isolate);
- if (value->IsFixedArray()) {
- // The value contains the constant_properties of a
- // simple object or array literal.
- Handle<FixedArray> array = Handle<FixedArray>::cast(value);
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, value, CreateLiteralBoilerplate(isolate, literals, array),
- Object);
- }
- MaybeHandle<Object> maybe_result;
- uint32_t element_index = 0;
- if (key->IsInternalizedString()) {
- if (Handle<String>::cast(key)->AsArrayIndex(&element_index)) {
- // Array index as string (uint32).
- if (value->IsUninitialized()) value = handle(Smi::FromInt(0), isolate);
- maybe_result =
- JSObject::SetOwnElement(boilerplate, element_index, value, SLOPPY);
- } else {
- Handle<String> name(String::cast(*key));
- DCHECK(!name->AsArrayIndex(&element_index));
- maybe_result = JSObject::SetOwnPropertyIgnoreAttributes(
- boilerplate, name, value, NONE);
- }
- } else if (key->ToArrayIndex(&element_index)) {
- // Array index (uint32).
- if (value->IsUninitialized()) value = handle(Smi::FromInt(0), isolate);
- maybe_result =
- JSObject::SetOwnElement(boilerplate, element_index, value, SLOPPY);
- } else {
- // Non-uint32 number.
- DCHECK(key->IsNumber());
- double num = key->Number();
- char arr[100];
- Vector<char> buffer(arr, arraysize(arr));
- const char* str = DoubleToCString(num, buffer);
- Handle<String> name = isolate->factory()->NewStringFromAsciiChecked(str);
- maybe_result = JSObject::SetOwnPropertyIgnoreAttributes(boilerplate, name,
- value, NONE);
- }
- // If setting the property on the boilerplate throws an
- // exception, the exception is converted to an empty handle in
- // the handle based operations. In that case, we need to
- // convert back to an exception.
- RETURN_ON_EXCEPTION(isolate, maybe_result, Object);
- }
-
- // Transform to fast properties if necessary. For object literals with
- // containing function literals we defer this operation until after all
- // computed properties have been assigned so that we can generate
- // constant function properties.
- if (should_transform && !has_function_literal) {
- JSObject::MigrateSlowToFast(boilerplate,
- boilerplate->map()->unused_property_fields());
- }
-
- return boilerplate;
-}
-
-
-MUST_USE_RESULT static MaybeHandle<Object> TransitionElements(
- Handle<Object> object, ElementsKind to_kind, Isolate* isolate) {
- HandleScope scope(isolate);
- if (!object->IsJSObject()) {
- isolate->ThrowIllegalOperation();
- return MaybeHandle<Object>();
- }
- ElementsKind from_kind =
- Handle<JSObject>::cast(object)->map()->elements_kind();
- if (Map::IsValidElementsTransition(from_kind, to_kind)) {
- JSObject::TransitionElementsKind(Handle<JSObject>::cast(object), to_kind);
- return object;
- }
- isolate->ThrowIllegalOperation();
- return MaybeHandle<Object>();
-}
-
-
-MaybeHandle<Object> Runtime::CreateArrayLiteralBoilerplate(
- Isolate* isolate, Handle<FixedArray> literals,
- Handle<FixedArray> elements) {
- // Create the JSArray.
- Handle<JSFunction> constructor(
- JSFunction::NativeContextFromLiterals(*literals)->array_function());
-
- PretenureFlag pretenure_flag =
- isolate->heap()->InNewSpace(*literals) ? NOT_TENURED : TENURED;
-
- Handle<JSArray> object = Handle<JSArray>::cast(
- isolate->factory()->NewJSObject(constructor, pretenure_flag));
-
- ElementsKind constant_elements_kind =
- static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
- Handle<FixedArrayBase> constant_elements_values(
- FixedArrayBase::cast(elements->get(1)));
-
- {
- DisallowHeapAllocation no_gc;
- DCHECK(IsFastElementsKind(constant_elements_kind));
- Context* native_context = isolate->context()->native_context();
- Object* maps_array = native_context->js_array_maps();
- DCHECK(!maps_array->IsUndefined());
- Object* map = FixedArray::cast(maps_array)->get(constant_elements_kind);
- object->set_map(Map::cast(map));
- }
-
- Handle<FixedArrayBase> copied_elements_values;
- if (IsFastDoubleElementsKind(constant_elements_kind)) {
- copied_elements_values = isolate->factory()->CopyFixedDoubleArray(
- Handle<FixedDoubleArray>::cast(constant_elements_values));
- } else {
- DCHECK(IsFastSmiOrObjectElementsKind(constant_elements_kind));
- const bool is_cow = (constant_elements_values->map() ==
- isolate->heap()->fixed_cow_array_map());
- if (is_cow) {
- copied_elements_values = constant_elements_values;
-#if DEBUG
- Handle<FixedArray> fixed_array_values =
- Handle<FixedArray>::cast(copied_elements_values);
- for (int i = 0; i < fixed_array_values->length(); i++) {
- DCHECK(!fixed_array_values->get(i)->IsFixedArray());
- }
-#endif
- } else {
- Handle<FixedArray> fixed_array_values =
- Handle<FixedArray>::cast(constant_elements_values);
- Handle<FixedArray> fixed_array_values_copy =
- isolate->factory()->CopyFixedArray(fixed_array_values);
- copied_elements_values = fixed_array_values_copy;
- for (int i = 0; i < fixed_array_values->length(); i++) {
- if (fixed_array_values->get(i)->IsFixedArray()) {
- // The value contains the constant_properties of a
- // simple object or array literal.
- Handle<FixedArray> fa(FixedArray::cast(fixed_array_values->get(i)));
- Handle<Object> result;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, result, CreateLiteralBoilerplate(isolate, literals, fa),
- Object);
- fixed_array_values_copy->set(i, *result);
- }
- }
- }
- }
- object->set_elements(*copied_elements_values);
- object->set_length(Smi::FromInt(copied_elements_values->length()));
-
- JSObject::ValidateElements(object);
- return object;
-}
-
-
-MUST_USE_RESULT static MaybeHandle<Object> CreateLiteralBoilerplate(
- Isolate* isolate, Handle<FixedArray> literals, Handle<FixedArray> array) {
- Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
- const bool kHasNoFunctionLiteral = false;
- switch (CompileTimeValue::GetLiteralType(array)) {
- case CompileTimeValue::OBJECT_LITERAL_FAST_ELEMENTS:
- return CreateObjectLiteralBoilerplate(isolate, literals, elements, true,
- kHasNoFunctionLiteral);
- case CompileTimeValue::OBJECT_LITERAL_SLOW_ELEMENTS:
- return CreateObjectLiteralBoilerplate(isolate, literals, elements, false,
- kHasNoFunctionLiteral);
- case CompileTimeValue::ARRAY_LITERAL:
- return Runtime::CreateArrayLiteralBoilerplate(isolate, literals,
- elements);
- default:
- UNREACHABLE();
- return MaybeHandle<Object>();
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateObjectLiteral) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
- CONVERT_SMI_ARG_CHECKED(literals_index, 1);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, constant_properties, 2);
- CONVERT_SMI_ARG_CHECKED(flags, 3);
- bool should_have_fast_elements = (flags & ObjectLiteral::kFastElements) != 0;
- bool has_function_literal = (flags & ObjectLiteral::kHasFunction) != 0;
-
- RUNTIME_ASSERT(literals_index >= 0 && literals_index < literals->length());
-
- // Check if boilerplate exists. If not, create it first.
- Handle<Object> literal_site(literals->get(literals_index), isolate);
- Handle<AllocationSite> site;
- Handle<JSObject> boilerplate;
- if (*literal_site == isolate->heap()->undefined_value()) {
- Handle<Object> raw_boilerplate;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, raw_boilerplate,
- CreateObjectLiteralBoilerplate(isolate, literals, constant_properties,
- should_have_fast_elements,
- has_function_literal));
- boilerplate = Handle<JSObject>::cast(raw_boilerplate);
-
- AllocationSiteCreationContext creation_context(isolate);
- site = creation_context.EnterNewScope();
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::DeepWalk(boilerplate, &creation_context));
- creation_context.ExitScope(site, boilerplate);
-
- // Update the functions literal and return the boilerplate.
- literals->set(literals_index, *site);
- } else {
- site = Handle<AllocationSite>::cast(literal_site);
- boilerplate =
- Handle<JSObject>(JSObject::cast(site->transition_info()), isolate);
- }
-
- AllocationSiteUsageContext usage_context(isolate, site, true);
- usage_context.EnterNewScope();
- MaybeHandle<Object> maybe_copy =
- JSObject::DeepCopy(boilerplate, &usage_context);
- usage_context.ExitScope(site, boilerplate);
- Handle<Object> copy;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, copy, maybe_copy);
- return *copy;
-}
-
-
-MUST_USE_RESULT static MaybeHandle<AllocationSite> GetLiteralAllocationSite(
- Isolate* isolate, Handle<FixedArray> literals, int literals_index,
- Handle<FixedArray> elements) {
- // Check if boilerplate exists. If not, create it first.
- Handle<Object> literal_site(literals->get(literals_index), isolate);
- Handle<AllocationSite> site;
- if (*literal_site == isolate->heap()->undefined_value()) {
- DCHECK(*elements != isolate->heap()->empty_fixed_array());
- Handle<Object> boilerplate;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, boilerplate,
- Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements),
- AllocationSite);
-
- AllocationSiteCreationContext creation_context(isolate);
- site = creation_context.EnterNewScope();
- if (JSObject::DeepWalk(Handle<JSObject>::cast(boilerplate),
- &creation_context).is_null()) {
- return Handle<AllocationSite>::null();
- }
- creation_context.ExitScope(site, Handle<JSObject>::cast(boilerplate));
-
- literals->set(literals_index, *site);
- } else {
- site = Handle<AllocationSite>::cast(literal_site);
- }
-
- return site;
-}
-
-
-static MaybeHandle<JSObject> CreateArrayLiteralImpl(Isolate* isolate,
- Handle<FixedArray> literals,
- int literals_index,
- Handle<FixedArray> elements,
- int flags) {
- RUNTIME_ASSERT_HANDLIFIED(
- literals_index >= 0 && literals_index < literals->length(), JSObject);
- Handle<AllocationSite> site;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, site,
- GetLiteralAllocationSite(isolate, literals, literals_index, elements),
- JSObject);
-
- bool enable_mementos = (flags & ArrayLiteral::kDisableMementos) == 0;
- Handle<JSObject> boilerplate(JSObject::cast(site->transition_info()));
- AllocationSiteUsageContext usage_context(isolate, site, enable_mementos);
- usage_context.EnterNewScope();
- JSObject::DeepCopyHints hints = (flags & ArrayLiteral::kShallowElements) == 0
- ? JSObject::kNoHints
- : JSObject::kObjectIsShallow;
- MaybeHandle<JSObject> copy =
- JSObject::DeepCopy(boilerplate, &usage_context, hints);
- usage_context.ExitScope(site, boilerplate);
- return copy;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateArrayLiteral) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
- CONVERT_SMI_ARG_CHECKED(literals_index, 1);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
- CONVERT_SMI_ARG_CHECKED(flags, 3);
-
- Handle<JSObject> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, CreateArrayLiteralImpl(isolate, literals, literals_index,
- elements, flags));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateArrayLiteralStubBailout) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 0);
- CONVERT_SMI_ARG_CHECKED(literals_index, 1);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
-
- Handle<JSObject> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- CreateArrayLiteralImpl(isolate, literals, literals_index, elements,
- ArrayLiteral::kShallowElements));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateSymbol) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
- RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
- Handle<Symbol> symbol = isolate->factory()->NewSymbol();
- if (name->IsString()) symbol->set_name(*name);
- return *symbol;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreatePrivateSymbol) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
- RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
- Handle<Symbol> symbol = isolate->factory()->NewPrivateSymbol();
- if (name->IsString()) symbol->set_name(*name);
- return *symbol;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreatePrivateOwnSymbol) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
- RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
- Handle<Symbol> symbol = isolate->factory()->NewPrivateOwnSymbol();
- if (name->IsString()) symbol->set_name(*name);
- return *symbol;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateGlobalPrivateOwnSymbol) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
- Handle<JSObject> registry = isolate->GetSymbolRegistry();
- Handle<String> part = isolate->factory()->private_intern_string();
- Handle<Object> privates;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, privates, Object::GetPropertyOrElement(registry, part));
- Handle<Object> symbol;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, symbol, Object::GetPropertyOrElement(privates, name));
- if (!symbol->IsSymbol()) {
- DCHECK(symbol->IsUndefined());
- symbol = isolate->factory()->NewPrivateSymbol();
- Handle<Symbol>::cast(symbol)->set_name(*name);
- Handle<Symbol>::cast(symbol)->set_is_own(true);
- JSObject::SetProperty(Handle<JSObject>::cast(privates), name, symbol,
- STRICT).Assert();
- }
- return *symbol;
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewSymbolWrapper) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Symbol, symbol, 0);
- return *Object::ToObject(isolate, symbol).ToHandleChecked();
-}
-
-
-RUNTIME_FUNCTION(Runtime_SymbolDescription) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Symbol, symbol, 0);
- return symbol->name();
-}
-
-
-RUNTIME_FUNCTION(Runtime_SymbolRegistry) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- return *isolate->GetSymbolRegistry();
-}
-
-
-RUNTIME_FUNCTION(Runtime_SymbolIsPrivate) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Symbol, symbol, 0);
- return isolate->heap()->ToBoolean(symbol->is_private());
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateJSProxy) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, handler, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
- if (!prototype->IsJSReceiver()) prototype = isolate->factory()->null_value();
- return *isolate->factory()->NewJSProxy(handler, prototype);
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateJSFunctionProxy) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, handler, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, call_trap, 1);
- RUNTIME_ASSERT(call_trap->IsJSFunction() || call_trap->IsJSFunctionProxy());
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, construct_trap, 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 3);
- if (!prototype->IsJSReceiver()) prototype = isolate->factory()->null_value();
- return *isolate->factory()->NewJSFunctionProxy(handler, call_trap,
- construct_trap, prototype);
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsJSProxy) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSProxy());
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsJSFunctionProxy) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSFunctionProxy());
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetHandler) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSProxy, proxy, 0);
- return proxy->handler();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetCallTrap) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunctionProxy, proxy, 0);
- return proxy->call_trap();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetConstructTrap) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunctionProxy, proxy, 0);
- return proxy->construct_trap();
-}
-
-
-RUNTIME_FUNCTION(Runtime_Fix) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSProxy, proxy, 0);
- JSProxy::Fix(proxy);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetPrototype) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);
- // We don't expect access checks to be needed on JSProxy objects.
- DCHECK(!obj->IsAccessCheckNeeded() || obj->IsJSObject());
- PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
- do {
- if (PrototypeIterator::GetCurrent(iter)->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
- isolate->factory()->proto_string(), v8::ACCESS_GET)) {
- isolate->ReportFailedAccessCheck(
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
- v8::ACCESS_GET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return isolate->heap()->undefined_value();
- }
- iter.AdvanceIgnoringProxies();
- if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
- return *PrototypeIterator::GetCurrent(iter);
- }
- } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
- return *PrototypeIterator::GetCurrent(iter);
-}
-
-
-static inline Handle<Object> GetPrototypeSkipHiddenPrototypes(
- Isolate* isolate, Handle<Object> receiver) {
- PrototypeIterator iter(isolate, receiver);
- while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN)) {
- if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
- return PrototypeIterator::GetCurrent(iter);
- }
- iter.Advance();
- }
- return PrototypeIterator::GetCurrent(iter);
-}
-
-
-RUNTIME_FUNCTION(Runtime_InternalSetPrototype) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
- DCHECK(!obj->IsAccessCheckNeeded());
- DCHECK(!obj->map()->is_observed());
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSObject::SetPrototype(obj, prototype, false));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetPrototype) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
- if (obj->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(obj, isolate->factory()->proto_string(),
- v8::ACCESS_SET)) {
- isolate->ReportFailedAccessCheck(obj, v8::ACCESS_SET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return isolate->heap()->undefined_value();
- }
- if (obj->map()->is_observed()) {
- Handle<Object> old_value = GetPrototypeSkipHiddenPrototypes(isolate, obj);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSObject::SetPrototype(obj, prototype, true));
-
- Handle<Object> new_value = GetPrototypeSkipHiddenPrototypes(isolate, obj);
- if (!new_value->SameValue(*old_value)) {
- JSObject::EnqueueChangeRecord(
- obj, "setPrototype", isolate->factory()->proto_string(), old_value);
- }
- return *result;
- }
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSObject::SetPrototype(obj, prototype, true));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsInPrototypeChain) {
- HandleScope shs(isolate);
- DCHECK(args.length() == 2);
- // See ECMA-262, section 15.3.5.3, page 88 (steps 5 - 8).
- CONVERT_ARG_HANDLE_CHECKED(Object, O, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, V, 1);
- PrototypeIterator iter(isolate, V, PrototypeIterator::START_AT_RECEIVER);
- while (true) {
- iter.AdvanceIgnoringProxies();
- if (iter.IsAtEnd()) return isolate->heap()->false_value();
- if (iter.IsAtEnd(O)) return isolate->heap()->true_value();
- }
-}
-
-
-// Enumerator used as indices into the array returned from GetOwnProperty
-enum PropertyDescriptorIndices {
- IS_ACCESSOR_INDEX,
- VALUE_INDEX,
- GETTER_INDEX,
- SETTER_INDEX,
- WRITABLE_INDEX,
- ENUMERABLE_INDEX,
- CONFIGURABLE_INDEX,
- DESCRIPTOR_SIZE
-};
-
-
-MUST_USE_RESULT static MaybeHandle<Object> GetOwnProperty(Isolate* isolate,
- Handle<JSObject> obj,
- Handle<Name> name) {
- Heap* heap = isolate->heap();
- Factory* factory = isolate->factory();
-
- PropertyAttributes attrs;
- uint32_t index = 0;
- Handle<Object> value;
- MaybeHandle<AccessorPair> maybe_accessors;
- // TODO(verwaest): Unify once indexed properties can be handled by the
- // LookupIterator.
- if (name->AsArrayIndex(&index)) {
- // Get attributes.
- Maybe<PropertyAttributes> maybe =
- JSReceiver::GetOwnElementAttribute(obj, index);
- if (!maybe.has_value) return MaybeHandle<Object>();
- attrs = maybe.value;
- if (attrs == ABSENT) return factory->undefined_value();
-
- // Get AccessorPair if present.
- maybe_accessors = JSObject::GetOwnElementAccessorPair(obj, index);
-
- // Get value if not an AccessorPair.
- if (maybe_accessors.is_null()) {
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, value, Runtime::GetElementOrCharAt(isolate, obj, index),
- Object);
- }
- } else {
- // Get attributes.
- LookupIterator it(obj, name, LookupIterator::HIDDEN);
- Maybe<PropertyAttributes> maybe = JSObject::GetPropertyAttributes(&it);
- if (!maybe.has_value) return MaybeHandle<Object>();
- attrs = maybe.value;
- if (attrs == ABSENT) return factory->undefined_value();
-
- // Get AccessorPair if present.
- if (it.state() == LookupIterator::ACCESSOR &&
- it.GetAccessors()->IsAccessorPair()) {
- maybe_accessors = Handle<AccessorPair>::cast(it.GetAccessors());
- }
-
- // Get value if not an AccessorPair.
- if (maybe_accessors.is_null()) {
- ASSIGN_RETURN_ON_EXCEPTION(isolate, value, Object::GetProperty(&it),
- Object);
- }
- }
- DCHECK(!isolate->has_pending_exception());
- Handle<FixedArray> elms = factory->NewFixedArray(DESCRIPTOR_SIZE);
- elms->set(ENUMERABLE_INDEX, heap->ToBoolean((attrs & DONT_ENUM) == 0));
- elms->set(CONFIGURABLE_INDEX, heap->ToBoolean((attrs & DONT_DELETE) == 0));
- elms->set(IS_ACCESSOR_INDEX, heap->ToBoolean(!maybe_accessors.is_null()));
-
- Handle<AccessorPair> accessors;
- if (maybe_accessors.ToHandle(&accessors)) {
- Handle<Object> getter(accessors->GetComponent(ACCESSOR_GETTER), isolate);
- Handle<Object> setter(accessors->GetComponent(ACCESSOR_SETTER), isolate);
- elms->set(GETTER_INDEX, *getter);
- elms->set(SETTER_INDEX, *setter);
- } else {
- elms->set(WRITABLE_INDEX, heap->ToBoolean((attrs & READ_ONLY) == 0));
- elms->set(VALUE_INDEX, *value);
- }
-
- return factory->NewJSArrayWithElements(elms);
-}
-
-
-// Returns an array with the property description:
-// if args[1] is not a property on args[0]
-// returns undefined
-// if args[1] is a data property on args[0]
-// [false, value, Writeable, Enumerable, Configurable]
-// if args[1] is an accessor on args[0]
-// [true, GetFunction, SetFunction, Enumerable, Configurable]
-RUNTIME_FUNCTION(Runtime_GetOwnProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
- GetOwnProperty(isolate, obj, name));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_PreventExtensions) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
- JSObject::PreventExtensions(obj));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_ToMethod) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- Handle<JSFunction> clone = JSFunction::CloneClosure(fun);
- Handle<Symbol> home_object_symbol(isolate->heap()->home_object_symbol());
- JSObject::SetOwnPropertyIgnoreAttributes(clone, home_object_symbol,
- home_object, DONT_ENUM).Assert();
- return *clone;
-}
-
-
-RUNTIME_FUNCTION(Runtime_HomeObjectSymbol) {
- DCHECK(args.length() == 0);
- return isolate->heap()->home_object_symbol();
-}
-
-
-RUNTIME_FUNCTION(Runtime_LoadFromSuper) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
-
- if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(home_object, name, v8::ACCESS_GET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_GET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- }
-
- PrototypeIterator iter(isolate, home_object);
- Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
- if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
-
- LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Object::GetProperty(&it));
- return *result;
-}
-
-
-static Object* StoreToSuper(Isolate* isolate, Handle<JSObject> home_object,
- Handle<Object> receiver, Handle<Name> name,
- Handle<Object> value, StrictMode strict_mode) {
- if (home_object->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(home_object, name, v8::ACCESS_SET)) {
- isolate->ReportFailedAccessCheck(home_object, v8::ACCESS_SET);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- }
-
- PrototypeIterator iter(isolate, home_object);
- Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
- if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
-
- LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::SetProperty(&it, value, strict_mode,
- Object::CERTAINLY_NOT_STORE_FROM_KEYED,
- Object::SUPER_PROPERTY));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_StoreToSuper_Strict) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 3);
-
- return StoreToSuper(isolate, home_object, receiver, name, value, STRICT);
-}
-
-
-RUNTIME_FUNCTION(Runtime_StoreToSuper_Sloppy) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 3);
-
- return StoreToSuper(isolate, home_object, receiver, name, value, SLOPPY);
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsExtensible) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSObject, obj, 0);
- if (obj->IsJSGlobalProxy()) {
- PrototypeIterator iter(isolate, obj);
- if (iter.IsAtEnd()) return isolate->heap()->false_value();
- DCHECK(iter.GetCurrent()->IsJSGlobalObject());
- obj = JSObject::cast(iter.GetCurrent());
- }
- return isolate->heap()->ToBoolean(obj->map()->is_extensible());
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateApiFunction) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(FunctionTemplateInfo, data, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
- return *isolate->factory()->CreateApiFunction(data, prototype);
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsTemplate) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, arg, 0);
- bool result = arg->IsObjectTemplateInfo() || arg->IsFunctionTemplateInfo();
- return isolate->heap()->ToBoolean(result);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetTemplateField) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(HeapObject, templ, 0);
- CONVERT_SMI_ARG_CHECKED(index, 1);
- int offset = index * kPointerSize + HeapObject::kHeaderSize;
- InstanceType type = templ->map()->instance_type();
- RUNTIME_ASSERT(type == FUNCTION_TEMPLATE_INFO_TYPE ||
- type == OBJECT_TEMPLATE_INFO_TYPE);
- RUNTIME_ASSERT(offset > 0);
- if (type == FUNCTION_TEMPLATE_INFO_TYPE) {
- RUNTIME_ASSERT(offset < FunctionTemplateInfo::kSize);
- } else {
- RUNTIME_ASSERT(offset < ObjectTemplateInfo::kSize);
- }
- return *HeapObject::RawField(templ, offset);
-}
-
-
-RUNTIME_FUNCTION(Runtime_DisableAccessChecks) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(HeapObject, object, 0);
- Handle<Map> old_map(object->map());
- bool needs_access_checks = old_map->is_access_check_needed();
- if (needs_access_checks) {
- // Copy map so it won't interfere constructor's initial map.
- Handle<Map> new_map = Map::Copy(old_map);
- new_map->set_is_access_check_needed(false);
- JSObject::MigrateToMap(Handle<JSObject>::cast(object), new_map);
- }
- return isolate->heap()->ToBoolean(needs_access_checks);
-}
-
-
-RUNTIME_FUNCTION(Runtime_EnableAccessChecks) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- Handle<Map> old_map(object->map());
- RUNTIME_ASSERT(!old_map->is_access_check_needed());
- // Copy map so it won't interfere constructor's initial map.
- Handle<Map> new_map = Map::Copy(old_map);
- new_map->set_is_access_check_needed(true);
- JSObject::MigrateToMap(object, new_map);
- return isolate->heap()->undefined_value();
-}
-
-
-static Object* ThrowRedeclarationError(Isolate* isolate, Handle<String> name) {
- HandleScope scope(isolate);
- Handle<Object> args[1] = {name};
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewTypeError("var_redeclaration", HandleVector(args, 1)));
-}
-
-
-// May throw a RedeclarationError.
-static Object* DeclareGlobals(Isolate* isolate, Handle<GlobalObject> global,
- Handle<String> name, Handle<Object> value,
- PropertyAttributes attr, bool is_var,
- bool is_const, bool is_function) {
- // Do the lookup own properties only, see ES5 erratum.
- LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- if (!maybe.has_value) return isolate->heap()->exception();
-
- if (it.IsFound()) {
- PropertyAttributes old_attributes = maybe.value;
- // The name was declared before; check for conflicting re-declarations.
- if (is_const) return ThrowRedeclarationError(isolate, name);
-
- // Skip var re-declarations.
- if (is_var) return isolate->heap()->undefined_value();
-
- DCHECK(is_function);
- if ((old_attributes & DONT_DELETE) != 0) {
- // Only allow reconfiguring globals to functions in user code (no
- // natives, which are marked as read-only).
- DCHECK((attr & READ_ONLY) == 0);
-
- // Check whether we can reconfigure the existing property into a
- // function.
- PropertyDetails old_details = it.property_details();
- // TODO(verwaest): CALLBACKS invalidly includes ExecutableAccessInfo,
- // which are actually data properties, not accessor properties.
- if (old_details.IsReadOnly() || old_details.IsDontEnum() ||
- old_details.type() == CALLBACKS) {
- return ThrowRedeclarationError(isolate, name);
- }
- // If the existing property is not configurable, keep its attributes. Do
- attr = old_attributes;
- }
- }
-
- // Define or redefine own property.
- RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- global, name, value, attr));
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- Handle<GlobalObject> global(isolate->global_object());
-
- CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, pairs, 1);
- CONVERT_SMI_ARG_CHECKED(flags, 2);
-
- // Traverse the name/value pairs and set the properties.
- int length = pairs->length();
- for (int i = 0; i < length; i += 2) {
- HandleScope scope(isolate);
- Handle<String> name(String::cast(pairs->get(i)));
- Handle<Object> initial_value(pairs->get(i + 1), isolate);
-
- // We have to declare a global const property. To capture we only
- // assign to it when evaluating the assignment for "const x =
- // <expr>" the initial value is the hole.
- bool is_var = initial_value->IsUndefined();
- bool is_const = initial_value->IsTheHole();
- bool is_function = initial_value->IsSharedFunctionInfo();
- DCHECK(is_var + is_const + is_function == 1);
-
- Handle<Object> value;
- if (is_function) {
- // Copy the function and update its context. Use it as value.
- Handle<SharedFunctionInfo> shared =
- Handle<SharedFunctionInfo>::cast(initial_value);
- Handle<JSFunction> function =
- isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
- TENURED);
- value = function;
- } else {
- value = isolate->factory()->undefined_value();
- }
-
- // Compute the property attributes. According to ECMA-262,
- // the property must be non-configurable except in eval.
- bool is_native = DeclareGlobalsNativeFlag::decode(flags);
- bool is_eval = DeclareGlobalsEvalFlag::decode(flags);
- int attr = NONE;
- if (is_const) attr |= READ_ONLY;
- if (is_function && is_native) attr |= READ_ONLY;
- if (!is_const && !is_eval) attr |= DONT_DELETE;
-
- Object* result = DeclareGlobals(isolate, global, name, value,
- static_cast<PropertyAttributes>(attr),
- is_var, is_const, is_function);
- if (isolate->has_pending_exception()) return result;
- }
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_InitializeVarGlobal) {
- HandleScope scope(isolate);
- // args[0] == name
- // args[1] == language_mode
- // args[2] == value (optional)
-
- // Determine if we need to assign to the variable if it already
- // exists (based on the number of arguments).
- RUNTIME_ASSERT(args.length() == 3);
-
- CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
- CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
-
- Handle<GlobalObject> global(isolate->context()->global_object());
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, Object::SetProperty(global, name, value, strict_mode));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_InitializeConstGlobal) {
- HandleScope handle_scope(isolate);
- // All constants are declared with an initial value. The name
- // of the constant is the first argument and the initial value
- // is the second.
- RUNTIME_ASSERT(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
-
- Handle<GlobalObject> global = isolate->global_object();
-
- // Lookup the property as own on the global object.
- LookupIterator it(global, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- DCHECK(maybe.has_value);
- PropertyAttributes old_attributes = maybe.value;
-
- PropertyAttributes attr =
- static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
- // Set the value if the property is either missing, or the property attributes
- // allow setting the value without invoking an accessor.
- if (it.IsFound()) {
- // Ignore if we can't reconfigure the value.
- if ((old_attributes & DONT_DELETE) != 0) {
- if ((old_attributes & READ_ONLY) != 0 ||
- it.state() == LookupIterator::ACCESSOR) {
- return *value;
- }
- attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
- }
- }
-
- RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- global, name, value, attr));
-
- return *value;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DeclareLookupSlot) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
-
- // Declarations are always made in a function, native, or global context. In
- // the case of eval code, the context passed is the context of the caller,
- // which may be some nested context and not the declaration context.
- CONVERT_ARG_HANDLE_CHECKED(Context, context_arg, 0);
- Handle<Context> context(context_arg->declaration_context());
- CONVERT_ARG_HANDLE_CHECKED(String, name, 1);
- CONVERT_SMI_ARG_CHECKED(attr_arg, 2);
- PropertyAttributes attr = static_cast<PropertyAttributes>(attr_arg);
- RUNTIME_ASSERT(attr == READ_ONLY || attr == NONE);
- CONVERT_ARG_HANDLE_CHECKED(Object, initial_value, 3);
-
- // TODO(verwaest): Unify the encoding indicating "var" with DeclareGlobals.
- bool is_var = *initial_value == NULL;
- bool is_const = initial_value->IsTheHole();
- bool is_function = initial_value->IsJSFunction();
- DCHECK(is_var + is_const + is_function == 1);
-
- int index;
- PropertyAttributes attributes;
- ContextLookupFlags flags = DONT_FOLLOW_CHAINS;
- BindingFlags binding_flags;
- Handle<Object> holder =
- context->Lookup(name, flags, &index, &attributes, &binding_flags);
-
- Handle<JSObject> object;
- Handle<Object> value =
- is_function ? initial_value
- : Handle<Object>::cast(isolate->factory()->undefined_value());
-
- // TODO(verwaest): This case should probably not be covered by this function,
- // but by DeclareGlobals instead.
- if ((attributes != ABSENT && holder->IsJSGlobalObject()) ||
- (context_arg->has_extension() &&
- context_arg->extension()->IsJSGlobalObject())) {
- return DeclareGlobals(isolate, Handle<JSGlobalObject>::cast(holder), name,
- value, attr, is_var, is_const, is_function);
- }
-
- if (attributes != ABSENT) {
- // The name was declared before; check for conflicting re-declarations.
- if (is_const || (attributes & READ_ONLY) != 0) {
- return ThrowRedeclarationError(isolate, name);
- }
-
- // Skip var re-declarations.
- if (is_var) return isolate->heap()->undefined_value();
-
- DCHECK(is_function);
- if (index >= 0) {
- DCHECK(holder.is_identical_to(context));
- context->set(index, *initial_value);
- return isolate->heap()->undefined_value();
- }
-
- object = Handle<JSObject>::cast(holder);
-
- } else if (context->has_extension()) {
- object = handle(JSObject::cast(context->extension()));
- DCHECK(object->IsJSContextExtensionObject() || object->IsJSGlobalObject());
- } else {
- DCHECK(context->IsFunctionContext());
- object =
- isolate->factory()->NewJSObject(isolate->context_extension_function());
- context->set_extension(*object);
- }
-
- RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- object, name, value, attr));
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_InitializeLegacyConstLookupSlot) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
-
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
- DCHECK(!value->IsTheHole());
- // Initializations are always done in a function or native context.
- CONVERT_ARG_HANDLE_CHECKED(Context, context_arg, 1);
- Handle<Context> context(context_arg->declaration_context());
- CONVERT_ARG_HANDLE_CHECKED(String, name, 2);
-
- int index;
- PropertyAttributes attributes;
- ContextLookupFlags flags = DONT_FOLLOW_CHAINS;
- BindingFlags binding_flags;
- Handle<Object> holder =
- context->Lookup(name, flags, &index, &attributes, &binding_flags);
-
- if (index >= 0) {
- DCHECK(holder->IsContext());
- // Property was found in a context. Perform the assignment if the constant
- // was uninitialized.
- Handle<Context> context = Handle<Context>::cast(holder);
- DCHECK((attributes & READ_ONLY) != 0);
- if (context->get(index)->IsTheHole()) context->set(index, *value);
- return *value;
- }
-
- PropertyAttributes attr =
- static_cast<PropertyAttributes>(DONT_DELETE | READ_ONLY);
-
- // Strict mode handling not needed (legacy const is disallowed in strict
- // mode).
-
- // The declared const was configurable, and may have been deleted in the
- // meanwhile. If so, re-introduce the variable in the context extension.
- DCHECK(context_arg->has_extension());
- if (attributes == ABSENT) {
- holder = handle(context_arg->extension(), isolate);
- } else {
- // For JSContextExtensionObjects, the initializer can be run multiple times
- // if in a for loop: for (var i = 0; i < 2; i++) { const x = i; }. Only the
- // first assignment should go through. For JSGlobalObjects, additionally any
- // code can run in between that modifies the declared property.
- DCHECK(holder->IsJSGlobalObject() || holder->IsJSContextExtensionObject());
-
- LookupIterator it(holder, name, LookupIterator::HIDDEN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- if (!maybe.has_value) return isolate->heap()->exception();
- PropertyAttributes old_attributes = maybe.value;
-
- // Ignore if we can't reconfigure the value.
- if ((old_attributes & DONT_DELETE) != 0) {
- if ((old_attributes & READ_ONLY) != 0 ||
- it.state() == LookupIterator::ACCESSOR) {
- return *value;
- }
- attr = static_cast<PropertyAttributes>(old_attributes | READ_ONLY);
- }
- }
-
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- Handle<JSObject>::cast(holder), name, value, attr));
-
- return *value;
-}
-
-
-RUNTIME_FUNCTION(Runtime_OptimizeObjectForAddingMultipleProperties) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_SMI_ARG_CHECKED(properties, 1);
- // Conservative upper limit to prevent fuzz tests from going OOM.
- RUNTIME_ASSERT(properties <= 100000);
- if (object->HasFastProperties() && !object->IsJSGlobalProxy()) {
- JSObject::NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, properties);
- }
- return *object;
-}
-
-
-RUNTIME_FUNCTION(Runtime_FinishArrayPrototypeSetup) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, prototype, 0);
- Object* length = prototype->length();
- RUNTIME_ASSERT(length->IsSmi() && Smi::cast(length)->value() == 0);
- RUNTIME_ASSERT(prototype->HasFastSmiOrObjectElements());
- // This is necessary to enable fast checks for absence of elements
- // on Array.prototype and below.
- prototype->set_elements(isolate->heap()->empty_fixed_array());
- return Smi::FromInt(0);
-}
-
-
-static void InstallBuiltin(Isolate* isolate, Handle<JSObject> holder,
- const char* name, Builtins::Name builtin_name) {
- Handle<String> key = isolate->factory()->InternalizeUtf8String(name);
- Handle<Code> code(isolate->builtins()->builtin(builtin_name));
- Handle<JSFunction> optimized =
- isolate->factory()->NewFunctionWithoutPrototype(key, code);
- optimized->shared()->DontAdaptArguments();
- JSObject::AddProperty(holder, key, optimized, NONE);
-}
-
-
-RUNTIME_FUNCTION(Runtime_SpecialArrayFunctions) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- Handle<JSObject> holder =
- isolate->factory()->NewJSObject(isolate->object_function());
-
- InstallBuiltin(isolate, holder, "pop", Builtins::kArrayPop);
- InstallBuiltin(isolate, holder, "push", Builtins::kArrayPush);
- InstallBuiltin(isolate, holder, "shift", Builtins::kArrayShift);
- InstallBuiltin(isolate, holder, "unshift", Builtins::kArrayUnshift);
- InstallBuiltin(isolate, holder, "slice", Builtins::kArraySlice);
- InstallBuiltin(isolate, holder, "splice", Builtins::kArraySplice);
- InstallBuiltin(isolate, holder, "concat", Builtins::kArrayConcat);
-
- return *holder;
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsSloppyModeFunction) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSReceiver, callable, 0);
- if (!callable->IsJSFunction()) {
- HandleScope scope(isolate);
- Handle<Object> delegate;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, delegate, Execution::TryGetFunctionDelegate(
- isolate, Handle<JSReceiver>(callable)));
- callable = JSFunction::cast(*delegate);
- }
- JSFunction* function = JSFunction::cast(callable);
- SharedFunctionInfo* shared = function->shared();
- return isolate->heap()->ToBoolean(shared->strict_mode() == SLOPPY);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetDefaultReceiver) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSReceiver, callable, 0);
-
- if (!callable->IsJSFunction()) {
- HandleScope scope(isolate);
- Handle<Object> delegate;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, delegate, Execution::TryGetFunctionDelegate(
- isolate, Handle<JSReceiver>(callable)));
- callable = JSFunction::cast(*delegate);
- }
- JSFunction* function = JSFunction::cast(callable);
-
- SharedFunctionInfo* shared = function->shared();
- if (shared->native() || shared->strict_mode() == STRICT) {
- return isolate->heap()->undefined_value();
- }
- // Returns undefined for strict or native functions, or
- // the associated global receiver for "normal" functions.
-
- return function->global_proxy();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetName) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return f->shared()->name();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionSetName) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- CONVERT_ARG_CHECKED(String, name, 1);
- f->shared()->set_name(name);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionNameShouldPrintAsAnonymous) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(
- f->shared()->name_should_print_as_anonymous());
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionMarkNameShouldPrintAsAnonymous) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- f->shared()->set_name_should_print_as_anonymous(true);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionIsGenerator) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(f->shared()->is_generator());
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionIsArrow) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(f->shared()->is_arrow());
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionIsConciseMethod) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(f->shared()->is_concise_method());
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionRemovePrototype) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- RUNTIME_ASSERT(f->RemovePrototype());
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetScript) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, fun, 0);
- Handle<Object> script = Handle<Object>(fun->shared()->script(), isolate);
- if (!script->IsScript()) return isolate->heap()->undefined_value();
-
- return *Script::GetWrapper(Handle<Script>::cast(script));
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetSourceCode) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, f, 0);
- Handle<SharedFunctionInfo> shared(f->shared());
- return *shared->GetSourceCode();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetScriptSourcePosition) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, fun, 0);
- int pos = fun->shared()->start_position();
- return Smi::FromInt(pos);
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetPositionForOffset) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_CHECKED(Code, code, 0);
- CONVERT_NUMBER_CHECKED(int, offset, Int32, args[1]);
-
- RUNTIME_ASSERT(0 <= offset && offset < code->Size());
-
- Address pc = code->address() + offset;
- return Smi::FromInt(code->SourcePosition(pc));
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionSetInstanceClassName) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_CHECKED(JSFunction, fun, 0);
- CONVERT_ARG_CHECKED(String, name, 1);
- fun->SetInstanceClassName(name);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionSetLength) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_CHECKED(JSFunction, fun, 0);
- CONVERT_SMI_ARG_CHECKED(length, 1);
- RUNTIME_ASSERT((length & 0xC0000000) == 0xC0000000 ||
- (length & 0xC0000000) == 0x0);
- fun->shared()->set_length(length);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionSetPrototype) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
- RUNTIME_ASSERT(fun->should_have_prototype());
- Accessors::FunctionSetPrototype(fun, value);
- return args[0]; // return TOS
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionIsAPIFunction) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(f->shared()->IsApiFunction());
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionIsBuiltin) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return isolate->heap()->ToBoolean(f->IsBuiltin());
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetCode) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, source, 1);
-
- Handle<SharedFunctionInfo> target_shared(target->shared());
- Handle<SharedFunctionInfo> source_shared(source->shared());
- RUNTIME_ASSERT(!source_shared->bound());
-
- if (!Compiler::EnsureCompiled(source, KEEP_EXCEPTION)) {
- return isolate->heap()->exception();
- }
-
- // Mark both, the source and the target, as un-flushable because the
- // shared unoptimized code makes them impossible to enqueue in a list.
- DCHECK(target_shared->code()->gc_metadata() == NULL);
- DCHECK(source_shared->code()->gc_metadata() == NULL);
- target_shared->set_dont_flush(true);
- source_shared->set_dont_flush(true);
-
- // Set the code, scope info, formal parameter count, and the length
- // of the target shared function info.
- target_shared->ReplaceCode(source_shared->code());
- target_shared->set_scope_info(source_shared->scope_info());
- target_shared->set_length(source_shared->length());
- target_shared->set_feedback_vector(source_shared->feedback_vector());
- target_shared->set_formal_parameter_count(
- source_shared->formal_parameter_count());
- target_shared->set_script(source_shared->script());
- target_shared->set_start_position_and_type(
- source_shared->start_position_and_type());
- target_shared->set_end_position(source_shared->end_position());
- bool was_native = target_shared->native();
- target_shared->set_compiler_hints(source_shared->compiler_hints());
- target_shared->set_native(was_native);
- target_shared->set_profiler_ticks(source_shared->profiler_ticks());
-
- // Set the code of the target function.
- target->ReplaceCode(source_shared->code());
- DCHECK(target->next_function_link()->IsUndefined());
-
- // Make sure we get a fresh copy of the literal vector to avoid cross
- // context contamination.
- Handle<Context> context(source->context());
- int number_of_literals = source->NumberOfLiterals();
- Handle<FixedArray> literals =
- isolate->factory()->NewFixedArray(number_of_literals, TENURED);
- if (number_of_literals > 0) {
- literals->set(JSFunction::kLiteralNativeContextIndex,
- context->native_context());
- }
- target->set_context(*context);
- target->set_literals(*literals);
-
- if (isolate->logger()->is_logging_code_events() ||
- isolate->cpu_profiler()->is_profiling()) {
- isolate->logger()->LogExistingFunction(source_shared,
- Handle<Code>(source_shared->code()));
- }
-
- return *target;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CreateJSGeneratorObject) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-
- JavaScriptFrameIterator it(isolate);
- JavaScriptFrame* frame = it.frame();
- Handle<JSFunction> function(frame->function());
- RUNTIME_ASSERT(function->shared()->is_generator());
-
- Handle<JSGeneratorObject> generator;
- if (frame->IsConstructor()) {
- generator = handle(JSGeneratorObject::cast(frame->receiver()));
- } else {
- generator = isolate->factory()->NewJSGeneratorObject(function);
- }
- generator->set_function(*function);
- generator->set_context(Context::cast(frame->context()));
- generator->set_receiver(frame->receiver());
- generator->set_continuation(0);
- generator->set_operand_stack(isolate->heap()->empty_fixed_array());
- generator->set_stack_handler_index(-1);
-
- return *generator;
-}
-
-
-RUNTIME_FUNCTION(Runtime_SuspendJSGeneratorObject) {
- HandleScope handle_scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator_object, 0);
-
- JavaScriptFrameIterator stack_iterator(isolate);
- JavaScriptFrame* frame = stack_iterator.frame();
- RUNTIME_ASSERT(frame->function()->shared()->is_generator());
- DCHECK_EQ(frame->function(), generator_object->function());
-
- // The caller should have saved the context and continuation already.
- DCHECK_EQ(generator_object->context(), Context::cast(frame->context()));
- DCHECK_LT(0, generator_object->continuation());
-
- // We expect there to be at least two values on the operand stack: the return
- // value of the yield expression, and the argument to this runtime call.
- // Neither of those should be saved.
- int operands_count = frame->ComputeOperandsCount();
- DCHECK_GE(operands_count, 2);
- operands_count -= 2;
-
- if (operands_count == 0) {
- // Although it's semantically harmless to call this function with an
- // operands_count of zero, it is also unnecessary.
- DCHECK_EQ(generator_object->operand_stack(),
- isolate->heap()->empty_fixed_array());
- DCHECK_EQ(generator_object->stack_handler_index(), -1);
- // If there are no operands on the stack, there shouldn't be a handler
- // active either.
- DCHECK(!frame->HasHandler());
- } else {
- int stack_handler_index = -1;
- Handle<FixedArray> operand_stack =
- isolate->factory()->NewFixedArray(operands_count);
- frame->SaveOperandStack(*operand_stack, &stack_handler_index);
- generator_object->set_operand_stack(*operand_stack);
- generator_object->set_stack_handler_index(stack_handler_index);
- }
-
- return isolate->heap()->undefined_value();
-}
-
-
-// Note that this function is the slow path for resuming generators. It is only
-// called if the suspended activation had operands on the stack, stack handlers
-// needing rewinding, or if the resume should throw an exception. The fast path
-// is handled directly in FullCodeGenerator::EmitGeneratorResume(), which is
-// inlined into GeneratorNext and GeneratorThrow. EmitGeneratorResumeResume is
-// called in any case, as it needs to reconstruct the stack frame and make space
-// for arguments and operands.
-RUNTIME_FUNCTION(Runtime_ResumeJSGeneratorObject) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_CHECKED(JSGeneratorObject, generator_object, 0);
- CONVERT_ARG_CHECKED(Object, value, 1);
- CONVERT_SMI_ARG_CHECKED(resume_mode_int, 2);
- JavaScriptFrameIterator stack_iterator(isolate);
- JavaScriptFrame* frame = stack_iterator.frame();
-
- DCHECK_EQ(frame->function(), generator_object->function());
- DCHECK(frame->function()->is_compiled());
-
- STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
- STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
-
- Address pc = generator_object->function()->code()->instruction_start();
- int offset = generator_object->continuation();
- DCHECK(offset > 0);
- frame->set_pc(pc + offset);
- if (FLAG_enable_ool_constant_pool) {
- frame->set_constant_pool(
- generator_object->function()->code()->constant_pool());
- }
- generator_object->set_continuation(JSGeneratorObject::kGeneratorExecuting);
-
- FixedArray* operand_stack = generator_object->operand_stack();
- int operands_count = operand_stack->length();
- if (operands_count != 0) {
- frame->RestoreOperandStack(operand_stack,
- generator_object->stack_handler_index());
- generator_object->set_operand_stack(isolate->heap()->empty_fixed_array());
- generator_object->set_stack_handler_index(-1);
- }
-
- JSGeneratorObject::ResumeMode resume_mode =
- static_cast<JSGeneratorObject::ResumeMode>(resume_mode_int);
- switch (resume_mode) {
- case JSGeneratorObject::NEXT:
- return value;
- case JSGeneratorObject::THROW:
- return isolate->Throw(value);
- }
-
- UNREACHABLE();
- return isolate->ThrowIllegalOperation();
-}
-
-
-RUNTIME_FUNCTION(Runtime_ThrowGeneratorStateError) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
- int continuation = generator->continuation();
- const char* message = continuation == JSGeneratorObject::kGeneratorClosed
- ? "generator_finished"
- : "generator_running";
- Vector<Handle<Object> > argv = HandleVector<Object>(NULL, 0);
- THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewError(message, argv));
-}
-
-
-RUNTIME_FUNCTION(Runtime_ObjectFreeze) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
-
- // %ObjectFreeze is a fast path and these cases are handled elsewhere.
- RUNTIME_ASSERT(!object->HasSloppyArgumentsElements() &&
- !object->map()->is_observed() && !object->IsJSProxy());
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, JSObject::Freeze(object));
- return *result;
-}
-
-
-// Returns a single character string where first character equals
-// string->Get(index).
-static Handle<Object> GetCharAt(Handle<String> string, uint32_t index) {
- if (index < static_cast<uint32_t>(string->length())) {
- Factory* factory = string->GetIsolate()->factory();
- return factory->LookupSingleCharacterStringFromCode(
- String::Flatten(string)->Get(index));
- }
- return Execution::CharAt(string, index);
-}
-
-
-MaybeHandle<Object> Runtime::GetElementOrCharAt(Isolate* isolate,
- Handle<Object> object,
- uint32_t index) {
- // Handle [] indexing on Strings
- if (object->IsString()) {
- Handle<Object> result = GetCharAt(Handle<String>::cast(object), index);
- if (!result->IsUndefined()) return result;
- }
-
- // Handle [] indexing on String objects
- if (object->IsStringObjectWithCharacterAt(index)) {
- Handle<JSValue> js_value = Handle<JSValue>::cast(object);
- Handle<Object> result =
- GetCharAt(Handle<String>(String::cast(js_value->value())), index);
- if (!result->IsUndefined()) return result;
- }
-
- Handle<Object> result;
- if (object->IsString() || object->IsNumber() || object->IsBoolean()) {
- PrototypeIterator iter(isolate, object);
- return Object::GetElement(isolate, PrototypeIterator::GetCurrent(iter),
- index);
- } else {
- return Object::GetElement(isolate, object, index);
- }
-}
-
-
-MUST_USE_RESULT
-static MaybeHandle<Name> ToName(Isolate* isolate, Handle<Object> key) {
- if (key->IsName()) {
- return Handle<Name>::cast(key);
- } else {
- Handle<Object> converted;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
- Execution::ToString(isolate, key), Name);
- return Handle<Name>::cast(converted);
- }
-}
-
-
-MaybeHandle<Object> Runtime::HasObjectProperty(Isolate* isolate,
- Handle<JSReceiver> object,
- Handle<Object> key) {
- Maybe<bool> maybe;
- // Check if the given key is an array index.
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- maybe = JSReceiver::HasElement(object, index);
- } else {
- // Convert the key to a name - possibly by calling back into JavaScript.
- Handle<Name> name;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, name, ToName(isolate, key), Object);
-
- maybe = JSReceiver::HasProperty(object, name);
- }
-
- if (!maybe.has_value) return MaybeHandle<Object>();
- return isolate->factory()->ToBoolean(maybe.value);
-}
-
-
-MaybeHandle<Object> Runtime::GetObjectProperty(Isolate* isolate,
- Handle<Object> object,
- Handle<Object> key) {
- if (object->IsUndefined() || object->IsNull()) {
- Handle<Object> args[2] = {key, object};
- THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_load",
- HandleVector(args, 2)),
- Object);
- }
-
- // Check if the given key is an array index.
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- return GetElementOrCharAt(isolate, object, index);
- }
-
- // Convert the key to a name - possibly by calling back into JavaScript.
- Handle<Name> name;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, name, ToName(isolate, key), Object);
-
- // Check if the name is trivially convertible to an index and get
- // the element if so.
- if (name->AsArrayIndex(&index)) {
- return GetElementOrCharAt(isolate, object, index);
- } else {
- return Object::GetProperty(object, name);
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, Runtime::GetObjectProperty(isolate, object, key));
- return *result;
-}
-
-
-// KeyedGetProperty is called from KeyedLoadIC::GenerateGeneric.
-RUNTIME_FUNCTION(Runtime_KeyedGetProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver_obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key_obj, 1);
-
- // Fast cases for getting named properties of the receiver JSObject
- // itself.
- //
- // The global proxy objects has to be excluded since LookupOwn on
- // the global proxy object can return a valid result even though the
- // global proxy object never has properties. This is the case
- // because the global proxy object forwards everything to its hidden
- // prototype including own lookups.
- //
- // Additionally, we need to make sure that we do not cache results
- // for objects that require access checks.
- if (receiver_obj->IsJSObject()) {
- if (!receiver_obj->IsJSGlobalProxy() &&
- !receiver_obj->IsAccessCheckNeeded() && key_obj->IsName()) {
- DisallowHeapAllocation no_allocation;
- Handle<JSObject> receiver = Handle<JSObject>::cast(receiver_obj);
- Handle<Name> key = Handle<Name>::cast(key_obj);
- if (receiver->HasFastProperties()) {
- // Attempt to use lookup cache.
- Handle<Map> receiver_map(receiver->map(), isolate);
- KeyedLookupCache* keyed_lookup_cache = isolate->keyed_lookup_cache();
- int index = keyed_lookup_cache->Lookup(receiver_map, key);
- if (index != -1) {
- // Doubles are not cached, so raw read the value.
- return receiver->RawFastPropertyAt(
- FieldIndex::ForKeyedLookupCacheIndex(*receiver_map, index));
- }
- // Lookup cache miss. Perform lookup and update the cache if
- // appropriate.
- LookupIterator it(receiver, key, LookupIterator::OWN);
- if (it.state() == LookupIterator::DATA &&
- it.property_details().type() == FIELD) {
- FieldIndex field_index = it.GetFieldIndex();
- // Do not track double fields in the keyed lookup cache. Reading
- // double values requires boxing.
- if (!it.representation().IsDouble()) {
- keyed_lookup_cache->Update(receiver_map, key,
- field_index.GetKeyedLookupCacheIndex());
- }
- AllowHeapAllocation allow_allocation;
- return *JSObject::FastPropertyAt(receiver, it.representation(),
- field_index);
- }
- } else {
- // Attempt dictionary lookup.
- NameDictionary* dictionary = receiver->property_dictionary();
- int entry = dictionary->FindEntry(key);
- if ((entry != NameDictionary::kNotFound) &&
- (dictionary->DetailsAt(entry).type() == NORMAL)) {
- Object* value = dictionary->ValueAt(entry);
- if (!receiver->IsGlobalObject()) return value;
- value = PropertyCell::cast(value)->value();
- if (!value->IsTheHole()) return value;
- // If value is the hole (meaning, absent) do the general lookup.
- }
- }
- } else if (key_obj->IsSmi()) {
- // JSObject without a name key. If the key is a Smi, check for a
- // definite out-of-bounds access to elements, which is a strong indicator
- // that subsequent accesses will also call the runtime. Proactively
- // transition elements to FAST_*_ELEMENTS to avoid excessive boxing of
- // doubles for those future calls in the case that the elements would
- // become FAST_DOUBLE_ELEMENTS.
- Handle<JSObject> js_object = Handle<JSObject>::cast(receiver_obj);
- ElementsKind elements_kind = js_object->GetElementsKind();
- if (IsFastDoubleElementsKind(elements_kind)) {
- Handle<Smi> key = Handle<Smi>::cast(key_obj);
- if (key->value() >= js_object->elements()->length()) {
- if (IsFastHoleyElementsKind(elements_kind)) {
- elements_kind = FAST_HOLEY_ELEMENTS;
- } else {
- elements_kind = FAST_ELEMENTS;
- }
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, TransitionElements(js_object, elements_kind, isolate));
- }
- } else {
- DCHECK(IsFastSmiOrObjectElementsKind(elements_kind) ||
- !IsFastElementsKind(elements_kind));
- }
- }
- } else if (receiver_obj->IsString() && key_obj->IsSmi()) {
- // Fast case for string indexing using [] with a smi index.
- Handle<String> str = Handle<String>::cast(receiver_obj);
- int index = args.smi_at(1);
- if (index >= 0 && index < str->length()) {
- return *GetCharAt(str, index);
- }
- }
-
- // Fall back to GetObjectProperty.
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Runtime::GetObjectProperty(isolate, receiver_obj, key_obj));
- return *result;
-}
-
-
-static bool IsValidAccessor(Handle<Object> obj) {
- return obj->IsUndefined() || obj->IsSpecFunction() || obj->IsNull();
-}
-
-
-// Transform getter or setter into something DefineAccessor can handle.
-static Handle<Object> InstantiateAccessorComponent(Isolate* isolate,
- Handle<Object> component) {
- if (component->IsUndefined()) return isolate->factory()->undefined_value();
- Handle<FunctionTemplateInfo> info =
- Handle<FunctionTemplateInfo>::cast(component);
- return Utils::OpenHandle(*Utils::ToLocal(info)->GetFunction());
-}
-
-
-RUNTIME_FUNCTION(Runtime_DefineApiAccessorProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 5);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, getter, 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, setter, 3);
- CONVERT_SMI_ARG_CHECKED(attribute, 4);
- RUNTIME_ASSERT(getter->IsUndefined() || getter->IsFunctionTemplateInfo());
- RUNTIME_ASSERT(setter->IsUndefined() || setter->IsFunctionTemplateInfo());
- RUNTIME_ASSERT(PropertyDetails::AttributesField::is_valid(
- static_cast<PropertyAttributes>(attribute)));
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::DefineAccessor(
- object, name, InstantiateAccessorComponent(isolate, getter),
- InstantiateAccessorComponent(isolate, setter),
- static_cast<PropertyAttributes>(attribute)));
- return isolate->heap()->undefined_value();
-}
-
-
-// Implements part of 8.12.9 DefineOwnProperty.
-// There are 3 cases that lead here:
-// Step 4b - define a new accessor property.
-// Steps 9c & 12 - replace an existing data property with an accessor property.
-// Step 12 - update an existing accessor property with an accessor or generic
-// descriptor.
-RUNTIME_FUNCTION(Runtime_DefineAccessorPropertyUnchecked) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 5);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- RUNTIME_ASSERT(!obj->IsNull());
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, getter, 2);
- RUNTIME_ASSERT(IsValidAccessor(getter));
- CONVERT_ARG_HANDLE_CHECKED(Object, setter, 3);
- RUNTIME_ASSERT(IsValidAccessor(setter));
- CONVERT_SMI_ARG_CHECKED(unchecked, 4);
- RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
-
- bool fast = obj->HasFastProperties();
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::DefineAccessor(obj, name, getter, setter, attr));
- if (fast) JSObject::MigrateSlowToFast(obj, 0);
- return isolate->heap()->undefined_value();
-}
-
-
-// Implements part of 8.12.9 DefineOwnProperty.
-// There are 3 cases that lead here:
-// Step 4a - define a new data property.
-// Steps 9b & 12 - replace an existing accessor property with a data property.
-// Step 12 - update an existing data property with a data or generic
-// descriptor.
-RUNTIME_FUNCTION(Runtime_DefineDataPropertyUnchecked) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, js_object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, obj_value, 2);
- CONVERT_SMI_ARG_CHECKED(unchecked, 3);
- RUNTIME_ASSERT((unchecked & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- PropertyAttributes attr = static_cast<PropertyAttributes>(unchecked);
-
- LookupIterator it(js_object, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
- if (it.IsFound() && it.state() == LookupIterator::ACCESS_CHECK) {
- if (!isolate->MayNamedAccess(js_object, name, v8::ACCESS_SET)) {
- return isolate->heap()->undefined_value();
- }
- it.Next();
- }
-
- // Take special care when attributes are different and there is already
- // a property.
- if (it.state() == LookupIterator::ACCESSOR) {
- // Use IgnoreAttributes version since a readonly property may be
- // overridden and SetProperty does not allow this.
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- JSObject::SetOwnPropertyIgnoreAttributes(
- js_object, name, obj_value, attr, JSObject::DONT_FORCE_FIELD));
- return *result;
- }
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Runtime::DefineObjectProperty(js_object, name, obj_value, attr));
- return *result;
-}
-
-
-// Return property without being observable by accessors or interceptors.
-RUNTIME_FUNCTION(Runtime_GetDataProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
- return *JSObject::GetDataProperty(object, key);
-}
-
-
-MaybeHandle<Object> Runtime::SetObjectProperty(Isolate* isolate,
- Handle<Object> object,
- Handle<Object> key,
- Handle<Object> value,
- StrictMode strict_mode) {
- if (object->IsUndefined() || object->IsNull()) {
- Handle<Object> args[2] = {key, object};
- THROW_NEW_ERROR(isolate, NewTypeError("non_object_property_store",
- HandleVector(args, 2)),
- Object);
- }
-
- if (object->IsJSProxy()) {
- Handle<Object> name_object;
- if (key->IsSymbol()) {
- name_object = key;
- } else {
- ASSIGN_RETURN_ON_EXCEPTION(isolate, name_object,
- Execution::ToString(isolate, key), Object);
- }
- Handle<Name> name = Handle<Name>::cast(name_object);
- return Object::SetProperty(Handle<JSProxy>::cast(object), name, value,
- strict_mode);
- }
-
- // Check if the given key is an array index.
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- // TODO(verwaest): Support non-JSObject receivers.
- if (!object->IsJSObject()) return value;
- Handle<JSObject> js_object = Handle<JSObject>::cast(object);
-
- // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
- // of a string using [] notation. We need to support this too in
- // JavaScript.
- // In the case of a String object we just need to redirect the assignment to
- // the underlying string if the index is in range. Since the underlying
- // string does nothing with the assignment then we can ignore such
- // assignments.
- if (js_object->IsStringObjectWithCharacterAt(index)) {
- return value;
- }
-
- JSObject::ValidateElements(js_object);
- if (js_object->HasExternalArrayElements() ||
- js_object->HasFixedTypedArrayElements()) {
- if (!value->IsNumber() && !value->IsUndefined()) {
- ASSIGN_RETURN_ON_EXCEPTION(isolate, value,
- Execution::ToNumber(isolate, value), Object);
- }
- }
-
- MaybeHandle<Object> result = JSObject::SetElement(
- js_object, index, value, NONE, strict_mode, true, SET_PROPERTY);
- JSObject::ValidateElements(js_object);
-
- return result.is_null() ? result : value;
- }
-
- if (key->IsName()) {
- Handle<Name> name = Handle<Name>::cast(key);
- if (name->AsArrayIndex(&index)) {
- // TODO(verwaest): Support non-JSObject receivers.
- if (!object->IsJSObject()) return value;
- Handle<JSObject> js_object = Handle<JSObject>::cast(object);
- if (js_object->HasExternalArrayElements()) {
- if (!value->IsNumber() && !value->IsUndefined()) {
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, value, Execution::ToNumber(isolate, value), Object);
- }
- }
- return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
- true, SET_PROPERTY);
- } else {
- if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
- return Object::SetProperty(object, name, value, strict_mode);
- }
- }
-
- // Call-back into JavaScript to convert the key to a string.
- Handle<Object> converted;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
- Execution::ToString(isolate, key), Object);
- Handle<String> name = Handle<String>::cast(converted);
-
- if (name->AsArrayIndex(&index)) {
- // TODO(verwaest): Support non-JSObject receivers.
- if (!object->IsJSObject()) return value;
- Handle<JSObject> js_object = Handle<JSObject>::cast(object);
- return JSObject::SetElement(js_object, index, value, NONE, strict_mode,
- true, SET_PROPERTY);
- }
- return Object::SetProperty(object, name, value, strict_mode);
-}
-
-
-MaybeHandle<Object> Runtime::DefineObjectProperty(Handle<JSObject> js_object,
- Handle<Object> key,
- Handle<Object> value,
- PropertyAttributes attr) {
- Isolate* isolate = js_object->GetIsolate();
- // Check if the given key is an array index.
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- // In Firefox/SpiderMonkey, Safari and Opera you can access the characters
- // of a string using [] notation. We need to support this too in
- // JavaScript.
- // In the case of a String object we just need to redirect the assignment to
- // the underlying string if the index is in range. Since the underlying
- // string does nothing with the assignment then we can ignore such
- // assignments.
- if (js_object->IsStringObjectWithCharacterAt(index)) {
- return value;
- }
-
- return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
- DEFINE_PROPERTY);
- }
-
- if (key->IsName()) {
- Handle<Name> name = Handle<Name>::cast(key);
- if (name->AsArrayIndex(&index)) {
- return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
- DEFINE_PROPERTY);
- } else {
- if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
- return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
- attr);
- }
- }
-
- // Call-back into JavaScript to convert the key to a string.
- Handle<Object> converted;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
- Execution::ToString(isolate, key), Object);
- Handle<String> name = Handle<String>::cast(converted);
-
- if (name->AsArrayIndex(&index)) {
- return JSObject::SetElement(js_object, index, value, attr, SLOPPY, false,
- DEFINE_PROPERTY);
- } else {
- return JSObject::SetOwnPropertyIgnoreAttributes(js_object, name, value,
- attr);
- }
-}
-
-
-MaybeHandle<Object> Runtime::DeleteObjectProperty(Isolate* isolate,
- Handle<JSReceiver> receiver,
- Handle<Object> key,
- JSReceiver::DeleteMode mode) {
- // Check if the given key is an array index.
- uint32_t index;
- if (key->ToArrayIndex(&index)) {
- // In Firefox/SpiderMonkey, Safari and Opera you can access the
- // characters of a string using [] notation. In the case of a
- // String object we just need to redirect the deletion to the
- // underlying string if the index is in range. Since the
- // underlying string does nothing with the deletion, we can ignore
- // such deletions.
- if (receiver->IsStringObjectWithCharacterAt(index)) {
- return isolate->factory()->true_value();
- }
-
- return JSReceiver::DeleteElement(receiver, index, mode);
- }
-
- Handle<Name> name;
- if (key->IsName()) {
- name = Handle<Name>::cast(key);
- } else {
- // Call-back into JavaScript to convert the key to a string.
- Handle<Object> converted;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, converted,
- Execution::ToString(isolate, key), Object);
- name = Handle<String>::cast(converted);
- }
-
- if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
- return JSReceiver::DeleteProperty(receiver, name, mode);
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetHiddenProperty) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 3);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- RUNTIME_ASSERT(key->IsUniqueName());
- return *JSObject::SetHiddenProperty(object, key, value);
-}
-
-
-RUNTIME_FUNCTION(Runtime_AddNamedProperty) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
- RUNTIME_ASSERT(
- (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- // Compute attributes.
- PropertyAttributes attributes =
- static_cast<PropertyAttributes>(unchecked_attributes);
-
-#ifdef DEBUG
- uint32_t index = 0;
- DCHECK(!key->ToArrayIndex(&index));
- LookupIterator it(object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- if (!maybe.has_value) return isolate->heap()->exception();
- RUNTIME_ASSERT(!it.IsFound());
-#endif
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- JSObject::SetOwnPropertyIgnoreAttributes(object, key, value, attributes));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_AddPropertyForTemplate) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
- RUNTIME_ASSERT(
- (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- // Compute attributes.
- PropertyAttributes attributes =
- static_cast<PropertyAttributes>(unchecked_attributes);
-
-#ifdef DEBUG
- bool duplicate;
- if (key->IsName()) {
- LookupIterator it(object, Handle<Name>::cast(key),
- LookupIterator::OWN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- DCHECK(maybe.has_value);
- duplicate = it.IsFound();
- } else {
- uint32_t index = 0;
- RUNTIME_ASSERT(key->ToArrayIndex(&index));
- Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index);
- if (!maybe.has_value) return isolate->heap()->exception();
- duplicate = maybe.value;
- }
- if (duplicate) {
- Handle<Object> args[1] = {key};
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewTypeError("duplicate_template_property", HandleVector(args, 1)));
- }
-#endif
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Runtime::DefineObjectProperty(object, key, value, attributes));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetProperty) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_arg, 3);
- StrictMode strict_mode = strict_mode_arg;
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Runtime::SetObjectProperty(isolate, object, key, value, strict_mode));
- return *result;
-}
-
-
-// Adds an element to an array.
-// This is used to create an indexed data property into an array.
-RUNTIME_FUNCTION(Runtime_AddElement) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
- RUNTIME_ASSERT(
- (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- // Compute attributes.
- PropertyAttributes attributes =
- static_cast<PropertyAttributes>(unchecked_attributes);
-
- uint32_t index = 0;
- key->ToArrayIndex(&index);
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSObject::SetElement(object, index, value, attributes,
- SLOPPY, false, DEFINE_PROPERTY));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_TransitionElementsKind) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
- CONVERT_ARG_HANDLE_CHECKED(Map, map, 1);
- JSObject::TransitionElementsKind(array, map->elements_kind());
- return *array;
-}
-
-
-// Set the native flag on the function.
-// This is used to decide if we should transform null and undefined
-// into the global object when doing call and apply.
-RUNTIME_FUNCTION(Runtime_SetNativeFlag) {
- SealHandleScope shs(isolate);
- RUNTIME_ASSERT(args.length() == 1);
-
- CONVERT_ARG_CHECKED(Object, object, 0);
-
- if (object->IsJSFunction()) {
- JSFunction* func = JSFunction::cast(object);
- func->shared()->set_native(true);
- }
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetInlineBuiltinFlag) {
- SealHandleScope shs(isolate);
- RUNTIME_ASSERT(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
-
- if (object->IsJSFunction()) {
- JSFunction* func = JSFunction::cast(*object);
- func->shared()->set_inline_builtin(true);
- }
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_StoreArrayLiteralElement) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 5);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_SMI_ARG_CHECKED(store_index, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, literals, 3);
- CONVERT_SMI_ARG_CHECKED(literal_index, 4);
-
- Object* raw_literal_cell = literals->get(literal_index);
- JSArray* boilerplate = NULL;
- if (raw_literal_cell->IsAllocationSite()) {
- AllocationSite* site = AllocationSite::cast(raw_literal_cell);
- boilerplate = JSArray::cast(site->transition_info());
- } else {
- boilerplate = JSArray::cast(raw_literal_cell);
- }
- Handle<JSArray> boilerplate_object(boilerplate);
- ElementsKind elements_kind = object->GetElementsKind();
- DCHECK(IsFastElementsKind(elements_kind));
- // Smis should never trigger transitions.
- DCHECK(!value->IsSmi());
-
- if (value->IsNumber()) {
- DCHECK(IsFastSmiElementsKind(elements_kind));
- ElementsKind transitioned_kind = IsFastHoleyElementsKind(elements_kind)
- ? FAST_HOLEY_DOUBLE_ELEMENTS
- : FAST_DOUBLE_ELEMENTS;
- if (IsMoreGeneralElementsKindTransition(
- boilerplate_object->GetElementsKind(), transitioned_kind)) {
- JSObject::TransitionElementsKind(boilerplate_object, transitioned_kind);
- }
- JSObject::TransitionElementsKind(object, transitioned_kind);
- DCHECK(IsFastDoubleElementsKind(object->GetElementsKind()));
- FixedDoubleArray* double_array = FixedDoubleArray::cast(object->elements());
- HeapNumber* number = HeapNumber::cast(*value);
- double_array->set(store_index, number->Number());
- } else {
- if (!IsFastObjectElementsKind(elements_kind)) {
- ElementsKind transitioned_kind = IsFastHoleyElementsKind(elements_kind)
- ? FAST_HOLEY_ELEMENTS
- : FAST_ELEMENTS;
- JSObject::TransitionElementsKind(object, transitioned_kind);
- ElementsKind boilerplate_elements_kind =
- boilerplate_object->GetElementsKind();
- if (IsMoreGeneralElementsKindTransition(boilerplate_elements_kind,
- transitioned_kind)) {
- JSObject::TransitionElementsKind(boilerplate_object, transitioned_kind);
- }
- }
- FixedArray* object_array = FixedArray::cast(object->elements());
- object_array->set(store_index, *value);
- }
- return *object;
-}
-
-
-// Check whether debugger and is about to step into the callback that is passed
-// to a built-in function such as Array.forEach.
-RUNTIME_FUNCTION(Runtime_DebugCallbackSupportsStepping) {
- DCHECK(args.length() == 1);
- if (!isolate->debug()->is_active() || !isolate->debug()->StepInActive()) {
- return isolate->heap()->false_value();
- }
- CONVERT_ARG_CHECKED(Object, callback, 0);
- // We do not step into the callback if it's a builtin or not even a function.
- return isolate->heap()->ToBoolean(callback->IsJSFunction() &&
- !JSFunction::cast(callback)->IsBuiltin());
-}
-
-
-// Set one shot breakpoints for the callback function that is passed to a
-// built-in function such as Array.forEach to enable stepping into the callback.
-RUNTIME_FUNCTION(Runtime_DebugPrepareStepInIfStepping) {
- DCHECK(args.length() == 1);
- Debug* debug = isolate->debug();
- if (!debug->IsStepping()) return isolate->heap()->undefined_value();
-
- HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- RUNTIME_ASSERT(object->IsJSFunction() || object->IsJSGeneratorObject());
- Handle<JSFunction> fun;
- if (object->IsJSFunction()) {
- fun = Handle<JSFunction>::cast(object);
- } else {
- fun = Handle<JSFunction>(
- Handle<JSGeneratorObject>::cast(object)->function(), isolate);
- }
- // When leaving the function, step out has been activated, but not performed
- // if we do not leave the builtin. To be able to step into the function
- // again, we need to clear the step out at this point.
- debug->ClearStepOut();
- debug->FloodWithOneShot(fun);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugPushPromise) {
- DCHECK(args.length() == 1);
- HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
- isolate->PushPromise(promise);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugPopPromise) {
- DCHECK(args.length() == 0);
- SealHandleScope shs(isolate);
- isolate->PopPromise();
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugPromiseEvent) {
- DCHECK(args.length() == 1);
- HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, data, 0);
- isolate->debug()->OnPromiseEvent(data);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugPromiseRejectEvent) {
- DCHECK(args.length() == 2);
- HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, promise, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
- isolate->debug()->OnPromiseReject(promise, value);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugAsyncTaskEvent) {
- DCHECK(args.length() == 1);
- HandleScope scope(isolate);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, data, 0);
- isolate->debug()->OnAsyncTaskEvent(data);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DeleteProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
- CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 2);
- JSReceiver::DeleteMode delete_mode = strict_mode == STRICT
- ? JSReceiver::STRICT_DELETION
- : JSReceiver::NORMAL_DELETION;
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSReceiver::DeleteProperty(object, key, delete_mode));
- return *result;
-}
-
-
-static Object* HasOwnPropertyImplementation(Isolate* isolate,
- Handle<JSObject> object,
- Handle<Name> key) {
- Maybe<bool> maybe = JSReceiver::HasOwnProperty(object, key);
- if (!maybe.has_value) return isolate->heap()->exception();
- if (maybe.value) return isolate->heap()->true_value();
- // Handle hidden prototypes. If there's a hidden prototype above this thing
- // then we have to check it for properties, because they are supposed to
- // look like they are on this object.
- PrototypeIterator iter(isolate, object);
- if (!iter.IsAtEnd() &&
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter))
- ->map()
- ->is_hidden_prototype()) {
- // TODO(verwaest): The recursion is not necessary for keys that are array
- // indices. Removing this.
- return HasOwnPropertyImplementation(
- isolate, Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
- key);
- }
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return isolate->heap()->false_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_HasOwnProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0)
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
-
- uint32_t index;
- const bool key_is_array_index = key->AsArrayIndex(&index);
-
- // Only JS objects can have properties.
- if (object->IsJSObject()) {
- Handle<JSObject> js_obj = Handle<JSObject>::cast(object);
- // Fast case: either the key is a real named property or it is not
- // an array index and there are no interceptors or hidden
- // prototypes.
- Maybe<bool> maybe = JSObject::HasRealNamedProperty(js_obj, key);
- if (!maybe.has_value) return isolate->heap()->exception();
- DCHECK(!isolate->has_pending_exception());
- if (maybe.value) {
- return isolate->heap()->true_value();
- }
- Map* map = js_obj->map();
- if (!key_is_array_index && !map->has_named_interceptor() &&
- !HeapObject::cast(map->prototype())->map()->is_hidden_prototype()) {
- return isolate->heap()->false_value();
- }
- // Slow case.
- return HasOwnPropertyImplementation(isolate, Handle<JSObject>(js_obj),
- Handle<Name>(key));
- } else if (object->IsString() && key_is_array_index) {
- // Well, there is one exception: Handle [] on strings.
- Handle<String> string = Handle<String>::cast(object);
- if (index < static_cast<uint32_t>(string->length())) {
- return isolate->heap()->true_value();
- }
- }
- return isolate->heap()->false_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_HasProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
-
- Maybe<bool> maybe = JSReceiver::HasProperty(receiver, key);
- if (!maybe.has_value) return isolate->heap()->exception();
- return isolate->heap()->ToBoolean(maybe.value);
-}
-
-
-RUNTIME_FUNCTION(Runtime_HasElement) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
- CONVERT_SMI_ARG_CHECKED(index, 1);
-
- Maybe<bool> maybe = JSReceiver::HasElement(receiver, index);
- if (!maybe.has_value) return isolate->heap()->exception();
- return isolate->heap()->ToBoolean(maybe.value);
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsPropertyEnumerable) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
-
- Maybe<PropertyAttributes> maybe =
- JSReceiver::GetOwnPropertyAttributes(object, key);
- if (!maybe.has_value) return isolate->heap()->exception();
- if (maybe.value == ABSENT) maybe.value = DONT_ENUM;
- return isolate->heap()->ToBoolean((maybe.value & DONT_ENUM) == 0);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetPropertyNames) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0);
- Handle<JSArray> result;
-
- isolate->counters()->for_in()->Increment();
- Handle<FixedArray> elements;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, elements,
- JSReceiver::GetKeys(object, JSReceiver::INCLUDE_PROTOS));
- return *isolate->factory()->NewJSArrayWithElements(elements);
-}
-
-
-// Returns either a FixedArray as Runtime_GetPropertyNames,
-// or, if the given object has an enum cache that contains
-// all enumerable properties of the object and its prototypes
-// have none, the map of the object. This is used to speed up
-// the check for deletions during a for-in.
-RUNTIME_FUNCTION(Runtime_GetPropertyNamesFast) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSReceiver, raw_object, 0);
-
- if (raw_object->IsSimpleEnum()) return raw_object->map();
-
- HandleScope scope(isolate);
- Handle<JSReceiver> object(raw_object);
- Handle<FixedArray> content;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, content,
- JSReceiver::GetKeys(object, JSReceiver::INCLUDE_PROTOS));
-
- // Test again, since cache may have been built by preceding call.
- if (object->IsSimpleEnum()) return object->map();
-
- return *content;
-}
-
-
-// Find the length of the prototype chain that is to be handled as one. If a
-// prototype object is hidden it is to be viewed as part of the the object it
-// is prototype for.
-static int OwnPrototypeChainLength(JSObject* obj) {
- int count = 1;
- for (PrototypeIterator iter(obj->GetIsolate(), obj);
- !iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN); iter.Advance()) {
- count++;
- }
- return count;
-}
-
-
-// Return the names of the own named properties.
-// args[0]: object
-// args[1]: PropertyAttributes as int
-RUNTIME_FUNCTION(Runtime_GetOwnPropertyNames) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- if (!args[0]->IsJSObject()) {
- return isolate->heap()->undefined_value();
- }
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_SMI_ARG_CHECKED(filter_value, 1);
- PropertyAttributes filter = static_cast<PropertyAttributes>(filter_value);
-
- // Skip the global proxy as it has no properties and always delegates to the
- // real global object.
- if (obj->IsJSGlobalProxy()) {
- // Only collect names if access is permitted.
- if (obj->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(obj, isolate->factory()->undefined_value(),
- v8::ACCESS_KEYS)) {
- isolate->ReportFailedAccessCheck(obj, v8::ACCESS_KEYS);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return *isolate->factory()->NewJSArray(0);
- }
- PrototypeIterator iter(isolate, obj);
- obj = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- }
-
- // Find the number of objects making up this.
- int length = OwnPrototypeChainLength(*obj);
-
- // Find the number of own properties for each of the objects.
- ScopedVector<int> own_property_count(length);
- int total_property_count = 0;
- {
- PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
- for (int i = 0; i < length; i++) {
- DCHECK(!iter.IsAtEnd());
- Handle<JSObject> jsproto =
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- // Only collect names if access is permitted.
- if (jsproto->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(jsproto,
- isolate->factory()->undefined_value(),
- v8::ACCESS_KEYS)) {
- isolate->ReportFailedAccessCheck(jsproto, v8::ACCESS_KEYS);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return *isolate->factory()->NewJSArray(0);
- }
- int n;
- n = jsproto->NumberOfOwnProperties(filter);
- own_property_count[i] = n;
- total_property_count += n;
- iter.Advance();
- }
- }
-
- // Allocate an array with storage for all the property names.
- Handle<FixedArray> names =
- isolate->factory()->NewFixedArray(total_property_count);
-
- // Get the property names.
- int next_copy_index = 0;
- int hidden_strings = 0;
- {
- PrototypeIterator iter(isolate, obj, PrototypeIterator::START_AT_RECEIVER);
- for (int i = 0; i < length; i++) {
- DCHECK(!iter.IsAtEnd());
- Handle<JSObject> jsproto =
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- jsproto->GetOwnPropertyNames(*names, next_copy_index, filter);
- if (i > 0) {
- // Names from hidden prototypes may already have been added
- // for inherited function template instances. Count the duplicates
- // and stub them out; the final copy pass at the end ignores holes.
- for (int j = next_copy_index;
- j < next_copy_index + own_property_count[i]; j++) {
- Object* name_from_hidden_proto = names->get(j);
- for (int k = 0; k < next_copy_index; k++) {
- if (names->get(k) != isolate->heap()->hidden_string()) {
- Object* name = names->get(k);
- if (name_from_hidden_proto == name) {
- names->set(j, isolate->heap()->hidden_string());
- hidden_strings++;
- break;
- }
- }
- }
- }
- }
- next_copy_index += own_property_count[i];
-
- // Hidden properties only show up if the filter does not skip strings.
- if ((filter & STRING) == 0 && JSObject::HasHiddenProperties(jsproto)) {
- hidden_strings++;
- }
- iter.Advance();
- }
- }
-
- // Filter out name of hidden properties object and
- // hidden prototype duplicates.
- if (hidden_strings > 0) {
- Handle<FixedArray> old_names = names;
- names = isolate->factory()->NewFixedArray(names->length() - hidden_strings);
- int dest_pos = 0;
- for (int i = 0; i < total_property_count; i++) {
- Object* name = old_names->get(i);
- if (name == isolate->heap()->hidden_string()) {
- hidden_strings--;
- continue;
- }
- names->set(dest_pos++, name);
- }
- DCHECK_EQ(0, hidden_strings);
- }
-
- return *isolate->factory()->NewJSArrayWithElements(names);
-}
-
-
-// Return the names of the own indexed properties.
-// args[0]: object
-RUNTIME_FUNCTION(Runtime_GetOwnElementNames) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- if (!args[0]->IsJSObject()) {
- return isolate->heap()->undefined_value();
- }
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
-
- int n = obj->NumberOfOwnElements(static_cast<PropertyAttributes>(NONE));
- Handle<FixedArray> names = isolate->factory()->NewFixedArray(n);
- obj->GetOwnElementKeys(*names, static_cast<PropertyAttributes>(NONE));
- return *isolate->factory()->NewJSArrayWithElements(names);
-}
-
-
-// Return information on whether an object has a named or indexed interceptor.
-// args[0]: object
-RUNTIME_FUNCTION(Runtime_GetInterceptorInfo) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- if (!args[0]->IsJSObject()) {
- return Smi::FromInt(0);
- }
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
-
- int result = 0;
- if (obj->HasNamedInterceptor()) result |= 2;
- if (obj->HasIndexedInterceptor()) result |= 1;
-
- return Smi::FromInt(result);
-}
-
-
-// Return property names from named interceptor.
-// args[0]: object
-RUNTIME_FUNCTION(Runtime_GetNamedInterceptorPropertyNames) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
-
- if (obj->HasNamedInterceptor()) {
- Handle<JSObject> result;
- if (JSObject::GetKeysForNamedInterceptor(obj, obj).ToHandle(&result)) {
- return *result;
- }
- }
- return isolate->heap()->undefined_value();
-}
-
-
-// Return element names from indexed interceptor.
-// args[0]: object
-RUNTIME_FUNCTION(Runtime_GetIndexedInterceptorElementNames) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
-
- if (obj->HasIndexedInterceptor()) {
- Handle<JSObject> result;
- if (JSObject::GetKeysForIndexedInterceptor(obj, obj).ToHandle(&result)) {
- return *result;
- }
- }
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_OwnKeys) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSObject, raw_object, 0);
- Handle<JSObject> object(raw_object);
-
- if (object->IsJSGlobalProxy()) {
- // Do access checks before going to the global object.
- if (object->IsAccessCheckNeeded() &&
- !isolate->MayNamedAccess(object, isolate->factory()->undefined_value(),
- v8::ACCESS_KEYS)) {
- isolate->ReportFailedAccessCheck(object, v8::ACCESS_KEYS);
- RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
- return *isolate->factory()->NewJSArray(0);
- }
-
- PrototypeIterator iter(isolate, object);
- // If proxy is detached we simply return an empty array.
- if (iter.IsAtEnd()) return *isolate->factory()->NewJSArray(0);
- object = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- }
-
- Handle<FixedArray> contents;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, contents, JSReceiver::GetKeys(object, JSReceiver::OWN_ONLY));
-
- // Some fast paths through GetKeysInFixedArrayFor reuse a cached
- // property array and since the result is mutable we have to create
- // a fresh clone on each invocation.
- int length = contents->length();
- Handle<FixedArray> copy = isolate->factory()->NewFixedArray(length);
- for (int i = 0; i < length; i++) {
- Object* entry = contents->get(i);
- if (entry->IsString()) {
- copy->set(i, entry);
- } else {
- DCHECK(entry->IsNumber());
- HandleScope scope(isolate);
- Handle<Object> entry_handle(entry, isolate);
- Handle<Object> entry_str =
- isolate->factory()->NumberToString(entry_handle);
- copy->set(i, *entry_str);
- }
- }
- return *isolate->factory()->NewJSArrayWithElements(copy);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetArgumentsProperty) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, raw_key, 0);
-
- // Compute the frame holding the arguments.
- JavaScriptFrameIterator it(isolate);
- it.AdvanceToArgumentsFrame();
- JavaScriptFrame* frame = it.frame();
-
- // Get the actual number of provided arguments.
- const uint32_t n = frame->ComputeParametersCount();
-
- // Try to convert the key to an index. If successful and within
- // index return the the argument from the frame.
- uint32_t index;
- if (raw_key->ToArrayIndex(&index) && index < n) {
- return frame->GetParameter(index);
- }
-
- HandleScope scope(isolate);
- if (raw_key->IsSymbol()) {
- Handle<Symbol> symbol = Handle<Symbol>::cast(raw_key);
- if (symbol->Equals(isolate->native_context()->iterator_symbol())) {
- return isolate->native_context()->array_values_iterator();
- }
- // Lookup in the initial Object.prototype object.
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::GetProperty(isolate->initial_object_prototype(),
- Handle<Symbol>::cast(raw_key)));
- return *result;
- }
-
- // Convert the key to a string.
- Handle<Object> converted;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, converted,
- Execution::ToString(isolate, raw_key));
- Handle<String> key = Handle<String>::cast(converted);
-
- // Try to convert the string key into an array index.
- if (key->AsArrayIndex(&index)) {
- if (index < n) {
- return frame->GetParameter(index);
- } else {
- Handle<Object> initial_prototype(isolate->initial_object_prototype());
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::GetElement(isolate, initial_prototype, index));
- return *result;
- }
- }
-
- // Handle special arguments properties.
- if (String::Equals(isolate->factory()->length_string(), key)) {
- return Smi::FromInt(n);
- }
- if (String::Equals(isolate->factory()->callee_string(), key)) {
- JSFunction* function = frame->function();
- if (function->shared()->strict_mode() == STRICT) {
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewTypeError("strict_arguments_callee",
- HandleVector<Object>(NULL, 0)));
- }
- return function;
- }
-
- // Lookup in the initial Object.prototype object.
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Object::GetProperty(isolate->initial_object_prototype(), key));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_ToFastProperties) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- if (object->IsJSObject() && !object->IsGlobalObject()) {
- JSObject::MigrateSlowToFast(Handle<JSObject>::cast(object), 0);
- }
- return *object;
-}
-
-
-RUNTIME_FUNCTION(Runtime_ToBool) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, object, 0);
-
- return isolate->heap()->ToBoolean(object->BooleanValue());
-}
-
-
-// Returns the type string of a value; see ECMA-262, 11.4.3 (p 47).
-// Possible optimizations: put the type string into the oddballs.
-RUNTIME_FUNCTION(Runtime_Typeof) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- if (obj->IsNumber()) return isolate->heap()->number_string();
- HeapObject* heap_obj = HeapObject::cast(obj);
-
- // typeof an undetectable object is 'undefined'
- if (heap_obj->map()->is_undetectable()) {
- return isolate->heap()->undefined_string();
- }
-
- InstanceType instance_type = heap_obj->map()->instance_type();
- if (instance_type < FIRST_NONSTRING_TYPE) {
- return isolate->heap()->string_string();
- }
-
- switch (instance_type) {
- case ODDBALL_TYPE:
- if (heap_obj->IsTrue() || heap_obj->IsFalse()) {
- return isolate->heap()->boolean_string();
- }
- if (heap_obj->IsNull()) {
- return isolate->heap()->object_string();
- }
- DCHECK(heap_obj->IsUndefined());
- return isolate->heap()->undefined_string();
- case SYMBOL_TYPE:
- return isolate->heap()->symbol_string();
- case JS_FUNCTION_TYPE:
- case JS_FUNCTION_PROXY_TYPE:
- return isolate->heap()->function_string();
- default:
- // For any kind of object not handled above, the spec rule for
- // host objects gives that it is okay to return "object"
- return isolate->heap()->object_string();
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_Booleanize) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(Object, value_raw, 0);
- CONVERT_SMI_ARG_CHECKED(token_raw, 1);
- intptr_t value = reinterpret_cast<intptr_t>(value_raw);
- Token::Value token = static_cast<Token::Value>(token_raw);
- switch (token) {
- case Token::EQ:
- case Token::EQ_STRICT:
- return isolate->heap()->ToBoolean(value == 0);
- case Token::NE:
- case Token::NE_STRICT:
- return isolate->heap()->ToBoolean(value != 0);
- case Token::LT:
- return isolate->heap()->ToBoolean(value < 0);
- case Token::GT:
- return isolate->heap()->ToBoolean(value > 0);
- case Token::LTE:
- return isolate->heap()->ToBoolean(value <= 0);
- case Token::GTE:
- return isolate->heap()->ToBoolean(value >= 0);
- default:
- // This should only happen during natives fuzzing.
- return isolate->heap()->undefined_value();
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewStringWrapper) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(String, value, 0);
- return *Object::ToObject(isolate, value).ToHandleChecked();
-}
-
-
-RUNTIME_FUNCTION(Runtime_AllocateHeapNumber) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- return *isolate->factory()->NewHeapNumber(0);
-}
-
-
-
-
-
-RUNTIME_FUNCTION(Runtime_DateMakeDay) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_SMI_ARG_CHECKED(year, 0);
- CONVERT_SMI_ARG_CHECKED(month, 1);
-
- int days = isolate->date_cache()->DaysFromYearMonth(year, month);
- RUNTIME_ASSERT(Smi::IsValid(days));
- return Smi::FromInt(days);
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateSetValue) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
-
- CONVERT_ARG_HANDLE_CHECKED(JSDate, date, 0);
- CONVERT_DOUBLE_ARG_CHECKED(time, 1);
- CONVERT_SMI_ARG_CHECKED(is_utc, 2);
-
- DateCache* date_cache = isolate->date_cache();
-
- Handle<Object> value;
- ;
- bool is_value_nan = false;
- if (std::isnan(time)) {
- value = isolate->factory()->nan_value();
- is_value_nan = true;
- } else if (!is_utc && (time < -DateCache::kMaxTimeBeforeUTCInMs ||
- time > DateCache::kMaxTimeBeforeUTCInMs)) {
- value = isolate->factory()->nan_value();
- is_value_nan = true;
- } else {
- time = is_utc ? time : date_cache->ToUTC(static_cast<int64_t>(time));
- if (time < -DateCache::kMaxTimeInMs || time > DateCache::kMaxTimeInMs) {
- value = isolate->factory()->nan_value();
- is_value_nan = true;
- } else {
- value = isolate->factory()->NewNumber(DoubleToInteger(time));
- }
- }
- date->SetValue(*value, is_value_nan);
- return *value;
-}
-
-
-static Handle<JSObject> NewSloppyArguments(Isolate* isolate,
- Handle<JSFunction> callee,
- Object** parameters,
- int argument_count) {
- Handle<JSObject> result =
- isolate->factory()->NewArgumentsObject(callee, argument_count);
-
- // Allocate the elements if needed.
- int parameter_count = callee->shared()->formal_parameter_count();
- if (argument_count > 0) {
- if (parameter_count > 0) {
- int mapped_count = Min(argument_count, parameter_count);
- Handle<FixedArray> parameter_map =
- isolate->factory()->NewFixedArray(mapped_count + 2, NOT_TENURED);
- parameter_map->set_map(isolate->heap()->sloppy_arguments_elements_map());
-
- Handle<Map> map = Map::Copy(handle(result->map()));
- map->set_elements_kind(SLOPPY_ARGUMENTS_ELEMENTS);
-
- result->set_map(*map);
- result->set_elements(*parameter_map);
-
- // Store the context and the arguments array at the beginning of the
- // parameter map.
- Handle<Context> context(isolate->context());
- Handle<FixedArray> arguments =
- isolate->factory()->NewFixedArray(argument_count, NOT_TENURED);
- parameter_map->set(0, *context);
- parameter_map->set(1, *arguments);
-
- // Loop over the actual parameters backwards.
- int index = argument_count - 1;
- while (index >= mapped_count) {
- // These go directly in the arguments array and have no
- // corresponding slot in the parameter map.
- arguments->set(index, *(parameters - index - 1));
- --index;
- }
-
- Handle<ScopeInfo> scope_info(callee->shared()->scope_info());
- while (index >= 0) {
- // Detect duplicate names to the right in the parameter list.
- Handle<String> name(scope_info->ParameterName(index));
- int context_local_count = scope_info->ContextLocalCount();
- bool duplicate = false;
- for (int j = index + 1; j < parameter_count; ++j) {
- if (scope_info->ParameterName(j) == *name) {
- duplicate = true;
- break;
- }
- }
-
- if (duplicate) {
- // This goes directly in the arguments array with a hole in the
- // parameter map.
- arguments->set(index, *(parameters - index - 1));
- parameter_map->set_the_hole(index + 2);
- } else {
- // The context index goes in the parameter map with a hole in the
- // arguments array.
- int context_index = -1;
- for (int j = 0; j < context_local_count; ++j) {
- if (scope_info->ContextLocalName(j) == *name) {
- context_index = j;
- break;
- }
- }
- DCHECK(context_index >= 0);
- arguments->set_the_hole(index);
- parameter_map->set(
- index + 2,
- Smi::FromInt(Context::MIN_CONTEXT_SLOTS + context_index));
- }
-
- --index;
- }
- } else {
- // If there is no aliasing, the arguments object elements are not
- // special in any way.
- Handle<FixedArray> elements =
- isolate->factory()->NewFixedArray(argument_count, NOT_TENURED);
- result->set_elements(*elements);
- for (int i = 0; i < argument_count; ++i) {
- elements->set(i, *(parameters - i - 1));
- }
- }
- }
- return result;
-}
-
-
-static Handle<JSObject> NewStrictArguments(Isolate* isolate,
- Handle<JSFunction> callee,
- Object** parameters,
- int argument_count) {
- Handle<JSObject> result =
- isolate->factory()->NewArgumentsObject(callee, argument_count);
-
- if (argument_count > 0) {
- Handle<FixedArray> array =
- isolate->factory()->NewUninitializedFixedArray(argument_count);
- DisallowHeapAllocation no_gc;
- WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc);
- for (int i = 0; i < argument_count; i++) {
- array->set(i, *--parameters, mode);
- }
- result->set_elements(*array);
- }
- return result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewArguments) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
- JavaScriptFrameIterator it(isolate);
-
- // Find the frame that holds the actual arguments passed to the function.
- it.AdvanceToArgumentsFrame();
- JavaScriptFrame* frame = it.frame();
-
- // Determine parameter location on the stack and dispatch on language mode.
- int argument_count = frame->GetArgumentsLength();
- Object** parameters = reinterpret_cast<Object**>(frame->GetParameterSlot(-1));
- return callee->shared()->strict_mode() == STRICT
- ? *NewStrictArguments(isolate, callee, parameters, argument_count)
- : *NewSloppyArguments(isolate, callee, parameters, argument_count);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewSloppyArguments) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0);
- Object** parameters = reinterpret_cast<Object**>(args[1]);
- CONVERT_SMI_ARG_CHECKED(argument_count, 2);
- return *NewSloppyArguments(isolate, callee, parameters, argument_count);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewStrictArguments) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, callee, 0)
- Object** parameters = reinterpret_cast<Object**>(args[1]);
- CONVERT_SMI_ARG_CHECKED(argument_count, 2);
- return *NewStrictArguments(isolate, callee, parameters, argument_count);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewClosureFromStubFailure) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 0);
- Handle<Context> context(isolate->context());
- PretenureFlag pretenure_flag = NOT_TENURED;
- return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
- pretenure_flag);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewClosure) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
- CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 1);
- CONVERT_BOOLEAN_ARG_CHECKED(pretenure, 2);
-
- // The caller ensures that we pretenure closures that are assigned
- // directly to properties.
- PretenureFlag pretenure_flag = pretenure ? TENURED : NOT_TENURED;
- return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
- pretenure_flag);
-}
-
-
-// Find the arguments of the JavaScript function invocation that called
-// into C++ code. Collect these in a newly allocated array of handles (possibly
-// prefixed by a number of empty handles).
-static SmartArrayPointer<Handle<Object> > GetCallerArguments(Isolate* isolate,
- int prefix_argc,
- int* total_argc) {
- // Find frame containing arguments passed to the caller.
- JavaScriptFrameIterator it(isolate);
- JavaScriptFrame* frame = it.frame();
- List<JSFunction*> functions(2);
- frame->GetFunctions(&functions);
- if (functions.length() > 1) {
- int inlined_jsframe_index = functions.length() - 1;
- JSFunction* inlined_function = functions[inlined_jsframe_index];
- SlotRefValueBuilder slot_refs(
- frame, inlined_jsframe_index,
- inlined_function->shared()->formal_parameter_count());
-
- int args_count = slot_refs.args_length();
-
- *total_argc = prefix_argc + args_count;
- SmartArrayPointer<Handle<Object> > param_data(
- NewArray<Handle<Object> >(*total_argc));
- slot_refs.Prepare(isolate);
- for (int i = 0; i < args_count; i++) {
- Handle<Object> val = slot_refs.GetNext(isolate, 0);
- param_data[prefix_argc + i] = val;
- }
- slot_refs.Finish(isolate);
-
- return param_data;
- } else {
- it.AdvanceToArgumentsFrame();
- frame = it.frame();
- int args_count = frame->ComputeParametersCount();
-
- *total_argc = prefix_argc + args_count;
- SmartArrayPointer<Handle<Object> > param_data(
- NewArray<Handle<Object> >(*total_argc));
- for (int i = 0; i < args_count; i++) {
- Handle<Object> val = Handle<Object>(frame->GetParameter(i), isolate);
- param_data[prefix_argc + i] = val;
- }
- return param_data;
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionBindArguments) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, bound_function, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, bindee, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, this_object, 2);
- CONVERT_NUMBER_ARG_HANDLE_CHECKED(new_length, 3);
-
- // TODO(lrn): Create bound function in C++ code from premade shared info.
- bound_function->shared()->set_bound(true);
- // Get all arguments of calling function (Function.prototype.bind).
- int argc = 0;
- SmartArrayPointer<Handle<Object> > arguments =
- GetCallerArguments(isolate, 0, &argc);
- // Don't count the this-arg.
- if (argc > 0) {
- RUNTIME_ASSERT(arguments[0].is_identical_to(this_object));
- argc--;
- } else {
- RUNTIME_ASSERT(this_object->IsUndefined());
- }
- // Initialize array of bindings (function, this, and any existing arguments
- // if the function was already bound).
- Handle<FixedArray> new_bindings;
- int i;
- if (bindee->IsJSFunction() && JSFunction::cast(*bindee)->shared()->bound()) {
- Handle<FixedArray> old_bindings(
- JSFunction::cast(*bindee)->function_bindings());
- RUNTIME_ASSERT(old_bindings->length() > JSFunction::kBoundFunctionIndex);
- new_bindings =
- isolate->factory()->NewFixedArray(old_bindings->length() + argc);
- bindee = Handle<Object>(old_bindings->get(JSFunction::kBoundFunctionIndex),
- isolate);
- i = 0;
- for (int n = old_bindings->length(); i < n; i++) {
- new_bindings->set(i, old_bindings->get(i));
- }
- } else {
- int array_size = JSFunction::kBoundArgumentsStartIndex + argc;
- new_bindings = isolate->factory()->NewFixedArray(array_size);
- new_bindings->set(JSFunction::kBoundFunctionIndex, *bindee);
- new_bindings->set(JSFunction::kBoundThisIndex, *this_object);
- i = 2;
- }
- // Copy arguments, skipping the first which is "this_arg".
- for (int j = 0; j < argc; j++, i++) {
- new_bindings->set(i, *arguments[j + 1]);
- }
- new_bindings->set_map_no_write_barrier(
- isolate->heap()->fixed_cow_array_map());
- bound_function->set_function_bindings(*new_bindings);
-
- // Update length. Have to remove the prototype first so that map migration
- // is happy about the number of fields.
- RUNTIME_ASSERT(bound_function->RemovePrototype());
- Handle<Map> bound_function_map(
- isolate->native_context()->bound_function_map());
- JSObject::MigrateToMap(bound_function, bound_function_map);
- Handle<String> length_string = isolate->factory()->length_string();
- PropertyAttributes attr =
- static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY);
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetOwnPropertyIgnoreAttributes(
- bound_function, length_string, new_length, attr));
- return *bound_function;
-}
-
-
-RUNTIME_FUNCTION(Runtime_BoundFunctionGetBindings) {
- HandleScope handles(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, callable, 0);
- if (callable->IsJSFunction()) {
- Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
- if (function->shared()->bound()) {
- Handle<FixedArray> bindings(function->function_bindings());
- RUNTIME_ASSERT(bindings->map() == isolate->heap()->fixed_cow_array_map());
- return *isolate->factory()->NewJSArrayWithElements(bindings);
- }
- }
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewObjectFromBound) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- // First argument is a function to use as a constructor.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- RUNTIME_ASSERT(function->shared()->bound());
-
- // The argument is a bound function. Extract its bound arguments
- // and callable.
- Handle<FixedArray> bound_args =
- Handle<FixedArray>(FixedArray::cast(function->function_bindings()));
- int bound_argc = bound_args->length() - JSFunction::kBoundArgumentsStartIndex;
- Handle<Object> bound_function(
- JSReceiver::cast(bound_args->get(JSFunction::kBoundFunctionIndex)),
- isolate);
- DCHECK(!bound_function->IsJSFunction() ||
- !Handle<JSFunction>::cast(bound_function)->shared()->bound());
-
- int total_argc = 0;
- SmartArrayPointer<Handle<Object> > param_data =
- GetCallerArguments(isolate, bound_argc, &total_argc);
- for (int i = 0; i < bound_argc; i++) {
- param_data[i] = Handle<Object>(
- bound_args->get(JSFunction::kBoundArgumentsStartIndex + i), isolate);
- }
-
- if (!bound_function->IsJSFunction()) {
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, bound_function,
- Execution::TryGetConstructorDelegate(isolate, bound_function));
- }
- DCHECK(bound_function->IsJSFunction());
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, Execution::New(Handle<JSFunction>::cast(bound_function),
- total_argc, param_data.get()));
- return *result;
-}
-
-
-static Object* Runtime_NewObjectHelper(Isolate* isolate,
- Handle<Object> constructor,
- Handle<AllocationSite> site) {
- // If the constructor isn't a proper function we throw a type error.
- if (!constructor->IsJSFunction()) {
- Vector<Handle<Object> > arguments = HandleVector(&constructor, 1);
- THROW_NEW_ERROR_RETURN_FAILURE(isolate,
- NewTypeError("not_constructor", arguments));
- }
-
- Handle<JSFunction> function = Handle<JSFunction>::cast(constructor);
-
- // If function should not have prototype, construction is not allowed. In this
- // case generated code bailouts here, since function has no initial_map.
- if (!function->should_have_prototype() && !function->shared()->bound()) {
- Vector<Handle<Object> > arguments = HandleVector(&constructor, 1);
- THROW_NEW_ERROR_RETURN_FAILURE(isolate,
- NewTypeError("not_constructor", arguments));
- }
-
- Debug* debug = isolate->debug();
- // Handle stepping into constructors if step into is active.
- if (debug->StepInActive()) {
- debug->HandleStepIn(function, Handle<Object>::null(), 0, true);
- }
-
- if (function->has_initial_map()) {
- if (function->initial_map()->instance_type() == JS_FUNCTION_TYPE) {
- // The 'Function' function ignores the receiver object when
- // called using 'new' and creates a new JSFunction object that
- // is returned. The receiver object is only used for error
- // reporting if an error occurs when constructing the new
- // JSFunction. Factory::NewJSObject() should not be used to
- // allocate JSFunctions since it does not properly initialize
- // the shared part of the function. Since the receiver is
- // ignored anyway, we use the global object as the receiver
- // instead of a new JSFunction object. This way, errors are
- // reported the same way whether or not 'Function' is called
- // using 'new'.
- return isolate->global_proxy();
- }
- }
-
- // The function should be compiled for the optimization hints to be
- // available.
- Compiler::EnsureCompiled(function, CLEAR_EXCEPTION);
-
- Handle<JSObject> result;
- if (site.is_null()) {
- result = isolate->factory()->NewJSObject(function);
- } else {
- result = isolate->factory()->NewJSObjectWithMemento(function, site);
- }
-
- isolate->counters()->constructed_objects()->Increment();
- isolate->counters()->constructed_objects_runtime()->Increment();
-
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewObject) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, constructor, 0);
- return Runtime_NewObjectHelper(isolate, constructor,
- Handle<AllocationSite>::null());
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewObjectWithAllocationSite) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, constructor, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, feedback, 0);
- Handle<AllocationSite> site;
- if (feedback->IsAllocationSite()) {
- // The feedback can be an AllocationSite or undefined.
- site = Handle<AllocationSite>::cast(feedback);
- }
- return Runtime_NewObjectHelper(isolate, constructor, site);
-}
-
-
-RUNTIME_FUNCTION(Runtime_FinalizeInstanceSize) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- function->CompleteInobjectSlackTracking();
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_CheckIsBootstrapping) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- RUNTIME_ASSERT(isolate->bootstrapper()->IsActive());
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetRootNaN) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- RUNTIME_ASSERT(isolate->bootstrapper()->IsActive());
- return isolate->heap()->nan_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_Call) {
- HandleScope scope(isolate);
- DCHECK(args.length() >= 2);
- int argc = args.length() - 2;
- CONVERT_ARG_CHECKED(JSReceiver, fun, argc + 1);
- Object* receiver = args[0];
-
- // If there are too many arguments, allocate argv via malloc.
- const int argv_small_size = 10;
- Handle<Object> argv_small_buffer[argv_small_size];
- SmartArrayPointer<Handle<Object> > argv_large_buffer;
- Handle<Object>* argv = argv_small_buffer;
- if (argc > argv_small_size) {
- argv = new Handle<Object>[argc];
- if (argv == NULL) return isolate->StackOverflow();
- argv_large_buffer = SmartArrayPointer<Handle<Object> >(argv);
- }
-
- for (int i = 0; i < argc; ++i) {
- argv[i] = Handle<Object>(args[1 + i], isolate);
- }
-
- Handle<JSReceiver> hfun(fun);
- Handle<Object> hreceiver(receiver, isolate);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Execution::Call(isolate, hfun, hreceiver, argc, argv, true));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_Apply) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 5);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, fun, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, arguments, 2);
- CONVERT_INT32_ARG_CHECKED(offset, 3);
- CONVERT_INT32_ARG_CHECKED(argc, 4);
- RUNTIME_ASSERT(offset >= 0);
- // Loose upper bound to allow fuzzing. We'll most likely run out of
- // stack space before hitting this limit.
- static int kMaxArgc = 1000000;
- RUNTIME_ASSERT(argc >= 0 && argc <= kMaxArgc);
-
- // If there are too many arguments, allocate argv via malloc.
- const int argv_small_size = 10;
- Handle<Object> argv_small_buffer[argv_small_size];
- SmartArrayPointer<Handle<Object> > argv_large_buffer;
- Handle<Object>* argv = argv_small_buffer;
- if (argc > argv_small_size) {
- argv = new Handle<Object>[argc];
- if (argv == NULL) return isolate->StackOverflow();
- argv_large_buffer = SmartArrayPointer<Handle<Object> >(argv);
- }
-
- for (int i = 0; i < argc; ++i) {
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, argv[i], Object::GetElement(isolate, arguments, offset + i));
- }
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Execution::Call(isolate, fun, receiver, argc, argv, true));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetFunctionDelegate) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- RUNTIME_ASSERT(!object->IsJSFunction());
- return *Execution::GetFunctionDelegate(isolate, object);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetConstructorDelegate) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- RUNTIME_ASSERT(!object->IsJSFunction());
- return *Execution::GetConstructorDelegate(isolate, object);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewGlobalContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
- Handle<Context> result =
- isolate->factory()->NewGlobalContext(function, scope_info);
-
- DCHECK(function->context() == isolate->context());
- DCHECK(function->context()->global_object() == result->global_object());
- result->global_object()->set_global_context(*result);
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
-
- DCHECK(function->context() == isolate->context());
- int length = function->shared()->scope_info()->ContextLength();
- return *isolate->factory()->NewFunctionContext(length, function);
-}
-
-
-RUNTIME_FUNCTION(Runtime_PushWithContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- Handle<JSReceiver> extension_object;
- if (args[0]->IsJSReceiver()) {
- extension_object = args.at<JSReceiver>(0);
- } else {
- // Try to convert the object to a proper JavaScript object.
- MaybeHandle<JSReceiver> maybe_object =
- Object::ToObject(isolate, args.at<Object>(0));
- if (!maybe_object.ToHandle(&extension_object)) {
- Handle<Object> handle = args.at<Object>(0);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewTypeError("with_expression", HandleVector(&handle, 1)));
- }
- }
-
- Handle<JSFunction> function;
- if (args[1]->IsSmi()) {
- // A smi sentinel indicates a context nested inside global code rather
- // than some function. There is a canonical empty function that can be
- // gotten from the native context.
- function = handle(isolate->native_context()->closure());
- } else {
- function = args.at<JSFunction>(1);
- }
-
- Handle<Context> current(isolate->context());
- Handle<Context> context =
- isolate->factory()->NewWithContext(function, current, extension_object);
- isolate->set_context(*context);
- return *context;
-}
-
-
-RUNTIME_FUNCTION(Runtime_PushCatchContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(String, name, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, thrown_object, 1);
- Handle<JSFunction> function;
- if (args[2]->IsSmi()) {
- // A smi sentinel indicates a context nested inside global code rather
- // than some function. There is a canonical empty function that can be
- // gotten from the native context.
- function = handle(isolate->native_context()->closure());
- } else {
- function = args.at<JSFunction>(2);
- }
- Handle<Context> current(isolate->context());
- Handle<Context> context = isolate->factory()->NewCatchContext(
- function, current, name, thrown_object);
- isolate->set_context(*context);
- return *context;
-}
-
-
-RUNTIME_FUNCTION(Runtime_PushBlockContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 0);
- Handle<JSFunction> function;
- if (args[1]->IsSmi()) {
- // A smi sentinel indicates a context nested inside global code rather
- // than some function. There is a canonical empty function that can be
- // gotten from the native context.
- function = handle(isolate->native_context()->closure());
- } else {
- function = args.at<JSFunction>(1);
- }
- Handle<Context> current(isolate->context());
- Handle<Context> context =
- isolate->factory()->NewBlockContext(function, current, scope_info);
- isolate->set_context(*context);
- return *context;
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsJSModule) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSModule());
-}
-
-
-RUNTIME_FUNCTION(Runtime_PushModuleContext) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_SMI_ARG_CHECKED(index, 0);
-
- if (!args[1]->IsScopeInfo()) {
- // Module already initialized. Find hosting context and retrieve context.
- Context* host = Context::cast(isolate->context())->global_context();
- Context* context = Context::cast(host->get(index));
- DCHECK(context->previous() == isolate->context());
- isolate->set_context(context);
- return context;
- }
-
- CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
-
- // Allocate module context.
- HandleScope scope(isolate);
- Factory* factory = isolate->factory();
- Handle<Context> context = factory->NewModuleContext(scope_info);
- Handle<JSModule> module = factory->NewJSModule(context, scope_info);
- context->set_module(*module);
- Context* previous = isolate->context();
- context->set_previous(previous);
- context->set_closure(previous->closure());
- context->set_global_object(previous->global_object());
- isolate->set_context(*context);
-
- // Find hosting scope and initialize internal variable holding module there.
- previous->global_context()->set(index, *context);
-
- return *context;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DeclareModules) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, descriptions, 0);
- Context* host_context = isolate->context();
-
- for (int i = 0; i < descriptions->length(); ++i) {
- Handle<ModuleInfo> description(ModuleInfo::cast(descriptions->get(i)));
- int host_index = description->host_index();
- Handle<Context> context(Context::cast(host_context->get(host_index)));
- Handle<JSModule> module(context->module());
-
- for (int j = 0; j < description->length(); ++j) {
- Handle<String> name(description->name(j));
- VariableMode mode = description->mode(j);
- int index = description->index(j);
- switch (mode) {
- case VAR:
- case LET:
- case CONST:
- case CONST_LEGACY: {
- PropertyAttributes attr =
- IsImmutableVariableMode(mode) ? FROZEN : SEALED;
- Handle<AccessorInfo> info =
- Accessors::MakeModuleExport(name, index, attr);
- Handle<Object> result =
- JSObject::SetAccessor(module, info).ToHandleChecked();
- DCHECK(!result->IsUndefined());
- USE(result);
- break;
- }
- case MODULE: {
- Object* referenced_context = Context::cast(host_context)->get(index);
- Handle<JSModule> value(Context::cast(referenced_context)->module());
- JSObject::SetOwnPropertyIgnoreAttributes(module, name, value, FROZEN)
- .Assert();
- break;
- }
- case INTERNAL:
- case TEMPORARY:
- case DYNAMIC:
- case DYNAMIC_GLOBAL:
- case DYNAMIC_LOCAL:
- UNREACHABLE();
- }
- }
-
- JSObject::PreventExtensions(module).Assert();
- }
-
- DCHECK(!isolate->has_pending_exception());
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DeleteLookupSlot) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(Context, context, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, name, 1);
-
- int index;
- PropertyAttributes attributes;
- ContextLookupFlags flags = FOLLOW_CHAINS;
- BindingFlags binding_flags;
- Handle<Object> holder =
- context->Lookup(name, flags, &index, &attributes, &binding_flags);
-
- // If the slot was not found the result is true.
- if (holder.is_null()) {
- return isolate->heap()->true_value();
- }
-
- // If the slot was found in a context, it should be DONT_DELETE.
- if (holder->IsContext()) {
- return isolate->heap()->false_value();
- }
-
- // The slot was found in a JSObject, either a context extension object,
- // the global object, or the subject of a with. Try to delete it
- // (respecting DONT_DELETE).
- Handle<JSObject> object = Handle<JSObject>::cast(holder);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
- JSReceiver::DeleteProperty(object, name));
- return *result;
-}
-
-
-static Object* ComputeReceiverForNonGlobal(Isolate* isolate, JSObject* holder) {
- DCHECK(!holder->IsGlobalObject());
- Context* top = isolate->context();
- // Get the context extension function.
- JSFunction* context_extension_function =
- top->native_context()->context_extension_function();
- // If the holder isn't a context extension object, we just return it
- // as the receiver. This allows arguments objects to be used as
- // receivers, but only if they are put in the context scope chain
- // explicitly via a with-statement.
- Object* constructor = holder->map()->constructor();
- if (constructor != context_extension_function) return holder;
- // Fall back to using the global object as the implicit receiver if
- // the property turns out to be a local variable allocated in a
- // context extension object - introduced via eval.
- return isolate->heap()->undefined_value();
-}
-
-
-static ObjectPair LoadLookupSlotHelper(Arguments args, Isolate* isolate,
- bool throw_error) {
- HandleScope scope(isolate);
- DCHECK_EQ(2, args.length());
-
- if (!args[0]->IsContext() || !args[1]->IsString()) {
- return MakePair(isolate->ThrowIllegalOperation(), NULL);
- }
- Handle<Context> context = args.at<Context>(0);
- Handle<String> name = args.at<String>(1);
-
- int index;
- PropertyAttributes attributes;
- ContextLookupFlags flags = FOLLOW_CHAINS;
- BindingFlags binding_flags;
- Handle<Object> holder =
- context->Lookup(name, flags, &index, &attributes, &binding_flags);
- if (isolate->has_pending_exception()) {
- return MakePair(isolate->heap()->exception(), NULL);
- }
-
- // If the index is non-negative, the slot has been found in a context.
- if (index >= 0) {
- DCHECK(holder->IsContext());
- // If the "property" we were looking for is a local variable, the
- // receiver is the global object; see ECMA-262, 3rd., 10.1.6 and 10.2.3.
- Handle<Object> receiver = isolate->factory()->undefined_value();
- Object* value = Context::cast(*holder)->get(index);
- // Check for uninitialized bindings.
- switch (binding_flags) {
- case MUTABLE_CHECK_INITIALIZED:
- case IMMUTABLE_CHECK_INITIALIZED_HARMONY:
- if (value->IsTheHole()) {
- Handle<Object> error;
- MaybeHandle<Object> maybe_error =
- isolate->factory()->NewReferenceError("not_defined",
- HandleVector(&name, 1));
- if (maybe_error.ToHandle(&error)) isolate->Throw(*error);
- return MakePair(isolate->heap()->exception(), NULL);
- }
- // FALLTHROUGH
- case MUTABLE_IS_INITIALIZED:
- case IMMUTABLE_IS_INITIALIZED:
- case IMMUTABLE_IS_INITIALIZED_HARMONY:
- DCHECK(!value->IsTheHole());
- return MakePair(value, *receiver);
- case IMMUTABLE_CHECK_INITIALIZED:
- if (value->IsTheHole()) {
- DCHECK((attributes & READ_ONLY) != 0);
- value = isolate->heap()->undefined_value();
- }
- return MakePair(value, *receiver);
- case MISSING_BINDING:
- UNREACHABLE();
- return MakePair(NULL, NULL);
- }
- }
-
- // Otherwise, if the slot was found the holder is a context extension
- // object, subject of a with, or a global object. We read the named
- // property from it.
- if (!holder.is_null()) {
- Handle<JSReceiver> object = Handle<JSReceiver>::cast(holder);
-#ifdef DEBUG
- if (!object->IsJSProxy()) {
- Maybe<bool> maybe = JSReceiver::HasProperty(object, name);
- DCHECK(maybe.has_value);
- DCHECK(maybe.value);
- }
-#endif
- // GetProperty below can cause GC.
- Handle<Object> receiver_handle(
- object->IsGlobalObject()
- ? Object::cast(isolate->heap()->undefined_value())
- : object->IsJSProxy() ? static_cast<Object*>(*object)
- : ComputeReceiverForNonGlobal(
- isolate, JSObject::cast(*object)),
- isolate);
-
- // No need to unhole the value here. This is taken care of by the
- // GetProperty function.
- Handle<Object> value;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate, value, Object::GetProperty(object, name),
- MakePair(isolate->heap()->exception(), NULL));
- return MakePair(*value, *receiver_handle);
- }
-
- if (throw_error) {
- // The property doesn't exist - throw exception.
- Handle<Object> error;
- MaybeHandle<Object> maybe_error = isolate->factory()->NewReferenceError(
- "not_defined", HandleVector(&name, 1));
- if (maybe_error.ToHandle(&error)) isolate->Throw(*error);
- return MakePair(isolate->heap()->exception(), NULL);
- } else {
- // The property doesn't exist - return undefined.
- return MakePair(isolate->heap()->undefined_value(),
- isolate->heap()->undefined_value());
- }
-}
-
-
-RUNTIME_FUNCTION_RETURN_PAIR(Runtime_LoadLookupSlot) {
- return LoadLookupSlotHelper(args, isolate, true);
-}
-
-
-RUNTIME_FUNCTION_RETURN_PAIR(Runtime_LoadLookupSlotNoReferenceError) {
- return LoadLookupSlotHelper(args, isolate, false);
-}
-
-
-RUNTIME_FUNCTION(Runtime_StoreLookupSlot) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);
- CONVERT_ARG_HANDLE_CHECKED(Context, context, 1);
- CONVERT_ARG_HANDLE_CHECKED(String, name, 2);
- CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 3);
-
- int index;
- PropertyAttributes attributes;
- ContextLookupFlags flags = FOLLOW_CHAINS;
- BindingFlags binding_flags;
- Handle<Object> holder =
- context->Lookup(name, flags, &index, &attributes, &binding_flags);
- // In case of JSProxy, an exception might have been thrown.
- if (isolate->has_pending_exception()) return isolate->heap()->exception();
-
- // The property was found in a context slot.
- if (index >= 0) {
- if ((attributes & READ_ONLY) == 0) {
- Handle<Context>::cast(holder)->set(index, *value);
- } else if (strict_mode == STRICT) {
- // Setting read only property in strict mode.
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewTypeError("strict_cannot_assign", HandleVector(&name, 1)));
- }
- return *value;
- }
-
- // Slow case: The property is not in a context slot. It is either in a
- // context extension object, a property of the subject of a with, or a
- // property of the global object.
- Handle<JSReceiver> object;
- if (attributes != ABSENT) {
- // The property exists on the holder.
- object = Handle<JSReceiver>::cast(holder);
- } else if (strict_mode == STRICT) {
- // If absent in strict mode: throw.
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewReferenceError("not_defined", HandleVector(&name, 1)));
- } else {
- // If absent in sloppy mode: add the property to the global object.
- object = Handle<JSReceiver>(context->global_object());
- }
-
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, Object::SetProperty(object, name, value, strict_mode));
-
- return *value;
-}
-
-
-RUNTIME_FUNCTION(Runtime_Throw) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- return isolate->Throw(args[0]);
-}
-
-
-RUNTIME_FUNCTION(Runtime_ReThrow) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- return isolate->ReThrow(args[0]);
-}
-
-
-RUNTIME_FUNCTION(Runtime_PromoteScheduledException) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- return isolate->PromoteScheduledException();
-}
-
-
-RUNTIME_FUNCTION(Runtime_ThrowReferenceError) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewReferenceError("not_defined", HandleVector(&name, 1)));
-}
-
-
-RUNTIME_FUNCTION(Runtime_ThrowNonMethodError) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewReferenceError("non_method", HandleVector<Object>(NULL, 0)));
-}
-
-
-RUNTIME_FUNCTION(Runtime_ThrowUnsupportedSuperError) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewReferenceError("unsupported_super", HandleVector<Object>(NULL, 0)));
-}
-
-
-RUNTIME_FUNCTION(Runtime_ThrowNotDateError) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate, NewTypeError("not_date_object", HandleVector<Object>(NULL, 0)));
-}
-
-
-RUNTIME_FUNCTION(Runtime_StackGuard) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
-
- // First check if this is a real stack overflow.
- StackLimitCheck check(isolate);
- if (check.JsHasOverflowed()) {
- return isolate->StackOverflow();
- }
-
- return isolate->stack_guard()->HandleInterrupts();
-}
-
-
-RUNTIME_FUNCTION(Runtime_Interrupt) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- return isolate->stack_guard()->HandleInterrupts();
-}
-
-
-static int StackSize(Isolate* isolate) {
- int n = 0;
- for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) n++;
- return n;
-}
-
-
-static void PrintTransition(Isolate* isolate, Object* result) {
- // indentation
- {
- const int nmax = 80;
- int n = StackSize(isolate);
- if (n <= nmax)
- PrintF("%4d:%*s", n, n, "");
- else
- PrintF("%4d:%*s", n, nmax, "...");
- }
-
- if (result == NULL) {
- JavaScriptFrame::PrintTop(isolate, stdout, true, false);
- PrintF(" {\n");
- } else {
- // function result
- PrintF("} -> ");
- result->ShortPrint();
- PrintF("\n");
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_TraceEnter) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- PrintTransition(isolate, NULL);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_TraceExit) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- PrintTransition(isolate, obj);
- return obj; // return TOS
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateCurrentTime) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- if (FLAG_log_timer_events) LOG(isolate, CurrentTimeEvent());
-
- // According to ECMA-262, section 15.9.1, page 117, the precision of
- // the number in a Date object representing a particular instant in
- // time is milliseconds. Therefore, we floor the result of getting
- // the OS time.
- double millis;
- if (FLAG_verify_predictable) {
- millis = 1388534400000.0; // Jan 1 2014 00:00:00 GMT+0000
- millis += Floor(isolate->heap()->synthetic_time());
- } else {
- millis = Floor(base::OS::TimeCurrentMillis());
- }
- return *isolate->factory()->NewNumber(millis);
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateParseString) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(String, str, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, output, 1);
-
- RUNTIME_ASSERT(output->HasFastElements());
- JSObject::EnsureCanContainHeapObjectElements(output);
- RUNTIME_ASSERT(output->HasFastObjectElements());
- Handle<FixedArray> output_array(FixedArray::cast(output->elements()));
- RUNTIME_ASSERT(output_array->length() >= DateParser::OUTPUT_SIZE);
-
- str = String::Flatten(str);
- DisallowHeapAllocation no_gc;
-
- bool result;
- String::FlatContent str_content = str->GetFlatContent();
- if (str_content.IsOneByte()) {
- result = DateParser::Parse(str_content.ToOneByteVector(), *output_array,
- isolate->unicode_cache());
- } else {
- DCHECK(str_content.IsTwoByte());
- result = DateParser::Parse(str_content.ToUC16Vector(), *output_array,
- isolate->unicode_cache());
- }
-
- if (result) {
- return *output;
- } else {
- return isolate->heap()->null_value();
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateLocalTimezone) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_DOUBLE_ARG_CHECKED(x, 0);
- RUNTIME_ASSERT(x >= -DateCache::kMaxTimeBeforeUTCInMs &&
- x <= DateCache::kMaxTimeBeforeUTCInMs);
- const char* zone =
- isolate->date_cache()->LocalTimezone(static_cast<int64_t>(x));
- Handle<String> result =
- isolate->factory()->NewStringFromUtf8(CStrVector(zone)).ToHandleChecked();
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateToUTC) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_DOUBLE_ARG_CHECKED(x, 0);
- RUNTIME_ASSERT(x >= -DateCache::kMaxTimeBeforeUTCInMs &&
- x <= DateCache::kMaxTimeBeforeUTCInMs);
- int64_t time = isolate->date_cache()->ToUTC(static_cast<int64_t>(x));
-
- return *isolate->factory()->NewNumber(static_cast<double>(time));
-}
-
-
-RUNTIME_FUNCTION(Runtime_DateCacheVersion) {
- HandleScope hs(isolate);
- DCHECK(args.length() == 0);
- if (!isolate->eternal_handles()->Exists(EternalHandles::DATE_CACHE_VERSION)) {
- Handle<FixedArray> date_cache_version =
- isolate->factory()->NewFixedArray(1, TENURED);
- date_cache_version->set(0, Smi::FromInt(0));
- isolate->eternal_handles()->CreateSingleton(
- isolate, *date_cache_version, EternalHandles::DATE_CACHE_VERSION);
- }
- Handle<FixedArray> date_cache_version =
- Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
- EternalHandles::DATE_CACHE_VERSION));
- // Return result as a JS array.
- Handle<JSObject> result =
- isolate->factory()->NewJSObject(isolate->array_function());
- JSArray::SetContent(Handle<JSArray>::cast(result), date_cache_version);
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_GlobalProxy) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, global, 0);
- if (!global->IsJSGlobalObject()) return isolate->heap()->null_value();
- return JSGlobalObject::cast(global)->global_proxy();
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsAttachedGlobal) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, global, 0);
- if (!global->IsJSGlobalObject()) return isolate->heap()->false_value();
- return isolate->heap()->ToBoolean(
- !JSGlobalObject::cast(global)->IsDetached());
-}
-
-
-RUNTIME_FUNCTION(Runtime_AllocateInNewSpace) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_SMI_ARG_CHECKED(size, 0);
- RUNTIME_ASSERT(IsAligned(size, kPointerSize));
- RUNTIME_ASSERT(size > 0);
- RUNTIME_ASSERT(size <= Page::kMaxRegularHeapObjectSize);
- return *isolate->factory()->NewFillerObject(size, false, NEW_SPACE);
-}
-
-
-RUNTIME_FUNCTION(Runtime_AllocateInTargetSpace) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_SMI_ARG_CHECKED(size, 0);
- CONVERT_SMI_ARG_CHECKED(flags, 1);
- RUNTIME_ASSERT(IsAligned(size, kPointerSize));
- RUNTIME_ASSERT(size > 0);
- RUNTIME_ASSERT(size <= Page::kMaxRegularHeapObjectSize);
- bool double_align = AllocateDoubleAlignFlag::decode(flags);
- AllocationSpace space = AllocateTargetSpace::decode(flags);
- return *isolate->factory()->NewFillerObject(size, double_align, space);
-}
-
-
-// Push an object unto an array of objects if it is not already in the
-// array. Returns true if the element was pushed on the stack and
-// false otherwise.
-RUNTIME_FUNCTION(Runtime_PushIfAbsent) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, element, 1);
- RUNTIME_ASSERT(array->HasFastSmiOrObjectElements());
- int length = Smi::cast(array->length())->value();
- FixedArray* elements = FixedArray::cast(array->elements());
- for (int i = 0; i < length; i++) {
- if (elements->get(i) == *element) return isolate->heap()->false_value();
- }
-
- // Strict not needed. Used for cycle detection in Array join implementation.
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetFastElement(array, length, element, SLOPPY, true));
- return isolate->heap()->true_value();
-}
-
-
-/**
- * A simple visitor visits every element of Array's.
- * The backend storage can be a fixed array for fast elements case,
- * or a dictionary for sparse array. Since Dictionary is a subtype
- * of FixedArray, the class can be used by both fast and slow cases.
- * The second parameter of the constructor, fast_elements, specifies
- * whether the storage is a FixedArray or Dictionary.
- *
- * An index limit is used to deal with the situation that a result array
- * length overflows 32-bit non-negative integer.
- */
-class ArrayConcatVisitor {
- public:
- ArrayConcatVisitor(Isolate* isolate, Handle<FixedArray> storage,
- bool fast_elements)
- : isolate_(isolate),
- storage_(Handle<FixedArray>::cast(
- isolate->global_handles()->Create(*storage))),
- index_offset_(0u),
- fast_elements_(fast_elements),
- exceeds_array_limit_(false) {}
-
- ~ArrayConcatVisitor() { clear_storage(); }
-
- void visit(uint32_t i, Handle<Object> elm) {
- if (i > JSObject::kMaxElementCount - index_offset_) {
- exceeds_array_limit_ = true;
- return;
- }
- uint32_t index = index_offset_ + i;
-
- if (fast_elements_) {
- if (index < static_cast<uint32_t>(storage_->length())) {
- storage_->set(index, *elm);
- return;
- }
- // Our initial estimate of length was foiled, possibly by
- // getters on the arrays increasing the length of later arrays
- // during iteration.
- // This shouldn't happen in anything but pathological cases.
- SetDictionaryMode();
- // Fall-through to dictionary mode.
- }
- DCHECK(!fast_elements_);
- Handle<SeededNumberDictionary> dict(
- SeededNumberDictionary::cast(*storage_));
- Handle<SeededNumberDictionary> result =
- SeededNumberDictionary::AtNumberPut(dict, index, elm);
- if (!result.is_identical_to(dict)) {
- // Dictionary needed to grow.
- clear_storage();
- set_storage(*result);
- }
- }
-
- void increase_index_offset(uint32_t delta) {
- if (JSObject::kMaxElementCount - index_offset_ < delta) {
- index_offset_ = JSObject::kMaxElementCount;
- } else {
- index_offset_ += delta;
- }
- // If the initial length estimate was off (see special case in visit()),
- // but the array blowing the limit didn't contain elements beyond the
- // provided-for index range, go to dictionary mode now.
- if (fast_elements_ &&
- index_offset_ >
- static_cast<uint32_t>(FixedArrayBase::cast(*storage_)->length())) {
- SetDictionaryMode();
- }
- }
-
- bool exceeds_array_limit() { return exceeds_array_limit_; }
-
- Handle<JSArray> ToArray() {
- Handle<JSArray> array = isolate_->factory()->NewJSArray(0);
- Handle<Object> length =
- isolate_->factory()->NewNumber(static_cast<double>(index_offset_));
- Handle<Map> map = JSObject::GetElementsTransitionMap(
- array, fast_elements_ ? FAST_HOLEY_ELEMENTS : DICTIONARY_ELEMENTS);
- array->set_map(*map);
- array->set_length(*length);
- array->set_elements(*storage_);
- return array;
- }
-
- private:
- // Convert storage to dictionary mode.
- void SetDictionaryMode() {
- DCHECK(fast_elements_);
- Handle<FixedArray> current_storage(*storage_);
- Handle<SeededNumberDictionary> slow_storage(
- SeededNumberDictionary::New(isolate_, current_storage->length()));
- uint32_t current_length = static_cast<uint32_t>(current_storage->length());
- for (uint32_t i = 0; i < current_length; i++) {
- HandleScope loop_scope(isolate_);
- Handle<Object> element(current_storage->get(i), isolate_);
- if (!element->IsTheHole()) {
- Handle<SeededNumberDictionary> new_storage =
- SeededNumberDictionary::AtNumberPut(slow_storage, i, element);
- if (!new_storage.is_identical_to(slow_storage)) {
- slow_storage = loop_scope.CloseAndEscape(new_storage);
- }
- }
- }
- clear_storage();
- set_storage(*slow_storage);
- fast_elements_ = false;
- }
-
- inline void clear_storage() {
- GlobalHandles::Destroy(Handle<Object>::cast(storage_).location());
- }
-
- inline void set_storage(FixedArray* storage) {
- storage_ =
- Handle<FixedArray>::cast(isolate_->global_handles()->Create(storage));
- }
-
- Isolate* isolate_;
- Handle<FixedArray> storage_; // Always a global handle.
- // Index after last seen index. Always less than or equal to
- // JSObject::kMaxElementCount.
- uint32_t index_offset_;
- bool fast_elements_ : 1;
- bool exceeds_array_limit_ : 1;
-};
-
-
-static uint32_t EstimateElementCount(Handle<JSArray> array) {
- uint32_t length = static_cast<uint32_t>(array->length()->Number());
- int element_count = 0;
- switch (array->GetElementsKind()) {
- case FAST_SMI_ELEMENTS:
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_ELEMENTS:
- case FAST_HOLEY_ELEMENTS: {
- // Fast elements can't have lengths that are not representable by
- // a 32-bit signed integer.
- DCHECK(static_cast<int32_t>(FixedArray::kMaxLength) >= 0);
- int fast_length = static_cast<int>(length);
- Handle<FixedArray> elements(FixedArray::cast(array->elements()));
- for (int i = 0; i < fast_length; i++) {
- if (!elements->get(i)->IsTheHole()) element_count++;
- }
- break;
- }
- case FAST_DOUBLE_ELEMENTS:
- case FAST_HOLEY_DOUBLE_ELEMENTS: {
- // Fast elements can't have lengths that are not representable by
- // a 32-bit signed integer.
- DCHECK(static_cast<int32_t>(FixedDoubleArray::kMaxLength) >= 0);
- int fast_length = static_cast<int>(length);
- if (array->elements()->IsFixedArray()) {
- DCHECK(FixedArray::cast(array->elements())->length() == 0);
- break;
- }
- Handle<FixedDoubleArray> elements(
- FixedDoubleArray::cast(array->elements()));
- for (int i = 0; i < fast_length; i++) {
- if (!elements->is_the_hole(i)) element_count++;
- }
- break;
- }
- case DICTIONARY_ELEMENTS: {
- Handle<SeededNumberDictionary> dictionary(
- SeededNumberDictionary::cast(array->elements()));
- int capacity = dictionary->Capacity();
- for (int i = 0; i < capacity; i++) {
- Handle<Object> key(dictionary->KeyAt(i), array->GetIsolate());
- if (dictionary->IsKey(*key)) {
- element_count++;
- }
- }
- break;
- }
- case SLOPPY_ARGUMENTS_ELEMENTS:
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
- case EXTERNAL_##TYPE##_ELEMENTS: \
- case TYPE##_ELEMENTS:
-
- TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
- // External arrays are always dense.
- return length;
- }
- // As an estimate, we assume that the prototype doesn't contain any
- // inherited elements.
- return element_count;
-}
-
-
-template <class ExternalArrayClass, class ElementType>
-static void IterateExternalArrayElements(Isolate* isolate,
- Handle<JSObject> receiver,
- bool elements_are_ints,
- bool elements_are_guaranteed_smis,
- ArrayConcatVisitor* visitor) {
- Handle<ExternalArrayClass> array(
- ExternalArrayClass::cast(receiver->elements()));
- uint32_t len = static_cast<uint32_t>(array->length());
-
- DCHECK(visitor != NULL);
- if (elements_are_ints) {
- if (elements_are_guaranteed_smis) {
- for (uint32_t j = 0; j < len; j++) {
- HandleScope loop_scope(isolate);
- Handle<Smi> e(Smi::FromInt(static_cast<int>(array->get_scalar(j))),
- isolate);
- visitor->visit(j, e);
- }
- } else {
- for (uint32_t j = 0; j < len; j++) {
- HandleScope loop_scope(isolate);
- int64_t val = static_cast<int64_t>(array->get_scalar(j));
- if (Smi::IsValid(static_cast<intptr_t>(val))) {
- Handle<Smi> e(Smi::FromInt(static_cast<int>(val)), isolate);
- visitor->visit(j, e);
- } else {
- Handle<Object> e =
- isolate->factory()->NewNumber(static_cast<ElementType>(val));
- visitor->visit(j, e);
- }
- }
- }
- } else {
- for (uint32_t j = 0; j < len; j++) {
- HandleScope loop_scope(isolate);
- Handle<Object> e = isolate->factory()->NewNumber(array->get_scalar(j));
- visitor->visit(j, e);
- }
- }
-}
-
-
-// Used for sorting indices in a List<uint32_t>.
-static int compareUInt32(const uint32_t* ap, const uint32_t* bp) {
- uint32_t a = *ap;
- uint32_t b = *bp;
- return (a == b) ? 0 : (a < b) ? -1 : 1;
-}
-
-
-static void CollectElementIndices(Handle<JSObject> object, uint32_t range,
- List<uint32_t>* indices) {
- Isolate* isolate = object->GetIsolate();
- ElementsKind kind = object->GetElementsKind();
- switch (kind) {
- case FAST_SMI_ELEMENTS:
- case FAST_ELEMENTS:
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_HOLEY_ELEMENTS: {
- Handle<FixedArray> elements(FixedArray::cast(object->elements()));
- uint32_t length = static_cast<uint32_t>(elements->length());
- if (range < length) length = range;
- for (uint32_t i = 0; i < length; i++) {
- if (!elements->get(i)->IsTheHole()) {
- indices->Add(i);
- }
- }
- break;
- }
- case FAST_HOLEY_DOUBLE_ELEMENTS:
- case FAST_DOUBLE_ELEMENTS: {
- if (object->elements()->IsFixedArray()) {
- DCHECK(object->elements()->length() == 0);
- break;
- }
- Handle<FixedDoubleArray> elements(
- FixedDoubleArray::cast(object->elements()));
- uint32_t length = static_cast<uint32_t>(elements->length());
- if (range < length) length = range;
- for (uint32_t i = 0; i < length; i++) {
- if (!elements->is_the_hole(i)) {
- indices->Add(i);
- }
- }
- break;
- }
- case DICTIONARY_ELEMENTS: {
- Handle<SeededNumberDictionary> dict(
- SeededNumberDictionary::cast(object->elements()));
- uint32_t capacity = dict->Capacity();
- for (uint32_t j = 0; j < capacity; j++) {
- HandleScope loop_scope(isolate);
- Handle<Object> k(dict->KeyAt(j), isolate);
- if (dict->IsKey(*k)) {
- DCHECK(k->IsNumber());
- uint32_t index = static_cast<uint32_t>(k->Number());
- if (index < range) {
- indices->Add(index);
- }
- }
- }
- break;
- }
-#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
- case TYPE##_ELEMENTS: \
- case EXTERNAL_##TYPE##_ELEMENTS:
-
- TYPED_ARRAYS(TYPED_ARRAY_CASE)
-#undef TYPED_ARRAY_CASE
- {
- uint32_t length = static_cast<uint32_t>(
- FixedArrayBase::cast(object->elements())->length());
- if (range <= length) {
- length = range;
- // We will add all indices, so we might as well clear it first
- // and avoid duplicates.
- indices->Clear();
- }
- for (uint32_t i = 0; i < length; i++) {
- indices->Add(i);
- }
- if (length == range) return; // All indices accounted for already.
- break;
- }
- case SLOPPY_ARGUMENTS_ELEMENTS: {
- MaybeHandle<Object> length_obj =
- Object::GetProperty(object, isolate->factory()->length_string());
- double length_num = length_obj.ToHandleChecked()->Number();
- uint32_t length = static_cast<uint32_t>(DoubleToInt32(length_num));
- ElementsAccessor* accessor = object->GetElementsAccessor();
- for (uint32_t i = 0; i < length; i++) {
- if (accessor->HasElement(object, object, i)) {
- indices->Add(i);
- }
- }
- break;
- }
- }
-
- PrototypeIterator iter(isolate, object);
- if (!iter.IsAtEnd()) {
- // The prototype will usually have no inherited element indices,
- // but we have to check.
- CollectElementIndices(
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), range,
- indices);
- }
-}
-
-
-/**
- * A helper function that visits elements of a JSArray in numerical
- * order.
- *
- * The visitor argument called for each existing element in the array
- * with the element index and the element's value.
- * Afterwards it increments the base-index of the visitor by the array
- * length.
- * Returns false if any access threw an exception, otherwise true.
- */
-static bool IterateElements(Isolate* isolate, Handle<JSArray> receiver,
- ArrayConcatVisitor* visitor) {
- uint32_t length = static_cast<uint32_t>(receiver->length()->Number());
- switch (receiver->GetElementsKind()) {
- case FAST_SMI_ELEMENTS:
- case FAST_ELEMENTS:
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_HOLEY_ELEMENTS: {
- // Run through the elements FixedArray and use HasElement and GetElement
- // to check the prototype for missing elements.
- Handle<FixedArray> elements(FixedArray::cast(receiver->elements()));
- int fast_length = static_cast<int>(length);
- DCHECK(fast_length <= elements->length());
- for (int j = 0; j < fast_length; j++) {
- HandleScope loop_scope(isolate);
- Handle<Object> element_value(elements->get(j), isolate);
- if (!element_value->IsTheHole()) {
- visitor->visit(j, element_value);
- } else {
- Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
- if (!maybe.has_value) return false;
- if (maybe.value) {
- // Call GetElement on receiver, not its prototype, or getters won't
- // have the correct receiver.
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate, element_value,
- Object::GetElement(isolate, receiver, j), false);
- visitor->visit(j, element_value);
- }
- }
- }
- break;
- }
- case FAST_HOLEY_DOUBLE_ELEMENTS:
- case FAST_DOUBLE_ELEMENTS: {
- // Empty array is FixedArray but not FixedDoubleArray.
- if (length == 0) break;
- // Run through the elements FixedArray and use HasElement and GetElement
- // to check the prototype for missing elements.
- if (receiver->elements()->IsFixedArray()) {
- DCHECK(receiver->elements()->length() == 0);
- break;
- }
- Handle<FixedDoubleArray> elements(
- FixedDoubleArray::cast(receiver->elements()));
- int fast_length = static_cast<int>(length);
- DCHECK(fast_length <= elements->length());
- for (int j = 0; j < fast_length; j++) {
- HandleScope loop_scope(isolate);
- if (!elements->is_the_hole(j)) {
- double double_value = elements->get_scalar(j);
- Handle<Object> element_value =
- isolate->factory()->NewNumber(double_value);
- visitor->visit(j, element_value);
- } else {
- Maybe<bool> maybe = JSReceiver::HasElement(receiver, j);
- if (!maybe.has_value) return false;
- if (maybe.value) {
- // Call GetElement on receiver, not its prototype, or getters won't
- // have the correct receiver.
- Handle<Object> element_value;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate, element_value,
- Object::GetElement(isolate, receiver, j), false);
- visitor->visit(j, element_value);
- }
- }
- }
- break;
- }
- case DICTIONARY_ELEMENTS: {
- Handle<SeededNumberDictionary> dict(receiver->element_dictionary());
- List<uint32_t> indices(dict->Capacity() / 2);
- // Collect all indices in the object and the prototypes less
- // than length. This might introduce duplicates in the indices list.
- CollectElementIndices(receiver, length, &indices);
- indices.Sort(&compareUInt32);
- int j = 0;
- int n = indices.length();
- while (j < n) {
- HandleScope loop_scope(isolate);
- uint32_t index = indices[j];
- Handle<Object> element;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate, element, Object::GetElement(isolate, receiver, index),
- false);
- visitor->visit(index, element);
- // Skip to next different index (i.e., omit duplicates).
- do {
- j++;
- } while (j < n && indices[j] == index);
- }
- break;
- }
- case EXTERNAL_UINT8_CLAMPED_ELEMENTS: {
- Handle<ExternalUint8ClampedArray> pixels(
- ExternalUint8ClampedArray::cast(receiver->elements()));
- for (uint32_t j = 0; j < length; j++) {
- Handle<Smi> e(Smi::FromInt(pixels->get_scalar(j)), isolate);
- visitor->visit(j, e);
- }
- break;
- }
- case EXTERNAL_INT8_ELEMENTS: {
- IterateExternalArrayElements<ExternalInt8Array, int8_t>(
- isolate, receiver, true, true, visitor);
- break;
- }
- case EXTERNAL_UINT8_ELEMENTS: {
- IterateExternalArrayElements<ExternalUint8Array, uint8_t>(
- isolate, receiver, true, true, visitor);
- break;
- }
- case EXTERNAL_INT16_ELEMENTS: {
- IterateExternalArrayElements<ExternalInt16Array, int16_t>(
- isolate, receiver, true, true, visitor);
- break;
- }
- case EXTERNAL_UINT16_ELEMENTS: {
- IterateExternalArrayElements<ExternalUint16Array, uint16_t>(
- isolate, receiver, true, true, visitor);
- break;
- }
- case EXTERNAL_INT32_ELEMENTS: {
- IterateExternalArrayElements<ExternalInt32Array, int32_t>(
- isolate, receiver, true, false, visitor);
- break;
- }
- case EXTERNAL_UINT32_ELEMENTS: {
- IterateExternalArrayElements<ExternalUint32Array, uint32_t>(
- isolate, receiver, true, false, visitor);
- break;
- }
- case EXTERNAL_FLOAT32_ELEMENTS: {
- IterateExternalArrayElements<ExternalFloat32Array, float>(
- isolate, receiver, false, false, visitor);
- break;
- }
- case EXTERNAL_FLOAT64_ELEMENTS: {
- IterateExternalArrayElements<ExternalFloat64Array, double>(
- isolate, receiver, false, false, visitor);
- break;
- }
- default:
- UNREACHABLE();
- break;
- }
- visitor->increase_index_offset(length);
- return true;
-}
-
-
-/**
- * Array::concat implementation.
- * See ECMAScript 262, 15.4.4.4.
- * TODO(581): Fix non-compliance for very large concatenations and update to
- * following the ECMAScript 5 specification.
- */
-RUNTIME_FUNCTION(Runtime_ArrayConcat) {
- HandleScope handle_scope(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_HANDLE_CHECKED(JSArray, arguments, 0);
- int argument_count = static_cast<int>(arguments->length()->Number());
- RUNTIME_ASSERT(arguments->HasFastObjectElements());
- Handle<FixedArray> elements(FixedArray::cast(arguments->elements()));
-
- // Pass 1: estimate the length and number of elements of the result.
- // The actual length can be larger if any of the arguments have getters
- // that mutate other arguments (but will otherwise be precise).
- // The number of elements is precise if there are no inherited elements.
-
- ElementsKind kind = FAST_SMI_ELEMENTS;
-
- uint32_t estimate_result_length = 0;
- uint32_t estimate_nof_elements = 0;
- for (int i = 0; i < argument_count; i++) {
- HandleScope loop_scope(isolate);
- Handle<Object> obj(elements->get(i), isolate);
- uint32_t length_estimate;
- uint32_t element_estimate;
- if (obj->IsJSArray()) {
- Handle<JSArray> array(Handle<JSArray>::cast(obj));
- length_estimate = static_cast<uint32_t>(array->length()->Number());
- if (length_estimate != 0) {
- ElementsKind array_kind =
- GetPackedElementsKind(array->map()->elements_kind());
- if (IsMoreGeneralElementsKindTransition(kind, array_kind)) {
- kind = array_kind;
- }
- }
- element_estimate = EstimateElementCount(array);
- } else {
- if (obj->IsHeapObject()) {
- if (obj->IsNumber()) {
- if (IsMoreGeneralElementsKindTransition(kind, FAST_DOUBLE_ELEMENTS)) {
- kind = FAST_DOUBLE_ELEMENTS;
- }
- } else if (IsMoreGeneralElementsKindTransition(kind, FAST_ELEMENTS)) {
- kind = FAST_ELEMENTS;
- }
- }
- length_estimate = 1;
- element_estimate = 1;
- }
- // Avoid overflows by capping at kMaxElementCount.
- if (JSObject::kMaxElementCount - estimate_result_length < length_estimate) {
- estimate_result_length = JSObject::kMaxElementCount;
- } else {
- estimate_result_length += length_estimate;
- }
- if (JSObject::kMaxElementCount - estimate_nof_elements < element_estimate) {
- estimate_nof_elements = JSObject::kMaxElementCount;
- } else {
- estimate_nof_elements += element_estimate;
- }
- }
-
- // If estimated number of elements is more than half of length, a
- // fixed array (fast case) is more time and space-efficient than a
- // dictionary.
- bool fast_case = (estimate_nof_elements * 2) >= estimate_result_length;
-
- if (fast_case && kind == FAST_DOUBLE_ELEMENTS) {
- Handle<FixedArrayBase> storage =
- isolate->factory()->NewFixedDoubleArray(estimate_result_length);
- int j = 0;
- bool failure = false;
- if (estimate_result_length > 0) {
- Handle<FixedDoubleArray> double_storage =
- Handle<FixedDoubleArray>::cast(storage);
- for (int i = 0; i < argument_count; i++) {
- Handle<Object> obj(elements->get(i), isolate);
- if (obj->IsSmi()) {
- double_storage->set(j, Smi::cast(*obj)->value());
- j++;
- } else if (obj->IsNumber()) {
- double_storage->set(j, obj->Number());
- j++;
- } else {
- JSArray* array = JSArray::cast(*obj);
- uint32_t length = static_cast<uint32_t>(array->length()->Number());
- switch (array->map()->elements_kind()) {
- case FAST_HOLEY_DOUBLE_ELEMENTS:
- case FAST_DOUBLE_ELEMENTS: {
- // Empty array is FixedArray but not FixedDoubleArray.
- if (length == 0) break;
- FixedDoubleArray* elements =
- FixedDoubleArray::cast(array->elements());
- for (uint32_t i = 0; i < length; i++) {
- if (elements->is_the_hole(i)) {
- // TODO(jkummerow/verwaest): We could be a bit more clever
- // here: Check if there are no elements/getters on the
- // prototype chain, and if so, allow creation of a holey
- // result array.
- // Same thing below (holey smi case).
- failure = true;
- break;
- }
- double double_value = elements->get_scalar(i);
- double_storage->set(j, double_value);
- j++;
- }
- break;
- }
- case FAST_HOLEY_SMI_ELEMENTS:
- case FAST_SMI_ELEMENTS: {
- FixedArray* elements(FixedArray::cast(array->elements()));
- for (uint32_t i = 0; i < length; i++) {
- Object* element = elements->get(i);
- if (element->IsTheHole()) {
- failure = true;
- break;
- }
- int32_t int_value = Smi::cast(element)->value();
- double_storage->set(j, int_value);
- j++;
- }
- break;
- }
- case FAST_HOLEY_ELEMENTS:
- case FAST_ELEMENTS:
- DCHECK_EQ(0, length);
- break;
- default:
- UNREACHABLE();
- }
- }
- if (failure) break;
- }
- }
- if (!failure) {
- Handle<JSArray> array = isolate->factory()->NewJSArray(0);
- Smi* length = Smi::FromInt(j);
- Handle<Map> map;
- map = JSObject::GetElementsTransitionMap(array, kind);
- array->set_map(*map);
- array->set_length(length);
- array->set_elements(*storage);
- return *array;
- }
- // In case of failure, fall through.
- }
-
- Handle<FixedArray> storage;
- if (fast_case) {
- // The backing storage array must have non-existing elements to preserve
- // holes across concat operations.
- storage =
- isolate->factory()->NewFixedArrayWithHoles(estimate_result_length);
- } else {
- // TODO(126): move 25% pre-allocation logic into Dictionary::Allocate
- uint32_t at_least_space_for =
- estimate_nof_elements + (estimate_nof_elements >> 2);
- storage = Handle<FixedArray>::cast(
- SeededNumberDictionary::New(isolate, at_least_space_for));
- }
-
- ArrayConcatVisitor visitor(isolate, storage, fast_case);
-
- for (int i = 0; i < argument_count; i++) {
- Handle<Object> obj(elements->get(i), isolate);
- if (obj->IsJSArray()) {
- Handle<JSArray> array = Handle<JSArray>::cast(obj);
- if (!IterateElements(isolate, array, &visitor)) {
- return isolate->heap()->exception();
- }
- } else {
- visitor.visit(0, obj);
- visitor.increase_index_offset(1);
- }
- }
-
- if (visitor.exceeds_array_limit()) {
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewRangeError("invalid_array_length", HandleVector<Object>(NULL, 0)));
- }
- return *visitor.ToArray();
-}
-
-
-// Moves all own elements of an object, that are below a limit, to positions
-// starting at zero. All undefined values are placed after non-undefined values,
-// and are followed by non-existing element. Does not change the length
-// property.
-// Returns the number of non-undefined elements collected.
-// Returns -1 if hole removal is not supported by this method.
-RUNTIME_FUNCTION(Runtime_RemoveArrayHoles) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[1]);
- return *JSObject::PrepareElementsForSort(object, limit);
-}
-
-
-// Move contents of argument 0 (an array) to argument 1 (an array)
-RUNTIME_FUNCTION(Runtime_MoveArrayContents) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, from, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, to, 1);
- JSObject::ValidateElements(from);
- JSObject::ValidateElements(to);
-
- Handle<FixedArrayBase> new_elements(from->elements());
- ElementsKind from_kind = from->GetElementsKind();
- Handle<Map> new_map = JSObject::GetElementsTransitionMap(to, from_kind);
- JSObject::SetMapAndElements(to, new_map, new_elements);
- to->set_length(from->length());
-
- JSObject::ResetElements(from);
- from->set_length(Smi::FromInt(0));
-
- JSObject::ValidateElements(to);
- return *to;
-}
-
-
-// How many elements does this object/array have?
-RUNTIME_FUNCTION(Runtime_EstimateNumberOfElements) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0);
- Handle<FixedArrayBase> elements(array->elements(), isolate);
- SealHandleScope shs(isolate);
- if (elements->IsDictionary()) {
- int result =
- Handle<SeededNumberDictionary>::cast(elements)->NumberOfElements();
- return Smi::FromInt(result);
- } else {
- DCHECK(array->length()->IsSmi());
- // For packed elements, we know the exact number of elements
- int length = elements->length();
- ElementsKind kind = array->GetElementsKind();
- if (IsFastPackedElementsKind(kind)) {
- return Smi::FromInt(length);
- }
- // For holey elements, take samples from the buffer checking for holes
- // to generate the estimate.
- const int kNumberOfHoleCheckSamples = 97;
- int increment = (length < kNumberOfHoleCheckSamples)
- ? 1
- : static_cast<int>(length / kNumberOfHoleCheckSamples);
- ElementsAccessor* accessor = array->GetElementsAccessor();
- int holes = 0;
- for (int i = 0; i < length; i += increment) {
- if (!accessor->HasElement(array, array, i, elements)) {
- ++holes;
- }
- }
- int estimate = static_cast<int>((kNumberOfHoleCheckSamples - holes) /
- kNumberOfHoleCheckSamples * length);
- return Smi::FromInt(estimate);
- }
-}
-
-
-// Returns an array that tells you where in the [0, length) interval an array
-// might have elements. Can either return an array of keys (positive integers
-// or undefined) or a number representing the positive length of an interval
-// starting at index 0.
-// Intervals can span over some keys that are not in the object.
-RUNTIME_FUNCTION(Runtime_GetArrayKeys) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
- CONVERT_NUMBER_CHECKED(uint32_t, length, Uint32, args[1]);
- if (array->elements()->IsDictionary()) {
- Handle<FixedArray> keys = isolate->factory()->empty_fixed_array();
- for (PrototypeIterator iter(isolate, array,
- PrototypeIterator::START_AT_RECEIVER);
- !iter.IsAtEnd(); iter.Advance()) {
- if (PrototypeIterator::GetCurrent(iter)->IsJSProxy() ||
- JSObject::cast(*PrototypeIterator::GetCurrent(iter))
- ->HasIndexedInterceptor()) {
- // Bail out if we find a proxy or interceptor, likely not worth
- // collecting keys in that case.
- return *isolate->factory()->NewNumberFromUint(length);
- }
- Handle<JSObject> current =
- Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- Handle<FixedArray> current_keys =
- isolate->factory()->NewFixedArray(current->NumberOfOwnElements(NONE));
- current->GetOwnElementKeys(*current_keys, NONE);
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, keys, FixedArray::UnionOfKeys(keys, current_keys));
- }
- // Erase any keys >= length.
- // TODO(adamk): Remove this step when the contract of %GetArrayKeys
- // is changed to let this happen on the JS side.
- for (int i = 0; i < keys->length(); i++) {
- if (NumberToUint32(keys->get(i)) >= length) keys->set_undefined(i);
- }
- return *isolate->factory()->NewJSArrayWithElements(keys);
- } else {
- RUNTIME_ASSERT(array->HasFastSmiOrObjectElements() ||
- array->HasFastDoubleElements());
- uint32_t actual_length = static_cast<uint32_t>(array->elements()->length());
- return *isolate->factory()->NewNumberFromUint(Min(actual_length, length));
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_LookupAccessor) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- CONVERT_SMI_ARG_CHECKED(flag, 2);
- AccessorComponent component = flag == 0 ? ACCESSOR_GETTER : ACCESSOR_SETTER;
- if (!receiver->IsJSObject()) return isolate->heap()->undefined_value();
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- JSObject::GetAccessor(Handle<JSObject>::cast(receiver), name, component));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugBreak) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- isolate->debug()->HandleDebugBreak();
- return isolate->heap()->undefined_value();
-}
-
-
-// Helper functions for wrapping and unwrapping stack frame ids.
-static Smi* WrapFrameId(StackFrame::Id id) {
- DCHECK(IsAligned(OffsetFrom(id), static_cast<intptr_t>(4)));
- return Smi::FromInt(id >> 2);
-}
-
-
-static StackFrame::Id UnwrapFrameId(int wrapped) {
- return static_cast<StackFrame::Id>(wrapped << 2);
-}
-
-
-// Adds a JavaScript function as a debug event listener.
-// args[0]: debug event listener function to set or null or undefined for
-// clearing the event listener function
-// args[1]: object supplied during callback
-RUNTIME_FUNCTION(Runtime_SetDebugEventListener) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- RUNTIME_ASSERT(args[0]->IsJSFunction() || args[0]->IsUndefined() ||
- args[0]->IsNull());
- CONVERT_ARG_HANDLE_CHECKED(Object, callback, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, data, 1);
- isolate->debug()->SetEventListener(callback, data);
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_Break) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- isolate->stack_guard()->RequestDebugBreak();
- return isolate->heap()->undefined_value();
-}
-
-
-static Handle<Object> DebugGetProperty(LookupIterator* it,
- bool* has_caught = NULL) {
- for (; it->IsFound(); it->Next()) {
- switch (it->state()) {
- case LookupIterator::NOT_FOUND:
- case LookupIterator::TRANSITION:
- UNREACHABLE();
- case LookupIterator::ACCESS_CHECK:
- // Ignore access checks.
- break;
- case LookupIterator::INTERCEPTOR:
- case LookupIterator::JSPROXY:
- return it->isolate()->factory()->undefined_value();
- case LookupIterator::ACCESSOR: {
- Handle<Object> accessors = it->GetAccessors();
- if (!accessors->IsAccessorInfo()) {
- return it->isolate()->factory()->undefined_value();
- }
- MaybeHandle<Object> maybe_result = JSObject::GetPropertyWithAccessor(
- it->GetReceiver(), it->name(), it->GetHolder<JSObject>(),
- accessors);
- Handle<Object> result;
- if (!maybe_result.ToHandle(&result)) {
- result = handle(it->isolate()->pending_exception(), it->isolate());
- it->isolate()->clear_pending_exception();
- if (has_caught != NULL) *has_caught = true;
- }
- return result;
- }
-
- case LookupIterator::DATA:
- return it->GetDataValue();
- }
- }
-
- return it->isolate()->factory()->undefined_value();
-}
-
-
-// Get debugger related details for an object property, in the following format:
-// 0: Property value
-// 1: Property details
-// 2: Property value is exception
-// 3: Getter function if defined
-// 4: Setter function if defined
-// Items 2-4 are only filled if the property has either a getter or a setter.
-RUNTIME_FUNCTION(Runtime_DebugGetPropertyDetails) {
- HandleScope scope(isolate);
-
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
-
- // Make sure to set the current context to the context before the debugger was
- // entered (if the debugger is entered). The reason for switching context here
- // is that for some property lookups (accessors and interceptors) callbacks
- // into the embedding application can occour, and the embedding application
- // could have the assumption that its own native context is the current
- // context and not some internal debugger context.
- SaveContext save(isolate);
- if (isolate->debug()->in_debug_scope()) {
- isolate->set_context(*isolate->debug()->debugger_entry()->GetContext());
- }
-
- // Check if the name is trivially convertible to an index and get the element
- // if so.
- uint32_t index;
- if (name->AsArrayIndex(&index)) {
- Handle<FixedArray> details = isolate->factory()->NewFixedArray(2);
- Handle<Object> element_or_char;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, element_or_char,
- Runtime::GetElementOrCharAt(isolate, obj, index));
- details->set(0, *element_or_char);
- details->set(1,
- PropertyDetails(NONE, NORMAL, Representation::None()).AsSmi());
- return *isolate->factory()->NewJSArrayWithElements(details);
- }
-
- LookupIterator it(obj, name, LookupIterator::HIDDEN);
- bool has_caught = false;
- Handle<Object> value = DebugGetProperty(&it, &has_caught);
- if (!it.IsFound()) return isolate->heap()->undefined_value();
-
- Handle<Object> maybe_pair;
- if (it.state() == LookupIterator::ACCESSOR) {
- maybe_pair = it.GetAccessors();
- }
-
- // If the callback object is a fixed array then it contains JavaScript
- // getter and/or setter.
- bool has_js_accessors = !maybe_pair.is_null() && maybe_pair->IsAccessorPair();
- Handle<FixedArray> details =
- isolate->factory()->NewFixedArray(has_js_accessors ? 6 : 3);
- details->set(0, *value);
- // TODO(verwaest): Get rid of this random way of handling interceptors.
- PropertyDetails d = it.state() == LookupIterator::INTERCEPTOR
- ? PropertyDetails(NONE, NORMAL, 0)
- : it.property_details();
- details->set(1, d.AsSmi());
- details->set(
- 2, isolate->heap()->ToBoolean(it.state() == LookupIterator::INTERCEPTOR));
- if (has_js_accessors) {
- AccessorPair* accessors = AccessorPair::cast(*maybe_pair);
- details->set(3, isolate->heap()->ToBoolean(has_caught));
- details->set(4, accessors->GetComponent(ACCESSOR_GETTER));
- details->set(5, accessors->GetComponent(ACCESSOR_SETTER));
- }
-
- return *isolate->factory()->NewJSArrayWithElements(details);
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugGetProperty) {
- HandleScope scope(isolate);
-
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
-
- LookupIterator it(obj, name);
- return *DebugGetProperty(&it);
-}
-
-
-// Return the property type calculated from the property details.
-// args[0]: smi with property details.
-RUNTIME_FUNCTION(Runtime_DebugPropertyTypeFromDetails) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
- return Smi::FromInt(static_cast<int>(details.type()));
-}
-
-
-// Return the property attribute calculated from the property details.
-// args[0]: smi with property details.
-RUNTIME_FUNCTION(Runtime_DebugPropertyAttributesFromDetails) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
- return Smi::FromInt(static_cast<int>(details.attributes()));
-}
-
-
-// Return the property insertion index calculated from the property details.
-// args[0]: smi with property details.
-RUNTIME_FUNCTION(Runtime_DebugPropertyIndexFromDetails) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);
- // TODO(verwaest): Depends on the type of details.
- return Smi::FromInt(details.dictionary_index());
-}
-
-
-// Return property value from named interceptor.
-// args[0]: object
-// args[1]: property name
-RUNTIME_FUNCTION(Runtime_DebugNamedInterceptorPropertyValue) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- RUNTIME_ASSERT(obj->HasNamedInterceptor());
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
- JSObject::GetProperty(obj, name));
- return *result;
-}
-
-
-// Return element value from indexed interceptor.
-// args[0]: object
-// args[1]: index
-RUNTIME_FUNCTION(Runtime_DebugIndexedInterceptorElementValue) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- RUNTIME_ASSERT(obj->HasIndexedInterceptor());
- CONVERT_NUMBER_CHECKED(uint32_t, index, Uint32, args[1]);
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, JSObject::GetElementWithInterceptor(obj, obj, index));
- return *result;
-}
-
-
-static bool CheckExecutionState(Isolate* isolate, int break_id) {
- return !isolate->debug()->debug_context().is_null() &&
- isolate->debug()->break_id() != 0 &&
- isolate->debug()->break_id() == break_id;
-}
-
-
-RUNTIME_FUNCTION(Runtime_CheckExecutionState) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
- return isolate->heap()->true_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetFrameCount) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- // Count all frames which are relevant to debugging stack trace.
- int n = 0;
- StackFrame::Id id = isolate->debug()->break_frame_id();
- if (id == StackFrame::NO_ID) {
- // If there is no JavaScript stack frame count is 0.
- return Smi::FromInt(0);
- }
-
- for (JavaScriptFrameIterator it(isolate, id); !it.done(); it.Advance()) {
- List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
- it.frame()->Summarize(&frames);
- for (int i = frames.length() - 1; i >= 0; i--) {
- // Omit functions from native scripts.
- if (!frames[i].function()->IsFromNativeScript()) n++;
- }
- }
- return Smi::FromInt(n);
-}
-
-
-class FrameInspector {
- public:
- FrameInspector(JavaScriptFrame* frame, int inlined_jsframe_index,
- Isolate* isolate)
- : frame_(frame), deoptimized_frame_(NULL), isolate_(isolate) {
- // Calculate the deoptimized frame.
- if (frame->is_optimized()) {
- deoptimized_frame_ = Deoptimizer::DebuggerInspectableFrame(
- frame, inlined_jsframe_index, isolate);
- }
- has_adapted_arguments_ = frame_->has_adapted_arguments();
- is_bottommost_ = inlined_jsframe_index == 0;
- is_optimized_ = frame_->is_optimized();
- }
-
- ~FrameInspector() {
- // Get rid of the calculated deoptimized frame if any.
- if (deoptimized_frame_ != NULL) {
- Deoptimizer::DeleteDebuggerInspectableFrame(deoptimized_frame_, isolate_);
- }
- }
-
- int GetParametersCount() {
- return is_optimized_ ? deoptimized_frame_->parameters_count()
- : frame_->ComputeParametersCount();
- }
- int expression_count() { return deoptimized_frame_->expression_count(); }
- Object* GetFunction() {
- return is_optimized_ ? deoptimized_frame_->GetFunction()
- : frame_->function();
- }
- Object* GetParameter(int index) {
- return is_optimized_ ? deoptimized_frame_->GetParameter(index)
- : frame_->GetParameter(index);
- }
- Object* GetExpression(int index) {
- return is_optimized_ ? deoptimized_frame_->GetExpression(index)
- : frame_->GetExpression(index);
- }
- int GetSourcePosition() {
- return is_optimized_ ? deoptimized_frame_->GetSourcePosition()
- : frame_->LookupCode()->SourcePosition(frame_->pc());
- }
- bool IsConstructor() {
- return is_optimized_ && !is_bottommost_
- ? deoptimized_frame_->HasConstructStub()
- : frame_->IsConstructor();
- }
- Object* GetContext() {
- return is_optimized_ ? deoptimized_frame_->GetContext() : frame_->context();
- }
-
- // To inspect all the provided arguments the frame might need to be
- // replaced with the arguments frame.
- void SetArgumentsFrame(JavaScriptFrame* frame) {
- DCHECK(has_adapted_arguments_);
- frame_ = frame;
- is_optimized_ = frame_->is_optimized();
- DCHECK(!is_optimized_);
- }
-
- private:
- JavaScriptFrame* frame_;
- DeoptimizedFrameInfo* deoptimized_frame_;
- Isolate* isolate_;
- bool is_optimized_;
- bool is_bottommost_;
- bool has_adapted_arguments_;
-
- DISALLOW_COPY_AND_ASSIGN(FrameInspector);
-};
-
-
-static const int kFrameDetailsFrameIdIndex = 0;
-static const int kFrameDetailsReceiverIndex = 1;
-static const int kFrameDetailsFunctionIndex = 2;
-static const int kFrameDetailsArgumentCountIndex = 3;
-static const int kFrameDetailsLocalCountIndex = 4;
-static const int kFrameDetailsSourcePositionIndex = 5;
-static const int kFrameDetailsConstructCallIndex = 6;
-static const int kFrameDetailsAtReturnIndex = 7;
-static const int kFrameDetailsFlagsIndex = 8;
-static const int kFrameDetailsFirstDynamicIndex = 9;
-
-
-static SaveContext* FindSavedContextForFrame(Isolate* isolate,
- JavaScriptFrame* frame) {
- SaveContext* save = isolate->save_context();
- while (save != NULL && !save->IsBelowFrame(frame)) {
- save = save->prev();
- }
- DCHECK(save != NULL);
- return save;
-}
-
-
-// Advances the iterator to the frame that matches the index and returns the
-// inlined frame index, or -1 if not found. Skips native JS functions.
-static int FindIndexedNonNativeFrame(JavaScriptFrameIterator* it, int index) {
- int count = -1;
- for (; !it->done(); it->Advance()) {
- List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
- it->frame()->Summarize(&frames);
- for (int i = frames.length() - 1; i >= 0; i--) {
- // Omit functions from native scripts.
- if (frames[i].function()->IsFromNativeScript()) continue;
- if (++count == index) return i;
- }
- }
- return -1;
-}
-
-
-// Return an array with frame details
-// args[0]: number: break id
-// args[1]: number: frame index
-//
-// The array returned contains the following information:
-// 0: Frame id
-// 1: Receiver
-// 2: Function
-// 3: Argument count
-// 4: Local count
-// 5: Source position
-// 6: Constructor call
-// 7: Is at return
-// 8: Flags
-// Arguments name, value
-// Locals name, value
-// Return value if any
-RUNTIME_FUNCTION(Runtime_GetFrameDetails) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
- Heap* heap = isolate->heap();
-
- // Find the relevant frame with the requested index.
- StackFrame::Id id = isolate->debug()->break_frame_id();
- if (id == StackFrame::NO_ID) {
- // If there are no JavaScript stack frames return undefined.
- return heap->undefined_value();
- }
-
- JavaScriptFrameIterator it(isolate, id);
- // Inlined frame index in optimized frame, starting from outer function.
- int inlined_jsframe_index = FindIndexedNonNativeFrame(&it, index);
- if (inlined_jsframe_index == -1) return heap->undefined_value();
-
- FrameInspector frame_inspector(it.frame(), inlined_jsframe_index, isolate);
- bool is_optimized = it.frame()->is_optimized();
-
- // Traverse the saved contexts chain to find the active context for the
- // selected frame.
- SaveContext* save = FindSavedContextForFrame(isolate, it.frame());
-
- // Get the frame id.
- Handle<Object> frame_id(WrapFrameId(it.frame()->id()), isolate);
-
- // Find source position in unoptimized code.
- int position = frame_inspector.GetSourcePosition();
-
- // Check for constructor frame.
- bool constructor = frame_inspector.IsConstructor();
-
- // Get scope info and read from it for local variable information.
- Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
- Handle<SharedFunctionInfo> shared(function->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
- DCHECK(*scope_info != ScopeInfo::Empty(isolate));
-
- // Get the locals names and values into a temporary array.
- int local_count = scope_info->LocalCount();
- for (int slot = 0; slot < scope_info->LocalCount(); ++slot) {
- // Hide compiler-introduced temporary variables, whether on the stack or on
- // the context.
- if (scope_info->LocalIsSynthetic(slot)) local_count--;
- }
-
- Handle<FixedArray> locals =
- isolate->factory()->NewFixedArray(local_count * 2);
-
- // Fill in the values of the locals.
- int local = 0;
- int i = 0;
- for (; i < scope_info->StackLocalCount(); ++i) {
- // Use the value from the stack.
- if (scope_info->LocalIsSynthetic(i)) continue;
- locals->set(local * 2, scope_info->LocalName(i));
- locals->set(local * 2 + 1, frame_inspector.GetExpression(i));
- local++;
- }
- if (local < local_count) {
- // Get the context containing declarations.
- Handle<Context> context(
- Context::cast(frame_inspector.GetContext())->declaration_context());
- for (; i < scope_info->LocalCount(); ++i) {
- if (scope_info->LocalIsSynthetic(i)) continue;
- Handle<String> name(scope_info->LocalName(i));
- VariableMode mode;
- InitializationFlag init_flag;
- MaybeAssignedFlag maybe_assigned_flag;
- locals->set(local * 2, *name);
- int context_slot_index = ScopeInfo::ContextSlotIndex(
- scope_info, name, &mode, &init_flag, &maybe_assigned_flag);
- Object* value = context->get(context_slot_index);
- locals->set(local * 2 + 1, value);
- local++;
- }
- }
-
- // Check whether this frame is positioned at return. If not top
- // frame or if the frame is optimized it cannot be at a return.
- bool at_return = false;
- if (!is_optimized && index == 0) {
- at_return = isolate->debug()->IsBreakAtReturn(it.frame());
- }
-
- // If positioned just before return find the value to be returned and add it
- // to the frame information.
- Handle<Object> return_value = isolate->factory()->undefined_value();
- if (at_return) {
- StackFrameIterator it2(isolate);
- Address internal_frame_sp = NULL;
- while (!it2.done()) {
- if (it2.frame()->is_internal()) {
- internal_frame_sp = it2.frame()->sp();
- } else {
- if (it2.frame()->is_java_script()) {
- if (it2.frame()->id() == it.frame()->id()) {
- // The internal frame just before the JavaScript frame contains the
- // value to return on top. A debug break at return will create an
- // internal frame to store the return value (eax/rax/r0) before
- // entering the debug break exit frame.
- if (internal_frame_sp != NULL) {
- return_value =
- Handle<Object>(Memory::Object_at(internal_frame_sp), isolate);
- break;
- }
- }
- }
-
- // Indicate that the previous frame was not an internal frame.
- internal_frame_sp = NULL;
- }
- it2.Advance();
- }
- }
-
- // Now advance to the arguments adapter frame (if any). It contains all
- // the provided parameters whereas the function frame always have the number
- // of arguments matching the functions parameters. The rest of the
- // information (except for what is collected above) is the same.
- if ((inlined_jsframe_index == 0) && it.frame()->has_adapted_arguments()) {
- it.AdvanceToArgumentsFrame();
- frame_inspector.SetArgumentsFrame(it.frame());
- }
-
- // Find the number of arguments to fill. At least fill the number of
- // parameters for the function and fill more if more parameters are provided.
- int argument_count = scope_info->ParameterCount();
- if (argument_count < frame_inspector.GetParametersCount()) {
- argument_count = frame_inspector.GetParametersCount();
- }
-
- // Calculate the size of the result.
- int details_size = kFrameDetailsFirstDynamicIndex +
- 2 * (argument_count + local_count) + (at_return ? 1 : 0);
- Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);
-
- // Add the frame id.
- details->set(kFrameDetailsFrameIdIndex, *frame_id);
-
- // Add the function (same as in function frame).
- details->set(kFrameDetailsFunctionIndex, frame_inspector.GetFunction());
-
- // Add the arguments count.
- details->set(kFrameDetailsArgumentCountIndex, Smi::FromInt(argument_count));
-
- // Add the locals count
- details->set(kFrameDetailsLocalCountIndex, Smi::FromInt(local_count));
-
- // Add the source position.
- if (position != RelocInfo::kNoPosition) {
- details->set(kFrameDetailsSourcePositionIndex, Smi::FromInt(position));
- } else {
- details->set(kFrameDetailsSourcePositionIndex, heap->undefined_value());
- }
-
- // Add the constructor information.
- details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(constructor));
-
- // Add the at return information.
- details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(at_return));
-
- // Add flags to indicate information on whether this frame is
- // bit 0: invoked in the debugger context.
- // bit 1: optimized frame.
- // bit 2: inlined in optimized frame
- int flags = 0;
- if (*save->context() == *isolate->debug()->debug_context()) {
- flags |= 1 << 0;
- }
- if (is_optimized) {
- flags |= 1 << 1;
- flags |= inlined_jsframe_index << 2;
- }
- details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));
-
- // Fill the dynamic part.
- int details_index = kFrameDetailsFirstDynamicIndex;
-
- // Add arguments name and value.
- for (int i = 0; i < argument_count; i++) {
- // Name of the argument.
- if (i < scope_info->ParameterCount()) {
- details->set(details_index++, scope_info->ParameterName(i));
- } else {
- details->set(details_index++, heap->undefined_value());
- }
-
- // Parameter value.
- if (i < frame_inspector.GetParametersCount()) {
- // Get the value from the stack.
- details->set(details_index++, frame_inspector.GetParameter(i));
- } else {
- details->set(details_index++, heap->undefined_value());
- }
- }
-
- // Add locals name and value from the temporary copy from the function frame.
- for (int i = 0; i < local_count * 2; i++) {
- details->set(details_index++, locals->get(i));
- }
-
- // Add the value being returned.
- if (at_return) {
- details->set(details_index++, *return_value);
- }
-
- // Add the receiver (same as in function frame).
- // THIS MUST BE DONE LAST SINCE WE MIGHT ADVANCE
- // THE FRAME ITERATOR TO WRAP THE RECEIVER.
- Handle<Object> receiver(it.frame()->receiver(), isolate);
- if (!receiver->IsJSObject() && shared->strict_mode() == SLOPPY &&
- !function->IsBuiltin()) {
- // If the receiver is not a JSObject and the function is not a
- // builtin or strict-mode we have hit an optimization where a
- // value object is not converted into a wrapped JS objects. To
- // hide this optimization from the debugger, we wrap the receiver
- // by creating correct wrapper object based on the calling frame's
- // native context.
- it.Advance();
- if (receiver->IsUndefined()) {
- receiver = handle(function->global_proxy());
- } else {
- Context* context = Context::cast(it.frame()->context());
- Handle<Context> native_context(Context::cast(context->native_context()));
- if (!Object::ToObject(isolate, receiver, native_context)
- .ToHandle(&receiver)) {
- // This only happens if the receiver is forcibly set in %_CallFunction.
- return heap->undefined_value();
- }
- }
- }
- details->set(kFrameDetailsReceiverIndex, *receiver);
-
- DCHECK_EQ(details_size, details_index);
- return *isolate->factory()->NewJSArrayWithElements(details);
-}
-
-
-static bool ParameterIsShadowedByContextLocal(Handle<ScopeInfo> info,
- Handle<String> parameter_name) {
- VariableMode mode;
- InitializationFlag init_flag;
- MaybeAssignedFlag maybe_assigned_flag;
- return ScopeInfo::ContextSlotIndex(info, parameter_name, &mode, &init_flag,
- &maybe_assigned_flag) != -1;
-}
-
-
-// Create a plain JSObject which materializes the local scope for the specified
-// frame.
-MUST_USE_RESULT
-static MaybeHandle<JSObject> MaterializeStackLocalsWithFrameInspector(
- Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function,
- FrameInspector* frame_inspector) {
- Handle<SharedFunctionInfo> shared(function->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- // First fill all parameters.
- for (int i = 0; i < scope_info->ParameterCount(); ++i) {
- // Do not materialize the parameter if it is shadowed by a context local.
- Handle<String> name(scope_info->ParameterName(i));
- if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
-
- HandleScope scope(isolate);
- Handle<Object> value(i < frame_inspector->GetParametersCount()
- ? frame_inspector->GetParameter(i)
- : isolate->heap()->undefined_value(),
- isolate);
- DCHECK(!value->IsTheHole());
-
- RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
- isolate, target, name, value, SLOPPY),
- JSObject);
- }
-
- // Second fill all stack locals.
- for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
- if (scope_info->LocalIsSynthetic(i)) continue;
- Handle<String> name(scope_info->StackLocalName(i));
- Handle<Object> value(frame_inspector->GetExpression(i), isolate);
- if (value->IsTheHole()) continue;
-
- RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
- isolate, target, name, value, SLOPPY),
- JSObject);
- }
-
- return target;
-}
-
-
-static void UpdateStackLocalsFromMaterializedObject(Isolate* isolate,
- Handle<JSObject> target,
- Handle<JSFunction> function,
- JavaScriptFrame* frame,
- int inlined_jsframe_index) {
- if (inlined_jsframe_index != 0 || frame->is_optimized()) {
- // Optimized frames are not supported.
- // TODO(yangguo): make sure all code deoptimized when debugger is active
- // and assert that this cannot happen.
- return;
- }
-
- Handle<SharedFunctionInfo> shared(function->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- // Parameters.
- for (int i = 0; i < scope_info->ParameterCount(); ++i) {
- // Shadowed parameters were not materialized.
- Handle<String> name(scope_info->ParameterName(i));
- if (ParameterIsShadowedByContextLocal(scope_info, name)) continue;
-
- DCHECK(!frame->GetParameter(i)->IsTheHole());
- HandleScope scope(isolate);
- Handle<Object> value =
- Object::GetPropertyOrElement(target, name).ToHandleChecked();
- frame->SetParameterValue(i, *value);
- }
-
- // Stack locals.
- for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
- if (scope_info->LocalIsSynthetic(i)) continue;
- if (frame->GetExpression(i)->IsTheHole()) continue;
- HandleScope scope(isolate);
- Handle<Object> value = Object::GetPropertyOrElement(
- target, handle(scope_info->StackLocalName(i),
- isolate)).ToHandleChecked();
- frame->SetExpression(i, *value);
- }
-}
-
-
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalContext(
- Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function,
- JavaScriptFrame* frame) {
- HandleScope scope(isolate);
- Handle<SharedFunctionInfo> shared(function->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- if (!scope_info->HasContext()) return target;
-
- // Third fill all context locals.
- Handle<Context> frame_context(Context::cast(frame->context()));
- Handle<Context> function_context(frame_context->declaration_context());
- if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, function_context,
- target)) {
- return MaybeHandle<JSObject>();
- }
-
- // Finally copy any properties from the function context extension.
- // These will be variables introduced by eval.
- if (function_context->closure() == *function) {
- if (function_context->has_extension() &&
- !function_context->IsNativeContext()) {
- Handle<JSObject> ext(JSObject::cast(function_context->extension()));
- Handle<FixedArray> keys;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, keys, JSReceiver::GetKeys(ext, JSReceiver::INCLUDE_PROTOS),
- JSObject);
-
- for (int i = 0; i < keys->length(); i++) {
- // Names of variables introduced by eval are strings.
- DCHECK(keys->get(i)->IsString());
- Handle<String> key(String::cast(keys->get(i)));
- Handle<Object> value;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, value, Object::GetPropertyOrElement(ext, key), JSObject);
- RETURN_ON_EXCEPTION(isolate, Runtime::SetObjectProperty(
- isolate, target, key, value, SLOPPY),
- JSObject);
- }
- }
- }
-
- return target;
-}
-
-
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeLocalScope(
- Isolate* isolate, JavaScriptFrame* frame, int inlined_jsframe_index) {
- FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
- Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
-
- Handle<JSObject> local_scope =
- isolate->factory()->NewJSObject(isolate->object_function());
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, local_scope,
- MaterializeStackLocalsWithFrameInspector(isolate, local_scope, function,
- &frame_inspector),
- JSObject);
-
- return MaterializeLocalContext(isolate, local_scope, function, frame);
-}
-
-
-// Set the context local variable value.
-static bool SetContextLocalValue(Isolate* isolate, Handle<ScopeInfo> scope_info,
- Handle<Context> context,
- Handle<String> variable_name,
- Handle<Object> new_value) {
- for (int i = 0; i < scope_info->ContextLocalCount(); i++) {
- Handle<String> next_name(scope_info->ContextLocalName(i));
- if (String::Equals(variable_name, next_name)) {
- VariableMode mode;
- InitializationFlag init_flag;
- MaybeAssignedFlag maybe_assigned_flag;
- int context_index = ScopeInfo::ContextSlotIndex(
- scope_info, next_name, &mode, &init_flag, &maybe_assigned_flag);
- context->set(context_index, *new_value);
- return true;
- }
- }
-
- return false;
-}
-
-
-static bool SetLocalVariableValue(Isolate* isolate, JavaScriptFrame* frame,
- int inlined_jsframe_index,
- Handle<String> variable_name,
- Handle<Object> new_value) {
- if (inlined_jsframe_index != 0 || frame->is_optimized()) {
- // Optimized frames are not supported.
- return false;
- }
-
- Handle<JSFunction> function(frame->function());
- Handle<SharedFunctionInfo> shared(function->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- bool default_result = false;
-
- // Parameters.
- for (int i = 0; i < scope_info->ParameterCount(); ++i) {
- HandleScope scope(isolate);
- if (String::Equals(handle(scope_info->ParameterName(i)), variable_name)) {
- frame->SetParameterValue(i, *new_value);
- // Argument might be shadowed in heap context, don't stop here.
- default_result = true;
- }
- }
-
- // Stack locals.
- for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
- HandleScope scope(isolate);
- if (String::Equals(handle(scope_info->StackLocalName(i)), variable_name)) {
- frame->SetExpression(i, *new_value);
- return true;
- }
- }
-
- if (scope_info->HasContext()) {
- // Context locals.
- Handle<Context> frame_context(Context::cast(frame->context()));
- Handle<Context> function_context(frame_context->declaration_context());
- if (SetContextLocalValue(isolate, scope_info, function_context,
- variable_name, new_value)) {
- return true;
- }
-
- // Function context extension. These are variables introduced by eval.
- if (function_context->closure() == *function) {
- if (function_context->has_extension() &&
- !function_context->IsNativeContext()) {
- Handle<JSObject> ext(JSObject::cast(function_context->extension()));
-
- Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
- DCHECK(maybe.has_value);
- if (maybe.value) {
- // We don't expect this to do anything except replacing
- // property value.
- Runtime::SetObjectProperty(isolate, ext, variable_name, new_value,
- SLOPPY).Assert();
- return true;
- }
- }
- }
- }
-
- return default_result;
-}
-
-
-// Create a plain JSObject which materializes the closure content for the
-// context.
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeClosure(
- Isolate* isolate, Handle<Context> context) {
- DCHECK(context->IsFunctionContext());
-
- Handle<SharedFunctionInfo> shared(context->closure()->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- // Allocate and initialize a JSObject with all the content of this function
- // closure.
- Handle<JSObject> closure_scope =
- isolate->factory()->NewJSObject(isolate->object_function());
-
- // Fill all context locals to the context extension.
- if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
- closure_scope)) {
- return MaybeHandle<JSObject>();
- }
-
- // Finally copy any properties from the function context extension. This will
- // be variables introduced by eval.
- if (context->has_extension()) {
- Handle<JSObject> ext(JSObject::cast(context->extension()));
- Handle<FixedArray> keys;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, keys, JSReceiver::GetKeys(ext, JSReceiver::INCLUDE_PROTOS),
- JSObject);
-
- for (int i = 0; i < keys->length(); i++) {
- HandleScope scope(isolate);
- // Names of variables introduced by eval are strings.
- DCHECK(keys->get(i)->IsString());
- Handle<String> key(String::cast(keys->get(i)));
- Handle<Object> value;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, value, Object::GetPropertyOrElement(ext, key), JSObject);
- RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
- closure_scope, key, value, NONE),
- JSObject);
- }
- }
-
- return closure_scope;
-}
-
-
-// This method copies structure of MaterializeClosure method above.
-static bool SetClosureVariableValue(Isolate* isolate, Handle<Context> context,
- Handle<String> variable_name,
- Handle<Object> new_value) {
- DCHECK(context->IsFunctionContext());
-
- Handle<SharedFunctionInfo> shared(context->closure()->shared());
- Handle<ScopeInfo> scope_info(shared->scope_info());
-
- // Context locals to the context extension.
- if (SetContextLocalValue(isolate, scope_info, context, variable_name,
- new_value)) {
- return true;
- }
-
- // Properties from the function context extension. This will
- // be variables introduced by eval.
- if (context->has_extension()) {
- Handle<JSObject> ext(JSObject::cast(context->extension()));
- Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
- DCHECK(maybe.has_value);
- if (maybe.value) {
- // We don't expect this to do anything except replacing property value.
- Runtime::DefineObjectProperty(ext, variable_name, new_value, NONE)
- .Assert();
- return true;
- }
- }
-
- return false;
-}
-
-
-// Create a plain JSObject which materializes the scope for the specified
-// catch context.
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeCatchScope(
- Isolate* isolate, Handle<Context> context) {
- DCHECK(context->IsCatchContext());
- Handle<String> name(String::cast(context->extension()));
- Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX),
- isolate);
- Handle<JSObject> catch_scope =
- isolate->factory()->NewJSObject(isolate->object_function());
- RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
- catch_scope, name, thrown_object, NONE),
- JSObject);
- return catch_scope;
-}
-
-
-static bool SetCatchVariableValue(Isolate* isolate, Handle<Context> context,
- Handle<String> variable_name,
- Handle<Object> new_value) {
- DCHECK(context->IsCatchContext());
- Handle<String> name(String::cast(context->extension()));
- if (!String::Equals(name, variable_name)) {
- return false;
- }
- context->set(Context::THROWN_OBJECT_INDEX, *new_value);
- return true;
-}
-
-
-// Create a plain JSObject which materializes the block scope for the specified
-// block context.
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeBlockScope(
- Isolate* isolate, Handle<Context> context) {
- DCHECK(context->IsBlockContext());
- Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
-
- // Allocate and initialize a JSObject with all the arguments, stack locals
- // heap locals and extension properties of the debugged function.
- Handle<JSObject> block_scope =
- isolate->factory()->NewJSObject(isolate->object_function());
-
- // Fill all context locals.
- if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
- block_scope)) {
- return MaybeHandle<JSObject>();
- }
-
- return block_scope;
-}
-
-
-// Create a plain JSObject which materializes the module scope for the specified
-// module context.
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeModuleScope(
- Isolate* isolate, Handle<Context> context) {
- DCHECK(context->IsModuleContext());
- Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
-
- // Allocate and initialize a JSObject with all the members of the debugged
- // module.
- Handle<JSObject> module_scope =
- isolate->factory()->NewJSObject(isolate->object_function());
-
- // Fill all context locals.
- if (!ScopeInfo::CopyContextLocalsToScopeObject(scope_info, context,
- module_scope)) {
- return MaybeHandle<JSObject>();
- }
-
- return module_scope;
-}
-
-
-// Iterate over the actual scopes visible from a stack frame or from a closure.
-// The iteration proceeds from the innermost visible nested scope outwards.
-// All scopes are backed by an actual context except the local scope,
-// which is inserted "artificially" in the context chain.
-class ScopeIterator {
- public:
- enum ScopeType {
- ScopeTypeGlobal = 0,
- ScopeTypeLocal,
- ScopeTypeWith,
- ScopeTypeClosure,
- ScopeTypeCatch,
- ScopeTypeBlock,
- ScopeTypeModule
- };
-
- ScopeIterator(Isolate* isolate, JavaScriptFrame* frame,
- int inlined_jsframe_index, bool ignore_nested_scopes = false)
- : isolate_(isolate),
- frame_(frame),
- inlined_jsframe_index_(inlined_jsframe_index),
- function_(frame->function()),
- context_(Context::cast(frame->context())),
- nested_scope_chain_(4),
- failed_(false) {
- // Catch the case when the debugger stops in an internal function.
- Handle<SharedFunctionInfo> shared_info(function_->shared());
- Handle<ScopeInfo> scope_info(shared_info->scope_info());
- if (shared_info->script() == isolate->heap()->undefined_value()) {
- while (context_->closure() == *function_) {
- context_ = Handle<Context>(context_->previous(), isolate_);
- }
- return;
- }
-
- // Get the debug info (create it if it does not exist).
- if (!isolate->debug()->EnsureDebugInfo(shared_info, function_)) {
- // Return if ensuring debug info failed.
- return;
- }
-
- // Currently it takes too much time to find nested scopes due to script
- // parsing. Sometimes we want to run the ScopeIterator as fast as possible
- // (for example, while collecting async call stacks on every
- // addEventListener call), even if we drop some nested scopes.
- // Later we may optimize getting the nested scopes (cache the result?)
- // and include nested scopes into the "fast" iteration case as well.
- if (!ignore_nested_scopes) {
- Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared_info);
-
- // Find the break point where execution has stopped.
- BreakLocationIterator break_location_iterator(debug_info,
- ALL_BREAK_LOCATIONS);
- // pc points to the instruction after the current one, possibly a break
- // location as well. So the "- 1" to exclude it from the search.
- break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
-
- // Within the return sequence at the moment it is not possible to
- // get a source position which is consistent with the current scope chain.
- // Thus all nested with, catch and block contexts are skipped and we only
- // provide the function scope.
- ignore_nested_scopes = break_location_iterator.IsExit();
- }
-
- if (ignore_nested_scopes) {
- if (scope_info->HasContext()) {
- context_ = Handle<Context>(context_->declaration_context(), isolate_);
- } else {
- while (context_->closure() == *function_) {
- context_ = Handle<Context>(context_->previous(), isolate_);
- }
- }
- if (scope_info->scope_type() == FUNCTION_SCOPE) {
- nested_scope_chain_.Add(scope_info);
- }
- } else {
- // Reparse the code and analyze the scopes.
- Handle<Script> script(Script::cast(shared_info->script()));
- Scope* scope = NULL;
-
- // Check whether we are in global, eval or function code.
- Handle<ScopeInfo> scope_info(shared_info->scope_info());
- if (scope_info->scope_type() != FUNCTION_SCOPE) {
- // Global or eval code.
- CompilationInfoWithZone info(script);
- if (scope_info->scope_type() == GLOBAL_SCOPE) {
- info.MarkAsGlobal();
- } else {
- DCHECK(scope_info->scope_type() == EVAL_SCOPE);
- info.MarkAsEval();
- info.SetContext(Handle<Context>(function_->context()));
- }
- if (Parser::Parse(&info) && Scope::Analyze(&info)) {
- scope = info.function()->scope();
- }
- RetrieveScopeChain(scope, shared_info);
- } else {
- // Function code
- CompilationInfoWithZone info(shared_info);
- if (Parser::Parse(&info) && Scope::Analyze(&info)) {
- scope = info.function()->scope();
- }
- RetrieveScopeChain(scope, shared_info);
- }
- }
- }
-
- ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
- : isolate_(isolate),
- frame_(NULL),
- inlined_jsframe_index_(0),
- function_(function),
- context_(function->context()),
- failed_(false) {
- if (function->IsBuiltin()) {
- context_ = Handle<Context>();
- }
- }
-
- // More scopes?
- bool Done() {
- DCHECK(!failed_);
- return context_.is_null();
- }
-
- bool Failed() { return failed_; }
-
- // Move to the next scope.
- void Next() {
- DCHECK(!failed_);
- ScopeType scope_type = Type();
- if (scope_type == ScopeTypeGlobal) {
- // The global scope is always the last in the chain.
- DCHECK(context_->IsNativeContext());
- context_ = Handle<Context>();
- return;
- }
- if (nested_scope_chain_.is_empty()) {
- context_ = Handle<Context>(context_->previous(), isolate_);
- } else {
- if (nested_scope_chain_.last()->HasContext()) {
- DCHECK(context_->previous() != NULL);
- context_ = Handle<Context>(context_->previous(), isolate_);
- }
- nested_scope_chain_.RemoveLast();
- }
- }
-
- // Return the type of the current scope.
- ScopeType Type() {
- DCHECK(!failed_);
- if (!nested_scope_chain_.is_empty()) {
- Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
- switch (scope_info->scope_type()) {
- case FUNCTION_SCOPE:
- DCHECK(context_->IsFunctionContext() || !scope_info->HasContext());
- return ScopeTypeLocal;
- case MODULE_SCOPE:
- DCHECK(context_->IsModuleContext());
- return ScopeTypeModule;
- case GLOBAL_SCOPE:
- DCHECK(context_->IsNativeContext());
- return ScopeTypeGlobal;
- case WITH_SCOPE:
- DCHECK(context_->IsWithContext());
- return ScopeTypeWith;
- case CATCH_SCOPE:
- DCHECK(context_->IsCatchContext());
- return ScopeTypeCatch;
- case BLOCK_SCOPE:
- DCHECK(!scope_info->HasContext() || context_->IsBlockContext());
- return ScopeTypeBlock;
- case EVAL_SCOPE:
- UNREACHABLE();
- }
- }
- if (context_->IsNativeContext()) {
- DCHECK(context_->global_object()->IsGlobalObject());
- return ScopeTypeGlobal;
- }
- if (context_->IsFunctionContext()) {
- return ScopeTypeClosure;
- }
- if (context_->IsCatchContext()) {
- return ScopeTypeCatch;
- }
- if (context_->IsBlockContext()) {
- return ScopeTypeBlock;
- }
- if (context_->IsModuleContext()) {
- return ScopeTypeModule;
- }
- DCHECK(context_->IsWithContext());
- return ScopeTypeWith;
- }
-
- // Return the JavaScript object with the content of the current scope.
- MaybeHandle<JSObject> ScopeObject() {
- DCHECK(!failed_);
- switch (Type()) {
- case ScopeIterator::ScopeTypeGlobal:
- return Handle<JSObject>(CurrentContext()->global_object());
- case ScopeIterator::ScopeTypeLocal:
- // Materialize the content of the local scope into a JSObject.
- DCHECK(nested_scope_chain_.length() == 1);
- return MaterializeLocalScope(isolate_, frame_, inlined_jsframe_index_);
- case ScopeIterator::ScopeTypeWith:
- // Return the with object.
- return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
- case ScopeIterator::ScopeTypeCatch:
- return MaterializeCatchScope(isolate_, CurrentContext());
- case ScopeIterator::ScopeTypeClosure:
- // Materialize the content of the closure scope into a JSObject.
- return MaterializeClosure(isolate_, CurrentContext());
- case ScopeIterator::ScopeTypeBlock:
- return MaterializeBlockScope(isolate_, CurrentContext());
- case ScopeIterator::ScopeTypeModule:
- return MaterializeModuleScope(isolate_, CurrentContext());
- }
- UNREACHABLE();
- return Handle<JSObject>();
- }
-
- bool SetVariableValue(Handle<String> variable_name,
- Handle<Object> new_value) {
- DCHECK(!failed_);
- switch (Type()) {
- case ScopeIterator::ScopeTypeGlobal:
- break;
- case ScopeIterator::ScopeTypeLocal:
- return SetLocalVariableValue(isolate_, frame_, inlined_jsframe_index_,
- variable_name, new_value);
- case ScopeIterator::ScopeTypeWith:
- break;
- case ScopeIterator::ScopeTypeCatch:
- return SetCatchVariableValue(isolate_, CurrentContext(), variable_name,
- new_value);
- case ScopeIterator::ScopeTypeClosure:
- return SetClosureVariableValue(isolate_, CurrentContext(),
- variable_name, new_value);
- case ScopeIterator::ScopeTypeBlock:
- // TODO(2399): should we implement it?
- break;
- case ScopeIterator::ScopeTypeModule:
- // TODO(2399): should we implement it?
- break;
- }
- return false;
- }
-
- Handle<ScopeInfo> CurrentScopeInfo() {
- DCHECK(!failed_);
- if (!nested_scope_chain_.is_empty()) {
- return nested_scope_chain_.last();
- } else if (context_->IsBlockContext()) {
- return Handle<ScopeInfo>(ScopeInfo::cast(context_->extension()));
- } else if (context_->IsFunctionContext()) {
- return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
- }
- return Handle<ScopeInfo>::null();
- }
-
- // Return the context for this scope. For the local context there might not
- // be an actual context.
- Handle<Context> CurrentContext() {
- DCHECK(!failed_);
- if (Type() == ScopeTypeGlobal || nested_scope_chain_.is_empty()) {
- return context_;
- } else if (nested_scope_chain_.last()->HasContext()) {
- return context_;
- } else {
- return Handle<Context>();
- }
- }
-
-#ifdef DEBUG
- // Debug print of the content of the current scope.
- void DebugPrint() {
- OFStream os(stdout);
- DCHECK(!failed_);
- switch (Type()) {
- case ScopeIterator::ScopeTypeGlobal:
- os << "Global:\n";
- CurrentContext()->Print(os);
- break;
-
- case ScopeIterator::ScopeTypeLocal: {
- os << "Local:\n";
- function_->shared()->scope_info()->Print();
- if (!CurrentContext().is_null()) {
- CurrentContext()->Print(os);
- if (CurrentContext()->has_extension()) {
- Handle<Object> extension(CurrentContext()->extension(), isolate_);
- if (extension->IsJSContextExtensionObject()) {
- extension->Print(os);
- }
- }
- }
- break;
- }
-
- case ScopeIterator::ScopeTypeWith:
- os << "With:\n";
- CurrentContext()->extension()->Print(os);
- break;
-
- case ScopeIterator::ScopeTypeCatch:
- os << "Catch:\n";
- CurrentContext()->extension()->Print(os);
- CurrentContext()->get(Context::THROWN_OBJECT_INDEX)->Print(os);
- break;
-
- case ScopeIterator::ScopeTypeClosure:
- os << "Closure:\n";
- CurrentContext()->Print(os);
- if (CurrentContext()->has_extension()) {
- Handle<Object> extension(CurrentContext()->extension(), isolate_);
- if (extension->IsJSContextExtensionObject()) {
- extension->Print(os);
- }
- }
- break;
-
- default:
- UNREACHABLE();
- }
- PrintF("\n");
- }
-#endif
-
- private:
- Isolate* isolate_;
- JavaScriptFrame* frame_;
- int inlined_jsframe_index_;
- Handle<JSFunction> function_;
- Handle<Context> context_;
- List<Handle<ScopeInfo> > nested_scope_chain_;
- bool failed_;
-
- void RetrieveScopeChain(Scope* scope,
- Handle<SharedFunctionInfo> shared_info) {
- if (scope != NULL) {
- int source_position = shared_info->code()->SourcePosition(frame_->pc());
- scope->GetNestedScopeChain(&nested_scope_chain_, source_position);
- } else {
- // A failed reparse indicates that the preparser has diverged from the
- // parser or that the preparse data given to the initial parse has been
- // faulty. We fail in debug mode but in release mode we only provide the
- // information we get from the context chain but nothing about
- // completely stack allocated scopes or stack allocated locals.
- // Or it could be due to stack overflow.
- DCHECK(isolate_->has_pending_exception());
- failed_ = true;
- }
- }
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(ScopeIterator);
-};
-
-
-RUNTIME_FUNCTION(Runtime_GetScopeCount) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator it(isolate, id);
- JavaScriptFrame* frame = it.frame();
-
- // Count the visible scopes.
- int n = 0;
- for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
- n++;
- }
-
- return Smi::FromInt(n);
-}
-
-
-// Returns the list of step-in positions (text offset) in a function of the
-// stack frame in a range from the current debug break position to the end
-// of the corresponding statement.
-RUNTIME_FUNCTION(Runtime_GetStepInPositions) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator frame_it(isolate, id);
- RUNTIME_ASSERT(!frame_it.done());
-
- JavaScriptFrame* frame = frame_it.frame();
-
- Handle<JSFunction> fun = Handle<JSFunction>(frame->function());
- Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>(fun->shared());
-
- if (!isolate->debug()->EnsureDebugInfo(shared, fun)) {
- return isolate->heap()->undefined_value();
- }
-
- Handle<DebugInfo> debug_info = Debug::GetDebugInfo(shared);
-
- int len = 0;
- Handle<JSArray> array(isolate->factory()->NewJSArray(10));
- // Find the break point where execution has stopped.
- BreakLocationIterator break_location_iterator(debug_info,
- ALL_BREAK_LOCATIONS);
-
- break_location_iterator.FindBreakLocationFromAddress(frame->pc() - 1);
- int current_statement_pos = break_location_iterator.statement_position();
-
- while (!break_location_iterator.Done()) {
- bool accept;
- if (break_location_iterator.pc() > frame->pc()) {
- accept = true;
- } else {
- StackFrame::Id break_frame_id = isolate->debug()->break_frame_id();
- // The break point is near our pc. Could be a step-in possibility,
- // that is currently taken by active debugger call.
- if (break_frame_id == StackFrame::NO_ID) {
- // We are not stepping.
- accept = false;
- } else {
- JavaScriptFrameIterator additional_frame_it(isolate, break_frame_id);
- // If our frame is a top frame and we are stepping, we can do step-in
- // at this place.
- accept = additional_frame_it.frame()->id() == id;
- }
- }
- if (accept) {
- if (break_location_iterator.IsStepInLocation(isolate)) {
- Smi* position_value = Smi::FromInt(break_location_iterator.position());
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::SetElement(
- array, len, Handle<Object>(position_value, isolate),
- NONE, SLOPPY));
- len++;
- }
- }
- // Advance iterator.
- break_location_iterator.Next();
- if (current_statement_pos != break_location_iterator.statement_position()) {
- break;
- }
- }
- return *array;
-}
-
-
-static const int kScopeDetailsTypeIndex = 0;
-static const int kScopeDetailsObjectIndex = 1;
-static const int kScopeDetailsSize = 2;
-
-
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeScopeDetails(
- Isolate* isolate, ScopeIterator* it) {
- // Calculate the size of the result.
- int details_size = kScopeDetailsSize;
- Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);
-
- // Fill in scope details.
- details->set(kScopeDetailsTypeIndex, Smi::FromInt(it->Type()));
- Handle<JSObject> scope_object;
- ASSIGN_RETURN_ON_EXCEPTION(isolate, scope_object, it->ScopeObject(),
- JSObject);
- details->set(kScopeDetailsObjectIndex, *scope_object);
-
- return isolate->factory()->NewJSArrayWithElements(details);
-}
-
-
-// Return an array with scope details
-// args[0]: number: break id
-// args[1]: number: frame index
-// args[2]: number: inlined frame index
-// args[3]: number: scope index
-//
-// The array returned contains the following information:
-// 0: Scope type
-// 1: Scope object
-RUNTIME_FUNCTION(Runtime_GetScopeDetails) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
- CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator frame_it(isolate, id);
- JavaScriptFrame* frame = frame_it.frame();
-
- // Find the requested scope.
- int n = 0;
- ScopeIterator it(isolate, frame, inlined_jsframe_index);
- for (; !it.Done() && n < index; it.Next()) {
- n++;
- }
- if (it.Done()) {
- return isolate->heap()->undefined_value();
- }
- Handle<JSObject> details;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
- MaterializeScopeDetails(isolate, &it));
- return *details;
-}
-
-
-// Return an array of scope details
-// args[0]: number: break id
-// args[1]: number: frame index
-// args[2]: number: inlined frame index
-// args[3]: boolean: ignore nested scopes
-//
-// The array returned contains arrays with the following information:
-// 0: Scope type
-// 1: Scope object
-RUNTIME_FUNCTION(Runtime_GetAllScopesDetails) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3 || args.length() == 4);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
- CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
-
- bool ignore_nested_scopes = false;
- if (args.length() == 4) {
- CONVERT_BOOLEAN_ARG_CHECKED(flag, 3);
- ignore_nested_scopes = flag;
- }
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator frame_it(isolate, id);
- JavaScriptFrame* frame = frame_it.frame();
-
- List<Handle<JSObject> > result(4);
- ScopeIterator it(isolate, frame, inlined_jsframe_index, ignore_nested_scopes);
- for (; !it.Done(); it.Next()) {
- Handle<JSObject> details;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
- MaterializeScopeDetails(isolate, &it));
- result.Add(details);
- }
-
- Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
- for (int i = 0; i < result.length(); ++i) {
- array->set(i, *result[i]);
- }
- return *isolate->factory()->NewJSArrayWithElements(array);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetFunctionScopeCount) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
-
- // Check arguments.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
-
- // Count the visible scopes.
- int n = 0;
- for (ScopeIterator it(isolate, fun); !it.Done(); it.Next()) {
- n++;
- }
-
- return Smi::FromInt(n);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetFunctionScopeDetails) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- // Check arguments.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
-
- // Find the requested scope.
- int n = 0;
- ScopeIterator it(isolate, fun);
- for (; !it.Done() && n < index; it.Next()) {
- n++;
- }
- if (it.Done()) {
- return isolate->heap()->undefined_value();
- }
-
- Handle<JSObject> details;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,
- MaterializeScopeDetails(isolate, &it));
- return *details;
-}
-
-
-static bool SetScopeVariableValue(ScopeIterator* it, int index,
- Handle<String> variable_name,
- Handle<Object> new_value) {
- for (int n = 0; !it->Done() && n < index; it->Next()) {
- n++;
- }
- if (it->Done()) {
- return false;
- }
- return it->SetVariableValue(variable_name, new_value);
-}
-
-
-// Change variable value in closure or local scope
-// args[0]: number or JsFunction: break id or function
-// args[1]: number: frame index (when arg[0] is break id)
-// args[2]: number: inlined frame index (when arg[0] is break id)
-// args[3]: number: scope index
-// args[4]: string: variable name
-// args[5]: object: new value
-//
-// Return true if success and false otherwise
-RUNTIME_FUNCTION(Runtime_SetScopeVariableValue) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 6);
-
- // Check arguments.
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);
- CONVERT_ARG_HANDLE_CHECKED(String, variable_name, 4);
- CONVERT_ARG_HANDLE_CHECKED(Object, new_value, 5);
-
- bool res;
- if (args[0]->IsNumber()) {
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
- CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator frame_it(isolate, id);
- JavaScriptFrame* frame = frame_it.frame();
-
- ScopeIterator it(isolate, frame, inlined_jsframe_index);
- res = SetScopeVariableValue(&it, index, variable_name, new_value);
- } else {
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- ScopeIterator it(isolate, fun);
- res = SetScopeVariableValue(&it, index, variable_name, new_value);
- }
-
- return isolate->heap()->ToBoolean(res);
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugPrintScopes) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-
-#ifdef DEBUG
- // Print the scopes for the top frame.
- StackFrameLocator locator(isolate);
- JavaScriptFrame* frame = locator.FindJavaScriptFrame(0);
- for (ScopeIterator it(isolate, frame, 0); !it.Done(); it.Next()) {
- it.DebugPrint();
- }
-#endif
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetThreadCount) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- // Count all archived V8 threads.
- int n = 0;
- for (ThreadState* thread = isolate->thread_manager()->FirstThreadStateInUse();
- thread != NULL; thread = thread->Next()) {
- n++;
- }
-
- // Total number of threads is current thread and archived threads.
- return Smi::FromInt(n + 1);
-}
-
-
-static const int kThreadDetailsCurrentThreadIndex = 0;
-static const int kThreadDetailsThreadIdIndex = 1;
-static const int kThreadDetailsSize = 2;
-
-// Return an array with thread details
-// args[0]: number: break id
-// args[1]: number: thread index
-//
-// The array returned contains the following information:
-// 0: Is current thread?
-// 1: Thread id
-RUNTIME_FUNCTION(Runtime_GetThreadDetails) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
-
- // Allocate array for result.
- Handle<FixedArray> details =
- isolate->factory()->NewFixedArray(kThreadDetailsSize);
-
- // Thread index 0 is current thread.
- if (index == 0) {
- // Fill the details.
- details->set(kThreadDetailsCurrentThreadIndex,
- isolate->heap()->true_value());
- details->set(kThreadDetailsThreadIdIndex,
- Smi::FromInt(ThreadId::Current().ToInteger()));
- } else {
- // Find the thread with the requested index.
- int n = 1;
- ThreadState* thread = isolate->thread_manager()->FirstThreadStateInUse();
- while (index != n && thread != NULL) {
- thread = thread->Next();
- n++;
- }
- if (thread == NULL) {
- return isolate->heap()->undefined_value();
- }
-
- // Fill the details.
- details->set(kThreadDetailsCurrentThreadIndex,
- isolate->heap()->false_value());
- details->set(kThreadDetailsThreadIdIndex,
- Smi::FromInt(thread->id().ToInteger()));
- }
-
- // Convert to JS array and return.
- return *isolate->factory()->NewJSArrayWithElements(details);
-}
-
-
-// Sets the disable break state
-// args[0]: disable break state
-RUNTIME_FUNCTION(Runtime_SetDisableBreak) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 0);
- isolate->debug()->set_disable_break(disable_break);
- return isolate->heap()->undefined_value();
-}
-
-
-static bool IsPositionAlignmentCodeCorrect(int alignment) {
- return alignment == STATEMENT_ALIGNED || alignment == BREAK_POSITION_ALIGNED;
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetBreakLocations) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
- CONVERT_NUMBER_CHECKED(int32_t, statement_aligned_code, Int32, args[1]);
-
- if (!IsPositionAlignmentCodeCorrect(statement_aligned_code)) {
- return isolate->ThrowIllegalOperation();
- }
- BreakPositionAlignment alignment =
- static_cast<BreakPositionAlignment>(statement_aligned_code);
-
- Handle<SharedFunctionInfo> shared(fun->shared());
- // Find the number of break points
- Handle<Object> break_locations =
- Debug::GetSourceBreakLocations(shared, alignment);
- if (break_locations->IsUndefined()) return isolate->heap()->undefined_value();
- // Return array as JS array
- return *isolate->factory()->NewJSArrayWithElements(
- Handle<FixedArray>::cast(break_locations));
-}
-
-
-// Set a break point in a function.
-// args[0]: function
-// args[1]: number: break source position (within the function source)
-// args[2]: number: break point object
-RUNTIME_FUNCTION(Runtime_SetFunctionBreakPoint) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
- RUNTIME_ASSERT(source_position >= function->shared()->start_position() &&
- source_position <= function->shared()->end_position());
- CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 2);
-
- // Set break point.
- RUNTIME_ASSERT(isolate->debug()->SetBreakPoint(
- function, break_point_object_arg, &source_position));
-
- return Smi::FromInt(source_position);
-}
-
-
-// Changes the state of a break point in a script and returns source position
-// where break point was set. NOTE: Regarding performance see the NOTE for
-// GetScriptFromScriptData.
-// args[0]: script to set break point in
-// args[1]: number: break source position (within the script source)
-// args[2]: number, breakpoint position alignment
-// args[3]: number: break point object
-RUNTIME_FUNCTION(Runtime_SetScriptBreakPoint) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_ARG_HANDLE_CHECKED(JSValue, wrapper, 0);
- CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
- RUNTIME_ASSERT(source_position >= 0);
- CONVERT_NUMBER_CHECKED(int32_t, statement_aligned_code, Int32, args[2]);
- CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 3);
-
- if (!IsPositionAlignmentCodeCorrect(statement_aligned_code)) {
- return isolate->ThrowIllegalOperation();
- }
- BreakPositionAlignment alignment =
- static_cast<BreakPositionAlignment>(statement_aligned_code);
-
- // Get the script from the script wrapper.
- RUNTIME_ASSERT(wrapper->value()->IsScript());
- Handle<Script> script(Script::cast(wrapper->value()));
-
- // Set break point.
- if (!isolate->debug()->SetBreakPointForScript(script, break_point_object_arg,
- &source_position, alignment)) {
- return isolate->heap()->undefined_value();
- }
-
- return Smi::FromInt(source_position);
-}
-
-
-// Clear a break point
-// args[0]: number: break point object
-RUNTIME_FUNCTION(Runtime_ClearBreakPoint) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, break_point_object_arg, 0);
-
- // Clear break point.
- isolate->debug()->ClearBreakPoint(break_point_object_arg);
-
- return isolate->heap()->undefined_value();
-}
-
-
-// Change the state of break on exceptions.
-// args[0]: Enum value indicating whether to affect caught/uncaught exceptions.
-// args[1]: Boolean indicating on/off.
-RUNTIME_FUNCTION(Runtime_ChangeBreakOnException) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(uint32_t, type_arg, Uint32, args[0]);
- CONVERT_BOOLEAN_ARG_CHECKED(enable, 1);
-
- // If the number doesn't match an enum value, the ChangeBreakOnException
- // function will default to affecting caught exceptions.
- ExceptionBreakType type = static_cast<ExceptionBreakType>(type_arg);
- // Update break point state.
- isolate->debug()->ChangeBreakOnException(type, enable);
- return isolate->heap()->undefined_value();
-}
-
-
-// Returns the state of break on exceptions
-// args[0]: boolean indicating uncaught exceptions
-RUNTIME_FUNCTION(Runtime_IsBreakOnException) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_NUMBER_CHECKED(uint32_t, type_arg, Uint32, args[0]);
-
- ExceptionBreakType type = static_cast<ExceptionBreakType>(type_arg);
- bool result = isolate->debug()->IsBreakOnException(type);
- return Smi::FromInt(result);
-}
-
-
-// Prepare for stepping
-// args[0]: break id for checking execution state
-// args[1]: step action from the enumeration StepAction
-// args[2]: number of times to perform the step, for step out it is the number
-// of frames to step down.
-RUNTIME_FUNCTION(Runtime_PrepareStep) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 4);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- if (!args[1]->IsNumber() || !args[2]->IsNumber()) {
- return isolate->Throw(isolate->heap()->illegal_argument_string());
- }
-
- CONVERT_NUMBER_CHECKED(int, wrapped_frame_id, Int32, args[3]);
-
- StackFrame::Id frame_id;
- if (wrapped_frame_id == 0) {
- frame_id = StackFrame::NO_ID;
- } else {
- frame_id = UnwrapFrameId(wrapped_frame_id);
- }
-
- // Get the step action and check validity.
- StepAction step_action = static_cast<StepAction>(NumberToInt32(args[1]));
- if (step_action != StepIn && step_action != StepNext &&
- step_action != StepOut && step_action != StepInMin &&
- step_action != StepMin) {
- return isolate->Throw(isolate->heap()->illegal_argument_string());
- }
-
- if (frame_id != StackFrame::NO_ID && step_action != StepNext &&
- step_action != StepMin && step_action != StepOut) {
- return isolate->ThrowIllegalOperation();
- }
-
- // Get the number of steps.
- int step_count = NumberToInt32(args[2]);
- if (step_count < 1) {
- return isolate->Throw(isolate->heap()->illegal_argument_string());
- }
-
- // Clear all current stepping setup.
- isolate->debug()->ClearStepping();
-
- // Prepare step.
- isolate->debug()->PrepareStep(static_cast<StepAction>(step_action),
- step_count, frame_id);
- return isolate->heap()->undefined_value();
-}
-
-
-// Clear all stepping set by PrepareStep.
-RUNTIME_FUNCTION(Runtime_ClearStepping) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- isolate->debug()->ClearStepping();
- return isolate->heap()->undefined_value();
-}
-
-
-// Helper function to find or create the arguments object for
-// Runtime_DebugEvaluate.
-MUST_USE_RESULT static MaybeHandle<JSObject> MaterializeArgumentsObject(
- Isolate* isolate, Handle<JSObject> target, Handle<JSFunction> function) {
- // Do not materialize the arguments object for eval or top-level code.
- // Skip if "arguments" is already taken.
- if (!function->shared()->is_function()) return target;
- Maybe<bool> maybe = JSReceiver::HasOwnProperty(
- target, isolate->factory()->arguments_string());
- if (!maybe.has_value) return MaybeHandle<JSObject>();
- if (maybe.value) return target;
-
- // FunctionGetArguments can't throw an exception.
- Handle<JSObject> arguments =
- Handle<JSObject>::cast(Accessors::FunctionGetArguments(function));
- Handle<String> arguments_str = isolate->factory()->arguments_string();
- RETURN_ON_EXCEPTION(isolate, Runtime::DefineObjectProperty(
- target, arguments_str, arguments, NONE),
- JSObject);
- return target;
-}
-
-
-// Compile and evaluate source for the given context.
-static MaybeHandle<Object> DebugEvaluate(Isolate* isolate,
- Handle<Context> context,
- Handle<Object> context_extension,
- Handle<Object> receiver,
- Handle<String> source) {
- if (context_extension->IsJSObject()) {
- Handle<JSObject> extension = Handle<JSObject>::cast(context_extension);
- Handle<JSFunction> closure(context->closure(), isolate);
- context = isolate->factory()->NewWithContext(closure, context, extension);
- }
-
- Handle<JSFunction> eval_fun;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, eval_fun, Compiler::GetFunctionFromEval(source, context, SLOPPY,
- NO_PARSE_RESTRICTION,
- RelocInfo::kNoPosition),
- Object);
-
- Handle<Object> result;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, result, Execution::Call(isolate, eval_fun, receiver, 0, NULL),
- Object);
-
- // Skip the global proxy as it has no properties and always delegates to the
- // real global object.
- if (result->IsJSGlobalProxy()) {
- PrototypeIterator iter(isolate, result);
- // TODO(verwaest): This will crash when the global proxy is detached.
- result = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
- }
-
- // Clear the oneshot breakpoints so that the debugger does not step further.
- isolate->debug()->ClearStepping();
- return result;
-}
-
-
-static Handle<JSObject> NewJSObjectWithNullProto(Isolate* isolate) {
- Handle<JSObject> result =
- isolate->factory()->NewJSObject(isolate->object_function());
- Handle<Map> new_map = Map::Copy(Handle<Map>(result->map()));
- new_map->set_prototype(*isolate->factory()->null_value());
- JSObject::MigrateToMap(result, new_map);
- return result;
-}
-
-
-// Evaluate a piece of JavaScript in the context of a stack frame for
-// debugging. Things that need special attention are:
-// - Parameters and stack-allocated locals need to be materialized. Altered
-// values need to be written back to the stack afterwards.
-// - The arguments object needs to materialized.
-RUNTIME_FUNCTION(Runtime_DebugEvaluate) {
- HandleScope scope(isolate);
-
- // Check the execution state and decode arguments frame and source to be
- // evaluated.
- DCHECK(args.length() == 6);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);
- CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);
- CONVERT_ARG_HANDLE_CHECKED(String, source, 3);
- CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 4);
- CONVERT_ARG_HANDLE_CHECKED(Object, context_extension, 5);
-
- // Handle the processing of break.
- DisableBreak disable_break_scope(isolate->debug(), disable_break);
-
- // Get the frame where the debugging is performed.
- StackFrame::Id id = UnwrapFrameId(wrapped_id);
- JavaScriptFrameIterator it(isolate, id);
- JavaScriptFrame* frame = it.frame();
- FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);
- Handle<JSFunction> function(JSFunction::cast(frame_inspector.GetFunction()));
-
- // Traverse the saved contexts chain to find the active context for the
- // selected frame.
- SaveContext* save = FindSavedContextForFrame(isolate, frame);
-
- SaveContext savex(isolate);
- isolate->set_context(*(save->context()));
-
- // Materialize stack locals and the arguments object.
- Handle<JSObject> materialized = NewJSObjectWithNullProto(isolate);
-
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, materialized,
- MaterializeStackLocalsWithFrameInspector(isolate, materialized, function,
- &frame_inspector));
-
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, materialized,
- MaterializeArgumentsObject(isolate, materialized, function));
-
- // At this point, the lookup chain may look like this:
- // [inner context] -> [function stack]+[function context] -> [outer context]
- // The function stack is not an actual context, it complements the function
- // context. In order to have the same lookup chain when debug-evaluating,
- // we materialize the stack and insert it into the context chain as a
- // with-context before the function context.
- // [inner context] -> [with context] -> [function context] -> [outer context]
- // Ordering the with-context before the function context forces a dynamic
- // lookup instead of a static lookup that could fail as the scope info is
- // outdated and may expect variables to still be stack-allocated.
- // Afterwards, we write changes to the with-context back to the stack
- // and remove it from the context chain.
- // This could cause lookup failures if debug-evaluate creates a closure that
- // uses this temporary context chain.
-
- Handle<Context> eval_context(Context::cast(frame_inspector.GetContext()));
- DCHECK(!eval_context.is_null());
- Handle<Context> function_context = eval_context;
- Handle<Context> outer_context(function->context(), isolate);
- Handle<Context> inner_context;
- // We iterate to find the function's context. If the function has no
- // context-allocated variables, we iterate until we hit the outer context.
- while (!function_context->IsFunctionContext() &&
- !function_context.is_identical_to(outer_context)) {
- inner_context = function_context;
- function_context = Handle<Context>(function_context->previous(), isolate);
- }
-
- Handle<Context> materialized_context = isolate->factory()->NewWithContext(
- function, function_context, materialized);
-
- if (inner_context.is_null()) {
- // No inner context. The with-context is now inner-most.
- eval_context = materialized_context;
- } else {
- inner_context->set_previous(*materialized_context);
- }
-
- Handle<Object> receiver(frame->receiver(), isolate);
- MaybeHandle<Object> maybe_result =
- DebugEvaluate(isolate, eval_context, context_extension, receiver, source);
-
- // Remove with-context if it was inserted in between.
- if (!inner_context.is_null()) inner_context->set_previous(*function_context);
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, maybe_result);
-
- // Write back potential changes to materialized stack locals to the stack.
- UpdateStackLocalsFromMaterializedObject(isolate, materialized, function,
- frame, inlined_jsframe_index);
-
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugEvaluateGlobal) {
- HandleScope scope(isolate);
-
- // Check the execution state and decode arguments frame and source to be
- // evaluated.
- DCHECK(args.length() == 4);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
- CONVERT_BOOLEAN_ARG_CHECKED(disable_break, 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, context_extension, 3);
-
- // Handle the processing of break.
- DisableBreak disable_break_scope(isolate->debug(), disable_break);
-
- // Enter the top context from before the debugger was invoked.
- SaveContext save(isolate);
- SaveContext* top = &save;
- while (top != NULL && *top->context() == *isolate->debug()->debug_context()) {
- top = top->prev();
- }
- if (top != NULL) {
- isolate->set_context(*top->context());
- }
-
- // Get the native context now set to the top context from before the
- // debugger was invoked.
- Handle<Context> context = isolate->native_context();
- Handle<JSObject> receiver(context->global_proxy());
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- DebugEvaluate(isolate, context, context_extension, receiver, source));
- return *result;
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugGetLoadedScripts) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-
- // Fill the script objects.
- Handle<FixedArray> instances = isolate->debug()->GetLoadedScripts();
-
- // Convert the script objects to proper JS objects.
- for (int i = 0; i < instances->length(); i++) {
- Handle<Script> script = Handle<Script>(Script::cast(instances->get(i)));
- // Get the script wrapper in a local handle before calling GetScriptWrapper,
- // because using
- // instances->set(i, *GetScriptWrapper(script))
- // is unsafe as GetScriptWrapper might call GC and the C++ compiler might
- // already have dereferenced the instances handle.
- Handle<JSObject> wrapper = Script::GetWrapper(script);
- instances->set(i, *wrapper);
- }
-
- // Return result as a JS array.
- Handle<JSObject> result =
- isolate->factory()->NewJSObject(isolate->array_function());
- JSArray::SetContent(Handle<JSArray>::cast(result), instances);
- return *result;
-}
-
-
-// Helper function used by Runtime_DebugReferencedBy below.
-static int DebugReferencedBy(HeapIterator* iterator, JSObject* target,
- Object* instance_filter, int max_references,
- FixedArray* instances, int instances_size,
- JSFunction* arguments_function) {
- Isolate* isolate = target->GetIsolate();
- SealHandleScope shs(isolate);
- DisallowHeapAllocation no_allocation;
-
- // Iterate the heap.
- int count = 0;
- JSObject* last = NULL;
- HeapObject* heap_obj = NULL;
- while (((heap_obj = iterator->next()) != NULL) &&
- (max_references == 0 || count < max_references)) {
- // Only look at all JSObjects.
- if (heap_obj->IsJSObject()) {
- // Skip context extension objects and argument arrays as these are
- // checked in the context of functions using them.
- JSObject* obj = JSObject::cast(heap_obj);
- if (obj->IsJSContextExtensionObject() ||
- obj->map()->constructor() == arguments_function) {
- continue;
- }
-
- // Check if the JS object has a reference to the object looked for.
- if (obj->ReferencesObject(target)) {
- // Check instance filter if supplied. This is normally used to avoid
- // references from mirror objects (see Runtime_IsInPrototypeChain).
- if (!instance_filter->IsUndefined()) {
- for (PrototypeIterator iter(isolate, obj); !iter.IsAtEnd();
- iter.Advance()) {
- if (iter.GetCurrent() == instance_filter) {
- obj = NULL; // Don't add this object.
- break;
- }
- }
- }
-
- if (obj != NULL) {
- // Valid reference found add to instance array if supplied an update
- // count.
- if (instances != NULL && count < instances_size) {
- instances->set(count, obj);
- }
- last = obj;
- count++;
- }
- }
- }
- }
-
- // Check for circular reference only. This can happen when the object is only
- // referenced from mirrors and has a circular reference in which case the
- // object is not really alive and would have been garbage collected if not
- // referenced from the mirror.
- if (count == 1 && last == target) {
- count = 0;
- }
-
- // Return the number of referencing objects found.
- return count;
-}
-
-
-// Scan the heap for objects with direct references to an object
-// args[0]: the object to find references to
-// args[1]: constructor function for instances to exclude (Mirror)
-// args[2]: the the maximum number of objects to return
-RUNTIME_FUNCTION(Runtime_DebugReferencedBy) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
-
- // Check parameters.
- CONVERT_ARG_HANDLE_CHECKED(JSObject, target, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, instance_filter, 1);
- RUNTIME_ASSERT(instance_filter->IsUndefined() ||
- instance_filter->IsJSObject());
- CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[2]);
- RUNTIME_ASSERT(max_references >= 0);
-
-
- // Get the constructor function for context extension and arguments array.
- Handle<JSFunction> arguments_function(
- JSFunction::cast(isolate->sloppy_arguments_map()->constructor()));
-
- // Get the number of referencing objects.
- int count;
- // First perform a full GC in order to avoid dead objects and to make the heap
- // iterable.
- Heap* heap = isolate->heap();
- heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "%DebugConstructedBy");
- {
- HeapIterator heap_iterator(heap);
- count = DebugReferencedBy(&heap_iterator, *target, *instance_filter,
- max_references, NULL, 0, *arguments_function);
- }
-
- // Allocate an array to hold the result.
- Handle<FixedArray> instances = isolate->factory()->NewFixedArray(count);
-
- // Fill the referencing objects.
- {
- HeapIterator heap_iterator(heap);
- count = DebugReferencedBy(&heap_iterator, *target, *instance_filter,
- max_references, *instances, count,
- *arguments_function);
- }
-
- // Return result as JS array.
- Handle<JSFunction> constructor = isolate->array_function();
-
- Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
- JSArray::SetContent(Handle<JSArray>::cast(result), instances);
- return *result;
-}
-
-
-// Helper function used by Runtime_DebugConstructedBy below.
-static int DebugConstructedBy(HeapIterator* iterator, JSFunction* constructor,
- int max_references, FixedArray* instances,
- int instances_size) {
- DisallowHeapAllocation no_allocation;
-
- // Iterate the heap.
- int count = 0;
- HeapObject* heap_obj = NULL;
- while (((heap_obj = iterator->next()) != NULL) &&
- (max_references == 0 || count < max_references)) {
- // Only look at all JSObjects.
- if (heap_obj->IsJSObject()) {
- JSObject* obj = JSObject::cast(heap_obj);
- if (obj->map()->constructor() == constructor) {
- // Valid reference found add to instance array if supplied an update
- // count.
- if (instances != NULL && count < instances_size) {
- instances->set(count, obj);
- }
- count++;
- }
- }
- }
-
- // Return the number of referencing objects found.
- return count;
-}
-
-
-// Scan the heap for objects constructed by a specific function.
-// args[0]: the constructor to find instances of
-// args[1]: the the maximum number of objects to return
-RUNTIME_FUNCTION(Runtime_DebugConstructedBy) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
-
- // Check parameters.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 0);
- CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[1]);
- RUNTIME_ASSERT(max_references >= 0);
-
- // Get the number of referencing objects.
- int count;
- // First perform a full GC in order to avoid dead objects and to make the heap
- // iterable.
- Heap* heap = isolate->heap();
- heap->CollectAllGarbage(Heap::kMakeHeapIterableMask, "%DebugConstructedBy");
- {
- HeapIterator heap_iterator(heap);
- count = DebugConstructedBy(&heap_iterator, *constructor, max_references,
- NULL, 0);
- }
-
- // Allocate an array to hold the result.
- Handle<FixedArray> instances = isolate->factory()->NewFixedArray(count);
-
- // Fill the referencing objects.
- {
- HeapIterator heap_iterator2(heap);
- count = DebugConstructedBy(&heap_iterator2, *constructor, max_references,
- *instances, count);
- }
-
- // Return result as JS array.
- Handle<JSFunction> array_function = isolate->array_function();
- Handle<JSObject> result = isolate->factory()->NewJSObject(array_function);
- JSArray::SetContent(Handle<JSArray>::cast(result), instances);
- return *result;
-}
-
-
-// Find the effective prototype object as returned by __proto__.
-// args[0]: the object to find the prototype for.
-RUNTIME_FUNCTION(Runtime_DebugGetPrototype) {
- HandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);
- return *GetPrototypeSkipHiddenPrototypes(isolate, obj);
-}
-
-
-// Patches script source (should be called upon BeforeCompile event).
-RUNTIME_FUNCTION(Runtime_DebugSetScriptSource) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
-
- CONVERT_ARG_HANDLE_CHECKED(JSValue, script_wrapper, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
-
- RUNTIME_ASSERT(script_wrapper->value()->IsScript());
- Handle<Script> script(Script::cast(script_wrapper->value()));
-
- int compilation_state = script->compilation_state();
- RUNTIME_ASSERT(compilation_state == Script::COMPILATION_STATE_INITIAL);
- script->set_source(*source);
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugDisassembleFunction) {
- HandleScope scope(isolate);
-#ifdef DEBUG
- DCHECK(args.length() == 1);
- // Get the function and make sure it is compiled.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, func, 0);
- if (!Compiler::EnsureCompiled(func, KEEP_EXCEPTION)) {
- return isolate->heap()->exception();
- }
- OFStream os(stdout);
- func->code()->Print(os);
- os << endl;
-#endif // DEBUG
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_DebugDisassembleConstructor) {
- HandleScope scope(isolate);
-#ifdef DEBUG
- DCHECK(args.length() == 1);
- // Get the function and make sure it is compiled.
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, func, 0);
- if (!Compiler::EnsureCompiled(func, KEEP_EXCEPTION)) {
- return isolate->heap()->exception();
- }
- OFStream os(stdout);
- func->shared()->construct_stub()->Print(os);
- os << endl;
-#endif // DEBUG
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_FunctionGetInferredName) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(JSFunction, f, 0);
- return f->shared()->inferred_name();
-}
-
-
-static int FindSharedFunctionInfosForScript(HeapIterator* iterator,
- Script* script,
- FixedArray* buffer) {
- DisallowHeapAllocation no_allocation;
- int counter = 0;
- int buffer_size = buffer->length();
- for (HeapObject* obj = iterator->next(); obj != NULL;
- obj = iterator->next()) {
- DCHECK(obj != NULL);
- if (!obj->IsSharedFunctionInfo()) {
- continue;
- }
- SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
- if (shared->script() != script) {
- continue;
- }
- if (counter < buffer_size) {
- buffer->set(counter, shared);
- }
- counter++;
- }
- return counter;
-}
-
-
-// For a script finds all SharedFunctionInfo's in the heap that points
-// to this script. Returns JSArray of SharedFunctionInfo wrapped
-// in OpaqueReferences.
-RUNTIME_FUNCTION(Runtime_LiveEditFindSharedFunctionInfosForScript) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSValue, script_value, 0);
-
- RUNTIME_ASSERT(script_value->value()->IsScript());
- Handle<Script> script = Handle<Script>(Script::cast(script_value->value()));
-
- const int kBufferSize = 32;
-
- Handle<FixedArray> array;
- array = isolate->factory()->NewFixedArray(kBufferSize);
- int number;
- Heap* heap = isolate->heap();
- {
- HeapIterator heap_iterator(heap);
- Script* scr = *script;
- FixedArray* arr = *array;
- number = FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
- }
- if (number > kBufferSize) {
- array = isolate->factory()->NewFixedArray(number);
- HeapIterator heap_iterator(heap);
- Script* scr = *script;
- FixedArray* arr = *array;
- FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
- }
-
- Handle<JSArray> result = isolate->factory()->NewJSArrayWithElements(array);
- result->set_length(Smi::FromInt(number));
-
- LiveEdit::WrapSharedFunctionInfos(result);
-
- return *result;
-}
-
-
-// For a script calculates compilation information about all its functions.
-// The script source is explicitly specified by the second argument.
-// The source of the actual script is not used, however it is important that
-// all generated code keeps references to this particular instance of script.
-// Returns a JSArray of compilation infos. The array is ordered so that
-// each function with all its descendant is always stored in a continues range
-// with the function itself going first. The root function is a script function.
-RUNTIME_FUNCTION(Runtime_LiveEditGatherCompileInfo) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(JSValue, script, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, source, 1);
-
- RUNTIME_ASSERT(script->value()->IsScript());
- Handle<Script> script_handle = Handle<Script>(Script::cast(script->value()));
-
- Handle<JSArray> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result, LiveEdit::GatherCompileInfo(script_handle, source));
- return *result;
-}
-
-
-// Changes the source of the script to a new_source.
-// If old_script_name is provided (i.e. is a String), also creates a copy of
-// the script with its original source and sends notification to debugger.
-RUNTIME_FUNCTION(Runtime_LiveEditReplaceScript) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 3);
- CONVERT_ARG_CHECKED(JSValue, original_script_value, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, new_source, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, old_script_name, 2);
-
- RUNTIME_ASSERT(original_script_value->value()->IsScript());
- Handle<Script> original_script(Script::cast(original_script_value->value()));
-
- Handle<Object> old_script = LiveEdit::ChangeScriptSource(
- original_script, new_source, old_script_name);
-
- if (old_script->IsScript()) {
- Handle<Script> script_handle = Handle<Script>::cast(old_script);
- return *Script::GetWrapper(script_handle);
- } else {
- return isolate->heap()->null_value();
- }
-}
-
-
-RUNTIME_FUNCTION(Runtime_LiveEditFunctionSourceUpdated) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_info, 0);
- RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_info));
-
- LiveEdit::FunctionSourceUpdated(shared_info);
- return isolate->heap()->undefined_value();
-}
-
-
-// Replaces code of SharedFunctionInfo with a new one.
-RUNTIME_FUNCTION(Runtime_LiveEditReplaceFunctionCode) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, new_compile_info, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_info, 1);
- RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_info));
-
- LiveEdit::ReplaceFunctionCode(new_compile_info, shared_info);
- return isolate->heap()->undefined_value();
-}
-
-
-// Connects SharedFunctionInfo to another script.
-RUNTIME_FUNCTION(Runtime_LiveEditFunctionSetScript) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, script_object, 1);
-
- if (function_object->IsJSValue()) {
- Handle<JSValue> function_wrapper = Handle<JSValue>::cast(function_object);
- if (script_object->IsJSValue()) {
- RUNTIME_ASSERT(JSValue::cast(*script_object)->value()->IsScript());
- Script* script = Script::cast(JSValue::cast(*script_object)->value());
- script_object = Handle<Object>(script, isolate);
- }
- RUNTIME_ASSERT(function_wrapper->value()->IsSharedFunctionInfo());
- LiveEdit::SetFunctionScript(function_wrapper, script_object);
- } else {
- // Just ignore this. We may not have a SharedFunctionInfo for some functions
- // and we check it in this function.
- }
-
- return isolate->heap()->undefined_value();
-}
-
-
-// In a code of a parent function replaces original function as embedded object
-// with a substitution one.
-RUNTIME_FUNCTION(Runtime_LiveEditReplaceRefToNestedFunction) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 3);
-
- CONVERT_ARG_HANDLE_CHECKED(JSValue, parent_wrapper, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSValue, orig_wrapper, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSValue, subst_wrapper, 2);
- RUNTIME_ASSERT(parent_wrapper->value()->IsSharedFunctionInfo());
- RUNTIME_ASSERT(orig_wrapper->value()->IsSharedFunctionInfo());
- RUNTIME_ASSERT(subst_wrapper->value()->IsSharedFunctionInfo());
-
- LiveEdit::ReplaceRefToNestedFunction(parent_wrapper, orig_wrapper,
- subst_wrapper);
- return isolate->heap()->undefined_value();
-}
-
-
-// Updates positions of a shared function info (first parameter) according
-// to script source change. Text change is described in second parameter as
-// array of groups of 3 numbers:
-// (change_begin, change_end, change_end_new_position).
-// Each group describes a change in text; groups are sorted by change_begin.
-RUNTIME_FUNCTION(Runtime_LiveEditPatchFunctionPositions) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_array, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, position_change_array, 1);
- RUNTIME_ASSERT(SharedInfoWrapper::IsInstance(shared_array))
-
- LiveEdit::PatchFunctionPositions(shared_array, position_change_array);
- return isolate->heap()->undefined_value();
-}
-
-
-// For array of SharedFunctionInfo's (each wrapped in JSValue)
-// checks that none of them have activations on stacks (of any thread).
-// Returns array of the same length with corresponding results of
-// LiveEdit::FunctionPatchabilityStatus type.
-RUNTIME_FUNCTION(Runtime_LiveEditCheckAndDropActivations) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSArray, shared_array, 0);
- CONVERT_BOOLEAN_ARG_CHECKED(do_drop, 1);
- RUNTIME_ASSERT(shared_array->length()->IsSmi());
- RUNTIME_ASSERT(shared_array->HasFastElements())
- int array_length = Smi::cast(shared_array->length())->value();
- for (int i = 0; i < array_length; i++) {
- Handle<Object> element =
- Object::GetElement(isolate, shared_array, i).ToHandleChecked();
- RUNTIME_ASSERT(
- element->IsJSValue() &&
- Handle<JSValue>::cast(element)->value()->IsSharedFunctionInfo());
- }
-
- return *LiveEdit::CheckAndDropActivations(shared_array, do_drop);
-}
-
-
-// Compares 2 strings line-by-line, then token-wise and returns diff in form
-// of JSArray of triplets (pos1, pos1_end, pos2_end) describing list
-// of diff chunks.
-RUNTIME_FUNCTION(Runtime_LiveEditCompareStrings) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(String, s1, 0);
- CONVERT_ARG_HANDLE_CHECKED(String, s2, 1);
-
- return *LiveEdit::CompareStrings(s1, s2);
-}
-
-
-// Restarts a call frame and completely drops all frames above.
-// Returns true if successful. Otherwise returns undefined or an error message.
-RUNTIME_FUNCTION(Runtime_LiveEditRestartFrame) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);
- RUNTIME_ASSERT(CheckExecutionState(isolate, break_id));
-
- CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);
- Heap* heap = isolate->heap();
-
- // Find the relevant frame with the requested index.
- StackFrame::Id id = isolate->debug()->break_frame_id();
- if (id == StackFrame::NO_ID) {
- // If there are no JavaScript stack frames return undefined.
- return heap->undefined_value();
- }
-
- JavaScriptFrameIterator it(isolate, id);
- int inlined_jsframe_index = FindIndexedNonNativeFrame(&it, index);
- if (inlined_jsframe_index == -1) return heap->undefined_value();
- // We don't really care what the inlined frame index is, since we are
- // throwing away the entire frame anyways.
- const char* error_message = LiveEdit::RestartFrame(it.frame());
- if (error_message) {
- return *(isolate->factory()->InternalizeUtf8String(error_message));
- }
- return heap->true_value();
-}
-
-
-// A testing entry. Returns statement position which is the closest to
-// source_position.
-RUNTIME_FUNCTION(Runtime_GetFunctionCodePositionFromSource) {
- HandleScope scope(isolate);
- CHECK(isolate->debug()->live_edit_enabled());
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- CONVERT_NUMBER_CHECKED(int32_t, source_position, Int32, args[1]);
-
- Handle<Code> code(function->code(), isolate);
-
- if (code->kind() != Code::FUNCTION &&
- code->kind() != Code::OPTIMIZED_FUNCTION) {
- return isolate->heap()->undefined_value();
- }
-
- RelocIterator it(*code, RelocInfo::ModeMask(RelocInfo::STATEMENT_POSITION));
- int closest_pc = 0;
- int distance = kMaxInt;
- while (!it.done()) {
- int statement_position = static_cast<int>(it.rinfo()->data());
- // Check if this break point is closer that what was previously found.
- if (source_position <= statement_position &&
- statement_position - source_position < distance) {
- closest_pc =
- static_cast<int>(it.rinfo()->pc() - code->instruction_start());
- distance = statement_position - source_position;
- // Check whether we can't get any closer.
- if (distance == 0) break;
- }
- it.next();
- }
-
- return Smi::FromInt(closest_pc);
-}
-
-
-// Calls specified function with or without entering the debugger.
-// This is used in unit tests to run code as if debugger is entered or simply
-// to have a stack with C++ frame in the middle.
-RUNTIME_FUNCTION(Runtime_ExecuteInDebugContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
- CONVERT_BOOLEAN_ARG_CHECKED(without_debugger, 1);
-
- MaybeHandle<Object> maybe_result;
- if (without_debugger) {
- maybe_result = Execution::Call(isolate, function,
- handle(function->global_proxy()), 0, NULL);
- } else {
- DebugScope debug_scope(isolate->debug());
- maybe_result = Execution::Call(isolate, function,
- handle(function->global_proxy()), 0, NULL);
- }
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, maybe_result);
- return *result;
-}
-
-
-// Performs a GC.
-// Presently, it only does a full GC.
-RUNTIME_FUNCTION(Runtime_CollectGarbage) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags, "%CollectGarbage");
- return isolate->heap()->undefined_value();
-}
-
-
-// Gets the current heap usage.
-RUNTIME_FUNCTION(Runtime_GetHeapUsage) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- int usage = static_cast<int>(isolate->heap()->SizeOfObjects());
- if (!Smi::IsValid(usage)) {
- return *isolate->factory()->NewNumberFromInt(usage);
- }
- return Smi::FromInt(usage);
-}
-
-
-// Finds the script object from the script data. NOTE: This operation uses
-// heap traversal to find the function generated for the source position
-// for the requested break point. For lazily compiled functions several heap
-// traversals might be required rendering this operation as a rather slow
-// operation. However for setting break points which is normally done through
-// some kind of user interaction the performance is not crucial.
-static Handle<Object> Runtime_GetScriptFromScriptName(
- Handle<String> script_name) {
- // Scan the heap for Script objects to find the script with the requested
- // script data.
- Handle<Script> script;
- Factory* factory = script_name->GetIsolate()->factory();
- Heap* heap = script_name->GetHeap();
- HeapIterator iterator(heap);
- HeapObject* obj = NULL;
- while (script.is_null() && ((obj = iterator.next()) != NULL)) {
- // If a script is found check if it has the script data requested.
- if (obj->IsScript()) {
- if (Script::cast(obj)->name()->IsString()) {
- if (String::cast(Script::cast(obj)->name())->Equals(*script_name)) {
- script = Handle<Script>(Script::cast(obj));
- }
- }
- }
- }
-
- // If no script with the requested script data is found return undefined.
- if (script.is_null()) return factory->undefined_value();
-
- // Return the script found.
- return Script::GetWrapper(script);
-}
-
-
-// Get the script object from script data. NOTE: Regarding performance
-// see the NOTE for GetScriptFromScriptData.
-// args[0]: script data for the script to find the source for
-RUNTIME_FUNCTION(Runtime_GetScript) {
- HandleScope scope(isolate);
-
- DCHECK(args.length() == 1);
-
- CONVERT_ARG_CHECKED(String, script_name, 0);
-
- // Find the requested script.
- Handle<Object> result =
- Runtime_GetScriptFromScriptName(Handle<String>(script_name));
- return *result;
-}
-
-
-// Collect the raw data for a stack trace. Returns an array of 4
-// element segments each containing a receiver, function, code and
-// native code offset.
-RUNTIME_FUNCTION(Runtime_CollectStackTrace) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, error_object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, caller, 1);
-
- if (!isolate->bootstrapper()->IsActive()) {
- // Optionally capture a more detailed stack trace for the message.
- isolate->CaptureAndSetDetailedStackTrace(error_object);
- // Capture a simple stack trace for the stack property.
- isolate->CaptureAndSetSimpleStackTrace(error_object, caller);
- }
- return isolate->heap()->undefined_value();
-}
-
-
-// Returns V8 version as a string.
-RUNTIME_FUNCTION(Runtime_GetV8Version) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-
- const char* version_string = v8::V8::GetVersion();
-
- return *isolate->factory()->NewStringFromAsciiChecked(version_string);
-}
-
-
-// Returns function of generator activation.
-RUNTIME_FUNCTION(Runtime_GeneratorGetFunction) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
-
- return generator->function();
-}
-
-
-// Returns context of generator activation.
-RUNTIME_FUNCTION(Runtime_GeneratorGetContext) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
-
- return generator->context();
-}
-
-
-// Returns receiver of generator activation.
-RUNTIME_FUNCTION(Runtime_GeneratorGetReceiver) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
-
- return generator->receiver();
-}
-
-
-// Returns generator continuation as a PC offset, or the magic -1 or 0 values.
-RUNTIME_FUNCTION(Runtime_GeneratorGetContinuation) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
-
- return Smi::FromInt(generator->continuation());
-}
-
-
-RUNTIME_FUNCTION(Runtime_GeneratorGetSourcePosition) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
-
- if (generator->is_suspended()) {
- Handle<Code> code(generator->function()->code(), isolate);
- int offset = generator->continuation();
-
- RUNTIME_ASSERT(0 <= offset && offset < code->Size());
- Address pc = code->address() + offset;
-
- return Smi::FromInt(code->SourcePosition(pc));
- }
-
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_LoadMutableDouble) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Smi, index, 1);
- RUNTIME_ASSERT((index->value() & 1) == 1);
- FieldIndex field_index =
- FieldIndex::ForLoadByFieldIndex(object->map(), index->value());
- if (field_index.is_inobject()) {
- RUNTIME_ASSERT(field_index.property_index() <
- object->map()->inobject_properties());
- } else {
- RUNTIME_ASSERT(field_index.outobject_array_index() <
- object->properties()->length());
- }
- Handle<Object> raw_value(object->RawFastPropertyAt(field_index), isolate);
- RUNTIME_ASSERT(raw_value->IsMutableHeapNumber());
- return *Object::WrapForRead(isolate, raw_value, Representation::Double());
-}
-
-
-RUNTIME_FUNCTION(Runtime_TryMigrateInstance) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, object, 0);
- if (!object->IsJSObject()) return Smi::FromInt(0);
- Handle<JSObject> js_object = Handle<JSObject>::cast(object);
- if (!js_object->map()->is_deprecated()) return Smi::FromInt(0);
- // This call must not cause lazy deopts, because it's called from deferred
- // code where we can't handle lazy deopts for lack of a suitable bailout
- // ID. So we just try migration and signal failure if necessary,
- // which will also trigger a deopt.
- if (!JSObject::TryMigrateInstance(js_object)) return Smi::FromInt(0);
- return *object;
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetFromCache) {
- SealHandleScope shs(isolate);
- // This is only called from codegen, so checks might be more lax.
- CONVERT_ARG_CHECKED(JSFunctionResultCache, cache, 0);
- CONVERT_ARG_CHECKED(Object, key, 1);
-
- {
- DisallowHeapAllocation no_alloc;
-
- int finger_index = cache->finger_index();
- Object* o = cache->get(finger_index);
- if (o == key) {
- // The fastest case: hit the same place again.
- return cache->get(finger_index + 1);
- }
-
- for (int i = finger_index - 2; i >= JSFunctionResultCache::kEntriesIndex;
- i -= 2) {
- o = cache->get(i);
- if (o == key) {
- cache->set_finger_index(i);
- return cache->get(i + 1);
- }
- }
-
- int size = cache->size();
- DCHECK(size <= cache->length());
-
- for (int i = size - 2; i > finger_index; i -= 2) {
- o = cache->get(i);
- if (o == key) {
- cache->set_finger_index(i);
- return cache->get(i + 1);
- }
- }
- }
-
- // There is no value in the cache. Invoke the function and cache result.
- HandleScope scope(isolate);
-
- Handle<JSFunctionResultCache> cache_handle(cache);
- Handle<Object> key_handle(key, isolate);
- Handle<Object> value;
- {
- Handle<JSFunction> factory(JSFunction::cast(
- cache_handle->get(JSFunctionResultCache::kFactoryIndex)));
- // TODO(antonm): consider passing a receiver when constructing a cache.
- Handle<JSObject> receiver(isolate->global_proxy());
- // This handle is nor shared, nor used later, so it's safe.
- Handle<Object> argv[] = {key_handle};
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, value,
- Execution::Call(isolate, factory, receiver, arraysize(argv), argv));
- }
-
-#ifdef VERIFY_HEAP
- if (FLAG_verify_heap) {
- cache_handle->JSFunctionResultCacheVerify();
- }
-#endif
-
- // Function invocation may have cleared the cache. Reread all the data.
- int finger_index = cache_handle->finger_index();
- int size = cache_handle->size();
-
- // If we have spare room, put new data into it, otherwise evict post finger
- // entry which is likely to be the least recently used.
- int index = -1;
- if (size < cache_handle->length()) {
- cache_handle->set_size(size + JSFunctionResultCache::kEntrySize);
- index = size;
- } else {
- index = finger_index + JSFunctionResultCache::kEntrySize;
- if (index == cache_handle->length()) {
- index = JSFunctionResultCache::kEntriesIndex;
- }
- }
-
- DCHECK(index % 2 == 0);
- DCHECK(index >= JSFunctionResultCache::kEntriesIndex);
- DCHECK(index < cache_handle->length());
-
- cache_handle->set(index, *key_handle);
- cache_handle->set(index + 1, *value);
- cache_handle->set_finger_index(index);
-
-#ifdef VERIFY_HEAP
- if (FLAG_verify_heap) {
- cache_handle->JSFunctionResultCacheVerify();
- }
-#endif
-
- return *value;
-}
-
-
-RUNTIME_FUNCTION(Runtime_MessageGetStartPosition) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
- return Smi::FromInt(message->start_position());
-}
-
-
-RUNTIME_FUNCTION(Runtime_MessageGetScript) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(JSMessageObject, message, 0);
- return message->script();
-}
-
-
-#ifdef DEBUG
-// ListNatives is ONLY used by the fuzz-natives.js in debug mode
-// Exclude the code in release mode.
-RUNTIME_FUNCTION(Runtime_ListNatives) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
-#define COUNT_ENTRY(Name, argc, ressize) +1
- int entry_count =
- 0 RUNTIME_FUNCTION_LIST(COUNT_ENTRY) INLINE_FUNCTION_LIST(COUNT_ENTRY)
- INLINE_OPTIMIZED_FUNCTION_LIST(COUNT_ENTRY);
-#undef COUNT_ENTRY
- Factory* factory = isolate->factory();
- Handle<FixedArray> elements = factory->NewFixedArray(entry_count);
- int index = 0;
- bool inline_runtime_functions = false;
-#define ADD_ENTRY(Name, argc, ressize) \
- { \
- HandleScope inner(isolate); \
- Handle<String> name; \
- /* Inline runtime functions have an underscore in front of the name. */ \
- if (inline_runtime_functions) { \
- name = factory->NewStringFromStaticChars("_" #Name); \
- } else { \
- name = factory->NewStringFromStaticChars(#Name); \
- } \
- Handle<FixedArray> pair_elements = factory->NewFixedArray(2); \
- pair_elements->set(0, *name); \
- pair_elements->set(1, Smi::FromInt(argc)); \
- Handle<JSArray> pair = factory->NewJSArrayWithElements(pair_elements); \
- elements->set(index++, *pair); \
- }
- inline_runtime_functions = false;
- RUNTIME_FUNCTION_LIST(ADD_ENTRY)
- INLINE_OPTIMIZED_FUNCTION_LIST(ADD_ENTRY)
- inline_runtime_functions = true;
- INLINE_FUNCTION_LIST(ADD_ENTRY)
-#undef ADD_ENTRY
- DCHECK_EQ(index, entry_count);
- Handle<JSArray> result = factory->NewJSArrayWithElements(elements);
- return *result;
-}
-#endif
-
-
-RUNTIME_FUNCTION(Runtime_IS_VAR) {
- UNREACHABLE(); // implemented as macro in the parser
- return NULL;
-}
-
-
-#define TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION(Type, type, TYPE, ctype, size) \
- RUNTIME_FUNCTION(Runtime_HasExternal##Type##Elements) { \
- CONVERT_ARG_CHECKED(JSObject, obj, 0); \
- return isolate->heap()->ToBoolean(obj->HasExternal##Type##Elements()); \
- }
-
-TYPED_ARRAYS(TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION)
-
-#undef TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
-
-
-#define FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION(Type, type, TYPE, ctype, s) \
- RUNTIME_FUNCTION(Runtime_HasFixed##Type##Elements) { \
- CONVERT_ARG_CHECKED(JSObject, obj, 0); \
- return isolate->heap()->ToBoolean(obj->HasFixed##Type##Elements()); \
- }
-
-TYPED_ARRAYS(FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION)
-
-#undef FIXED_TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
-
-
-RUNTIME_FUNCTION(Runtime_IsJSGlobalProxy) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSGlobalProxy());
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsObserved) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
-
- if (!args[0]->IsJSReceiver()) return isolate->heap()->false_value();
- CONVERT_ARG_CHECKED(JSReceiver, obj, 0);
- DCHECK(!obj->IsJSGlobalProxy() || !obj->map()->is_observed());
- return isolate->heap()->ToBoolean(obj->map()->is_observed());
-}
-
-
-RUNTIME_FUNCTION(Runtime_SetIsObserved) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSReceiver, obj, 0);
- RUNTIME_ASSERT(!obj->IsJSGlobalProxy());
- if (obj->IsJSProxy()) return isolate->heap()->undefined_value();
- RUNTIME_ASSERT(!obj->map()->is_observed());
-
- DCHECK(obj->IsJSObject());
- JSObject::SetObserved(Handle<JSObject>::cast(obj));
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_EnqueueMicrotask) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, microtask, 0);
- isolate->EnqueueMicrotask(microtask);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_RunMicrotasks) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 0);
- isolate->RunMicrotasks();
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetObservationState) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- return isolate->heap()->observation_state();
-}
-
-
-static bool ContextsHaveSameOrigin(Handle<Context> context1,
- Handle<Context> context2) {
- return context1->security_token() == context2->security_token();
-}
-
-
-RUNTIME_FUNCTION(Runtime_ObserverObjectAndRecordHaveSameOrigin) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 3);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, observer, 0);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, record, 2);
-
- Handle<Context> observer_context(observer->context()->native_context());
- Handle<Context> object_context(object->GetCreationContext());
- Handle<Context> record_context(record->GetCreationContext());
-
- return isolate->heap()->ToBoolean(
- ContextsHaveSameOrigin(object_context, observer_context) &&
- ContextsHaveSameOrigin(object_context, record_context));
-}
-
-
-RUNTIME_FUNCTION(Runtime_ObjectWasCreatedInCurrentOrigin) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
-
- Handle<Context> creation_context(object->GetCreationContext(), isolate);
- return isolate->heap()->ToBoolean(
- ContextsHaveSameOrigin(creation_context, isolate->native_context()));
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetObjectContextObjectObserve) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
-
- Handle<Context> context(object->GetCreationContext(), isolate);
- return context->native_object_observe();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetObjectContextObjectGetNotifier) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
-
- Handle<Context> context(object->GetCreationContext(), isolate);
- return context->native_object_get_notifier();
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetObjectContextNotifierPerformChange) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object_info, 0);
-
- Handle<Context> context(object_info->GetCreationContext(), isolate);
- return context->native_object_notifier_perform_change();
-}
-
-
-static Object* ArrayConstructorCommon(Isolate* isolate,
- Handle<JSFunction> constructor,
- Handle<AllocationSite> site,
- Arguments* caller_args) {
- Factory* factory = isolate->factory();
-
- bool holey = false;
- bool can_use_type_feedback = true;
- if (caller_args->length() == 1) {
- Handle<Object> argument_one = caller_args->at<Object>(0);
- if (argument_one->IsSmi()) {
- int value = Handle<Smi>::cast(argument_one)->value();
- if (value < 0 || value >= JSObject::kInitialMaxFastElementArray) {
- // the array is a dictionary in this case.
- can_use_type_feedback = false;
- } else if (value != 0) {
- holey = true;
- }
- } else {
- // Non-smi length argument produces a dictionary
- can_use_type_feedback = false;
- }
- }
-
- Handle<JSArray> array;
- if (!site.is_null() && can_use_type_feedback) {
- ElementsKind to_kind = site->GetElementsKind();
- if (holey && !IsFastHoleyElementsKind(to_kind)) {
- to_kind = GetHoleyElementsKind(to_kind);
- // Update the allocation site info to reflect the advice alteration.
- site->SetElementsKind(to_kind);
- }
-
- // We should allocate with an initial map that reflects the allocation site
- // advice. Therefore we use AllocateJSObjectFromMap instead of passing
- // the constructor.
- Handle<Map> initial_map(constructor->initial_map(), isolate);
- if (to_kind != initial_map->elements_kind()) {
- initial_map = Map::AsElementsKind(initial_map, to_kind);
- }
-
- // If we don't care to track arrays of to_kind ElementsKind, then
- // don't emit a memento for them.
- Handle<AllocationSite> allocation_site;
- if (AllocationSite::GetMode(to_kind) == TRACK_ALLOCATION_SITE) {
- allocation_site = site;
- }
-
- array = Handle<JSArray>::cast(factory->NewJSObjectFromMap(
- initial_map, NOT_TENURED, true, allocation_site));
- } else {
- array = Handle<JSArray>::cast(factory->NewJSObject(constructor));
-
- // We might need to transition to holey
- ElementsKind kind = constructor->initial_map()->elements_kind();
- if (holey && !IsFastHoleyElementsKind(kind)) {
- kind = GetHoleyElementsKind(kind);
- JSObject::TransitionElementsKind(array, kind);
- }
- }
-
- factory->NewJSArrayStorage(array, 0, 0, DONT_INITIALIZE_ARRAY_ELEMENTS);
-
- ElementsKind old_kind = array->GetElementsKind();
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, ArrayConstructInitializeElements(array, caller_args));
- if (!site.is_null() &&
- (old_kind != array->GetElementsKind() || !can_use_type_feedback)) {
- // The arguments passed in caused a transition. This kind of complexity
- // can't be dealt with in the inlined hydrogen array constructor case.
- // We must mark the allocationsite as un-inlinable.
- site->SetDoNotInlineCall();
- }
- return *array;
-}
-
-
-RUNTIME_FUNCTION(Runtime_ArrayConstructor) {
- HandleScope scope(isolate);
- // If we get 2 arguments then they are the stub parameters (constructor, type
- // info). If we get 4, then the first one is a pointer to the arguments
- // passed by the caller, and the last one is the length of the arguments
- // passed to the caller (redundant, but useful to check on the deoptimizer
- // with an assert).
- Arguments empty_args(0, NULL);
- bool no_caller_args = args.length() == 2;
- DCHECK(no_caller_args || args.length() == 4);
- int parameters_start = no_caller_args ? 0 : 1;
- Arguments* caller_args =
- no_caller_args ? &empty_args : reinterpret_cast<Arguments*>(args[0]);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, parameters_start);
- CONVERT_ARG_HANDLE_CHECKED(Object, type_info, parameters_start + 1);
-#ifdef DEBUG
- if (!no_caller_args) {
- CONVERT_SMI_ARG_CHECKED(arg_count, parameters_start + 2);
- DCHECK(arg_count == caller_args->length());
- }
-#endif
-
- Handle<AllocationSite> site;
- if (!type_info.is_null() &&
- *type_info != isolate->heap()->undefined_value()) {
- site = Handle<AllocationSite>::cast(type_info);
- DCHECK(!site->SitePointsToLiteral());
- }
-
- return ArrayConstructorCommon(isolate, constructor, site, caller_args);
-}
-
-
-RUNTIME_FUNCTION(Runtime_InternalArrayConstructor) {
- HandleScope scope(isolate);
- Arguments empty_args(0, NULL);
- bool no_caller_args = args.length() == 1;
- DCHECK(no_caller_args || args.length() == 3);
- int parameters_start = no_caller_args ? 0 : 1;
- Arguments* caller_args =
- no_caller_args ? &empty_args : reinterpret_cast<Arguments*>(args[0]);
- CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, parameters_start);
-#ifdef DEBUG
- if (!no_caller_args) {
- CONVERT_SMI_ARG_CHECKED(arg_count, parameters_start + 1);
- DCHECK(arg_count == caller_args->length());
- }
-#endif
- return ArrayConstructorCommon(isolate, constructor,
- Handle<AllocationSite>::null(), caller_args);
-}
-
-
-RUNTIME_FUNCTION(Runtime_NormalizeElements) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
- RUNTIME_ASSERT(!array->HasExternalArrayElements() &&
- !array->HasFixedTypedArrayElements());
- JSObject::NormalizeElements(array);
- return *array;
-}
-
-
-RUNTIME_FUNCTION(Runtime_MaxSmi) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- return Smi::FromInt(Smi::kMaxValue);
-}
-
-
-// TODO(dcarney): remove this function when TurboFan supports it.
-// Takes the object to be iterated over and the result of GetPropertyNamesFast
-// Returns pair (cache_array, cache_type).
-RUNTIME_FUNCTION_RETURN_PAIR(Runtime_ForInInit) {
- SealHandleScope scope(isolate);
- DCHECK(args.length() == 2);
- // This simulates CONVERT_ARG_HANDLE_CHECKED for calls returning pairs.
- // Not worth creating a macro atm as this function should be removed.
- if (!args[0]->IsJSReceiver() || !args[1]->IsObject()) {
- Object* error = isolate->ThrowIllegalOperation();
- return MakePair(error, isolate->heap()->undefined_value());
- }
- Handle<JSReceiver> object = args.at<JSReceiver>(0);
- Handle<Object> cache_type = args.at<Object>(1);
- if (cache_type->IsMap()) {
- // Enum cache case.
- if (Map::EnumLengthBits::decode(Map::cast(*cache_type)->bit_field3()) ==
- 0) {
- // 0 length enum.
- // Can't handle this case in the graph builder,
- // so transform it into the empty fixed array case.
- return MakePair(isolate->heap()->empty_fixed_array(), Smi::FromInt(1));
- }
- return MakePair(object->map()->instance_descriptors()->GetEnumCache(),
- *cache_type);
- } else {
- // FixedArray case.
- Smi* new_cache_type = Smi::FromInt(object->IsJSProxy() ? 0 : 1);
- return MakePair(*Handle<FixedArray>::cast(cache_type), new_cache_type);
- }
-}
-
+#include "src/v8.h"
-// TODO(dcarney): remove this function when TurboFan supports it.
-RUNTIME_FUNCTION(Runtime_ForInCacheArrayLength) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, cache_type, 0);
- CONVERT_ARG_HANDLE_CHECKED(FixedArray, array, 1);
- int length = 0;
- if (cache_type->IsMap()) {
- length = Map::cast(*cache_type)->EnumLength();
- } else {
- DCHECK(cache_type->IsSmi());
- length = array->length();
- }
- return Smi::FromInt(length);
-}
+#include "src/runtime/runtime.h"
+#include "src/runtime/runtime-utils.h"
+namespace v8 {
+namespace internal {
-// TODO(dcarney): remove this function when TurboFan supports it.
-// Takes (the object to be iterated over,
-// cache_array from ForInInit,
-// cache_type from ForInInit,
-// the current index)
-// Returns pair (array[index], needs_filtering).
-RUNTIME_FUNCTION_RETURN_PAIR(Runtime_ForInNext) {
- SealHandleScope scope(isolate);
- DCHECK(args.length() == 4);
- int32_t index;
- // This simulates CONVERT_ARG_HANDLE_CHECKED for calls returning pairs.
- // Not worth creating a macro atm as this function should be removed.
- if (!args[0]->IsJSReceiver() || !args[1]->IsFixedArray() ||
- !args[2]->IsObject() || !args[3]->ToInt32(&index)) {
- Object* error = isolate->ThrowIllegalOperation();
- return MakePair(error, isolate->heap()->undefined_value());
- }
- Handle<JSReceiver> object = args.at<JSReceiver>(0);
- Handle<FixedArray> array = args.at<FixedArray>(1);
- Handle<Object> cache_type = args.at<Object>(2);
- // Figure out first if a slow check is needed for this object.
- bool slow_check_needed = false;
- if (cache_type->IsMap()) {
- if (object->map() != Map::cast(*cache_type)) {
- // Object transitioned. Need slow check.
- slow_check_needed = true;
- }
- } else {
- // No slow check needed for proxies.
- slow_check_needed = Smi::cast(*cache_type)->value() == 1;
- }
- return MakePair(array->get(index),
- isolate->heap()->ToBoolean(slow_check_needed));
-}
+// Header of runtime functions.
+#define F(name, number_of_args, result_size) \
+ Object* Runtime_##name(int args_length, Object** args_object, \
+ Isolate* isolate);
+#define P(name, number_of_args, result_size) \
+ ObjectPair Runtime_##name(int args_length, Object** args_object, \
+ Isolate* isolate);
-// ----------------------------------------------------------------------------
// Reference implementation for inlined runtime functions. Only used when the
// compiler does not support a certain intrinsic. Don't optimize these, but
// implement the intrinsic in the respective compiler instead.
-
// TODO(mstarzinger): These are place-holder stubs for TurboFan and will
// eventually all have a C++ implementation and this macro will be gone.
-#define U(name) \
- RUNTIME_FUNCTION(RuntimeReference_##name) { \
- UNIMPLEMENTED(); \
- return NULL; \
- }
-
-U(IsStringWrapperSafeForDefaultValueOf)
-U(DebugBreakInOptimizedCode)
-
-#undef U
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsSmi) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsSmi());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsNonNegativeSmi) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsSmi() &&
- Smi::cast(obj)->value() >= 0);
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsArray) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSArray());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsRegExp) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSRegExp());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsConstructCall) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- JavaScriptFrameIterator it(isolate);
- JavaScriptFrame* frame = it.frame();
- return isolate->heap()->ToBoolean(frame->IsConstructor());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_CallFunction) {
- SealHandleScope shs(isolate);
- return __RT_impl_Runtime_Call(args, isolate);
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_ArgumentsLength) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 0);
- JavaScriptFrameIterator it(isolate);
- JavaScriptFrame* frame = it.frame();
- return Smi::FromInt(frame->GetArgumentsLength());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_Arguments) {
- SealHandleScope shs(isolate);
- return __RT_impl_Runtime_GetArgumentsProperty(args, isolate);
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_ValueOf) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- if (!obj->IsJSValue()) return obj;
- return JSValue::cast(obj)->value();
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_SetValueOf) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- CONVERT_ARG_CHECKED(Object, value, 1);
- if (!obj->IsJSValue()) return value;
- JSValue::cast(obj)->set_value(value);
- return value;
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_DateField) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- CONVERT_SMI_ARG_CHECKED(index, 1);
- if (!obj->IsJSDate()) {
- HandleScope scope(isolate);
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewTypeError("not_date_object", HandleVector<Object>(NULL, 0)));
- }
- JSDate* date = JSDate::cast(obj);
- if (index == 0) return date->value();
- return JSDate::GetField(date, Smi::FromInt(index));
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_ObjectEquals) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(Object, obj1, 0);
- CONVERT_ARG_CHECKED(Object, obj2, 1);
- return isolate->heap()->ToBoolean(obj1 == obj2);
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsObject) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- if (!obj->IsHeapObject()) return isolate->heap()->false_value();
- if (obj->IsNull()) return isolate->heap()->true_value();
- if (obj->IsUndetectableObject()) return isolate->heap()->false_value();
- Map* map = HeapObject::cast(obj)->map();
- bool is_non_callable_spec_object =
- map->instance_type() >= FIRST_NONCALLABLE_SPEC_OBJECT_TYPE &&
- map->instance_type() <= LAST_NONCALLABLE_SPEC_OBJECT_TYPE;
- return isolate->heap()->ToBoolean(is_non_callable_spec_object);
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsFunction) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsJSFunction());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsUndetectableObject) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsUndetectableObject());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_IsSpecObject) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- return isolate->heap()->ToBoolean(obj->IsSpecObject());
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_HasCachedArrayIndex) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- return isolate->heap()->false_value();
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_GetCachedArrayIndex) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_FastOneByteArrayJoin) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_GeneratorNext) {
- UNREACHABLE(); // Optimization disabled in SetUpGenerators().
- return NULL;
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_GeneratorThrow) {
- UNREACHABLE(); // Optimization disabled in SetUpGenerators().
- return NULL;
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_ClassOf) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_CHECKED(Object, obj, 0);
- if (!obj->IsJSReceiver()) return isolate->heap()->null_value();
- return JSReceiver::cast(obj)->class_name();
-}
-
-
-RUNTIME_FUNCTION(RuntimeReference_GetFromCache) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_SMI_ARG_CHECKED(id, 0);
- args[0] = isolate->native_context()->jsfunction_result_caches()->get(id);
- return __RT_impl_Runtime_GetFromCache(args, isolate);
-}
-
+#define I(name, number_of_args, result_size) \
+ Object* RuntimeReference_##name(int args_length, Object** args_object, \
+ Isolate* isolate);
-RUNTIME_FUNCTION(RuntimeReference_DebugIsActive) {
- SealHandleScope shs(isolate);
- return Smi::FromInt(isolate->debug()->is_active());
-}
+RUNTIME_FUNCTION_LIST_RETURN_OBJECT(F)
+RUNTIME_FUNCTION_LIST_RETURN_PAIR(P)
+INLINE_OPTIMIZED_FUNCTION_LIST(F)
+INLINE_FUNCTION_LIST(I)
+#undef I
+#undef F
+#undef P
-// ----------------------------------------------------------------------------
-// Implementation of Runtime
#define F(name, number_of_args, result_size) \
{ \
const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
return &(kIntrinsicFunctions[static_cast<int>(id)]);
}
+
+
+std::ostream& operator<<(std::ostream& os, Runtime::FunctionId id) {
+ return os << Runtime::FunctionForId(id)->name;
}
-} // namespace v8::internal
+
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_RUNTIME_H_
-#define V8_RUNTIME_H_
+#ifndef V8_RUNTIME_RUNTIME_H_
+#define V8_RUNTIME_RUNTIME_H_
#include "src/allocation.h"
+#include "src/objects.h"
#include "src/zone.h"
namespace v8 {
F(DebugPushPromise, 1, 1) \
F(DebugPopPromise, 0, 1) \
F(DebugPromiseEvent, 1, 1) \
- F(DebugPromiseRejectEvent, 2, 1) \
F(DebugAsyncTaskEvent, 1, 1) \
+ F(PromiseRejectEvent, 3, 1) \
+ F(PromiseRevokeReject, 1, 1) \
+ F(PromiseHasHandlerSymbol, 0, 1) \
F(FlattenString, 1, 1) \
F(LoadMutableDouble, 2, 1) \
F(TryMigrateInstance, 1, 1) \
/* Classes support */ \
F(ToMethod, 2, 1) \
F(HomeObjectSymbol, 0, 1) \
+ F(DefineClass, 6, 1) \
+ F(DefineClassMethod, 3, 1) \
+ F(DefineClassGetter, 3, 1) \
+ F(DefineClassSetter, 3, 1) \
+ F(ClassGetSourceCode, 1, 1) \
F(ThrowNonMethodError, 0, 1) \
F(ThrowUnsupportedSuperError, 0, 1) \
F(LoadFromSuper, 3, 1) \
+ F(LoadKeyedFromSuper, 3, 1) \
F(StoreToSuper_Strict, 4, 1) \
- F(StoreToSuper_Sloppy, 4, 1)
+ F(StoreToSuper_Sloppy, 4, 1) \
+ F(StoreKeyedToSuper_Strict, 4, 1) \
+ F(StoreKeyedToSuper_Sloppy, 4, 1)
#define RUNTIME_FUNCTION_LIST_ALWAYS_2(F) \
F(DefineDataPropertyUnchecked, 4, 1) \
F(DefineAccessorPropertyUnchecked, 5, 1) \
F(GetDataProperty, 2, 1) \
- F(SetHiddenProperty, 3, 1) \
\
/* Arrays */ \
F(RemoveArrayHoles, 2, 1) \
F(MoveArrayContents, 2, 1) \
F(EstimateNumberOfElements, 1, 1) \
F(NormalizeElements, 1, 1) \
+ F(HasComplexElements, 1, 1) \
\
/* Getters and Setters */ \
F(LookupAccessor, 3, 1) \
/* Harmony proxies */ \
F(CreateJSProxy, 2, 1) \
F(CreateJSFunctionProxy, 4, 1) \
- F(IsJSProxy, 1, 1) \
F(IsJSFunctionProxy, 1, 1) \
F(GetHandler, 1, 1) \
F(GetCallTrap, 1, 1) \
F(SetGetSize, 1, 1) \
\
F(SetIteratorInitialize, 3, 1) \
+ F(SetIteratorClone, 1, 1) \
F(SetIteratorNext, 2, 1) \
\
/* Harmony maps */ \
F(MapGetSize, 1, 1) \
\
F(MapIteratorInitialize, 3, 1) \
+ F(MapIteratorClone, 1, 1) \
F(MapIteratorNext, 2, 1) \
\
/* Harmony weak maps and sets */ \
F(GetObjectContextObjectObserve, 1, 1) \
F(GetObjectContextObjectGetNotifier, 1, 1) \
F(GetObjectContextNotifierPerformChange, 1, 1) \
+ F(DeliverObservationChangeRecords, 2, 1) \
\
/* Harmony typed arrays */ \
F(ArrayBufferInitialize, 2, 1) \
F(ArrayBufferIsView, 1, 1) \
F(ArrayBufferNeuter, 1, 1) \
\
+ F(IsTypedArray, 1, 1) \
F(TypedArrayInitializeFromArrayLike, 4, 1) \
F(TypedArrayGetBuffer, 1, 1) \
F(TypedArraySetFastCases, 3, 1) \
F(TraceExit, 1, 1) \
F(Abort, 1, 1) \
F(AbortJS, 1, 1) \
+ F(NativeScriptsCount, 0, 1) \
/* ES5 */ \
F(OwnKeys, 1, 1) \
\
#define RUNTIME_FUNCTION_LIST_RETURN_PAIR(F) \
F(LoadLookupSlot, 2, 2) \
F(LoadLookupSlotNoReferenceError, 2, 2) \
- F(ResolvePossiblyDirectEval, 5, 2) \
+ F(ResolvePossiblyDirectEval, 6, 2) \
F(ForInInit, 2, 2) /* TODO(turbofan): Only temporary */ \
F(ForInNext, 4, 2) /* TODO(turbofan): Only temporary */
#endif
-#ifdef DEBUG
-#define RUNTIME_FUNCTION_LIST_DEBUG(F) \
- /* Testing */ \
- F(ListNatives, 0, 1)
-#else
-#define RUNTIME_FUNCTION_LIST_DEBUG(F)
-#endif
-
// ----------------------------------------------------------------------------
// RUNTIME_FUNCTION_LIST defines all runtime functions accessed
// either directly by id (via the code generator), or indirectly
RUNTIME_FUNCTION_LIST_ALWAYS_1(F) \
RUNTIME_FUNCTION_LIST_ALWAYS_2(F) \
RUNTIME_FUNCTION_LIST_ALWAYS_3(F) \
- RUNTIME_FUNCTION_LIST_DEBUG(F) \
RUNTIME_FUNCTION_LIST_DEBUGGER(F) \
RUNTIME_FUNCTION_LIST_I18N_SUPPORT(F)
F(IsNonNegativeSmi, 1, 1) \
F(IsArray, 1, 1) \
F(IsRegExp, 1, 1) \
+ F(IsJSProxy, 1, 1) \
F(IsConstructCall, 0, 1) \
F(CallFunction, -1 /* receiver + n args + function */, 1) \
F(ArgumentsLength, 0, 1) \
class RuntimeState {
public:
- StaticResource<ConsStringIteratorOp>* string_iterator() {
- return &string_iterator_;
- }
unibrow::Mapping<unibrow::ToUppercase, 128>* to_upper_mapping() {
return &to_upper_mapping_;
}
unibrow::Mapping<unibrow::ToLowercase, 128>* to_lower_mapping() {
return &to_lower_mapping_;
}
- ConsStringIteratorOp* string_iterator_compare_x() {
- return &string_iterator_compare_x_;
- }
- ConsStringIteratorOp* string_iterator_compare_y() {
- return &string_iterator_compare_y_;
- }
- ConsStringIteratorOp* string_locale_compare_it1() {
- return &string_locale_compare_it1_;
- }
- ConsStringIteratorOp* string_locale_compare_it2() {
- return &string_locale_compare_it2_;
- }
private:
RuntimeState() {}
- // Non-reentrant string buffer for efficient general use in the runtime.
- StaticResource<ConsStringIteratorOp> string_iterator_;
unibrow::Mapping<unibrow::ToUppercase, 128> to_upper_mapping_;
unibrow::Mapping<unibrow::ToLowercase, 128> to_lower_mapping_;
- ConsStringIteratorOp string_iterator_compare_x_;
- ConsStringIteratorOp string_iterator_compare_y_;
- ConsStringIteratorOp string_locale_compare_it1_;
- ConsStringIteratorOp string_locale_compare_it2_;
friend class Isolate;
friend class Runtime;
};
+class JavaScriptFrameIterator; // Forward declaration.
+
+
class Runtime : public AllStatic {
public:
enum FunctionId {
// Get the intrinsic function with the given function entry address.
static const Function* FunctionForEntry(Address ref);
- // General-purpose helper functions for runtime system.
- static int StringMatch(Isolate* isolate, Handle<String> sub,
- Handle<String> pat, int index);
-
// TODO(1240886): Some of the following methods are *not* handle safe, but
// accept handle arguments. This seems fragile.
Handle<JSObject> object, Handle<Object> key, Handle<Object> value,
PropertyAttributes attr);
- MUST_USE_RESULT static MaybeHandle<Object> DeleteObjectProperty(
- Isolate* isolate, Handle<JSReceiver> object, Handle<Object> key,
- JSReceiver::DeleteMode mode);
-
- MUST_USE_RESULT static MaybeHandle<Object> HasObjectProperty(
- Isolate* isolate, Handle<JSReceiver> object, Handle<Object> key);
-
MUST_USE_RESULT static MaybeHandle<Object> GetObjectProperty(
Isolate* isolate, Handle<Object> object, Handle<Object> key);
+ MUST_USE_RESULT static MaybeHandle<Name> ToName(Isolate* isolate,
+ Handle<Object> key);
+
static void SetupArrayBuffer(Isolate* isolate,
Handle<JSArrayBuffer> array_buffer,
bool is_external, void* data,
static void FreeArrayBuffer(Isolate* isolate,
JSArrayBuffer* phantom_array_buffer);
+ static int FindIndexedNonNativeFrame(JavaScriptFrameIterator* it, int index);
+
enum TypedArrayId {
// arrayIds below should be synchromized with typedarray.js natives.
ARRAY_ID_UINT8 = 1,
};
+std::ostream& operator<<(std::ostream&, Runtime::FunctionId);
+
//---------------------------------------------------------------------------
// Constants used by interface to runtime functions.
class DeclareGlobalsEvalFlag : public BitField<bool, 0, 1> {};
class DeclareGlobalsNativeFlag : public BitField<bool, 1, 1> {};
class DeclareGlobalsStrictMode : public BitField<StrictMode, 2, 1> {};
-}
-} // namespace v8::internal
-#endif // V8_RUNTIME_H_
+} // namespace internal
+} // namespace v8
+
+#endif // V8_RUNTIME_RUNTIME_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_STRING_BUILDER_H_
-#define V8_STRING_BUILDER_H_
+#ifndef V8_RUNTIME_STRING_BUILDER_H_
+#define V8_RUNTIME_STRING_BUILDER_H_
namespace v8 {
namespace internal {
}
} // namespace v8::internal
-#endif // V8_STRING_BUILDER_H_
+#endif // V8_RUNTIME_STRING_BUILDER_H_
}
-void SafepointTable::PrintEntry(unsigned index, OStream& os) const { // NOLINT
+void SafepointTable::PrintEntry(unsigned index,
+ std::ostream& os) const { // NOLINT
disasm::NameConverter converter;
SafepointEntry entry = GetEntry(index);
uint8_t* bits = entry.bits();
}
-void SafepointTable::PrintBits(OStream& os, // NOLINT
+void SafepointTable::PrintBits(std::ostream& os, // NOLINT
uint8_t byte, int digits) {
DCHECK(digits >= 0 && digits <= kBitsPerByte);
for (int i = 0; i < digits; i++) {
// Returns the entry for the given pc.
SafepointEntry FindEntry(Address pc) const;
- void PrintEntry(unsigned index, OStream& os) const; // NOLINT
+ void PrintEntry(unsigned index, std::ostream& os) const; // NOLINT
private:
static const uint8_t kNoRegisters = 0xFF;
return GetPcOffsetLocation(index) + kPcSize;
}
- static void PrintBits(OStream& os, // NOLINT
+ static void PrintBits(std::ostream& os, // NOLINT
uint8_t byte, int digits);
DisallowHeapAllocation no_allocation_;
#if defined(USE_SIMULATOR)
class SimulatorHelper {
public:
- inline bool Init(Sampler* sampler, Isolate* isolate) {
+ inline bool Init(Isolate* isolate) {
simulator_ = isolate->thread_local_top()->simulator_;
// Check if there is active simulator.
return simulator_ != NULL;
}
- inline void FillRegisters(RegisterState* state) {
+ inline void FillRegisters(v8::RegisterState* state) {
#if V8_TARGET_ARCH_ARM
state->pc = reinterpret_cast<Address>(simulator_->get_pc());
state->sp = reinterpret_cast<Address>(simulator_->get_register(
Simulator::r11));
#elif V8_TARGET_ARCH_ARM64
if (simulator_->sp() == 0 || simulator_->fp() == 0) {
- // It possible that the simulator is interrupted while it is updating
+ // It's possible that the simulator is interrupted while it is updating
// the sp or fp register. ARM64 simulator does this in two steps:
- // first setting it to zero and then setting it to the new value.
+ // first setting it to zero and then setting it to a new value.
// Bailout if sp/fp doesn't contain the new value.
return;
}
state->pc = reinterpret_cast<Address>(simulator_->pc());
state->sp = reinterpret_cast<Address>(simulator_->sp());
state->fp = reinterpret_cast<Address>(simulator_->fp());
-#elif V8_TARGET_ARCH_MIPS
- state->pc = reinterpret_cast<Address>(simulator_->get_pc());
- state->sp = reinterpret_cast<Address>(simulator_->get_register(
- Simulator::sp));
- state->fp = reinterpret_cast<Address>(simulator_->get_register(
- Simulator::fp));
-#elif V8_TARGET_ARCH_MIPS64
+#elif V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64
state->pc = reinterpret_cast<Address>(simulator_->get_pc());
state->sp = reinterpret_cast<Address>(simulator_->get_register(
Simulator::sp));
USE(info);
if (signal != SIGPROF) return;
Isolate* isolate = Isolate::UnsafeCurrent();
- if (isolate == NULL || !isolate->IsInitialized() || !isolate->IsInUse()) {
+ if (isolate == NULL || !isolate->IsInUse()) {
// We require a fully initialized and entered isolate.
return;
}
Sampler* sampler = isolate->logger()->sampler();
if (sampler == NULL) return;
- RegisterState state;
+ v8::RegisterState state;
#if defined(USE_SIMULATOR)
SimulatorHelper helper;
- if (!helper.Init(sampler, isolate)) return;
+ if (!helper.Init(isolate)) return;
helper.FillRegisters(&state);
// It possible that the simulator is interrupted while it is updating
// the sp or fp register. ARM64 simulator does this in two steps:
state.sp = reinterpret_cast<Address>(mcontext.gregs[REG_RSP]);
state.fp = reinterpret_cast<Address>(mcontext.gregs[REG_RBP]);
#elif V8_HOST_ARCH_ARM
-#if defined(__GLIBC__) && !defined(__UCLIBC__) && \
- (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
+#if V8_LIBC_GLIBC && !V8_GLIBC_PREREQ(2, 4)
// Old GLibc ARM versions used a gregs[] array to access the register
// values from mcontext_t.
state.pc = reinterpret_cast<Address>(mcontext.gregs[R15]);
state.pc = reinterpret_cast<Address>(mcontext.arm_pc);
state.sp = reinterpret_cast<Address>(mcontext.arm_sp);
state.fp = reinterpret_cast<Address>(mcontext.arm_fp);
-#endif // defined(__GLIBC__) && !defined(__UCLIBC__) &&
- // (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
+#endif // V8_LIBC_GLIBC && !V8_GLIBC_PREREQ(2, 4)
#elif V8_HOST_ARCH_ARM64
state.pc = reinterpret_cast<Address>(mcontext.pc);
state.sp = reinterpret_cast<Address>(mcontext.sp);
// profiled. We must not suspend.
for (int i = 0; i < active_samplers_.length(); ++i) {
Sampler* sampler = active_samplers_.at(i);
- if (!sampler->isolate()->IsInitialized()) continue;
if (!sampler->IsProfiling()) continue;
sampler->DoSample();
}
// StackTracer implementation
//
DISABLE_ASAN void TickSample::Init(Isolate* isolate,
- const RegisterState& regs) {
- DCHECK(isolate->IsInitialized());
+ const v8::RegisterState& regs,
+ RecordCEntryFrame record_c_entry_frame) {
timestamp = base::TimeTicks::HighResolutionNow();
- pc = regs.pc;
+ pc = reinterpret_cast<Address>(regs.pc);
state = isolate->current_vm_state();
// Avoid collecting traces while doing GC.
if (state == GC) return;
Address js_entry_sp = isolate->js_entry_sp();
- if (js_entry_sp == 0) {
- // Not executing JS now.
- return;
- }
+ if (js_entry_sp == 0) return; // Not executing JS now.
ExternalCallbackScope* scope = isolate->external_callback_scope();
Address handler = Isolate::handler(isolate->thread_local_top());
} else {
// Sample potential return address value for frameless invocation of
// stubs (we'll figure out later, if this value makes sense).
- tos = Memory::Address_at(regs.sp);
+ tos = Memory::Address_at(reinterpret_cast<Address>(regs.sp));
has_external_callback = false;
}
- SafeStackFrameIterator it(isolate, regs.fp, regs.sp, js_entry_sp);
+ SafeStackFrameIterator it(isolate, reinterpret_cast<Address>(regs.fp),
+ reinterpret_cast<Address>(regs.sp), js_entry_sp);
top_frame_type = it.top_frame_type();
- unsigned i = 0;
- while (!it.done() && i < TickSample::kMaxFramesCount) {
- stack[i++] = it.frame()->pc();
+
+ SampleInfo info;
+ GetStackSample(isolate, regs, record_c_entry_frame,
+ reinterpret_cast<void**>(&stack[0]), kMaxFramesCount, &info);
+ frames_count = static_cast<unsigned>(info.frames_count);
+}
+
+
+void TickSample::GetStackSample(Isolate* isolate, const v8::RegisterState& regs,
+ RecordCEntryFrame record_c_entry_frame,
+ void** frames, size_t frames_limit,
+ v8::SampleInfo* sample_info) {
+ sample_info->frames_count = 0;
+ sample_info->vm_state = isolate->current_vm_state();
+ if (sample_info->vm_state == GC) return;
+
+ Address js_entry_sp = isolate->js_entry_sp();
+ if (js_entry_sp == 0) return; // Not executing JS now.
+
+ SafeStackFrameIterator it(isolate, reinterpret_cast<Address>(regs.fp),
+ reinterpret_cast<Address>(regs.sp), js_entry_sp);
+ size_t i = 0;
+ if (record_c_entry_frame == kIncludeCEntryFrame && !it.done() &&
+ it.top_frame_type() == StackFrame::EXIT) {
+ frames[i++] = isolate->c_function();
+ }
+ while (!it.done() && i < frames_limit) {
+ frames[i++] = it.frame()->pc();
it.Advance();
}
- frames_count = i;
+ sample_info->frames_count = i;
}
}
-void Sampler::SampleStack(const RegisterState& state) {
+void Sampler::SampleStack(const v8::RegisterState& state) {
TickSample* sample = isolate_->cpu_profiler()->StartTickSample();
TickSample sample_obj;
if (sample == NULL) sample = &sample_obj;
- sample->Init(isolate_, state);
+ sample->Init(isolate_, state, TickSample::kIncludeCEntryFrame);
if (is_counting_samples_) {
if (sample->state == JS || sample->state == EXTERNAL) {
++js_and_external_sample_count_;
#if defined(USE_SIMULATOR)
SimulatorHelper helper;
- if (!helper.Init(this, isolate())) return;
+ if (!helper.Init(isolate())) return;
#endif
const DWORD kSuspendFailed = static_cast<DWORD>(-1);
memset(&context, 0, sizeof(context));
context.ContextFlags = CONTEXT_FULL;
if (GetThreadContext(profiled_thread, &context) != 0) {
- RegisterState state;
+ v8::RegisterState state;
#if defined(USE_SIMULATOR)
helper.FillRegisters(&state);
#else
#ifndef V8_SAMPLER_H_
#define V8_SAMPLER_H_
+#include "include/v8.h"
+
#include "src/base/atomicops.h"
#include "src/frames.h"
#include "src/globals.h"
// (if used for profiling) the program counter and stack pointer for
// the thread that created it.
-struct RegisterState {
- RegisterState() : pc(NULL), sp(NULL), fp(NULL) {}
- Address pc; // Instruction pointer.
- Address sp; // Stack pointer.
- Address fp; // Frame pointer.
-};
-
// TickSample captures the information collected for each sample.
struct TickSample {
+ // Internal profiling (with --prof + tools/$OS-tick-processor) wants to
+ // include the runtime function we're calling. Externally exposed tick
+ // samples don't care.
+ enum RecordCEntryFrame { kIncludeCEntryFrame, kSkipCEntryFrame };
+
TickSample()
: state(OTHER),
pc(NULL),
frames_count(0),
has_external_callback(false),
top_frame_type(StackFrame::NONE) {}
- void Init(Isolate* isolate, const RegisterState& state);
+ void Init(Isolate* isolate, const v8::RegisterState& state,
+ RecordCEntryFrame record_c_entry_frame);
+ static void GetStackSample(Isolate* isolate, const v8::RegisterState& state,
+ RecordCEntryFrame record_c_entry_frame,
+ void** frames, size_t frames_limit,
+ v8::SampleInfo* sample_info);
StateTag state; // The state of the VM.
Address pc; // Instruction pointer.
union {
int interval() const { return interval_; }
// Performs stack sampling.
- void SampleStack(const RegisterState& regs);
+ void SampleStack(const v8::RegisterState& regs);
// Start and stop sampler.
void Start();
unsigned CopyCharsHelper(uint16_t* dest, unsigned length, const uint8_t* src,
unsigned* src_pos, unsigned src_length,
ScriptCompiler::StreamedSource::Encoding encoding) {
+ // It's possible that this will be called with length 0, but don't assume that
+ // the functions this calls handle it gracefully.
+ if (length == 0) return 0;
+
if (encoding == ScriptCompiler::StreamedSource::UTF8) {
return v8::internal::Utf8ToUtf16CharacterStream::CopyChars(
dest, length, src, src_pos, src_length);
void ExternalStreamingStream::HandleUtf8SplitCharacters(
unsigned* data_in_buffer) {
+ // Note the following property of UTF-8 which makes this function possible:
+ // Given any byte, we can always read its local environment (in both
+ // directions) to find out the (possibly multi-byte) character it belongs
+ // to. Single byte characters are of the form 0b0XXXXXXX. The first byte of a
+ // multi-byte character is of the form 0b110XXXXX, 0b1110XXXX or
+ // 0b11110XXX. The continuation bytes are of the form 0b10XXXXXX.
+
// First check if we have leftover data from the last chunk.
unibrow::uchar c;
if (utf8_split_char_buffer_length_ > 0) {
// Move the bytes which are part of the split character (which started in
- // the previous chunk) into utf8_split_char_buffer_.
+ // the previous chunk) into utf8_split_char_buffer_. Note that the
+ // continuation bytes are of the form 0b10XXXXXX, thus c >> 6 == 2.
while (current_data_offset_ < current_data_length_ &&
utf8_split_char_buffer_length_ < 4 &&
- (c = current_data_[current_data_offset_]) >
- unibrow::Utf8::kMaxOneByteChar) {
+ (c = current_data_[current_data_offset_]) >> 6 == 2) {
utf8_split_char_buffer_[utf8_split_char_buffer_length_] = c;
++utf8_split_char_buffer_length_;
++current_data_offset_;
utf8_split_char_buffer_length_ < 4) {
--current_data_length_;
++utf8_split_char_buffer_length_;
+ if (c >= (3 << 6)) {
+ // 3 << 6 = 0b11000000; this is the first byte of the multi-byte
+ // character. No need to copy the previous characters into the conversion
+ // buffer (even if they're multi-byte).
+ break;
+ }
}
CHECK(utf8_split_char_buffer_length_ <= 4);
for (unsigned i = 0; i < utf8_split_char_buffer_length_; ++i) {
return 0;
}
- virtual unsigned FillBuffer(unsigned position);
+ virtual unsigned FillBuffer(unsigned position) OVERRIDE;
private:
void HandleUtf8SplitCharacters(unsigned* data_in_buffer);
// Features shared by parsing and pre-parsing scanners.
+#include <stdint.h>
+
#include <cmath>
#include "src/v8.h"
-#include "include/v8stdint.h"
#include "src/ast-value-factory.h"
#include "src/char-predicates-inl.h"
#include "src/conversions-inl.h"
uc32 Scanner::ScanHexNumber(int expected_length) {
DCHECK(expected_length <= 4); // prevent overflow
- uc32 digits[4] = { 0, 0, 0, 0 };
uc32 x = 0;
for (int i = 0; i < expected_length; i++) {
- digits[i] = c0_;
int d = HexValue(c0_);
if (d < 0) {
- // According to ECMA-262, 3rd, 7.8.4, page 18, these hex escapes
- // should be illegal, but other JS VMs just return the
- // non-escaped version of the original character.
-
- // Push back digits that we have advanced past.
- for (int j = i-1; j >= 0; j--) {
- PushBack(digits[j]);
- }
return -1;
}
x = x * 16 + d;
while (true) {
while (true) {
+ // The unicode cache accepts unsigned inputs.
+ if (c0_ < 0) break;
// Advance as long as character is a WhiteSpace or LineTerminator.
// Remember if the latter is the case.
if (unicode_cache_->IsLineTerminator(c0_)) {
while (c0_ >= 0) {
uc32 ch = c0_;
Advance();
- if (unicode_cache_->IsLineTerminator(ch)) {
+ if (c0_ >= 0 && unicode_cache_->IsLineTerminator(ch)) {
// Following ECMA-262, section 7.4, a comment containing
// a newline will make the comment count as a line-terminator.
has_multiline_comment_before_next_ = true;
break;
default:
- if (unicode_cache_->IsIdentifierStart(c0_)) {
+ if (c0_ < 0) {
+ token = Token::EOS;
+ } else if (unicode_cache_->IsIdentifierStart(c0_)) {
token = ScanIdentifierOrKeyword();
} else if (IsDecimalDigit(c0_)) {
token = ScanNumber(false);
} else if (SkipWhiteSpace()) {
token = Token::WHITESPACE;
- } else if (c0_ < 0) {
- token = Token::EOS;
} else {
token = Select(Token::ILLEGAL);
}
Advance();
// Skip escaped newlines.
- if (unicode_cache_->IsLineTerminator(c)) {
+ if (c0_ >= 0 && unicode_cache_->IsLineTerminator(c)) {
// Allow CR+LF newlines in multiline string literals.
if (IsCarriageReturn(c) && IsLineFeed(c0_)) Advance();
// Allow LF+CR newlines in multiline string literals.
// not be an identifier start or a decimal digit; see ECMA-262
// section 7.8.3, page 17 (note that we read only one decimal digit
// if the value is 0).
- if (IsDecimalDigit(c0_) || unicode_cache_->IsIdentifierStart(c0_))
+ if (IsDecimalDigit(c0_) ||
+ (c0_ >= 0 && unicode_cache_->IsIdentifierStart(c0_)))
return Token::ILLEGAL;
literal.Complete();
Advance();
if (c0_ != 'u') return -1;
Advance();
- uc32 result = ScanHexNumber(4);
- if (result < 0) PushBack('u');
- return result;
+ return ScanHexNumber(4);
}
bool Scanner::IdentifierIsFutureStrictReserved(
const AstRawString* string) const {
// Keywords are always 1-byte strings.
- return string->is_one_byte() &&
- Token::FUTURE_STRICT_RESERVED_WORD ==
- KeywordOrIdentifierToken(string->raw_data(), string->length(),
- harmony_scoping_, harmony_modules_,
- harmony_classes_);
+ if (!string->is_one_byte()) return false;
+ if (string->IsOneByteEqualTo("let") || string->IsOneByteEqualTo("static") ||
+ string->IsOneByteEqualTo("yield")) {
+ return true;
+ }
+ return Token::FUTURE_STRICT_RESERVED_WORD ==
+ KeywordOrIdentifierToken(string->raw_data(), string->length(),
+ harmony_scoping_, harmony_modules_,
+ harmony_classes_);
}
AddLiteralChar(first_char);
// Scan the rest of the identifier characters.
- while (unicode_cache_->IsIdentifierPart(c0_)) {
+ while (c0_ >= 0 && unicode_cache_->IsIdentifierPart(c0_)) {
if (c0_ != '\\') {
uc32 next_char = c0_;
Advance();
Token::Value Scanner::ScanIdentifierSuffix(LiteralScope* literal) {
// Scan the rest of the identifier characters.
- while (unicode_cache_->IsIdentifierPart(c0_)) {
+ while (c0_ >= 0 && unicode_cache_->IsIdentifierPart(c0_)) {
if (c0_ == '\\') {
uc32 c = ScanIdentifierUnicodeEscape();
// Only allow legal identifier part characters.
}
while (c0_ != '/' || in_character_class) {
- if (unicode_cache_->IsLineTerminator(c0_) || c0_ < 0) return false;
+ if (c0_ < 0 || unicode_cache_->IsLineTerminator(c0_)) return false;
if (c0_ == '\\') { // Escape sequence.
AddLiteralCharAdvance();
- if (unicode_cache_->IsLineTerminator(c0_) || c0_ < 0) return false;
+ if (c0_ < 0 || unicode_cache_->IsLineTerminator(c0_)) return false;
AddLiteralCharAdvance();
// If the escape allows more characters, i.e., \x??, \u????, or \c?,
// only "safe" characters are allowed (letters, digits, underscore),
bool Scanner::ScanLiteralUnicodeEscape() {
DCHECK(c0_ == '\\');
- uc32 chars_read[6] = {'\\', 'u', 0, 0, 0, 0};
+ AddLiteralChar(c0_);
Advance();
- int i = 1;
+ int hex_digits_read = 0;
if (c0_ == 'u') {
- i++;
- while (i < 6) {
+ AddLiteralChar(c0_);
+ while (hex_digits_read < 4) {
Advance();
if (!IsHexDigit(c0_)) break;
- chars_read[i] = c0_;
- i++;
- }
- }
- if (i < 6) {
- // Incomplete escape. Undo all advances and return false.
- while (i > 0) {
- i--;
- PushBack(chars_read[i]);
+ AddLiteralChar(c0_);
+ ++hex_digits_read;
}
- return false;
}
- // Complete escape. Add all chars to current literal buffer.
- for (int i = 0; i < 6; i++) {
- AddLiteralChar(chars_read[i]);
- }
- return true;
+ return hex_digits_read == 4;
}
bool Scanner::ScanRegExpFlags() {
// Scan regular expression flags.
LiteralScope literal(this);
- while (unicode_cache_->IsIdentifierPart(c0_)) {
+ while (c0_ >= 0 && unicode_cache_->IsIdentifierPart(c0_)) {
if (c0_ != '\\') {
AddLiteralCharAdvance();
} else {
if (!ScanLiteralUnicodeEscape()) {
- break;
+ return false;
}
Advance();
}
#include "src/list.h"
#include "src/token.h"
#include "src/unicode-inl.h"
+#include "src/unicode-decoder.h"
#include "src/utils.h"
namespace v8 {
}
ConvertToTwoByte();
}
- DCHECK(code_unit < 0x10000u);
- *reinterpret_cast<uint16_t*>(&backing_store_[position_]) = code_unit;
- position_ += kUC16Size;
+ if (code_unit <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
+ *reinterpret_cast<uint16_t*>(&backing_store_[position_]) = code_unit;
+ position_ += kUC16Size;
+ } else {
+ *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
+ unibrow::Utf16::LeadSurrogate(code_unit);
+ position_ += kUC16Size;
+ if (position_ >= backing_store_.length()) ExpandBuffer();
+ *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
+ unibrow::Utf16::TrailSurrogate(code_unit);
+ position_ += kUC16Size;
+ }
}
bool is_one_byte() const { return is_one_byte_; }
const AstRawString* NextSymbol(AstValueFactory* ast_value_factory);
double DoubleValue();
- bool UnescapedLiteralMatches(const char* data, int length) {
+ bool LiteralMatches(const char* data, int length, bool allow_escapes = true) {
if (is_literal_one_byte() &&
literal_length() == length &&
- !literal_contains_escapes()) {
+ (allow_escapes || !literal_contains_escapes())) {
const char* token =
reinterpret_cast<const char*>(literal_one_byte_string().start());
return !strncmp(token, data, length);
}
return false;
}
+ inline bool UnescapedLiteralMatches(const char* data, int length) {
+ return LiteralMatches(data, length, false);
+ }
+
void IsGetOrSet(bool* is_get, bool* is_set) {
if (is_literal_one_byte() &&
literal_length() == 3 &&
}
// Low-level scanning support.
- void Advance() { c0_ = source_->Advance(); }
+ void Advance() {
+ c0_ = source_->Advance();
+ if (unibrow::Utf16::IsLeadSurrogate(c0_)) {
+ uc32 c1 = source_->Advance();
+ if (!unibrow::Utf16::IsTrailSurrogate(c1)) {
+ source_->PushBack(c1);
+ } else {
+ c0_ = unibrow::Utf16::CombineSurrogatePair(c0_, c1);
+ }
+ }
+ }
+
void PushBack(uc32 ch) {
- source_->PushBack(c0_);
+ if (ch > static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
+ source_->PushBack(unibrow::Utf16::TrailSurrogate(c0_));
+ source_->PushBack(unibrow::Utf16::LeadSurrogate(c0_));
+ } else {
+ source_->PushBack(c0_);
+ }
c0_ = ch;
}
int context_locals = ContextLocalCount();
bool function_name_context_slot =
FunctionVariableField::decode(Flags()) == CONTEXT;
- bool has_context = context_locals > 0 ||
- function_name_context_slot ||
- scope_type() == WITH_SCOPE ||
- (scope_type() == FUNCTION_SCOPE && CallsEval()) ||
- scope_type() == MODULE_SCOPE;
+ bool has_context = context_locals > 0 || function_name_context_slot ||
+ scope_type() == WITH_SCOPE ||
+ (scope_type() == ARROW_SCOPE && CallsEval()) ||
+ (scope_type() == FUNCTION_SCOPE && CallsEval()) ||
+ scope_type() == MODULE_SCOPE;
if (has_context) {
return Context::MIN_CONTEXT_SLOTS + context_locals +
(function_name_context_slot ? 1 : 0);
scope_inside_with_ = false;
scope_contains_with_ = false;
scope_calls_eval_ = false;
+ scope_uses_this_ = false;
+ scope_uses_arguments_ = false;
asm_module_ = false;
asm_function_ = outer_scope != NULL && outer_scope->asm_module_;
// Inherit the strict mode from the parent scope.
strict_mode_ = outer_scope != NULL ? outer_scope->strict_mode_ : SLOPPY;
outer_scope_calls_sloppy_eval_ = false;
inner_scope_calls_eval_ = false;
+ inner_scope_uses_this_ = false;
+ inner_scope_uses_arguments_ = false;
force_eager_compilation_ = false;
force_context_allocation_ = (outer_scope != NULL && !is_function_scope())
? outer_scope->has_forced_context_allocation() : false;
// Allocate the variables.
{
- AstNodeFactory<AstNullVisitor> ast_node_factory(
- info->zone(), info->ast_value_factory(), info->ast_node_id_gen());
+ AstNodeFactory<AstNullVisitor> ast_node_factory(info->ast_value_factory());
if (!top->AllocateVariables(info, &ast_node_factory)) return false;
}
case CATCH_SCOPE: return "catch";
case BLOCK_SCOPE: return "block";
case WITH_SCOPE: return "with";
+ case ARROW_SCOPE: return "arrow";
}
UNREACHABLE();
return NULL;
if (scope_inside_with_) Indent(n1, "// scope inside 'with'\n");
if (scope_contains_with_) Indent(n1, "// scope contains 'with'\n");
if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
+ if (scope_uses_this_) Indent(n1, "// scope uses 'this'\n");
+ if (scope_uses_arguments_) Indent(n1, "// scope uses 'arguments'\n");
+ if (inner_scope_uses_this_) Indent(n1, "// inner scope uses 'this'\n");
+ if (inner_scope_uses_arguments_) {
+ Indent(n1, "// inner scope uses 'arguments'\n");
+ }
if (outer_scope_calls_sloppy_eval_) {
Indent(n1, "// outer scope calls 'eval' in sloppy context\n");
}
// If the proxy is already resolved there's nothing to do
// (functions and consts may be resolved by the parser).
- if (proxy->var() != NULL) return true;
+ if (proxy->is_resolved()) return true;
// Otherwise, try to resolve the variable.
BindingKind binding_kind;
if (inner->scope_calls_eval_ || inner->inner_scope_calls_eval_) {
inner_scope_calls_eval_ = true;
}
+ // If the inner scope is an arrow function, propagate the flags tracking
+ // usage of this/arguments, but do not propagate them out from normal
+ // functions.
+ if (!inner->is_function_scope() || inner->is_arrow_scope()) {
+ if (inner->scope_uses_this_ || inner->inner_scope_uses_this_) {
+ inner_scope_uses_this_ = true;
+ }
+ if (inner->scope_uses_arguments_ || inner->inner_scope_uses_arguments_) {
+ inner_scope_uses_arguments_ = true;
+ }
+ }
if (inner->force_eager_compilation_) {
force_eager_compilation_ = true;
}
// Inform the scope that the corresponding code contains an eval call.
void RecordEvalCall() { if (!is_global_scope()) scope_calls_eval_ = true; }
+ // Inform the scope that the corresponding code uses "this".
+ void RecordThisUsage() { scope_uses_this_ = true; }
+
+ // Inform the scope that the corresponding code uses "arguments".
+ void RecordArgumentsUsage() { scope_uses_arguments_ = true; }
+
// Set the strict mode flag (unless disabled by a global flag).
void SetStrictMode(StrictMode strict_mode) { strict_mode_ = strict_mode; }
// Specific scope types.
bool is_eval_scope() const { return scope_type_ == EVAL_SCOPE; }
- bool is_function_scope() const { return scope_type_ == FUNCTION_SCOPE; }
+ bool is_function_scope() const {
+ return scope_type_ == FUNCTION_SCOPE || scope_type_ == ARROW_SCOPE;
+ }
bool is_module_scope() const { return scope_type_ == MODULE_SCOPE; }
bool is_global_scope() const { return scope_type_ == GLOBAL_SCOPE; }
bool is_catch_scope() const { return scope_type_ == CATCH_SCOPE; }
bool is_block_scope() const { return scope_type_ == BLOCK_SCOPE; }
bool is_with_scope() const { return scope_type_ == WITH_SCOPE; }
+ bool is_arrow_scope() const { return scope_type_ == ARROW_SCOPE; }
bool is_declaration_scope() const {
return is_eval_scope() || is_function_scope() ||
is_module_scope() || is_global_scope();
// Does this scope contain a with statement.
bool contains_with() const { return scope_contains_with_; }
+ // Does this scope access "this".
+ bool uses_this() const { return scope_uses_this_; }
+ // Does any inner scope access "this".
+ bool inner_uses_this() const { return inner_scope_uses_this_; }
+ // Does this scope access "arguments".
+ bool uses_arguments() const { return scope_uses_arguments_; }
+ // Does any inner scope access "arguments".
+ bool inner_uses_arguments() const { return inner_scope_uses_arguments_; }
+
// ---------------------------------------------------------------------------
// Accessors.
// This scope or a nested catch scope or with scope contain an 'eval' call. At
// the 'eval' call site this scope is the declaration scope.
bool scope_calls_eval_;
+ // This scope uses "this".
+ bool scope_uses_this_;
+ // This scope uses "arguments".
+ bool scope_uses_arguments_;
// This scope contains an "use asm" annotation.
bool asm_module_;
// This scope's outer context is an asm module.
// Computed via PropagateScopeInfo.
bool outer_scope_calls_sloppy_eval_;
bool inner_scope_calls_eval_;
+ bool inner_scope_uses_this_;
+ bool inner_scope_uses_arguments_;
bool force_eager_compilation_;
bool force_context_allocation_;
}
+RootIndexMap::RootIndexMap(Isolate* isolate) {
+ map_ = new HashMap(HashMap::PointersMatch);
+ Object** root_array = isolate->heap()->roots_array_start();
+ for (int i = 0; i < Heap::kStrongRootListLength; i++) {
+ Object* root = root_array[i];
+ if (root->IsHeapObject() && !isolate->heap()->InNewSpace(root)) {
+ HeapObject* heap_object = HeapObject::cast(root);
+ if (LookupEntry(map_, heap_object, false) != NULL) {
+ // Some root values are initialized to the empty FixedArray();
+ // Do not add them to the map.
+ DCHECK_EQ(isolate->heap()->empty_fixed_array(), heap_object);
+ } else {
+ SetValue(LookupEntry(map_, heap_object, true), i);
+ }
+ }
+ }
+}
+
+
class CodeAddressMap: public CodeEventLogger {
public:
explicit CodeAddressMap(Isolate* isolate)
source_(source),
external_reference_decoder_(NULL),
deserialized_large_objects_(0) {
- for (int i = 0; i < kNumberOfSpaces; i++) {
- reservations_[i] = kUninitializedReservation;
- }
+ for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) current_chunk_[i] = 0;
}
}
+bool Deserializer::ReserveSpace() {
+ if (!isolate_->heap()->ReserveSpace(reservations_)) return false;
+ for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
+ high_water_[i] = reservations_[i][0].start;
+ }
+ return true;
+}
+
+
void Deserializer::Deserialize(Isolate* isolate) {
isolate_ = isolate;
DCHECK(isolate_ != NULL);
- isolate_->heap()->ReserveSpace(reservations_, high_water_);
+ if (!ReserveSpace()) FatalProcessOutOfMemory("deserializing context");
// No active threads.
DCHECK_EQ(NULL, isolate_->thread_manager()->FirstThreadStateInUse());
// No active handles.
}
-void Deserializer::DeserializePartial(Isolate* isolate, Object** root) {
+void Deserializer::DeserializePartial(Isolate* isolate, Object** root,
+ OnOOM on_oom) {
isolate_ = isolate;
for (int i = NEW_SPACE; i < kNumberOfSpaces; i++) {
- DCHECK(reservations_[i] != kUninitializedReservation);
+ DCHECK(reservations_[i].length() > 0);
+ }
+ if (!ReserveSpace()) {
+ if (on_oom == FATAL_ON_OOM) FatalProcessOutOfMemory("deserialize context");
+ *root = NULL;
+ return;
}
- Heap* heap = isolate->heap();
- heap->ReserveSpace(reservations_, high_water_);
if (external_reference_decoder_ == NULL) {
external_reference_decoder_ = new ExternalReferenceDecoder(isolate);
}
void Deserializer::VisitPointers(Object** start, Object** end) {
// The space must be new space. Any other space would cause ReadChunk to try
// to update the remembered using NULL as the address.
- ReadChunk(start, end, NEW_SPACE, NULL);
+ ReadData(start, end, NEW_SPACE, NULL);
}
DCHECK(string->IsInternalizedString());
}
- virtual bool IsMatch(Object* string) {
+ virtual bool IsMatch(Object* string) OVERRIDE {
// We know that all entries in a hash table had their hash keys created.
// Use that knowledge to have fast failure.
if (hash_ != HashForObject(string)) return false;
if (FLAG_log_snapshot_positions) {
LOG(isolate_, SnapshotPositionEvent(address, source_->position()));
}
- ReadChunk(current, limit, space_number, address);
+ ReadData(current, limit, space_number, address);
// TODO(mvstanton): consider treating the heap()->allocation_sites_list()
// as a (weak) root. If this root is relocated correctly,
// pre-allocate that reserved space. During deserialization, all we need
// to do is to bump up the pointer for each space in the reserved
// space. This is also used for fixing back references.
+// We may have to split up the pre-allocation into several chunks
+// because it would not fit onto a single page, we have to keep track
+// of when to move to the next chunk.
// Since multiple large objects cannot be folded into one large object
// space allocation, we have to do an actual allocation when deserializing
// each large object. Instead of tracking offset for back references, we
if (space_index == LO_SPACE) {
AlwaysAllocateScope scope(isolate_);
LargeObjectSpace* lo_space = isolate_->heap()->lo_space();
- Executability exec = static_cast<Executability>(source_->GetInt());
+ Executability exec = static_cast<Executability>(source_->Get());
AllocationResult result = lo_space->AllocateRaw(size, exec);
HeapObject* obj = HeapObject::cast(result.ToObjectChecked());
deserialized_large_objects_.Add(obj);
} else {
DCHECK(space_index < kNumberOfPreallocatedSpaces);
Address address = high_water_[space_index];
+ DCHECK_NE(NULL, address);
+ const Heap::Reservation& reservation = reservations_[space_index];
+ int chunk_index = current_chunk_[space_index];
+ if (address + size > reservation[chunk_index].end) {
+ // The last chunk size matches exactly the already deserialized data.
+ DCHECK_EQ(address, reservation[chunk_index].end);
+ // Move to next reserved chunk.
+ chunk_index = ++current_chunk_[space_index];
+ DCHECK_LT(chunk_index, reservation.length());
+ // Prepare for next allocation in the next chunk.
+ address = reservation[chunk_index].start;
+ } else {
+ high_water_[space_index] = address + size;
+ }
high_water_[space_index] = address + size;
return address;
}
}
-void Deserializer::ReadChunk(Object** current,
- Object** limit,
- int source_space,
- Address current_object_address) {
+
+void Deserializer::ReadData(Object** current, Object** limit, int source_space,
+ Address current_object_address) {
Isolate* const isolate = isolate_;
// Write barrier support costs around 1% in startup time. In fact there
// are no new space objects in current boot snapshots, so it's not needed,
new_object = reinterpret_cast<Object*>(address); \
} else if (where == kBackref) { \
emit_write_barrier = (space_number == NEW_SPACE); \
- new_object = GetAddressFromEnd(data & kSpaceMask); \
+ new_object = GetBackReferencedObject(data & kSpaceMask); \
if (deserializing_user_code()) { \
new_object = ProcessBackRefInSerializedCode(new_object); \
} \
current = reinterpret_cast<Object**>( \
reinterpret_cast<Address>(current) + skip); \
emit_write_barrier = (space_number == NEW_SPACE); \
- new_object = GetAddressFromEnd(data & kSpaceMask); \
+ new_object = GetBackReferencedObject(data & kSpaceMask); \
if (deserializing_user_code()) { \
new_object = ProcessBackRefInSerializedCode(new_object); \
} \
// Find a builtin and write a pointer to it to the current object.
CASE_STATEMENT(kBuiltin, kPlain, kStartOfObject, 0)
CASE_BODY(kBuiltin, kPlain, kStartOfObject, 0)
-#if V8_OOL_CONSTANT_POOL
- // Find a builtin code entry and write a pointer to it to the current
- // object.
CASE_STATEMENT(kBuiltin, kPlain, kInnerPointer, 0)
CASE_BODY(kBuiltin, kPlain, kInnerPointer, 0)
-#endif
- // Find a builtin and write a pointer to it in the current code object.
CASE_STATEMENT(kBuiltin, kFromCode, kInnerPointer, 0)
CASE_BODY(kBuiltin, kFromCode, kInnerPointer, 0)
// Find an object in the attached references and write a pointer to it to
: isolate_(isolate),
sink_(sink),
external_reference_encoder_(new ExternalReferenceEncoder(isolate)),
- root_index_wave_front_(0),
+ root_index_map_(isolate),
code_address_map_(NULL),
+ large_objects_total_size_(0),
seen_large_objects_index_(0) {
// The serializer is meant to be used only to generate initial heap images
// from a context in which there is only one isolate.
- for (int i = 0; i < kNumberOfSpaces; i++) fullness_[i] = 0;
+ for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
+ pending_chunk_[i] = 0;
+ max_chunk_size_[i] = static_cast<uint32_t>(
+ MemoryAllocator::PageAreaSize(static_cast<AllocationSpace>(i)));
+ }
}
}
+void StartupSerializer::VisitPointers(Object** start, Object** end) {
+ for (Object** current = start; current < end; current++) {
+ if (start == isolate()->heap()->roots_array_start()) {
+ root_index_wave_front_ =
+ Max(root_index_wave_front_, static_cast<intptr_t>(current - start));
+ }
+ if (ShouldBeSkipped(current)) {
+ sink_->Put(kSkip, "Skip");
+ sink_->PutInt(kPointerSize, "SkipOneWord");
+ } else if ((*current)->IsSmi()) {
+ sink_->Put(kRawData + 1, "Smi");
+ for (int i = 0; i < kPointerSize; i++) {
+ sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
+ }
+ } else {
+ SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject, 0);
+ }
+ }
+}
+
+
void PartialSerializer::Serialize(Object** object) {
this->VisitPointer(object);
Pad();
void Serializer::VisitPointers(Object** start, Object** end) {
- Isolate* isolate = this->isolate();;
-
for (Object** current = start; current < end; current++) {
- if (start == isolate->heap()->roots_array_start()) {
- root_index_wave_front_ =
- Max(root_index_wave_front_, static_cast<intptr_t>(current - start));
- }
- if (ShouldBeSkipped(current)) {
- sink_->Put(kSkip, "Skip");
- sink_->PutInt(kPointerSize, "SkipOneWord");
- } else if ((*current)->IsSmi()) {
+ if ((*current)->IsSmi()) {
sink_->Put(kRawData + 1, "Smi");
for (int i = 0; i < kPointerSize; i++) {
sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
}
} else {
- SerializeObject(*current, kPlain, kStartOfObject, 0);
+ SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject, 0);
+ }
+ }
+}
+
+
+void Serializer::FinalizeAllocation() {
+ for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
+ // Complete the last pending chunk and if there are no completed chunks,
+ // make sure there is at least one empty chunk.
+ if (pending_chunk_[i] > 0 || completed_chunks_[i].length() == 0) {
+ completed_chunks_[i].Add(pending_chunk_[i]);
+ pending_chunk_[i] = 0;
}
}
}
}
-int Serializer::RootIndex(HeapObject* heap_object, HowToCode from) {
- Heap* heap = isolate()->heap();
- if (heap->InNewSpace(heap_object)) return kInvalidRootIndex;
- for (int i = 0; i < root_index_wave_front_; i++) {
- Object* root = heap->roots_array_start()[i];
- if (!root->IsSmi() && root == heap_object) {
- return i;
- }
- }
- return kInvalidRootIndex;
-}
-
-
// Encode the location of an already deserialized object in order to write its
// location into a later object. We can encode the location as an offset from
// the start of the deserialized objects or as an offset backwards from the
// current allocation pointer.
-void Serializer::SerializeReferenceToPreviousObject(HeapObject* heap_object,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip) {
- int space = SpaceOfObject(heap_object);
-
+void Serializer::SerializeBackReference(BackReference back_reference,
+ HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) {
+ AllocationSpace space = back_reference.space();
if (skip == 0) {
sink_->Put(kBackref + how_to_code + where_to_point + space, "BackRefSer");
} else {
sink_->PutInt(skip, "BackRefSkipDistance");
}
- if (space == LO_SPACE) {
- int index = address_mapper_.MappedTo(heap_object);
- sink_->PutInt(index, "large object index");
- } else {
- int address = address_mapper_.MappedTo(heap_object);
- int offset = CurrentAllocationAddress(space) - address;
- // Shift out the bits that are always 0.
- offset >>= kObjectAlignmentBits;
- sink_->PutInt(offset, "offset");
- }
+ sink_->PutInt(back_reference.reference(),
+ (space == LO_SPACE) ? "large object index" : "allocation");
}
-void StartupSerializer::SerializeObject(
- Object* o,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip) {
- CHECK(o->IsHeapObject());
- HeapObject* heap_object = HeapObject::cast(o);
- DCHECK(!heap_object->IsJSFunction());
+void StartupSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) {
+ DCHECK(!obj->IsJSFunction());
- int root_index;
- if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
- PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
+ int root_index = root_index_map_.Lookup(obj);
+ // We can only encode roots as such if it has already been serialized.
+ // That applies to root indices below the wave front.
+ if (root_index != RootIndexMap::kInvalidRootIndex &&
+ root_index < root_index_wave_front_) {
+ PutRoot(root_index, obj, how_to_code, where_to_point, skip);
return;
}
- if (address_mapper_.IsMapped(heap_object)) {
- SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
- skip);
- } else {
- if (skip != 0) {
- sink_->Put(kSkip, "FlushPendingSkip");
- sink_->PutInt(skip, "SkipDistance");
- }
+ BackReference back_reference = back_reference_map_.Lookup(obj);
+ if (back_reference.is_valid()) {
+ SerializeBackReference(back_reference, how_to_code, where_to_point, skip);
+ return;
+ }
- // Object has not yet been serialized. Serialize it here.
- ObjectSerializer object_serializer(this,
- heap_object,
- sink_,
- how_to_code,
- where_to_point);
- object_serializer.Serialize();
+ if (skip != 0) {
+ sink_->Put(kSkip, "FlushPendingSkip");
+ sink_->PutInt(skip, "SkipDistance");
}
+
+ // Object has not yet been serialized. Serialize it here.
+ ObjectSerializer object_serializer(this, obj, sink_, how_to_code,
+ where_to_point);
+ object_serializer.Serialize();
}
}
-void PartialSerializer::SerializeObject(
- Object* o,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip) {
- CHECK(o->IsHeapObject());
- HeapObject* heap_object = HeapObject::cast(o);
-
- if (heap_object->IsMap()) {
+void PartialSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) {
+ if (obj->IsMap()) {
// The code-caches link to context-specific code objects, which
// the startup and context serializes cannot currently handle.
- DCHECK(Map::cast(heap_object)->code_cache() ==
- heap_object->GetHeap()->empty_fixed_array());
+ DCHECK(Map::cast(obj)->code_cache() == obj->GetHeap()->empty_fixed_array());
}
- int root_index;
- if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
- PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
+ int root_index = root_index_map_.Lookup(obj);
+ if (root_index != RootIndexMap::kInvalidRootIndex) {
+ PutRoot(root_index, obj, how_to_code, where_to_point, skip);
return;
}
- if (ShouldBeInThePartialSnapshotCache(heap_object)) {
+ if (ShouldBeInThePartialSnapshotCache(obj)) {
if (skip != 0) {
sink_->Put(kSkip, "SkipFromSerializeObject");
sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
}
- int cache_index = PartialSnapshotCacheIndex(heap_object);
+ int cache_index = PartialSnapshotCacheIndex(obj);
sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
"PartialSnapshotCache");
sink_->PutInt(cache_index, "partial_snapshot_cache_index");
// Pointers from the partial snapshot to the objects in the startup snapshot
// should go through the root array or through the partial snapshot cache.
// If this is not the case you may have to add something to the root array.
- DCHECK(!startup_serializer_->address_mapper()->IsMapped(heap_object));
+ DCHECK(!startup_serializer_->back_reference_map()->Lookup(obj).is_valid());
// All the internalized strings that the partial snapshot needs should be
// either in the root table or in the partial snapshot cache.
- DCHECK(!heap_object->IsInternalizedString());
+ DCHECK(!obj->IsInternalizedString());
- if (address_mapper_.IsMapped(heap_object)) {
- SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
- skip);
- } else {
- if (skip != 0) {
- sink_->Put(kSkip, "SkipFromSerializeObject");
- sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
- }
- // Object has not yet been serialized. Serialize it here.
- ObjectSerializer serializer(this,
- heap_object,
- sink_,
- how_to_code,
- where_to_point);
- serializer.Serialize();
+ BackReference back_reference = back_reference_map_.Lookup(obj);
+ if (back_reference.is_valid()) {
+ SerializeBackReference(back_reference, how_to_code, where_to_point, skip);
+ return;
}
-}
+ if (skip != 0) {
+ sink_->Put(kSkip, "SkipFromSerializeObject");
+ sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
+ }
+ // Object has not yet been serialized. Serialize it here.
+ ObjectSerializer serializer(this, obj, sink_, how_to_code, where_to_point);
+ serializer.Serialize();
+}
-void Serializer::ObjectSerializer::Serialize() {
- int space = Serializer::SpaceOfObject(object_);
- int size = object_->Size();
+void Serializer::ObjectSerializer::SerializePrologue(AllocationSpace space,
+ int size, Map* map) {
sink_->Put(kNewObject + reference_representation_ + space,
"ObjectSerialization");
sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
}
// Mark this object as already serialized.
+ BackReference back_reference;
if (space == LO_SPACE) {
if (object_->IsCode()) {
- sink_->PutInt(EXECUTABLE, "executable large object");
+ sink_->Put(EXECUTABLE, "executable large object");
} else {
- sink_->PutInt(NOT_EXECUTABLE, "not executable large object");
+ sink_->Put(NOT_EXECUTABLE, "not executable large object");
}
- int index = serializer_->AllocateLargeObject(size);
- serializer_->address_mapper()->AddMapping(object_, index);
+ back_reference = serializer_->AllocateLargeObject(size);
} else {
- int offset = serializer_->Allocate(space, size);
- serializer_->address_mapper()->AddMapping(object_, offset);
+ back_reference = serializer_->Allocate(space, size);
}
+ serializer_->back_reference_map()->Add(object_, back_reference);
// Serialize the map (first word of the object).
- serializer_->SerializeObject(object_->map(), kPlain, kStartOfObject, 0);
+ serializer_->SerializeObject(map, kPlain, kStartOfObject, 0);
+}
+
+
+void Serializer::ObjectSerializer::SerializeExternalString() {
+ // Instead of serializing this as an external string, we serialize
+ // an imaginary sequential string with the same content.
+ Isolate* isolate = serializer_->isolate();
+ DCHECK(object_->IsExternalString());
+ DCHECK(object_->map() != isolate->heap()->native_source_string_map());
+ ExternalString* string = ExternalString::cast(object_);
+ int length = string->length();
+ Map* map;
+ int content_size;
+ int allocation_size;
+ const byte* resource;
+ // Find the map and size for the imaginary sequential string.
+ bool internalized = object_->IsInternalizedString();
+ if (object_->IsExternalOneByteString()) {
+ map = internalized ? isolate->heap()->one_byte_internalized_string_map()
+ : isolate->heap()->one_byte_string_map();
+ allocation_size = SeqOneByteString::SizeFor(length);
+ content_size = length * kCharSize;
+ resource = reinterpret_cast<const byte*>(
+ ExternalOneByteString::cast(string)->resource()->data());
+ } else {
+ map = internalized ? isolate->heap()->internalized_string_map()
+ : isolate->heap()->string_map();
+ allocation_size = SeqTwoByteString::SizeFor(length);
+ content_size = length * kShortSize;
+ resource = reinterpret_cast<const byte*>(
+ ExternalTwoByteString::cast(string)->resource()->data());
+ }
+
+ AllocationSpace space = (allocation_size > Page::kMaxRegularHeapObjectSize)
+ ? LO_SPACE
+ : OLD_DATA_SPACE;
+ SerializePrologue(space, allocation_size, map);
+
+ // Output the rest of the imaginary string.
+ int bytes_to_output = allocation_size - HeapObject::kHeaderSize;
+
+ // Output raw data header. Do not bother with common raw length cases here.
+ sink_->Put(kRawData, "RawDataForString");
+ sink_->PutInt(bytes_to_output, "length");
+
+ // Serialize string header (except for map).
+ Address string_start = string->address();
+ for (int i = HeapObject::kHeaderSize; i < SeqString::kHeaderSize; i++) {
+ sink_->PutSection(string_start[i], "StringHeader");
+ }
+
+ // Serialize string content.
+ sink_->PutRaw(const_cast<byte*>(resource), content_size, "StringContent");
+
+ // Since the allocation size is rounded up to object alignment, there
+ // maybe left-over bytes that need to be padded.
+ int padding_size = allocation_size - SeqString::kHeaderSize - content_size;
+ DCHECK(0 <= padding_size && padding_size < kObjectAlignment);
+ for (int i = 0; i < padding_size; i++) sink_->PutSection(0, "StringPadding");
+
+ sink_->Put(kSkip, "SkipAfterString");
+ sink_->PutInt(bytes_to_output, "SkipDistance");
+}
+
+
+void Serializer::ObjectSerializer::Serialize() {
+ if (object_->IsExternalString()) {
+ Heap* heap = serializer_->isolate()->heap();
+ if (object_->map() != heap->native_source_string_map()) {
+ // Usually we cannot recreate resources for external strings. To work
+ // around this, external strings are serialized to look like ordinary
+ // sequential strings.
+ // The exception are native source code strings, since we can recreate
+ // their resources. In that case we fall through and leave it to
+ // VisitExternalOneByteString further down.
+ SerializeExternalString();
+ return;
+ }
+ }
+
+ int size = object_->Size();
+ Map* map = object_->map();
+ SerializePrologue(Serializer::SpaceOfObject(object_), size, map);
// Serialize the rest of the object.
CHECK_EQ(0, bytes_processed_so_far_);
bytes_processed_so_far_ = kPointerSize;
- object_->IterateBody(object_->map()->instance_type(), size, this);
+
+ object_->IterateBody(map->instance_type(), size, this);
OutputRawData(object_->address() + size);
}
while (current < end && !(*current)->IsSmi()) {
HeapObject* current_contents = HeapObject::cast(*current);
- int root_index = serializer_->RootIndex(current_contents, kPlain);
- // Repeats are not subject to the write barrier so there are only some
- // objects that can be used in a repeat encoding. These are the early
- // ones in the root array that are never in new space.
- if (current != start &&
- root_index != kInvalidRootIndex &&
- root_index < kRootArrayNumberOfConstantEncodings &&
+ int root_index = serializer_->root_index_map()->Lookup(current_contents);
+ // Repeats are not subject to the write barrier so we can only use
+ // immortal immovable root members. They are never in new space.
+ if (current != start && root_index != RootIndexMap::kInvalidRootIndex &&
+ Heap::RootIsImmortalImmovable(root_index) &&
current_contents == current[-1]) {
DCHECK(!serializer_->isolate()->heap()->InNewSpace(current_contents));
int repeat_count = 1;
kCanReturnSkipInsteadOfSkipping);
HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
Object* object = rinfo->target_object();
- serializer_->SerializeObject(object, how_to_code, kStartOfObject, skip);
+ serializer_->SerializeObject(HeapObject::cast(object), how_to_code,
+ kStartOfObject, skip);
bytes_processed_so_far_ += rinfo->target_address_size();
}
}
}
// One of the strings in the natives cache should match the resource. We
- // can't serialize any other kinds of external strings.
+ // don't expect any other kinds of external strings here.
UNREACHABLE();
}
}
const char* description = code_object_ ? "Code" : "Byte";
- for (int i = 0; i < bytes_to_output; i++) {
- sink_->PutSection(object_start[base + i], description);
- }
+ sink_->PutRaw(object_start + base, bytes_to_output, description);
if (code_object_) delete[] object_start;
}
if (to_skip != 0 && return_skip == kIgnoringReturn) {
}
-int Serializer::SpaceOfObject(HeapObject* object) {
+AllocationSpace Serializer::SpaceOfObject(HeapObject* object) {
for (int i = FIRST_SPACE; i <= LAST_SPACE; i++) {
AllocationSpace s = static_cast<AllocationSpace>(i);
if (object->GetHeap()->InSpace(object, s)) {
DCHECK(i < kNumberOfSpaces);
- return i;
+ return s;
}
}
UNREACHABLE();
- return 0;
+ return FIRST_SPACE;
}
-int Serializer::AllocateLargeObject(int size) {
- fullness_[LO_SPACE] += size;
- return seen_large_objects_index_++;
+BackReference Serializer::AllocateLargeObject(int size) {
+ // Large objects are allocated one-by-one when deserializing. We do not
+ // have to keep track of multiple chunks.
+ large_objects_total_size_ += size;
+ return BackReference::LargeObjectReference(seen_large_objects_index_++);
}
-int Serializer::Allocate(int space, int size) {
+BackReference Serializer::Allocate(AllocationSpace space, int size) {
CHECK(space >= 0 && space < kNumberOfPreallocatedSpaces);
- int allocation_address = fullness_[space];
- fullness_[space] = allocation_address + size;
- return allocation_address;
-}
-
-
-int Serializer::SpaceAreaSize(int space) {
- if (space == CODE_SPACE) {
- return isolate_->memory_allocator()->CodePageAreaSize();
- } else {
- return Page::kPageSize - Page::kObjectStartOffset;
+ DCHECK(size > 0 && size <= static_cast<int>(max_chunk_size(space)));
+ uint32_t new_chunk_size = pending_chunk_[space] + size;
+ if (new_chunk_size > max_chunk_size(space)) {
+ // The new chunk size would not fit onto a single page. Complete the
+ // current chunk and start a new one.
+ completed_chunks_[space].Add(pending_chunk_[space]);
+ pending_chunk_[space] = 0;
+ new_chunk_size = size;
}
+ uint32_t offset = pending_chunk_[space];
+ pending_chunk_[space] = new_chunk_size;
+ return BackReference::Reference(space, completed_chunks_[space].length(),
+ offset);
}
Handle<String> source) {
base::ElapsedTimer timer;
if (FLAG_profile_deserialization) timer.Start();
+ if (FLAG_trace_code_serializer) {
+ PrintF("[Serializing from");
+ Object* script = info->script();
+ if (script->IsScript()) Script::cast(script)->name()->ShortPrint();
+ PrintF("]\n");
+ }
// Serialize code object.
- List<byte> payload;
- ListSnapshotSink list_sink(&payload);
- DebugSnapshotSink debug_sink(&list_sink);
- SnapshotByteSink* sink = FLAG_trace_code_serializer
- ? static_cast<SnapshotByteSink*>(&debug_sink)
- : static_cast<SnapshotByteSink*>(&list_sink);
- CodeSerializer cs(isolate, sink, *source, info->code());
+ SnapshotByteSink sink(info->code()->CodeSize() * 2);
+ CodeSerializer cs(isolate, &sink, *source, info->code());
DisallowHeapAllocation no_gc;
Object** location = Handle<Object>::cast(info).location();
cs.VisitPointer(location);
cs.Pad();
+ cs.FinalizeAllocation();
- SerializedCodeData data(&payload, &cs);
+ for (int i = 0; i < kNumberOfPreallocatedSpaces; i++) {
+ // Fail if any chunk index exceeds the limit.
+ if (cs.FinalAllocationChunks(i).length() > BackReference::kMaxChunkIndex) {
+ return NULL;
+ }
+ }
+
+ SerializedCodeData data(sink.data(), &cs);
ScriptData* script_data = data.GetScriptData();
if (FLAG_profile_deserialization) {
}
-void CodeSerializer::SerializeObject(Object* o, HowToCode how_to_code,
+void CodeSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
WhereToPoint where_to_point, int skip) {
- HeapObject* heap_object = HeapObject::cast(o);
-
- int root_index;
- if ((root_index = RootIndex(heap_object, how_to_code)) != kInvalidRootIndex) {
- PutRoot(root_index, heap_object, how_to_code, where_to_point, skip);
+ int root_index = root_index_map_.Lookup(obj);
+ if (root_index != RootIndexMap::kInvalidRootIndex) {
+ if (FLAG_trace_code_serializer) {
+ PrintF(" Encoding root: %d\n", root_index);
+ }
+ PutRoot(root_index, obj, how_to_code, where_to_point, skip);
return;
}
- if (address_mapper_.IsMapped(heap_object)) {
- SerializeReferenceToPreviousObject(heap_object, how_to_code, where_to_point,
- skip);
+ BackReference back_reference = back_reference_map_.Lookup(obj);
+ if (back_reference.is_valid()) {
+ if (back_reference.is_source()) {
+ DCHECK_EQ(source_, obj);
+ SerializeSourceObject(how_to_code, where_to_point);
+ } else {
+ if (FLAG_trace_code_serializer) {
+ PrintF(" Encoding back reference to: ");
+ obj->ShortPrint();
+ PrintF("\n");
+ }
+ SerializeBackReference(back_reference, how_to_code, where_to_point, skip);
+ }
return;
}
sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
}
- if (heap_object->IsCode()) {
- Code* code_object = Code::cast(heap_object);
+ if (obj->IsCode()) {
+ Code* code_object = Code::cast(obj);
switch (code_object->kind()) {
case Code::OPTIMIZED_FUNCTION: // No optimized code compiled yet.
case Code::HANDLER: // No handlers patched in yet.
case Code::NUMBER_OF_KINDS: // Pseudo enum value.
CHECK(false);
case Code::BUILTIN:
- SerializeBuiltin(code_object, how_to_code, where_to_point);
+ SerializeBuiltin(code_object->builtin_index(), how_to_code,
+ where_to_point);
return;
case Code::STUB:
- SerializeCodeStub(code_object, how_to_code, where_to_point);
+ SerializeCodeStub(code_object->stub_key(), how_to_code, where_to_point);
return;
#define IC_KIND_CASE(KIND) case Code::KIND:
IC_KIND_LIST(IC_KIND_CASE)
#undef IC_KIND_CASE
- SerializeHeapObject(code_object, how_to_code, where_to_point);
+ SerializeIC(code_object, how_to_code, where_to_point);
return;
- // TODO(yangguo): add special handling to canonicalize ICs.
case Code::FUNCTION:
// Only serialize the code for the toplevel function. Replace code
// of included function literals by the lazy compile builtin.
// This is safe, as checked in Compiler::BuildFunctionInfo.
if (code_object != main_code_) {
- Code* lazy = *isolate()->builtins()->CompileLazy();
- SerializeBuiltin(lazy, how_to_code, where_to_point);
+ SerializeBuiltin(Builtins::kCompileLazy, how_to_code, where_to_point);
} else {
- SerializeHeapObject(code_object, how_to_code, where_to_point);
+ code_object->MakeYoung();
+ SerializeGeneric(code_object, how_to_code, where_to_point);
}
return;
}
- }
-
- if (heap_object == source_) {
- SerializeSourceObject(how_to_code, where_to_point);
- return;
+ UNREACHABLE();
}
// Past this point we should not see any (context-specific) maps anymore.
- CHECK(!heap_object->IsMap());
+ CHECK(!obj->IsMap());
// There should be no references to the global object embedded.
- CHECK(!heap_object->IsJSGlobalProxy() && !heap_object->IsGlobalObject());
+ CHECK(!obj->IsJSGlobalProxy() && !obj->IsGlobalObject());
// There should be no hash table embedded. They would require rehashing.
- CHECK(!heap_object->IsHashTable());
+ CHECK(!obj->IsHashTable());
- SerializeHeapObject(heap_object, how_to_code, where_to_point);
+ SerializeGeneric(obj, how_to_code, where_to_point);
}
-void CodeSerializer::SerializeHeapObject(HeapObject* heap_object,
- HowToCode how_to_code,
- WhereToPoint where_to_point) {
- if (heap_object->IsScript()) {
- // The wrapper cache uses a Foreign object to point to a global handle.
- // However, the object visitor expects foreign objects to point to external
- // references. Clear the cache to avoid this issue.
- Script::cast(heap_object)->ClearWrapperCache();
- }
-
+void CodeSerializer::SerializeGeneric(HeapObject* heap_object,
+ HowToCode how_to_code,
+ WhereToPoint where_to_point) {
if (FLAG_trace_code_serializer) {
- PrintF("Encoding heap object: ");
+ PrintF(" Encoding heap object: ");
heap_object->ShortPrint();
PrintF("\n");
}
+ if (heap_object->IsInternalizedString()) num_internalized_strings_++;
+
// Object has not yet been serialized. Serialize it here.
ObjectSerializer serializer(this, heap_object, sink_, how_to_code,
where_to_point);
}
-void CodeSerializer::SerializeBuiltin(Code* builtin, HowToCode how_to_code,
+void CodeSerializer::SerializeBuiltin(int builtin_index, HowToCode how_to_code,
WhereToPoint where_to_point) {
DCHECK((how_to_code == kPlain && where_to_point == kStartOfObject) ||
(how_to_code == kPlain && where_to_point == kInnerPointer) ||
(how_to_code == kFromCode && where_to_point == kInnerPointer));
- int builtin_index = builtin->builtin_index();
DCHECK_LT(builtin_index, Builtins::builtin_count);
DCHECK_LE(0, builtin_index);
if (FLAG_trace_code_serializer) {
- PrintF("Encoding builtin: %s\n",
+ PrintF(" Encoding builtin: %s\n",
isolate()->builtins()->name(builtin_index));
}
}
-void CodeSerializer::SerializeCodeStub(Code* stub, HowToCode how_to_code,
+void CodeSerializer::SerializeCodeStub(uint32_t stub_key, HowToCode how_to_code,
WhereToPoint where_to_point) {
DCHECK((how_to_code == kPlain && where_to_point == kStartOfObject) ||
(how_to_code == kPlain && where_to_point == kInnerPointer) ||
(how_to_code == kFromCode && where_to_point == kInnerPointer));
- uint32_t stub_key = stub->stub_key();
DCHECK(CodeStub::MajorKeyFromKey(stub_key) != CodeStub::NoCache);
+ DCHECK(!CodeStub::GetCode(isolate(), stub_key).is_null());
int index = AddCodeStubKey(stub_key) + kCodeStubsBaseIndex;
if (FLAG_trace_code_serializer) {
- PrintF("Encoding code stub %s as %d\n",
+ PrintF(" Encoding code stub %s as %d\n",
CodeStub::MajorName(CodeStub::MajorKeyFromKey(stub_key), false),
index);
}
}
+void CodeSerializer::SerializeIC(Code* ic, HowToCode how_to_code,
+ WhereToPoint where_to_point) {
+ // The IC may be implemented as a stub.
+ uint32_t stub_key = ic->stub_key();
+ if (stub_key != CodeStub::NoCacheKey()) {
+ if (FLAG_trace_code_serializer) {
+ PrintF(" %s is a code stub\n", Code::Kind2String(ic->kind()));
+ }
+ SerializeCodeStub(stub_key, how_to_code, where_to_point);
+ return;
+ }
+ // The IC may be implemented as builtin. Only real builtins have an
+ // actual builtin_index value attached (otherwise it's just garbage).
+ // Compare to make sure we are really dealing with a builtin.
+ int builtin_index = ic->builtin_index();
+ if (builtin_index < Builtins::builtin_count) {
+ Builtins::Name name = static_cast<Builtins::Name>(builtin_index);
+ Code* builtin = isolate()->builtins()->builtin(name);
+ if (builtin == ic) {
+ if (FLAG_trace_code_serializer) {
+ PrintF(" %s is a builtin\n", Code::Kind2String(ic->kind()));
+ }
+ DCHECK(ic->kind() == Code::KEYED_LOAD_IC ||
+ ic->kind() == Code::KEYED_STORE_IC);
+ SerializeBuiltin(builtin_index, how_to_code, where_to_point);
+ return;
+ }
+ }
+ // The IC may also just be a piece of code kept in the non_monomorphic_cache.
+ // In that case, just serialize as a normal code object.
+ if (FLAG_trace_code_serializer) {
+ PrintF(" %s has no special handling\n", Code::Kind2String(ic->kind()));
+ }
+ DCHECK(ic->kind() == Code::LOAD_IC || ic->kind() == Code::STORE_IC);
+ SerializeGeneric(ic, how_to_code, where_to_point);
+}
+
+
int CodeSerializer::AddCodeStubKey(uint32_t stub_key) {
// TODO(yangguo) Maybe we need a hash table for a faster lookup than O(n^2).
int index = 0;
void CodeSerializer::SerializeSourceObject(HowToCode how_to_code,
WhereToPoint where_to_point) {
- if (FLAG_trace_code_serializer) PrintF("Encoding source object\n");
+ if (FLAG_trace_code_serializer) PrintF(" Encoding source object\n");
DCHECK(how_to_code == kPlain && where_to_point == kStartOfObject);
sink_->Put(kAttachedReference + how_to_code + where_to_point, "Source");
}
-Handle<SharedFunctionInfo> CodeSerializer::Deserialize(Isolate* isolate,
- ScriptData* data,
- Handle<String> source) {
+MaybeHandle<SharedFunctionInfo> CodeSerializer::Deserialize(
+ Isolate* isolate, ScriptData* data, Handle<String> source) {
base::ElapsedTimer timer;
if (FLAG_profile_deserialization) timer.Start();
SerializedCodeData scd(data, *source);
SnapshotByteSource payload(scd.Payload(), scd.PayloadLength());
Deserializer deserializer(&payload);
+
+ // Eagerly expand string table to avoid allocations during deserialization.
+ StringTable::EnsureCapacityForDeserialization(isolate,
+ scd.NumInternalizedStrings());
+
+ // Set reservations.
STATIC_ASSERT(NEW_SPACE == 0);
- for (int i = NEW_SPACE; i < kNumberOfSpaces; i++) {
- deserializer.set_reservation(i, scd.GetReservation(i));
+ int current_space = NEW_SPACE;
+ Vector<const SerializedCodeData::Reservation> res = scd.Reservations();
+ for (const auto& r : res) {
+ deserializer.AddReservation(current_space, r.chunk_size());
+ if (r.is_last_chunk()) current_space++;
}
+ DCHECK_EQ(kNumberOfSpaces, current_space);
// Prepare and register list of attached objects.
Vector<const uint32_t> code_stub_keys = scd.CodeStubKeys();
deserializer.SetAttachedObjects(&attached_objects);
// Deserialize.
- deserializer.DeserializePartial(isolate, &root);
+ deserializer.DeserializePartial(isolate, &root, Deserializer::NULL_ON_OOM);
+ if (root == NULL) {
+ // Deserializing may fail if the reservations cannot be fulfilled.
+ if (FLAG_profile_deserialization) PrintF("[Deserializing failed]\n");
+ return MaybeHandle<SharedFunctionInfo>();
+ }
deserializer.FlushICacheForNewCodeObjects();
}
int length = data->length();
PrintF("[Deserializing from %d bytes took %0.3f ms]\n", length, ms);
}
- return Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(root), isolate);
+ Handle<SharedFunctionInfo> result(SharedFunctionInfo::cast(root), isolate);
+ result->set_deserialized(true);
+
+ if (isolate->logger()->is_logging_code_events() ||
+ isolate->cpu_profiler()->is_profiling()) {
+ String* name = isolate->heap()->empty_string();
+ if (result->script()->IsScript()) {
+ Script* script = Script::cast(result->script());
+ if (script->name()->IsString()) name = String::cast(script->name());
+ }
+ isolate->logger()->CodeCreateEvent(Logger::SCRIPT_TAG, result->code(),
+ *result, NULL, name);
+ }
+
+ return result;
}
-SerializedCodeData::SerializedCodeData(List<byte>* payload, CodeSerializer* cs)
- : owns_script_data_(true) {
+SerializedCodeData::SerializedCodeData(const List<byte>& payload,
+ CodeSerializer* cs)
+ : script_data_(NULL), owns_script_data_(true) {
DisallowHeapAllocation no_gc;
List<uint32_t>* stub_keys = cs->stub_keys();
+ // Gather reservation chunk sizes.
+ List<uint32_t> reservations(SerializerDeserializer::kNumberOfSpaces);
+ STATIC_ASSERT(NEW_SPACE == 0);
+ for (int i = 0; i < SerializerDeserializer::kNumberOfSpaces; i++) {
+ Vector<const uint32_t> chunks = cs->FinalAllocationChunks(i);
+ for (int j = 0; j < chunks.length(); j++) {
+ uint32_t chunk = ChunkSizeBits::encode(chunks[j]) |
+ IsLastChunkBits::encode(j == chunks.length() - 1);
+ reservations.Add(chunk);
+ }
+ }
+
// Calculate sizes.
+ int reservation_size = reservations.length() * kInt32Size;
int num_stub_keys = stub_keys->length();
int stub_keys_size = stub_keys->length() * kInt32Size;
- int data_length = kHeaderSize + stub_keys_size + payload->length();
+ int data_length =
+ kHeaderSize + reservation_size + stub_keys_size + payload.length();
// Allocate backing store and create result data.
byte* data = NewArray<byte>(data_length);
// Set header values.
SetHeaderValue(kCheckSumOffset, CheckSum(cs->source()));
+ SetHeaderValue(kNumInternalizedStringsOffset, cs->num_internalized_strings());
+ SetHeaderValue(kReservationsOffset, reservations.length());
SetHeaderValue(kNumCodeStubKeysOffset, num_stub_keys);
- SetHeaderValue(kPayloadLengthOffset, payload->length());
- STATIC_ASSERT(NEW_SPACE == 0);
- for (int i = 0; i < SerializerDeserializer::kNumberOfSpaces; i++) {
- SetHeaderValue(kReservationsOffset + i, cs->CurrentAllocationAddress(i));
- }
+ SetHeaderValue(kPayloadLengthOffset, payload.length());
+
+ // Copy reservation chunk sizes.
+ CopyBytes(data + kHeaderSize, reinterpret_cast<byte*>(reservations.begin()),
+ reservation_size);
// Copy code stub keys.
- CopyBytes(data + kHeaderSize, reinterpret_cast<byte*>(stub_keys->begin()),
- stub_keys_size);
+ CopyBytes(data + kHeaderSize + reservation_size,
+ reinterpret_cast<byte*>(stub_keys->begin()), stub_keys_size);
// Copy serialized data.
- CopyBytes(data + kHeaderSize + stub_keys_size, payload->begin(),
- static_cast<size_t>(payload->length()));
+ CopyBytes(data + kHeaderSize + reservation_size + stub_keys_size,
+ payload.begin(), static_cast<size_t>(payload.length()));
}
};
+class AddressMapBase {
+ protected:
+ static void SetValue(HashMap::Entry* entry, uint32_t v) {
+ entry->value = reinterpret_cast<void*>(v);
+ }
+
+ static uint32_t GetValue(HashMap::Entry* entry) {
+ return static_cast<uint32_t>(reinterpret_cast<intptr_t>(entry->value));
+ }
+
+ static HashMap::Entry* LookupEntry(HashMap* map, HeapObject* obj,
+ bool insert) {
+ return map->Lookup(Key(obj), Hash(obj), insert);
+ }
+
+ private:
+ static uint32_t Hash(HeapObject* obj) {
+ return static_cast<int32_t>(reinterpret_cast<intptr_t>(obj->address()));
+ }
+
+ static void* Key(HeapObject* obj) {
+ return reinterpret_cast<void*>(obj->address());
+ }
+};
+
+
+class RootIndexMap : public AddressMapBase {
+ public:
+ explicit RootIndexMap(Isolate* isolate);
+
+ ~RootIndexMap() { delete map_; }
+
+ static const int kInvalidRootIndex = -1;
+ int Lookup(HeapObject* obj) {
+ HashMap::Entry* entry = LookupEntry(map_, obj, false);
+ if (entry) return GetValue(entry);
+ return kInvalidRootIndex;
+ }
+
+ private:
+ HashMap* map_;
+
+ DISALLOW_COPY_AND_ASSIGN(RootIndexMap);
+};
+
+
+class BackReference {
+ public:
+ explicit BackReference(uint32_t bitfield) : bitfield_(bitfield) {}
+
+ BackReference() : bitfield_(kInvalidValue) {}
+
+ static BackReference SourceReference() { return BackReference(kSourceValue); }
+
+ static BackReference LargeObjectReference(uint32_t index) {
+ return BackReference(SpaceBits::encode(LO_SPACE) |
+ ChunkOffsetBits::encode(index));
+ }
+
+ static BackReference Reference(AllocationSpace space, uint32_t chunk_index,
+ uint32_t chunk_offset) {
+ DCHECK(IsAligned(chunk_offset, kObjectAlignment));
+ DCHECK_NE(LO_SPACE, space);
+ return BackReference(
+ SpaceBits::encode(space) | ChunkIndexBits::encode(chunk_index) |
+ ChunkOffsetBits::encode(chunk_offset >> kObjectAlignmentBits));
+ }
+
+ bool is_valid() const { return bitfield_ != kInvalidValue; }
+ bool is_source() const { return bitfield_ == kSourceValue; }
+
+ AllocationSpace space() const {
+ DCHECK(is_valid());
+ return SpaceBits::decode(bitfield_);
+ }
+
+ uint32_t chunk_offset() const {
+ DCHECK(is_valid());
+ return ChunkOffsetBits::decode(bitfield_) << kObjectAlignmentBits;
+ }
+
+ uint32_t chunk_index() const {
+ DCHECK(is_valid());
+ return ChunkIndexBits::decode(bitfield_);
+ }
+
+ uint32_t reference() const {
+ DCHECK(is_valid());
+ return bitfield_ & (ChunkOffsetBits::kMask | ChunkIndexBits::kMask);
+ }
+
+ uint32_t bitfield() const { return bitfield_; }
+
+ private:
+ static const uint32_t kInvalidValue = 0xFFFFFFFF;
+ static const uint32_t kSourceValue = 0xFFFFFFFE;
+ static const int kChunkOffsetSize = kPageSizeBits - kObjectAlignmentBits;
+ static const int kChunkIndexSize = 32 - kChunkOffsetSize - kSpaceTagSize;
+
+ public:
+ static const int kMaxChunkIndex = (1 << kChunkIndexSize) - 1;
+
+ private:
+ class ChunkOffsetBits : public BitField<uint32_t, 0, kChunkOffsetSize> {};
+ class ChunkIndexBits
+ : public BitField<uint32_t, ChunkOffsetBits::kNext, kChunkIndexSize> {};
+ class SpaceBits
+ : public BitField<AllocationSpace, ChunkIndexBits::kNext, kSpaceTagSize> {
+ };
+
+ uint32_t bitfield_;
+};
+
+
+// Mapping objects to their location after deserialization.
+// This is used during building, but not at runtime by V8.
+class BackReferenceMap : public AddressMapBase {
+ public:
+ BackReferenceMap()
+ : no_allocation_(), map_(new HashMap(HashMap::PointersMatch)) {}
+
+ ~BackReferenceMap() { delete map_; }
+
+ BackReference Lookup(HeapObject* obj) {
+ HashMap::Entry* entry = LookupEntry(map_, obj, false);
+ return entry ? BackReference(GetValue(entry)) : BackReference();
+ }
+
+ void Add(HeapObject* obj, BackReference b) {
+ DCHECK(b.is_valid());
+ DCHECK_EQ(NULL, LookupEntry(map_, obj, false));
+ HashMap::Entry* entry = LookupEntry(map_, obj, true);
+ SetValue(entry, b.bitfield());
+ }
+
+ void AddSourceString(String* string) {
+ Add(string, BackReference::SourceReference());
+ }
+
+ private:
+ DisallowHeapAllocation no_allocation_;
+ HashMap* map_;
+ DISALLOW_COPY_AND_ASSIGN(BackReferenceMap);
+};
+
+
// The Serializer/Deserializer class is a common superclass for Serializer and
// Deserializer which is used to store common constants and methods used by
// both.
// No reservation for large object space necessary.
static const int kNumberOfPreallocatedSpaces = LO_SPACE;
- static const int kNumberOfSpaces = INVALID_SPACE;
+ static const int kNumberOfSpaces = LAST_SPACE + 1;
protected:
// Where the pointed-to object can be found:
// Deserialize the snapshot into an empty heap.
void Deserialize(Isolate* isolate);
+ enum OnOOM { FATAL_ON_OOM, NULL_ON_OOM };
+
// Deserialize a single object and the objects reachable from it.
- void DeserializePartial(Isolate* isolate, Object** root);
+ // We may want to abort gracefully even if deserialization fails.
+ void DeserializePartial(Isolate* isolate, Object** root,
+ OnOOM on_oom = FATAL_ON_OOM);
- void set_reservation(int space_number, int reservation) {
- DCHECK(space_number >= 0);
- DCHECK(space_number < kNumberOfSpaces);
- reservations_[space_number] = reservation;
+ void AddReservation(int space, uint32_t chunk) {
+ DCHECK(space >= 0);
+ DCHECK(space < kNumberOfSpaces);
+ reservations_[space].Add({chunk, NULL, NULL});
}
void FlushICacheForNewCodeObjects();
UNREACHABLE();
}
+ bool ReserveSpace();
+
// Allocation sites are present in the snapshot, and must be linked into
// a list at deserialization time.
void RelinkAllocationSite(AllocationSite* site);
// of the object we are writing into, or NULL if we are not writing into an
// object, i.e. if we are writing a series of tagged values that are not on
// the heap.
- void ReadChunk(
- Object** start, Object** end, int space, Address object_address);
+ void ReadData(Object** start, Object** end, int space,
+ Address object_address);
void ReadObject(int space_number, Object** write_back);
Address Allocate(int space_index, int size);
Object* ProcessBackRefInSerializedCode(Object* obj);
// This returns the address of an object that has been described in the
- // snapshot as being offset bytes back in a particular space.
- HeapObject* GetAddressFromEnd(int space) {
- int offset = source_->GetInt();
- if (space == LO_SPACE) return deserialized_large_objects_[offset];
- DCHECK(space < kNumberOfPreallocatedSpaces);
- offset <<= kObjectAlignmentBits;
- return HeapObject::FromAddress(high_water_[space] - offset);
+ // snapshot by chunk index and offset.
+ HeapObject* GetBackReferencedObject(int space) {
+ if (space == LO_SPACE) {
+ uint32_t index = source_->GetInt();
+ return deserialized_large_objects_[index];
+ } else {
+ BackReference back_reference(source_->GetInt());
+ DCHECK(space < kNumberOfPreallocatedSpaces);
+ uint32_t chunk_index = back_reference.chunk_index();
+ DCHECK_LE(chunk_index, current_chunk_[space]);
+ uint32_t chunk_offset = back_reference.chunk_offset();
+ return HeapObject::FromAddress(reservations_[space][chunk_index].start +
+ chunk_offset);
+ }
}
// Cached current isolate.
Vector<Handle<Object> >* attached_objects_;
SnapshotByteSource* source_;
- // This is the address of the next object that will be allocated in each
- // space. It is used to calculate the addresses of back-references.
+ // The address of the next object that will be allocated in each space.
+ // Each space has a number of chunks reserved by the GC, with each chunk
+ // fitting into a page. Deserialized objects are allocated into the
+ // current chunk of the target space by bumping up high water mark.
+ Heap::Reservation reservations_[kNumberOfSpaces];
+ uint32_t current_chunk_[kNumberOfPreallocatedSpaces];
Address high_water_[kNumberOfPreallocatedSpaces];
- int reservations_[kNumberOfSpaces];
- static const intptr_t kUninitializedReservation = -1;
-
ExternalReferenceDecoder* external_reference_decoder_;
List<HeapObject*> deserialized_large_objects_;
};
-// Mapping objects to their location after deserialization.
-// This is used during building, but not at runtime by V8.
-class SerializationAddressMapper {
- public:
- SerializationAddressMapper()
- : no_allocation_(),
- serialization_map_(new HashMap(HashMap::PointersMatch)) { }
-
- ~SerializationAddressMapper() {
- delete serialization_map_;
- }
-
- bool IsMapped(HeapObject* obj) {
- return serialization_map_->Lookup(Key(obj), Hash(obj), false) != NULL;
- }
-
- int MappedTo(HeapObject* obj) {
- DCHECK(IsMapped(obj));
- return static_cast<int>(reinterpret_cast<intptr_t>(
- serialization_map_->Lookup(Key(obj), Hash(obj), false)->value));
- }
-
- void AddMapping(HeapObject* obj, int to) {
- DCHECK(!IsMapped(obj));
- HashMap::Entry* entry =
- serialization_map_->Lookup(Key(obj), Hash(obj), true);
- entry->value = Value(to);
- }
-
- private:
- static uint32_t Hash(HeapObject* obj) {
- return static_cast<int32_t>(reinterpret_cast<intptr_t>(obj->address()));
- }
-
- static void* Key(HeapObject* obj) {
- return reinterpret_cast<void*>(obj->address());
- }
-
- static void* Value(int v) {
- return reinterpret_cast<void*>(v);
- }
-
- DisallowHeapAllocation no_allocation_;
- HashMap* serialization_map_;
- DISALLOW_COPY_AND_ASSIGN(SerializationAddressMapper);
-};
-
-
class CodeAddressMap;
// There can be only one serializer per V8 process.
public:
Serializer(Isolate* isolate, SnapshotByteSink* sink);
~Serializer();
- void VisitPointers(Object** start, Object** end);
- // You can call this after serialization to find out how much space was used
- // in each space.
- int CurrentAllocationAddress(int space) const {
- DCHECK(space < kNumberOfSpaces);
- return fullness_[space];
+ virtual void VisitPointers(Object** start, Object** end) OVERRIDE;
+
+ void FinalizeAllocation();
+
+ Vector<const uint32_t> FinalAllocationChunks(int space) const {
+ if (space == LO_SPACE) {
+ return Vector<const uint32_t>(&large_objects_total_size_, 1);
+ } else {
+ DCHECK_EQ(0, pending_chunk_[space]); // No pending chunks.
+ return completed_chunks_[space].ToConstVector();
+ }
}
Isolate* isolate() const { return isolate_; }
- SerializationAddressMapper* address_mapper() { return &address_mapper_; }
- void PutRoot(int index,
- HeapObject* object,
- HowToCode how,
- WhereToPoint where,
- int skip);
+ BackReferenceMap* back_reference_map() { return &back_reference_map_; }
+ RootIndexMap* root_index_map() { return &root_index_map_; }
protected:
- static const int kInvalidRootIndex = -1;
-
- int RootIndex(HeapObject* heap_object, HowToCode from);
- intptr_t root_index_wave_front() { return root_index_wave_front_; }
- void set_root_index_wave_front(intptr_t value) {
- DCHECK(value >= root_index_wave_front_);
- root_index_wave_front_ = value;
- }
-
class ObjectSerializer : public ObjectVisitor {
public:
ObjectSerializer(Serializer* serializer,
}
private:
+ void SerializePrologue(AllocationSpace space, int size, Map* map);
+
enum ReturnSkip { kCanReturnSkipInsteadOfSkipping, kIgnoringReturn };
// This function outputs or skips the raw data between the last pointer and
// up to the current position. It optionally can just return the number of
// bytes to skip instead of performing a skip instruction, in case the skip
// can be merged into the next instruction.
int OutputRawData(Address up_to, ReturnSkip return_skip = kIgnoringReturn);
+ // External strings are serialized in a way to resemble sequential strings.
+ void SerializeExternalString();
Serializer* serializer_;
HeapObject* object_;
bool code_has_been_output_;
};
- virtual void SerializeObject(Object* o,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip) = 0;
- void SerializeReferenceToPreviousObject(HeapObject* heap_object,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip);
+ virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) = 0;
+
+ void PutRoot(int index, HeapObject* object, HowToCode how, WhereToPoint where,
+ int skip);
+
+ void SerializeBackReference(BackReference back_reference,
+ HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip);
void InitializeAllocators();
// This will return the space for an object.
- static int SpaceOfObject(HeapObject* object);
- int AllocateLargeObject(int size);
- int Allocate(int space, int size);
+ static AllocationSpace SpaceOfObject(HeapObject* object);
+ BackReference AllocateLargeObject(int size);
+ BackReference Allocate(AllocationSpace space, int size);
int EncodeExternalReference(Address addr) {
return external_reference_encoder_->Encode(addr);
}
- int SpaceAreaSize(int space);
+ // GetInt reads 4 bytes at once, requiring padding at the end.
+ void Pad();
// Some roots should not be serialized, because their actual value depends on
// absolute addresses and they are reset after deserialization, anyway.
bool ShouldBeSkipped(Object** current);
+ // We may not need the code address map for logging for every instance
+ // of the serializer. Initialize it on demand.
+ void InitializeCodeAddressMap();
+
+ inline uint32_t max_chunk_size(int space) const {
+ DCHECK_LE(0, space);
+ DCHECK_LT(space, kNumberOfSpaces);
+ return max_chunk_size_[space];
+ }
+
Isolate* isolate_;
- // Keep track of the fullness of each space in order to generate
- // relative addresses for back references.
- int fullness_[kNumberOfSpaces];
+
SnapshotByteSink* sink_;
ExternalReferenceEncoder* external_reference_encoder_;
- SerializationAddressMapper address_mapper_;
- intptr_t root_index_wave_front_;
- void Pad();
+ BackReferenceMap back_reference_map_;
+ RootIndexMap root_index_map_;
friend class ObjectSerializer;
friend class Deserializer;
- // We may not need the code address map for logging for every instance
- // of the serializer. Initialize it on demand.
- void InitializeCodeAddressMap();
-
private:
CodeAddressMap* code_address_map_;
+ // Objects from the same space are put into chunks for bulk-allocation
+ // when deserializing. We have to make sure that each chunk fits into a
+ // page. So we track the chunk size in pending_chunk_ of a space, but
+ // when it exceeds a page, we complete the current chunk and start a new one.
+ uint32_t pending_chunk_[kNumberOfPreallocatedSpaces];
+ List<uint32_t> completed_chunks_[kNumberOfPreallocatedSpaces];
+ uint32_t max_chunk_size_[kNumberOfPreallocatedSpaces];
+
// We map serialized large objects to indexes for back-referencing.
- int seen_large_objects_index_;
+ uint32_t large_objects_total_size_;
+ uint32_t seen_large_objects_index_;
+
DISALLOW_COPY_AND_ASSIGN(Serializer);
};
SnapshotByteSink* sink)
: Serializer(isolate, sink),
startup_serializer_(startup_snapshot_serializer) {
- set_root_index_wave_front(Heap::kStrongRootListLength);
InitializeCodeAddressMap();
}
// Serialize the objects reachable from a single object pointer.
void Serialize(Object** o);
- virtual void SerializeObject(Object* o,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip);
+ virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) OVERRIDE;
private:
int PartialSnapshotCacheIndex(HeapObject* o);
class StartupSerializer : public Serializer {
public:
StartupSerializer(Isolate* isolate, SnapshotByteSink* sink)
- : Serializer(isolate, sink) {
+ : Serializer(isolate, sink), root_index_wave_front_(0) {
// Clear the cache of objects used by the partial snapshot. After the
// strong roots have been serialized we can create a partial snapshot
// which will repopulate the cache with objects needed by that partial
isolate->set_serialize_partial_snapshot_cache_length(0);
InitializeCodeAddressMap();
}
+
+ // The StartupSerializer has to serialize the root array, which is slightly
+ // different.
+ virtual void VisitPointers(Object** start, Object** end) OVERRIDE;
+
// Serialize the current state of the heap. The order is:
// 1) Strong references.
// 2) Partial snapshot cache.
// 3) Weak references (e.g. the string table).
virtual void SerializeStrongReferences();
- virtual void SerializeObject(Object* o,
- HowToCode how_to_code,
- WhereToPoint where_to_point,
- int skip);
+ virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) OVERRIDE;
void SerializeWeakReferences();
void Serialize() {
SerializeStrongReferences();
}
private:
+ intptr_t root_index_wave_front_;
DISALLOW_COPY_AND_ASSIGN(StartupSerializer);
};
Handle<SharedFunctionInfo> info,
Handle<String> source);
- static Handle<SharedFunctionInfo> Deserialize(Isolate* isolate,
- ScriptData* data,
- Handle<String> source);
+ MUST_USE_RESULT static MaybeHandle<SharedFunctionInfo> Deserialize(
+ Isolate* isolate, ScriptData* data, Handle<String> source);
static const int kSourceObjectIndex = 0;
static const int kCodeStubsBaseIndex = 1;
- String* source() {
+ String* source() const {
DCHECK(!AllowHeapAllocation::IsAllowed());
return source_;
}
List<uint32_t>* stub_keys() { return &stub_keys_; }
+ int num_internalized_strings() const { return num_internalized_strings_; }
private:
CodeSerializer(Isolate* isolate, SnapshotByteSink* sink, String* source,
Code* main_code)
- : Serializer(isolate, sink), source_(source), main_code_(main_code) {
- set_root_index_wave_front(Heap::kStrongRootListLength);
- InitializeCodeAddressMap();
+ : Serializer(isolate, sink),
+ source_(source),
+ main_code_(main_code),
+ num_internalized_strings_(0) {
+ back_reference_map_.AddSourceString(source);
}
- virtual void SerializeObject(Object* o, HowToCode how_to_code,
- WhereToPoint where_to_point, int skip);
+ virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
+ WhereToPoint where_to_point, int skip) OVERRIDE;
- void SerializeBuiltin(Code* builtin, HowToCode how_to_code,
+ void SerializeBuiltin(int builtin_index, HowToCode how_to_code,
WhereToPoint where_to_point);
- void SerializeCodeStub(Code* stub, HowToCode how_to_code,
+ void SerializeIC(Code* ic, HowToCode how_to_code,
+ WhereToPoint where_to_point);
+ void SerializeCodeStub(uint32_t stub_key, HowToCode how_to_code,
WhereToPoint where_to_point);
void SerializeSourceObject(HowToCode how_to_code,
WhereToPoint where_to_point);
- void SerializeHeapObject(HeapObject* heap_object, HowToCode how_to_code,
- WhereToPoint where_to_point);
+ void SerializeGeneric(HeapObject* heap_object, HowToCode how_to_code,
+ WhereToPoint where_to_point);
int AddCodeStubKey(uint32_t stub_key);
DisallowHeapAllocation no_gc_;
String* source_;
Code* main_code_;
+ int num_internalized_strings_;
List<uint32_t> stub_keys_;
DISALLOW_COPY_AND_ASSIGN(CodeSerializer);
};
}
// Used when producing.
- SerializedCodeData(List<byte>* payload, CodeSerializer* cs);
+ SerializedCodeData(const List<byte>& payload, CodeSerializer* cs);
~SerializedCodeData() {
if (owns_script_data_) delete script_data_;
return result;
}
+ class Reservation {
+ public:
+ uint32_t chunk_size() const { return ChunkSizeBits::decode(reservation); }
+ bool is_last_chunk() const { return IsLastChunkBits::decode(reservation); }
+
+ private:
+ uint32_t reservation;
+
+ DISALLOW_COPY_AND_ASSIGN(Reservation);
+ };
+
+ int NumInternalizedStrings() const {
+ return GetHeaderValue(kNumInternalizedStringsOffset);
+ }
+
+ Vector<const Reservation> Reservations() const {
+ return Vector<const Reservation>(reinterpret_cast<const Reservation*>(
+ script_data_->data() + kHeaderSize),
+ GetHeaderValue(kReservationsOffset));
+ }
+
Vector<const uint32_t> CodeStubKeys() const {
- return Vector<const uint32_t>(
- reinterpret_cast<const uint32_t*>(script_data_->data() + kHeaderSize),
- GetHeaderValue(kNumCodeStubKeysOffset));
+ int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
+ const byte* start = script_data_->data() + kHeaderSize + reservations_size;
+ return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
+ GetHeaderValue(kNumCodeStubKeysOffset));
}
const byte* Payload() const {
+ int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
int code_stubs_size = GetHeaderValue(kNumCodeStubKeysOffset) * kInt32Size;
- return script_data_->data() + kHeaderSize + code_stubs_size;
+ return script_data_->data() + kHeaderSize + reservations_size +
+ code_stubs_size;
}
int PayloadLength() const {
return payload_length;
}
- int GetReservation(int space) const {
- return GetHeaderValue(kReservationsOffset + space);
- }
-
private:
void SetHeaderValue(int offset, int value) {
reinterpret_cast<int*>(const_cast<byte*>(script_data_->data()))[offset] =
// The data header consists of int-sized entries:
// [0] version hash
- // [1] number of code stub keys
- // [2] payload length
- // [3..9] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
+ // [1] number of internalized strings
+ // [2] number of code stub keys
+ // [3] payload length
+ // [4..10] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
static const int kCheckSumOffset = 0;
- static const int kNumCodeStubKeysOffset = 1;
- static const int kPayloadLengthOffset = 2;
- static const int kReservationsOffset = 3;
-
- static const int kHeaderEntries =
- kReservationsOffset + SerializerDeserializer::kNumberOfSpaces;
- static const int kHeaderSize = kHeaderEntries * kIntSize;
+ static const int kNumInternalizedStringsOffset = 1;
+ static const int kReservationsOffset = 2;
+ static const int kNumCodeStubKeysOffset = 3;
+ static const int kPayloadLengthOffset = 4;
+ static const int kHeaderSize = (kPayloadLengthOffset + 1) * kIntSize;
+
+ class ChunkSizeBits : public BitField<uint32_t, 0, 31> {};
+ class IsLastChunkBits : public BitField<bool, 31, 1> {};
// Following the header, we store, in sequential order
// - code stub keys
namespace internal {
void Snapshot::ReserveSpaceForLinkedInSnapshot(Deserializer* deserializer) {
- deserializer->set_reservation(NEW_SPACE, new_space_used_);
- deserializer->set_reservation(OLD_POINTER_SPACE, pointer_space_used_);
- deserializer->set_reservation(OLD_DATA_SPACE, data_space_used_);
- deserializer->set_reservation(CODE_SPACE, code_space_used_);
- deserializer->set_reservation(MAP_SPACE, map_space_used_);
- deserializer->set_reservation(CELL_SPACE, cell_space_used_);
- deserializer->set_reservation(PROPERTY_CELL_SPACE, property_cell_space_used_);
- deserializer->set_reservation(LO_SPACE, lo_space_used_);
+ deserializer->AddReservation(NEW_SPACE, new_space_used_);
+ deserializer->AddReservation(OLD_POINTER_SPACE, pointer_space_used_);
+ deserializer->AddReservation(OLD_DATA_SPACE, data_space_used_);
+ deserializer->AddReservation(CODE_SPACE, code_space_used_);
+ deserializer->AddReservation(MAP_SPACE, map_space_used_);
+ deserializer->AddReservation(CELL_SPACE, cell_space_used_);
+ deserializer->AddReservation(PROPERTY_CELL_SPACE, property_cell_space_used_);
+ deserializer->AddReservation(LO_SPACE, lo_space_used_);
}
context_raw_size_);
Deserializer deserializer(&source);
Object* root;
- deserializer.set_reservation(NEW_SPACE, context_new_space_used_);
- deserializer.set_reservation(OLD_POINTER_SPACE, context_pointer_space_used_);
- deserializer.set_reservation(OLD_DATA_SPACE, context_data_space_used_);
- deserializer.set_reservation(CODE_SPACE, context_code_space_used_);
- deserializer.set_reservation(MAP_SPACE, context_map_space_used_);
- deserializer.set_reservation(CELL_SPACE, context_cell_space_used_);
- deserializer.set_reservation(PROPERTY_CELL_SPACE,
- context_property_cell_space_used_);
- deserializer.set_reservation(LO_SPACE, context_lo_space_used_);
+ deserializer.AddReservation(NEW_SPACE, context_new_space_used_);
+ deserializer.AddReservation(OLD_POINTER_SPACE, context_pointer_space_used_);
+ deserializer.AddReservation(OLD_DATA_SPACE, context_data_space_used_);
+ deserializer.AddReservation(CODE_SPACE, context_code_space_used_);
+ deserializer.AddReservation(MAP_SPACE, context_map_space_used_);
+ deserializer.AddReservation(CELL_SPACE, context_cell_space_used_);
+ deserializer.AddReservation(PROPERTY_CELL_SPACE,
+ context_property_cell_space_used_);
+ deserializer.AddReservation(LO_SPACE, context_lo_space_used_);
deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsContext());
return Handle<Context>(Context::cast(root));
}
SnapshotByteSource source(snapshot_impl_->data, snapshot_impl_->size);
Deserializer deserializer(&source);
- deserializer.set_reservation(NEW_SPACE, snapshot_impl_->new_space_used);
- deserializer.set_reservation(OLD_POINTER_SPACE,
- snapshot_impl_->pointer_space_used);
- deserializer.set_reservation(OLD_DATA_SPACE,
- snapshot_impl_->data_space_used);
- deserializer.set_reservation(CODE_SPACE, snapshot_impl_->code_space_used);
- deserializer.set_reservation(MAP_SPACE, snapshot_impl_->map_space_used);
- deserializer.set_reservation(CELL_SPACE, snapshot_impl_->cell_space_used);
- deserializer.set_reservation(PROPERTY_CELL_SPACE,
- snapshot_impl_->property_cell_space_used);
- deserializer.set_reservation(LO_SPACE, snapshot_impl_->lo_space_used);
+ deserializer.AddReservation(NEW_SPACE, snapshot_impl_->new_space_used);
+ deserializer.AddReservation(OLD_POINTER_SPACE,
+ snapshot_impl_->pointer_space_used);
+ deserializer.AddReservation(OLD_DATA_SPACE, snapshot_impl_->data_space_used);
+ deserializer.AddReservation(CODE_SPACE, snapshot_impl_->code_space_used);
+ deserializer.AddReservation(MAP_SPACE, snapshot_impl_->map_space_used);
+ deserializer.AddReservation(CELL_SPACE, snapshot_impl_->cell_space_used);
+ deserializer.AddReservation(PROPERTY_CELL_SPACE,
+ snapshot_impl_->property_cell_space_used);
+ deserializer.AddReservation(LO_SPACE, snapshot_impl_->lo_space_used);
bool success = isolate->Init(&deserializer);
if (FLAG_profile_deserialization) {
double ms = timer.Elapsed().InMillisecondsF();
SnapshotByteSource source(snapshot_impl_->context_data,
snapshot_impl_->context_size);
Deserializer deserializer(&source);
- deserializer.set_reservation(NEW_SPACE,
- snapshot_impl_->context_new_space_used);
- deserializer.set_reservation(OLD_POINTER_SPACE,
- snapshot_impl_->context_pointer_space_used);
- deserializer.set_reservation(OLD_DATA_SPACE,
- snapshot_impl_->context_data_space_used);
- deserializer.set_reservation(CODE_SPACE,
- snapshot_impl_->context_code_space_used);
- deserializer.set_reservation(MAP_SPACE,
- snapshot_impl_->context_map_space_used);
- deserializer.set_reservation(CELL_SPACE,
- snapshot_impl_->context_cell_space_used);
- deserializer.set_reservation(PROPERTY_CELL_SPACE,
- snapshot_impl_->
- context_property_cell_space_used);
- deserializer.set_reservation(LO_SPACE, snapshot_impl_->context_lo_space_used);
+ deserializer.AddReservation(NEW_SPACE,
+ snapshot_impl_->context_new_space_used);
+ deserializer.AddReservation(OLD_POINTER_SPACE,
+ snapshot_impl_->context_pointer_space_used);
+ deserializer.AddReservation(OLD_DATA_SPACE,
+ snapshot_impl_->context_data_space_used);
+ deserializer.AddReservation(CODE_SPACE,
+ snapshot_impl_->context_code_space_used);
+ deserializer.AddReservation(MAP_SPACE,
+ snapshot_impl_->context_map_space_used);
+ deserializer.AddReservation(CELL_SPACE,
+ snapshot_impl_->context_cell_space_used);
+ deserializer.AddReservation(PROPERTY_CELL_SPACE,
+ snapshot_impl_->context_property_cell_space_used);
+ deserializer.AddReservation(LO_SPACE, snapshot_impl_->context_lo_space_used);
Object* root;
deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsContext());
snapshot_impl_->context_map_space_used = source.GetInt();
snapshot_impl_->context_cell_space_used = source.GetInt();
snapshot_impl_->context_property_cell_space_used = source.GetInt();
+ snapshot_impl_->context_lo_space_used = source.GetInt();
DCHECK(success);
}
void SnapshotByteSink::PutRaw(byte* data, int number_of_bytes,
const char* description) {
- for (int i = 0; i < number_of_bytes; ++i) {
- Put(data[i], description);
- }
+ data_.AddAll(Vector<byte>(data, number_of_bytes));
}
void SnapshotByteSink::PutBlob(byte* data, int number_of_bytes,
}
}
-
-void DebugSnapshotSink::Put(byte b, const char* description) {
- PrintF("%24s: %x\n", description, b);
- sink_->Put(b, description);
-}
-
} // namespace v8::internal
} // namespace v8
*/
class SnapshotByteSink {
public:
- virtual ~SnapshotByteSink() { }
- virtual void Put(byte b, const char* description) = 0;
- virtual void PutSection(int b, const char* description) {
+ SnapshotByteSink() {}
+ explicit SnapshotByteSink(int initial_size) : data_(initial_size) {}
+
+ ~SnapshotByteSink() {}
+
+ void Put(byte b, const char* description) { data_.Add(b); }
+
+ void PutSection(int b, const char* description) {
DCHECK_LE(b, kMaxUInt8);
Put(static_cast<byte>(b), description);
}
+
void PutInt(uintptr_t integer, const char* description);
void PutRaw(byte* data, int number_of_bytes, const char* description);
void PutBlob(byte* data, int number_of_bytes, const char* description);
- virtual int Position() = 0;
-};
-
+ int Position() { return data_.length(); }
-class DummySnapshotSink : public SnapshotByteSink {
- public:
- DummySnapshotSink() : length_(0) {}
- virtual ~DummySnapshotSink() {}
- virtual void Put(byte b, const char* description) { length_++; }
- virtual int Position() { return length_; }
-
- private:
- int length_;
-};
-
-
-// Wrap a SnapshotByteSink into a DebugSnapshotSink to get debugging output.
-class DebugSnapshotSink : public SnapshotByteSink {
- public:
- explicit DebugSnapshotSink(SnapshotByteSink* chained) : sink_(chained) {}
- virtual void Put(byte b, const char* description) OVERRIDE;
- virtual int Position() OVERRIDE { return sink_->Position(); }
-
- private:
- SnapshotByteSink* sink_;
-};
-
-
-class ListSnapshotSink : public i::SnapshotByteSink {
- public:
- explicit ListSnapshotSink(i::List<byte>* data) : data_(data) {}
- virtual void Put(byte b, const char* description) OVERRIDE {
- data_->Add(b);
- }
- virtual int Position() OVERRIDE { return data_->length(); }
+ const List<byte>& data() const { return data_; }
private:
- i::List<byte>* data_;
+ List<byte> data_;
};
} // namespace v8::internal
%FunctionSetName(StringIteratorIterator, '[Symbol.iterator]');
%AddNamedProperty(StringIterator.prototype, symbolIterator,
StringIteratorIterator, DONT_ENUM);
+ %AddNamedProperty(StringIterator.prototype, symbolToStringTag,
+ "String Iterator", READ_ONLY | DONT_ENUM);
}
SetUpStringIterator();
bool StringStream::Put(String* str, int start, int end) {
- ConsStringIteratorOp op;
- StringCharacterStream stream(str, &op, start);
+ StringCharacterStream stream(str, start);
for (int i = start; i < end && stream.HasMore(); i++) {
uint16_t c = stream.GetNext();
if (c >= 127 || c < 32) {
// ES6 19.1.2.8
function ObjectGetOwnPropertySymbols(obj) {
- if (!IS_SPEC_OBJECT(obj)) {
- throw MakeTypeError("called_on_non_object",
- ["Object.getOwnPropertySymbols"]);
- }
+ obj = ToObject(obj);
// TODO(arv): Proxies use a shared trap for String and Symbol keys.
- return ObjectGetOwnPropertyKeys(obj, true);
+ return ObjectGetOwnPropertyKeys(obj, PROPERTY_ATTRIBUTES_STRING);
}
// "isConcatSpreadable", symbolIsConcatSpreadable,
// "isRegExp", symbolIsRegExp,
"iterator", symbolIterator,
+ // TODO(dslomov, caitp): Currently defined in harmony-tostring.js ---
+ // Move here when shipping
// "toStringTag", symbolToStringTag,
"unscopables", symbolUnscopables
));
));
%AddNamedProperty($Symbol.prototype, "constructor", $Symbol, DONT_ENUM);
+ %AddNamedProperty(
+ $Symbol.prototype, symbolToStringTag, "Symbol", DONT_ENUM | READ_ONLY);
InstallFunctions($Symbol.prototype, DONT_ENUM, $Array(
"toString", SymbolToString,
"valueOf", SymbolValueOf
+++ /dev/null
-include_rules = [
- "+include/libplatform/libplatform.h"
-]
+++ /dev/null
-// 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/test/test-utils.h"
-
-#include "src/isolate-inl.h"
-
-namespace v8 {
-
-// static
-Isolate* TestWithIsolate::isolate_ = NULL;
-
-
-TestWithIsolate::TestWithIsolate()
- : isolate_scope_(isolate()), handle_scope_(isolate()) {}
-
-
-TestWithIsolate::~TestWithIsolate() {}
-
-
-// static
-void TestWithIsolate::SetUpTestCase() {
- Test::SetUpTestCase();
- EXPECT_EQ(NULL, isolate_);
- isolate_ = v8::Isolate::New();
- EXPECT_TRUE(isolate_ != NULL);
-}
-
-
-// static
-void TestWithIsolate::TearDownTestCase() {
- ASSERT_TRUE(isolate_ != NULL);
- isolate_->Dispose();
- isolate_ = NULL;
- Test::TearDownTestCase();
-}
-
-
-TestWithContext::TestWithContext()
- : context_(Context::New(isolate())), context_scope_(context_) {}
-
-
-TestWithContext::~TestWithContext() {}
-
-
-namespace internal {
-
-TestWithIsolate::~TestWithIsolate() {}
-
-
-Factory* TestWithIsolate::factory() const { return isolate()->factory(); }
-
-
-TestWithZone::~TestWithZone() {}
-
-} // namespace internal
-} // namespace v8
+++ /dev/null
-# 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.
-
-{
- 'variables': {
- 'v8_code': 1,
- },
- 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
- 'targets': [
- {
- 'target_name': 'run-all-unittests',
- 'type': 'static_library',
- 'variables': {
- 'optimize': 'max',
- },
- 'dependencies': [
- '../../testing/gmock.gyp:gmock',
- '../../testing/gtest.gyp:gtest',
- '../../tools/gyp/v8.gyp:v8_libplatform',
- ],
- 'include_dirs': [
- '../..',
- ],
- 'sources': [ ### gcmole(all) ###
- 'run-all-unittests.cc',
- 'test-utils.h',
- 'test-utils.cc',
- ],
- 'export_dependent_settings': [
- '../../testing/gmock.gyp:gmock',
- '../../testing/gtest.gyp:gtest',
- ],
- 'conditions': [
- ['component=="shared_library"', {
- # compiler-unittests can't be built against a shared library, so we
- # need to depend on the underlying static target in that case.
- 'conditions': [
- ['v8_use_snapshot=="true"', {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8_snapshot'],
- },
- {
- 'dependencies': [
- '../../tools/gyp/v8.gyp:v8_nosnapshot',
- ],
- }],
- ],
- }, {
- 'dependencies': ['../../tools/gyp/v8.gyp:v8'],
- }],
- ['os_posix == 1', {
- # TODO(svenpanne): This is a temporary work-around to fix the warnings
- # that show up because we use -std=gnu++0x instead of -std=c++11.
- 'cflags!': [
- '-pedantic',
- ],
- 'direct_dependent_settings': {
- 'cflags!': [
- '-pedantic',
- ],
- },
- }],
- ['want_separate_host_toolset==1', {
- 'toolsets': ['host', 'target'],
- }, {
- 'toolsets': ['target'],
- }],
- ],
- },
- ],
-}
#include "src/v8.h"
#include "src/double.h"
-#include "third_party/fdlibm/fdlibm.h"
+#include "src/third_party/fdlibm/fdlibm.h"
namespace v8 {
}
}
}
- if (ix >= 0x3fe59429) { // |x| > .6744
+ if (ix >= 0x3fe59428) { // |x| > .6744
if (x < 0) {
x = -x;
y = -y;
namespace vTune {
-void InitializeVtuneForV8(v8::Isolate::CreateParams& params);
+v8::JitCodeEventHandler GetVtuneCodeEventHandler();
} // namespace vTune
} // namespace internal
-void InitializeVtuneForV8(v8::Isolate::CreateParams& params) {
+v8::JitCodeEventHandler GetVtuneCodeEventHandler() {
v8::V8::SetFlagsFromString("--nocompact_code_space",
(int)strlen("--nocompact_code_space"));
- params.code_event_handler = vTune::internal::VTUNEJITInterface::event_handler;
+ return vTune::internal::VTUNEJITInterface::event_handler;
}
} // namespace vTune
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/token.h"
namespace v8 {
#define V8_TOKEN_H_
#include "src/base/logging.h"
+#include "src/globals.h"
namespace v8 {
namespace internal {
return token_type[tok] == 'K';
}
+ static bool IsIdentifier(Value tok, StrictMode strict_mode,
+ bool is_generator) {
+ switch (tok) {
+ case IDENTIFIER:
+ return true;
+ case FUTURE_STRICT_RESERVED_WORD:
+ case LET:
+ case STATIC:
+ return strict_mode == SLOPPY;
+ case YIELD:
+ return !is_generator && strict_mode == SLOPPY;
+ default:
+ return false;
+ }
+ UNREACHABLE();
+ return false;
+ }
+
static bool IsAssignmentOp(Value tok) {
return INIT_VAR <= tok && tok <= ASSIGN_MOD;
}
bool TransitionArray::HasElementsTransition() {
- return Search(GetHeap()->elements_transition_symbol()) != kNotFound;
+ return SearchSpecial(GetHeap()->elements_transition_symbol()) != kNotFound;
}
}
-int TransitionArray::Search(Name* name) {
+Object* TransitionArray::GetTargetValue(int transition_number) {
+ Map* map = GetTarget(transition_number);
+ return map->instance_descriptors()->GetValue(map->LastAdded());
+}
+
+
+int TransitionArray::SearchName(Name* name, int* out_insertion_index) {
if (IsSimpleTransition()) {
Name* key = GetKey(kSimpleTransitionIndex);
if (key->Equals(name)) return kSimpleTransitionIndex;
+ if (out_insertion_index != NULL) {
+ *out_insertion_index = key->Hash() > name->Hash() ? 0 : 1;
+ }
return kNotFound;
}
- return internal::Search<ALL_ENTRIES>(this, name);
+ return internal::Search<ALL_ENTRIES>(this, name, 0, out_insertion_index);
+}
+
+
+#ifdef DEBUG
+bool TransitionArray::IsSpecialTransition(Name* name) {
+ if (!name->IsSymbol()) return false;
+ Heap* heap = name->GetHeap();
+ return name == heap->frozen_symbol() ||
+ name == heap->elements_transition_symbol() ||
+ name == heap->observed_symbol();
+}
+#endif
+
+
+int TransitionArray::CompareKeys(Name* key1, uint32_t hash1,
+ bool is_data_property1,
+ PropertyAttributes attributes1, Name* key2,
+ uint32_t hash2, bool is_data_property2,
+ PropertyAttributes attributes2) {
+ int cmp = CompareNames(key1, hash1, key2, hash2);
+ if (cmp != 0) return cmp;
+
+ return CompareDetails(is_data_property1, attributes1, is_data_property2,
+ attributes2);
+}
+
+
+int TransitionArray::CompareNames(Name* key1, uint32_t hash1, Name* key2,
+ uint32_t hash2) {
+ if (key1 != key2) {
+ // In case of hash collisions key1 is always "less" than key2.
+ return hash1 <= hash2 ? -1 : 1;
+ }
+
+ return 0;
+}
+
+
+int TransitionArray::CompareDetails(bool is_data_property1,
+ PropertyAttributes attributes1,
+ bool is_data_property2,
+ PropertyAttributes attributes2) {
+ if (is_data_property1 != is_data_property2) {
+ return static_cast<int>(is_data_property1) <
+ static_cast<int>(is_data_property2)
+ ? -1
+ : 1;
+ }
+
+ if (attributes1 != attributes2) {
+ return static_cast<int>(attributes1) < static_cast<int>(attributes2) ? -1
+ : 1;
+ }
+
+ return 0;
+}
+
+
+PropertyDetails TransitionArray::GetTargetDetails(Name* name, Map* target) {
+ DCHECK(!IsSpecialTransition(name));
+ int descriptor = target->LastAdded();
+ DescriptorArray* descriptors = target->instance_descriptors();
+ // Transitions are allowed only for the last added property.
+ DCHECK(descriptors->GetKey(descriptor)->Equals(name));
+ return descriptors->GetDetails(descriptor);
}
}
+void TransitionArray::SetNumberOfTransitions(int number_of_transitions) {
+ if (IsFullTransitionArray()) {
+ DCHECK(number_of_transitions <= number_of_transitions_storage());
+ WRITE_FIELD(this, kTransitionLengthOffset,
+ Smi::FromInt(number_of_transitions));
+ }
+}
+
+
#undef FIELD_ADDR
#undef WRITE_FIELD
#undef CONDITIONAL_WRITE_BARRIER
Handle<TransitionArray> TransitionArray::Allocate(Isolate* isolate,
- int number_of_transitions) {
- Handle<FixedArray> array =
- isolate->factory()->NewFixedArray(ToKeyIndex(number_of_transitions));
+ int number_of_transitions,
+ int slack) {
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(
+ LengthFor(number_of_transitions + slack));
array->set(kPrototypeTransitionsIndex, Smi::FromInt(0));
+ array->set(kTransitionLengthIndex, Smi::FromInt(number_of_transitions));
return Handle<TransitionArray>::cast(array);
}
}
-static bool InsertionPointFound(Name* key1, Name* key2) {
- return key1->Hash() > key2->Hash();
-}
-
-
Handle<TransitionArray> TransitionArray::NewWith(Handle<Map> map,
Handle<Name> name,
Handle<Map> target,
Handle<TransitionArray> result;
Isolate* isolate = name->GetIsolate();
- if (flag == SIMPLE_TRANSITION) {
+ if (flag == SIMPLE_PROPERTY_TRANSITION) {
result = AllocateSimple(isolate, target);
} else {
result = Allocate(isolate, 1);
if (new_nof != nof) {
DCHECK(new_nof == 0);
result->Shrink(ToKeyIndex(0));
+ result->SetNumberOfTransitions(0);
} else if (nof == 1) {
result->NoIncrementalWriteBarrierCopyFrom(
containing_map->transitions(), kSimpleTransitionIndex, 0);
}
-Handle<TransitionArray> TransitionArray::CopyInsert(Handle<Map> map,
- Handle<Name> name,
- Handle<Map> target,
- SimpleTransitionFlag flag) {
+Handle<TransitionArray> TransitionArray::Insert(Handle<Map> map,
+ Handle<Name> name,
+ Handle<Map> target,
+ SimpleTransitionFlag flag) {
if (!map->HasTransitionArray()) {
return TransitionArray::NewWith(map, name, target, flag);
}
int number_of_transitions = map->transitions()->number_of_transitions();
- int new_size = number_of_transitions;
+ int new_nof = number_of_transitions;
+
+ bool is_special_transition = flag == SPECIAL_TRANSITION;
+ DCHECK_EQ(is_special_transition, IsSpecialTransition(*name));
+ PropertyDetails details = is_special_transition
+ ? PropertyDetails(NONE, NORMAL, 0)
+ : GetTargetDetails(*name, *target);
+
+ int insertion_index = kNotFound;
+ int index =
+ is_special_transition
+ ? map->transitions()->SearchSpecial(Symbol::cast(*name),
+ &insertion_index)
+ : map->transitions()->Search(details.type(), *name,
+ details.attributes(), &insertion_index);
+ if (index == kNotFound) {
+ ++new_nof;
+ } else {
+ insertion_index = index;
+ }
+ DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
+
+ CHECK(new_nof <= kMaxNumberOfTransitions);
- int insertion_index = map->transitions()->Search(*name);
- if (insertion_index == kNotFound) ++new_size;
+ if (new_nof <= map->transitions()->number_of_transitions_storage()) {
+ DisallowHeapAllocation no_gc;
+ TransitionArray* array = map->transitions();
- Handle<TransitionArray> result = Allocate(map->GetIsolate(), new_size);
+ if (index != kNotFound) {
+ array->SetTarget(index, *target);
+ return handle(array);
+ }
+
+ array->SetNumberOfTransitions(new_nof);
+ for (index = number_of_transitions; index > insertion_index; --index) {
+ Name* key = array->GetKey(index - 1);
+ array->SetKey(index, key);
+ array->SetTarget(index, array->GetTarget(index - 1));
+ }
+ array->SetKey(index, *name);
+ array->SetTarget(index, *target);
+ SLOW_DCHECK(array->IsSortedNoDuplicates());
+ return handle(array);
+ }
+
+ Handle<TransitionArray> result = Allocate(
+ map->GetIsolate(), new_nof,
+ Map::SlackForArraySize(number_of_transitions, kMaxNumberOfTransitions));
// The map's transition array may grown smaller during the allocation above as
// it was weakly traversed, though it is guaranteed not to disappear. Trim the
DCHECK(array->number_of_transitions() < number_of_transitions);
number_of_transitions = array->number_of_transitions();
- new_size = number_of_transitions;
-
- insertion_index = array->Search(*name);
- if (insertion_index == kNotFound) ++new_size;
+ new_nof = number_of_transitions;
+
+ insertion_index = kNotFound;
+ index = is_special_transition ? map->transitions()->SearchSpecial(
+ Symbol::cast(*name), &insertion_index)
+ : map->transitions()->Search(
+ details.type(), *name,
+ details.attributes(), &insertion_index);
+ if (index == kNotFound) {
+ ++new_nof;
+ } else {
+ insertion_index = index;
+ }
+ DCHECK(insertion_index >= 0 && insertion_index <= number_of_transitions);
- result->Shrink(ToKeyIndex(new_size));
+ result->Shrink(ToKeyIndex(new_nof));
+ result->SetNumberOfTransitions(new_nof);
}
if (array->HasPrototypeTransitions()) {
result->SetPrototypeTransitions(array->GetPrototypeTransitions());
}
- if (insertion_index != kNotFound) {
- for (int i = 0; i < number_of_transitions; ++i) {
- if (i != insertion_index) {
- result->NoIncrementalWriteBarrierCopyFrom(array, i, i);
- }
- }
- result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
- result->set_back_pointer_storage(array->back_pointer_storage());
- return result;
- }
-
- insertion_index = 0;
- for (; insertion_index < number_of_transitions; ++insertion_index) {
- if (InsertionPointFound(array->GetKey(insertion_index), *name)) break;
- result->NoIncrementalWriteBarrierCopyFrom(
- array, insertion_index, insertion_index);
+ DCHECK_NE(kNotFound, insertion_index);
+ for (int i = 0; i < insertion_index; ++i) {
+ result->NoIncrementalWriteBarrierCopyFrom(array, i, i);
}
-
result->NoIncrementalWriteBarrierSet(insertion_index, *name, *target);
-
- for (; insertion_index < number_of_transitions; ++insertion_index) {
- result->NoIncrementalWriteBarrierCopyFrom(
- array, insertion_index, insertion_index + 1);
+ for (int i = insertion_index; i < number_of_transitions; ++i) {
+ result->NoIncrementalWriteBarrierCopyFrom(array, i, i + 1);
}
result->set_back_pointer_storage(array->back_pointer_storage());
+ SLOW_DCHECK(result->IsSortedNoDuplicates());
return result;
}
+int TransitionArray::SearchDetails(int transition, PropertyType type,
+ PropertyAttributes attributes,
+ int* out_insertion_index) {
+ int nof_transitions = number_of_transitions();
+ DCHECK(transition < nof_transitions);
+ Name* key = GetKey(transition);
+ bool is_data = type == FIELD || type == CONSTANT;
+ for (; transition < nof_transitions && GetKey(transition) == key;
+ transition++) {
+ Map* target = GetTarget(transition);
+ PropertyDetails target_details = GetTargetDetails(key, target);
+
+ bool target_is_data =
+ target_details.type() == FIELD || target_details.type() == CONSTANT;
+
+ int cmp = CompareDetails(is_data, attributes, target_is_data,
+ target_details.attributes());
+ if (cmp == 0) {
+ return transition;
+ } else if (cmp < 0) {
+ break;
+ }
+ }
+ if (out_insertion_index != NULL) *out_insertion_index = transition;
+ return kNotFound;
+}
+
+
+int TransitionArray::Search(PropertyType type, Name* name,
+ PropertyAttributes attributes,
+ int* out_insertion_index) {
+ int transition = SearchName(name, out_insertion_index);
+ if (transition == kNotFound) {
+ return kNotFound;
+ }
+ return SearchDetails(transition, type, attributes, out_insertion_index);
+}
} } // namespace v8::internal
// The full format is:
// [0] Undefined or back pointer map
// [1] Smi(0) or fixed array of prototype transitions
-// [2] First transition
-// [length() - kTransitionSize] Last transition
+// [2] Number of transitions
+// [3] First transition
+// [3 + number of transitions * kTransitionSize]: start of slack
class TransitionArray: public FixedArray {
public:
// Accessors for fetching instance transition at transition number.
inline void SetTarget(int transition_number, Map* target);
inline PropertyDetails GetTargetDetails(int transition_number);
+ inline Object* GetTargetValue(int transition_number);
inline bool HasElementsTransition();
// Returns the number of transitions in the array.
int number_of_transitions() {
if (IsSimpleTransition()) return 1;
- int len = length();
- return len <= kFirstIndex ? 0 : (len - kFirstIndex) / kTransitionSize;
+ if (length() <= kFirstIndex) return 0;
+ return Smi::cast(get(kTransitionLengthIndex))->value();
}
+ int number_of_transitions_storage() {
+ if (IsSimpleTransition()) return 1;
+ if (length() <= kFirstIndex) return 0;
+ return (length() - kFirstIndex) / kTransitionSize;
+ }
+
+ int NumberOfSlackTransitions() {
+ return number_of_transitions_storage() - number_of_transitions();
+ }
+
+ inline void SetNumberOfTransitions(int number_of_transitions);
inline int number_of_entries() { return number_of_transitions(); }
// Creates a FullTransitionArray from a SimpleTransitionArray in
static Handle<TransitionArray> ExtendToFullTransitionArray(
Handle<Map> containing_map);
- // Create a transition array, copying from the owning map if it already has
- // one, otherwise creating a new one according to flag.
+ // Return a transition array, using the array from the owning map if it
+ // already has one (copying into a larger array if necessary), otherwise
+ // creating a new one according to flag.
// TODO(verwaest): This should not cause an existing transition to be
// overwritten.
- static Handle<TransitionArray> CopyInsert(Handle<Map> map,
- Handle<Name> name,
- Handle<Map> target,
- SimpleTransitionFlag flag);
+ static Handle<TransitionArray> Insert(Handle<Map> map, Handle<Name> name,
+ Handle<Map> target,
+ SimpleTransitionFlag flag);
+ // Search a transition for a given type, property name and attributes.
+ int Search(PropertyType type, Name* name, PropertyAttributes attributes,
+ int* out_insertion_index = NULL);
+
+ // Search a non-property transition (like elements kind, observe or frozen
+ // transitions).
+ inline int SearchSpecial(Symbol* symbol, int* out_insertion_index = NULL) {
+ return SearchName(symbol, out_insertion_index);
+ }
- // Search a transition for a given property name.
- inline int Search(Name* name);
+ static inline PropertyDetails GetTargetDetails(Name* name, Map* target);
// Allocates a TransitionArray.
- static Handle<TransitionArray> Allocate(
- Isolate* isolate, int number_of_transitions);
+ static Handle<TransitionArray> Allocate(Isolate* isolate,
+ int number_of_transitions,
+ int slack = 0);
bool IsSimpleTransition() {
return length() == kSimpleTransitionSize &&
// Layout for full transition arrays.
static const int kPrototypeTransitionsIndex = 1;
- static const int kFirstIndex = 2;
+ static const int kTransitionLengthIndex = 2;
+ static const int kFirstIndex = 3;
// Layout for simple transition arrays.
static const int kSimpleTransitionTarget = 1;
// Layout for the full transition array header.
static const int kPrototypeTransitionsOffset = kBackPointerStorageOffset +
kPointerSize;
+ static const int kTransitionLengthOffset =
+ kPrototypeTransitionsOffset + kPointerSize;
// Layout of map transition entries in full transition arrays.
static const int kTransitionKey = 0;
static const int kTransitionSize = 2;
#ifdef OBJECT_PRINT
+ // For our gdb macros, we should perhaps change these in the future.
+ void Print();
+
// Print all the transitions.
- void PrintTransitions(OStream& os); // NOLINT
+ void PrintTransitions(std::ostream& os, bool print_header = true); // NOLINT
#endif
#ifdef DEBUG
bool IsSortedNoDuplicates(int valid_entries = -1);
bool IsConsistentWithBackPointers(Map* current_map);
bool IsEqualTo(TransitionArray* other);
+
+ // Returns true for a non-property transitions like elements kind, observed
+ // or frozen transitions.
+ static inline bool IsSpecialTransition(Name* name);
#endif
// The maximum number of transitions we want in a transition array (should
// fit in a page).
static const int kMaxNumberOfTransitions = 1024 + 512;
+ // Returns the fixed array length required to hold number_of_transitions
+ // transitions.
+ static int LengthFor(int number_of_transitions) {
+ return ToKeyIndex(number_of_transitions);
+ }
+
private:
// Conversion from transition number to array indices.
static int ToKeyIndex(int transition_number) {
Handle<Map> target,
SimpleTransitionFlag flag);
+ // Search a first transition for a given property name.
+ inline int SearchName(Name* name, int* out_insertion_index = NULL);
+ int SearchDetails(int transition, PropertyType type,
+ PropertyAttributes attributes, int* out_insertion_index);
+
+ // Compares two tuples <key, is_data_property, attributes>, returns -1 if
+ // tuple1 is "less" than tuple2, 0 if tuple1 equal to tuple2 and 1 otherwise.
+ static inline int CompareKeys(Name* key1, uint32_t hash1,
+ bool is_data_property1,
+ PropertyAttributes attributes1, Name* key2,
+ uint32_t hash2, bool is_data_property2,
+ PropertyAttributes attributes2);
+
+ // Compares keys, returns -1 if key1 is "less" than key2,
+ // 0 if key1 equal to key2 and 1 otherwise.
+ static inline int CompareNames(Name* key1, uint32_t hash1, Name* key2,
+ uint32_t hash2);
+
+ // Compares two details, returns -1 if details1 is "less" than details2,
+ // 0 if details1 equal to details2 and 1 otherwise.
+ static inline int CompareDetails(bool is_data_property1,
+ PropertyAttributes attributes1,
+ bool is_data_property2,
+ PropertyAttributes attributes2);
+
inline void NoIncrementalWriteBarrierSet(int transition_number,
Name* key,
Map* target);
namespace v8 {
namespace internal {
+int TypeFeedbackVector::ic_metadata_length() const {
+ return FLAG_vector_ics ? VectorICComputer::word_count(ICSlots()) : 0;
+}
+
+
Handle<Object> TypeFeedbackVector::UninitializedSentinel(Isolate* isolate) {
return isolate->factory()->uninitialized_symbol();
}
Handle<Object> TypeFeedbackVector::PremonomorphicSentinel(Isolate* isolate) {
- return isolate->factory()->megamorphic_symbol();
+ return isolate->factory()->premonomorphic_symbol();
}
#include "src/v8.h"
+#include "src/ic/ic.h"
+#include "src/ic/ic-state.h"
#include "src/objects.h"
#include "src/type-feedback-vector-inl.h"
namespace internal {
// static
+TypeFeedbackVector::VectorICKind TypeFeedbackVector::FromCodeKind(
+ Code::Kind kind) {
+ switch (kind) {
+ case Code::CALL_IC:
+ return KindCallIC;
+ case Code::LOAD_IC:
+ return KindLoadIC;
+ case Code::KEYED_LOAD_IC:
+ return KindKeyedLoadIC;
+ default:
+ // Shouldn't get here.
+ UNREACHABLE();
+ }
+
+ return KindUnused;
+}
+
+
+// static
+Code::Kind TypeFeedbackVector::FromVectorICKind(VectorICKind kind) {
+ switch (kind) {
+ case KindCallIC:
+ return Code::CALL_IC;
+ case KindLoadIC:
+ return Code::LOAD_IC;
+ case KindKeyedLoadIC:
+ return Code::KEYED_LOAD_IC;
+ case KindUnused:
+ break;
+ }
+ // Sentinel for no information.
+ return Code::NUMBER_OF_KINDS;
+}
+
+
+Code::Kind TypeFeedbackVector::GetKind(FeedbackVectorICSlot slot) const {
+ if (!FLAG_vector_ics) {
+ // We only have CALL_ICs
+ return Code::CALL_IC;
+ }
+
+ int index = VectorICComputer::index(kReservedIndexCount, slot.ToInt());
+ int data = Smi::cast(get(index))->value();
+ VectorICKind b = VectorICComputer::decode(data, slot.ToInt());
+ return FromVectorICKind(b);
+}
+
+
+void TypeFeedbackVector::SetKind(FeedbackVectorICSlot slot, Code::Kind kind) {
+ if (!FLAG_vector_ics) {
+ // Nothing to do if we only have CALL_ICs
+ return;
+ }
+
+ VectorICKind b = FromCodeKind(kind);
+ int index = VectorICComputer::index(kReservedIndexCount, slot.ToInt());
+ int data = Smi::cast(get(index))->value();
+ int new_data = VectorICComputer::encode(data, slot.ToInt(), b);
+ set(index, Smi::FromInt(new_data));
+}
+
+
+// static
+Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(Isolate* isolate,
+ int slot_count,
+ int ic_slot_count) {
+ int index_count =
+ FLAG_vector_ics ? VectorICComputer::word_count(ic_slot_count) : 0;
+ int length = slot_count + ic_slot_count + index_count + kReservedIndexCount;
+ if (length == kReservedIndexCount) {
+ return Handle<TypeFeedbackVector>::cast(
+ isolate->factory()->empty_fixed_array());
+ }
+
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(length, TENURED);
+ if (ic_slot_count > 0) {
+ array->set(kFirstICSlotIndex,
+ Smi::FromInt(slot_count + index_count + kReservedIndexCount));
+ } else {
+ array->set(kFirstICSlotIndex, Smi::FromInt(length));
+ }
+ array->set(kWithTypesIndex, Smi::FromInt(0));
+ array->set(kGenericCountIndex, Smi::FromInt(0));
+ // Fill the indexes with zeros.
+ for (int i = 0; i < index_count; i++) {
+ array->set(kReservedIndexCount + i, Smi::FromInt(0));
+ }
+
+ // Ensure we can skip the write barrier
+ Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
+ DCHECK_EQ(isolate->heap()->uninitialized_symbol(), *uninitialized_sentinel);
+ for (int i = kReservedIndexCount + index_count; i < length; i++) {
+ array->set(i, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
+ }
+ return Handle<TypeFeedbackVector>::cast(array);
+}
+
+
+// static
Handle<TypeFeedbackVector> TypeFeedbackVector::Copy(
Isolate* isolate, Handle<TypeFeedbackVector> vector) {
Handle<TypeFeedbackVector> result;
isolate->factory()->CopyFixedArray(Handle<FixedArray>::cast(vector)));
return result;
}
+
+
+void TypeFeedbackVector::ClearSlots(SharedFunctionInfo* shared) {
+ int slots = Slots();
+ Isolate* isolate = GetIsolate();
+ Object* uninitialized_sentinel =
+ TypeFeedbackVector::RawUninitializedSentinel(isolate->heap());
+
+ for (int i = 0; i < slots; i++) {
+ FeedbackVectorSlot slot(i);
+ Object* obj = Get(slot);
+ if (obj->IsHeapObject()) {
+ InstanceType instance_type =
+ HeapObject::cast(obj)->map()->instance_type();
+ // AllocationSites are exempt from clearing. They don't store Maps
+ // or Code pointers which can cause memory leaks if not cleared
+ // regularly.
+ if (instance_type != ALLOCATION_SITE_TYPE) {
+ Set(slot, uninitialized_sentinel, SKIP_WRITE_BARRIER);
+ }
+ }
+ }
+
+ slots = ICSlots();
+ if (slots == 0) return;
+
+ // Now clear vector-based ICs. They are all CallICs.
+ // Try and pass the containing code (the "host").
+ Code* host = shared->code();
+ for (int i = 0; i < slots; i++) {
+ FeedbackVectorICSlot slot(i);
+ Object* obj = Get(slot);
+ if (obj != uninitialized_sentinel) {
+ // TODO(mvstanton): To make this code work with --vector-ics,
+ // additional Nexus types must be created.
+ DCHECK(!FLAG_vector_ics);
+ DCHECK(GetKind(slot) == Code::CALL_IC);
+ CallICNexus nexus(this, slot);
+ ICUtility::Clear(isolate, Code::CALL_IC, host, &nexus);
+ }
+ }
+}
+
+
+Handle<FixedArray> FeedbackNexus::EnsureArrayOfSize(int length) {
+ Isolate* isolate = GetIsolate();
+ Handle<Object> feedback = handle(GetFeedback(), isolate);
+ if (!feedback->IsFixedArray() ||
+ FixedArray::cast(*feedback)->length() != length) {
+ Handle<FixedArray> array = isolate->factory()->NewFixedArray(length);
+ SetFeedback(*array);
+ return array;
+ }
+ return Handle<FixedArray>::cast(feedback);
+}
+
+
+void FeedbackNexus::InstallHandlers(int start_index, TypeHandleList* types,
+ CodeHandleList* handlers) {
+ Isolate* isolate = GetIsolate();
+ FixedArray* array = FixedArray::cast(GetFeedback());
+ int receiver_count = types->length();
+ for (int current = 0; current < receiver_count; ++current) {
+ Handle<HeapType> type = types->at(current);
+ Handle<Map> map = IC::TypeToMap(*type, isolate);
+ array->set(start_index + (current * 2), *map);
+ array->set(start_index + (current * 2 + 1), *handlers->at(current));
+ }
+}
+
+
+InlineCacheState CallICNexus::StateFromFeedback() const {
+ Isolate* isolate = GetIsolate();
+ InlineCacheState state = UNINITIALIZED;
+ Object* feedback = GetFeedback();
+
+ if (feedback == *vector()->MegamorphicSentinel(isolate)) {
+ state = GENERIC;
+ } else if (feedback->IsAllocationSite() || feedback->IsJSFunction()) {
+ state = MONOMORPHIC;
+ } else {
+ CHECK(feedback == *vector()->UninitializedSentinel(isolate));
+ }
+
+ return state;
+}
+
+
+void CallICNexus::ConfigureGeneric() {
+ SetFeedback(*vector()->MegamorphicSentinel(GetIsolate()), SKIP_WRITE_BARRIER);
+}
+
+
+void CallICNexus::ConfigureMonomorphicArray() {
+ Object* feedback = GetFeedback();
+ if (!feedback->IsAllocationSite()) {
+ Handle<AllocationSite> new_site =
+ GetIsolate()->factory()->NewAllocationSite();
+ SetFeedback(*new_site);
+ }
+}
+
+
+void CallICNexus::ConfigureUninitialized() {
+ SetFeedback(*vector()->UninitializedSentinel(GetIsolate()),
+ SKIP_WRITE_BARRIER);
+}
+
+
+void CallICNexus::ConfigureMonomorphic(Handle<JSFunction> function) {
+ SetFeedback(*function);
+}
+
+
+int FeedbackNexus::ExtractMaps(int start_index, MapHandleList* maps) const {
+ Isolate* isolate = GetIsolate();
+ Object* feedback = GetFeedback();
+ if (feedback->IsFixedArray()) {
+ FixedArray* array = FixedArray::cast(feedback);
+ // The array should be of the form [<optional name>], then
+ // [map, handler, map, handler, ... ]
+ DCHECK(array->length() >= (2 + start_index));
+ for (int i = start_index; i < array->length(); i += 2) {
+ Map* map = Map::cast(array->get(i));
+ maps->Add(handle(map, isolate));
+ }
+ return (array->length() - start_index) / 2;
+ }
+
+ return 0;
+}
+
+
+MaybeHandle<Code> FeedbackNexus::FindHandlerForMap(int start_index,
+ Handle<Map> map) const {
+ Object* feedback = GetFeedback();
+ if (feedback->IsFixedArray()) {
+ FixedArray* array = FixedArray::cast(feedback);
+ for (int i = start_index; i < array->length(); i += 2) {
+ Map* array_map = Map::cast(array->get(i));
+ if (array_map == *map) {
+ Code* code = Code::cast(array->get(i + 1));
+ DCHECK(code->kind() == Code::HANDLER);
+ return handle(code);
+ }
+ }
+ }
+
+ return MaybeHandle<Code>();
+}
+
+
+bool FeedbackNexus::FindHandlers(int start_index, CodeHandleList* code_list,
+ int length) const {
+ Object* feedback = GetFeedback();
+ int count = 0;
+ if (feedback->IsFixedArray()) {
+ FixedArray* array = FixedArray::cast(feedback);
+ // The array should be of the form [<optional name>], then
+ // [map, handler, map, handler, ... ]
+ DCHECK(array->length() >= (2 + start_index));
+ for (int i = start_index; i < array->length(); i += 2) {
+ Code* code = Code::cast(array->get(i + 1));
+ DCHECK(code->kind() == Code::HANDLER);
+ code_list->Add(handle(code));
+ count++;
+ }
+ }
+ return count == length;
+}
}
} // namespace v8::internal
namespace v8 {
namespace internal {
+// The shape of the TypeFeedbackVector is an array with:
+// 0: first_ic_slot_index (== length() if no ic slots are present)
+// 1: ics_with_types
+// 2: ics_with_generic_info
+// 3: type information for ic slots, if any
+// ...
+// N: first feedback slot (N >= 3)
+// ...
+// [<first_ic_slot_index>: feedback slot]
+// ...to length() - 1
+//
class TypeFeedbackVector : public FixedArray {
public:
// Casting.
return reinterpret_cast<TypeFeedbackVector*>(obj);
}
+ static const int kReservedIndexCount = 3;
+ static const int kFirstICSlotIndex = 0;
+ static const int kWithTypesIndex = 1;
+ static const int kGenericCountIndex = 2;
+
+ int first_ic_slot_index() const {
+ DCHECK(length() >= kReservedIndexCount);
+ return Smi::cast(get(kFirstICSlotIndex))->value();
+ }
+
+ int ic_with_type_info_count() {
+ return length() > 0 ? Smi::cast(get(kWithTypesIndex))->value() : 0;
+ }
+
+ void change_ic_with_type_info_count(int delta) {
+ if (delta == 0) return;
+ int value = ic_with_type_info_count() + delta;
+ // Could go negative because of the debugger.
+ if (value >= 0) {
+ set(kWithTypesIndex, Smi::FromInt(value));
+ }
+ }
+
+ int ic_generic_count() {
+ return length() > 0 ? Smi::cast(get(kGenericCountIndex))->value() : 0;
+ }
+
+ void change_ic_generic_count(int delta) {
+ if (delta == 0) return;
+ int value = ic_generic_count() + delta;
+ if (value >= 0) {
+ set(kGenericCountIndex, Smi::FromInt(value));
+ }
+ }
+
+ inline int ic_metadata_length() const;
+
+ int Slots() const {
+ if (length() == 0) return 0;
+ return Max(
+ 0, first_ic_slot_index() - ic_metadata_length() - kReservedIndexCount);
+ }
+
+ int ICSlots() const {
+ if (length() == 0) return 0;
+ return length() - first_ic_slot_index();
+ }
+
+ // Conversion from a slot or ic slot to an integer index to the underlying
+ // array.
+ int GetIndex(FeedbackVectorSlot slot) const {
+ return kReservedIndexCount + ic_metadata_length() + slot.ToInt();
+ }
+
+ int GetIndex(FeedbackVectorICSlot slot) const {
+ int first_ic_slot = first_ic_slot_index();
+ DCHECK(slot.ToInt() < ICSlots());
+ return first_ic_slot + slot.ToInt();
+ }
+
+ // Conversion from an integer index to either a slot or an ic slot. The caller
+ // should know what kind she expects.
+ FeedbackVectorSlot ToSlot(int index) const {
+ DCHECK(index >= kReservedIndexCount && index < first_ic_slot_index());
+ return FeedbackVectorSlot(index - ic_metadata_length() -
+ kReservedIndexCount);
+ }
+
+ FeedbackVectorICSlot ToICSlot(int index) const {
+ DCHECK(index >= first_ic_slot_index() && index < length());
+ return FeedbackVectorICSlot(index - first_ic_slot_index());
+ }
+
+ Object* Get(FeedbackVectorSlot slot) const { return get(GetIndex(slot)); }
+ void Set(FeedbackVectorSlot slot, Object* value,
+ WriteBarrierMode mode = UPDATE_WRITE_BARRIER) {
+ set(GetIndex(slot), value, mode);
+ }
+
+ Object* Get(FeedbackVectorICSlot slot) const { return get(GetIndex(slot)); }
+ void Set(FeedbackVectorICSlot slot, Object* value,
+ WriteBarrierMode mode = UPDATE_WRITE_BARRIER) {
+ set(GetIndex(slot), value, mode);
+ }
+
+ // IC slots need metadata to recognize the type of IC. Set a Kind for every
+ // slot. If GetKind() returns Code::NUMBER_OF_KINDS, then there is
+ // no kind associated with this slot. This may happen in the current design
+ // if a decision is made at compile time not to emit an IC that was planned
+ // for at parse time. This can be eliminated if we encode kind at parse
+ // time.
+ Code::Kind GetKind(FeedbackVectorICSlot slot) const;
+ void SetKind(FeedbackVectorICSlot slot, Code::Kind kind);
+
+ static Handle<TypeFeedbackVector> Allocate(Isolate* isolate, int slot_count,
+ int ic_slot_count);
+
static Handle<TypeFeedbackVector> Copy(Isolate* isolate,
Handle<TypeFeedbackVector> vector);
+ // Clears the vector slots and the vector ic slots.
+ void ClearSlots(SharedFunctionInfo* shared);
+
// The object that indicates an uninitialized cache.
static inline Handle<Object> UninitializedSentinel(Isolate* isolate);
static inline Object* RawUninitializedSentinel(Heap* heap);
private:
+ enum VectorICKind {
+ KindUnused = 0x0,
+ KindCallIC = 0x1,
+ KindLoadIC = 0x2,
+ KindKeyedLoadIC = 0x3
+ };
+
+ static const int kVectorICKindBits = 2;
+ static VectorICKind FromCodeKind(Code::Kind kind);
+ static Code::Kind FromVectorICKind(VectorICKind kind);
+ typedef BitSetComputer<VectorICKind, kVectorICKindBits, kSmiValueSize,
+ uint32_t> VectorICComputer;
+
DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackVector);
};
+
+
+// A FeedbackNexus is the combination of a TypeFeedbackVector and a slot.
+// Derived classes customize the update and retrieval of feedback.
+class FeedbackNexus {
+ public:
+ FeedbackNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
+ : vector_handle_(vector), vector_(NULL), slot_(slot) {}
+ FeedbackNexus(TypeFeedbackVector* vector, FeedbackVectorICSlot slot)
+ : vector_(vector), slot_(slot) {}
+ virtual ~FeedbackNexus() {}
+
+ Handle<TypeFeedbackVector> vector_handle() const {
+ DCHECK(vector_ == NULL);
+ return vector_handle_;
+ }
+ TypeFeedbackVector* vector() const {
+ return vector_handle_.is_null() ? vector_ : *vector_handle_;
+ }
+ FeedbackVectorICSlot slot() const { return slot_; }
+
+ InlineCacheState ic_state() const { return StateFromFeedback(); }
+ Map* FindFirstMap() const {
+ MapHandleList maps;
+ ExtractMaps(&maps);
+ if (maps.length() > 0) return *maps.at(0);
+ return NULL;
+ }
+
+ virtual InlineCacheState StateFromFeedback() const = 0;
+ virtual int ExtractMaps(MapHandleList* maps) const = 0;
+ virtual MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const = 0;
+ virtual bool FindHandlers(CodeHandleList* code_list, int length = -1) const {
+ return length == 0;
+ }
+ virtual Name* FindFirstName() const { return NULL; }
+
+ Object* GetFeedback() const { return vector()->Get(slot()); }
+
+ protected:
+ Isolate* GetIsolate() const { return vector()->GetIsolate(); }
+
+ void SetFeedback(Object* feedback,
+ WriteBarrierMode mode = UPDATE_WRITE_BARRIER) {
+ vector()->Set(slot(), feedback, mode);
+ }
+
+ Handle<FixedArray> EnsureArrayOfSize(int length);
+ void InstallHandlers(int start_index, TypeHandleList* types,
+ CodeHandleList* handlers);
+ int ExtractMaps(int start_index, MapHandleList* maps) const;
+ MaybeHandle<Code> FindHandlerForMap(int start_index, Handle<Map> map) const;
+ bool FindHandlers(int start_index, CodeHandleList* code_list,
+ int length) const;
+
+ private:
+ // The reason for having a vector handle and a raw pointer is that we can and
+ // should use handles during IC miss, but not during GC when we clear ICs. If
+ // you have a handle to the vector that is better because more operations can
+ // be done, like allocation.
+ Handle<TypeFeedbackVector> vector_handle_;
+ TypeFeedbackVector* vector_;
+ FeedbackVectorICSlot slot_;
+};
+
+
+class CallICNexus : public FeedbackNexus {
+ public:
+ CallICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
+ : FeedbackNexus(vector, slot) {
+ DCHECK(vector->GetKind(slot) == Code::CALL_IC);
+ }
+ CallICNexus(TypeFeedbackVector* vector, FeedbackVectorICSlot slot)
+ : FeedbackNexus(vector, slot) {
+ DCHECK(vector->GetKind(slot) == Code::CALL_IC);
+ }
+
+ void ConfigureUninitialized();
+ void ConfigureGeneric();
+ void ConfigureMonomorphicArray();
+ void ConfigureMonomorphic(Handle<JSFunction> function);
+
+ virtual InlineCacheState StateFromFeedback() const OVERRIDE;
+
+ virtual int ExtractMaps(MapHandleList* maps) const OVERRIDE {
+ // CallICs don't record map feedback.
+ return 0;
+ }
+ virtual MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const OVERRIDE {
+ return MaybeHandle<Code>();
+ }
+ virtual bool FindHandlers(CodeHandleList* code_list,
+ int length = -1) const OVERRIDE {
+ return length == 0;
+ }
+};
}
} // namespace v8::internal
#include "src/compiler.h"
#include "src/ic/ic.h"
#include "src/ic/stub-cache.h"
-#include "src/macro-assembler.h"
#include "src/type-info.h"
-#include "src/objects-inl.h"
-
namespace v8 {
namespace internal {
}
-Handle<Object> TypeFeedbackOracle::GetInfo(int slot) {
- DCHECK(slot >= 0 && slot < feedback_vector_->length());
- Object* obj = feedback_vector_->get(slot);
+Handle<Object> TypeFeedbackOracle::GetInfo(FeedbackVectorSlot slot) {
+ DCHECK(slot.ToInt() >= 0 && slot.ToInt() < feedback_vector_->length());
+ Object* obj = feedback_vector_->Get(slot);
+ if (!obj->IsJSFunction() ||
+ !CanRetainOtherContext(JSFunction::cast(obj), *native_context_)) {
+ return Handle<Object>(obj, isolate());
+ }
+ return Handle<Object>::cast(isolate()->factory()->undefined_value());
+}
+
+
+Handle<Object> TypeFeedbackOracle::GetInfo(FeedbackVectorICSlot slot) {
+ DCHECK(slot.ToInt() >= 0 && slot.ToInt() < feedback_vector_->length());
+ Object* obj = feedback_vector_->Get(slot);
if (!obj->IsJSFunction() ||
!CanRetainOtherContext(JSFunction::cast(obj), *native_context_)) {
return Handle<Object>(obj, isolate());
}
-bool TypeFeedbackOracle::StoreIsKeyedPolymorphic(TypeFeedbackId ast_id) {
- Handle<Object> maybe_code = GetInfo(ast_id);
- if (maybe_code->IsCode()) {
- Handle<Code> code = Handle<Code>::cast(maybe_code);
- return code->is_keyed_store_stub() &&
- code->ic_state() == POLYMORPHIC;
- }
- return false;
-}
-
-
-bool TypeFeedbackOracle::CallIsMonomorphic(int slot) {
+bool TypeFeedbackOracle::CallIsMonomorphic(FeedbackVectorICSlot slot) {
Handle<Object> value = GetInfo(slot);
return value->IsAllocationSite() || value->IsJSFunction();
}
-bool TypeFeedbackOracle::CallNewIsMonomorphic(int slot) {
+bool TypeFeedbackOracle::CallNewIsMonomorphic(FeedbackVectorSlot slot) {
Handle<Object> info = GetInfo(slot);
return FLAG_pretenuring_call_new
? info->IsJSFunction()
}
-byte TypeFeedbackOracle::ForInType(int feedback_vector_slot) {
+byte TypeFeedbackOracle::ForInType(FeedbackVectorSlot feedback_vector_slot) {
Handle<Object> value = GetInfo(feedback_vector_slot);
return value.is_identical_to(
TypeFeedbackVector::UninitializedSentinel(isolate()))
}
-KeyedAccessStoreMode TypeFeedbackOracle::GetStoreMode(
- TypeFeedbackId ast_id) {
+void TypeFeedbackOracle::GetStoreModeAndKeyType(
+ TypeFeedbackId ast_id, KeyedAccessStoreMode* store_mode,
+ IcCheckType* key_type) {
Handle<Object> maybe_code = GetInfo(ast_id);
if (maybe_code->IsCode()) {
Handle<Code> code = Handle<Code>::cast(maybe_code);
if (code->kind() == Code::KEYED_STORE_IC) {
- return KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state());
+ ExtraICState extra_ic_state = code->extra_ic_state();
+ *store_mode = KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state);
+ *key_type = KeyedStoreIC::GetKeyType(extra_ic_state);
+ return;
}
}
- return STANDARD_STORE;
+ *store_mode = STANDARD_STORE;
+ *key_type = ELEMENT;
}
-Handle<JSFunction> TypeFeedbackOracle::GetCallTarget(int slot) {
+Handle<JSFunction> TypeFeedbackOracle::GetCallTarget(
+ FeedbackVectorICSlot slot) {
Handle<Object> info = GetInfo(slot);
if (info->IsAllocationSite()) {
return Handle<JSFunction>(isolate()->native_context()->array_function());
}
-Handle<JSFunction> TypeFeedbackOracle::GetCallNewTarget(int slot) {
+Handle<JSFunction> TypeFeedbackOracle::GetCallNewTarget(
+ FeedbackVectorSlot slot) {
Handle<Object> info = GetInfo(slot);
if (FLAG_pretenuring_call_new || info->IsJSFunction()) {
return Handle<JSFunction>::cast(info);
}
-Handle<AllocationSite> TypeFeedbackOracle::GetCallAllocationSite(int slot) {
+Handle<AllocationSite> TypeFeedbackOracle::GetCallAllocationSite(
+ FeedbackVectorICSlot slot) {
Handle<Object> info = GetInfo(slot);
if (info->IsAllocationSite()) {
return Handle<AllocationSite>::cast(info);
}
-Handle<AllocationSite> TypeFeedbackOracle::GetCallNewAllocationSite(int slot) {
+Handle<AllocationSite> TypeFeedbackOracle::GetCallNewAllocationSite(
+ FeedbackVectorSlot slot) {
Handle<Object> info = GetInfo(slot);
if (FLAG_pretenuring_call_new || info->IsAllocationSite()) {
return Handle<AllocationSite>::cast(info);
void TypeFeedbackOracle::KeyedPropertyReceiverTypes(
TypeFeedbackId id, SmallMapList* receiver_types, bool* is_string) {
receiver_types->Clear();
- *is_string = false;
- if (LoadIsBuiltin(id, Builtins::kKeyedLoadIC_String)) {
- *is_string = true;
- } else {
- CollectReceiverTypes(id, receiver_types);
+ CollectReceiverTypes(id, receiver_types);
+
+ // Are all the receiver maps string maps?
+ bool all_strings = receiver_types->length() > 0;
+ for (int i = 0; i < receiver_types->length(); i++) {
+ all_strings &= receiver_types->at(i)->IsStringMap();
}
+ *is_string = all_strings;
}
void TypeFeedbackOracle::KeyedAssignmentReceiverTypes(
TypeFeedbackId id, SmallMapList* receiver_types,
- KeyedAccessStoreMode* store_mode) {
+ KeyedAccessStoreMode* store_mode, IcCheckType* key_type) {
receiver_types->Clear();
CollectReceiverTypes(id, receiver_types);
- *store_mode = GetStoreMode(id);
+ GetStoreModeAndKeyType(id, store_mode, key_type);
}
bool LoadIsUninitialized(TypeFeedbackId id);
bool StoreIsUninitialized(TypeFeedbackId id);
- bool StoreIsKeyedPolymorphic(TypeFeedbackId id);
- bool CallIsMonomorphic(int slot);
- bool CallIsMonomorphic(TypeFeedbackId aid);
+ bool CallIsMonomorphic(FeedbackVectorICSlot slot);
bool KeyedArrayCallIsHoley(TypeFeedbackId id);
- bool CallNewIsMonomorphic(int slot);
+ bool CallNewIsMonomorphic(FeedbackVectorSlot slot);
// TODO(1571) We can't use ForInStatement::ForInType as the return value due
// to various cycles in our headers.
// TODO(rossberg): once all oracle access is removed from ast.cc, it should
// be possible.
- byte ForInType(int feedback_vector_slot);
+ byte ForInType(FeedbackVectorSlot feedback_vector_slot);
- KeyedAccessStoreMode GetStoreMode(TypeFeedbackId id);
+ void GetStoreModeAndKeyType(TypeFeedbackId id,
+ KeyedAccessStoreMode* store_mode,
+ IcCheckType* key_type);
void PropertyReceiverTypes(TypeFeedbackId id, Handle<String> name,
SmallMapList* receiver_types);
SmallMapList* receiver_types);
void KeyedAssignmentReceiverTypes(TypeFeedbackId id,
SmallMapList* receiver_types,
- KeyedAccessStoreMode* store_mode);
+ KeyedAccessStoreMode* store_mode,
+ IcCheckType* key_type);
void CountReceiverTypes(TypeFeedbackId id,
SmallMapList* receiver_types);
static bool CanRetainOtherContext(JSFunction* function,
Context* native_context);
- Handle<JSFunction> GetCallTarget(int slot);
- Handle<AllocationSite> GetCallAllocationSite(int slot);
- Handle<JSFunction> GetCallNewTarget(int slot);
- Handle<AllocationSite> GetCallNewAllocationSite(int slot);
+ Handle<JSFunction> GetCallTarget(FeedbackVectorICSlot slot);
+ Handle<AllocationSite> GetCallAllocationSite(FeedbackVectorICSlot slot);
+ Handle<JSFunction> GetCallNewTarget(FeedbackVectorSlot slot);
+ Handle<AllocationSite> GetCallNewAllocationSite(FeedbackVectorSlot slot);
bool LoadIsBuiltin(TypeFeedbackId id, Builtins::Name builtin_id);
// Returns an element from the type feedback vector. Returns undefined
// if there is no information.
- Handle<Object> GetInfo(int slot);
+ Handle<Object> GetInfo(FeedbackVectorSlot slot);
+ Handle<Object> GetInfo(FeedbackVectorICSlot slot);
private:
Handle<Context> native_context_;
}
}
+function TypedArrayGetToStringTag() {
+ if (!%IsTypedArray(this)) return;
+ var name = %_ClassOf(this);
+ if (IS_UNDEFINED(name)) return;
+ return name;
+}
+
// -------------------------------------------------------------------
function SetupTypedArrays() {
InstallGetter(global.NAME.prototype, "byteOffset", NAME_GetByteOffset);
InstallGetter(global.NAME.prototype, "byteLength", NAME_GetByteLength);
InstallGetter(global.NAME.prototype, "length", NAME_GetLength);
-
+ InstallGetter(global.NAME.prototype, symbolToStringTag,
+ TypedArrayGetToStringTag);
InstallFunctions(global.NAME.prototype, DONT_ENUM, $Array(
"subarray", NAMESubArray,
"set", TypedArraySet
// Set up constructor property on the DataView prototype.
%AddNamedProperty($DataView.prototype, "constructor", $DataView, DONT_ENUM);
+ %AddNamedProperty(
+ $DataView.prototype, symbolToStringTag, "DataView", READ_ONLY|DONT_ENUM);
InstallGetter($DataView.prototype, "buffer", DataViewGetBufferJS);
InstallGetter($DataView.prototype, "byteOffset", DataViewGetByteOffset);
// static
template<class T>
+T* ZoneTypeConfig::null_handle() {
+ return NULL;
+}
+
+
+// static
+template<class T>
T* ZoneTypeConfig::handle(T* type) {
return type;
}
// static
template<class T>
+i::Handle<T> HeapTypeConfig::null_handle() {
+ return i::Handle<T>();
+}
+
+
+// static
+template<class T>
i::Handle<T> HeapTypeConfig::handle(T* type) {
return i::handle(type, i::HeapObject::cast(type)->GetIsolate());
}
case SHARED_FUNCTION_INFO_TYPE:
case ACCESSOR_PAIR_TYPE:
case FIXED_ARRAY_TYPE:
+ case BYTE_ARRAY_TYPE:
case FOREIGN_TYPE:
case CODE_TYPE:
return kInternal & kTaggedPtr;
DisallowHeapAllocation no_allocation;
if (i::IsMinusZero(value)) return kMinusZero;
if (std::isnan(value)) return kNaN;
- if (IsUint32Double(value)) return Lub(FastD2UI(value));
- if (IsInt32Double(value)) return Lub(FastD2I(value));
+ if (IsUint32Double(value) || IsInt32Double(value)) return Lub(value, value);
return kOtherNumber;
}
-template<class Config>
-typename TypeImpl<Config>::bitset
-TypeImpl<Config>::BitsetType::Lub(int32_t value) {
- DisallowHeapAllocation no_allocation;
- if (value >= 0x40000000) {
- return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall;
- }
- if (value >= 0) return kUnsignedSmall;
- if (value >= -0x40000000) return kOtherSignedSmall;
- return i::SmiValuesAre31Bits() ? kOtherSigned32 : kOtherSignedSmall;
-}
-
-
-template<class Config>
-typename TypeImpl<Config>::bitset
-TypeImpl<Config>::BitsetType::Lub(uint32_t value) {
- DisallowHeapAllocation no_allocation;
- if (value >= 0x80000000u) return kOtherUnsigned32;
- if (value >= 0x40000000u) {
- return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall;
- }
- return kUnsignedSmall;
-}
-
-
// Minimum values of regular numeric bitsets when SmiValuesAre31Bits.
template<class Config>
const typename TypeImpl<Config>::BitsetType::BitsetMin
template<class Config>
typename TypeImpl<Config>::bitset
-TypeImpl<Config>::BitsetType::Lub(Limits lim) {
+TypeImpl<Config>::BitsetType::Lub(double min, double max) {
DisallowHeapAllocation no_allocation;
- double min = lim.min->Number();
- double max = lim.max->Number();
int lub = kNone;
const BitsetMin* mins = BitsetMins();
DisallowHeapAllocation no_allocation;
DCHECK(Is(bits, kNumber));
const BitsetMin* mins = BitsetMins();
- bool mz = bits & kMinusZero;
+ bool mz = SEMANTIC(bits & kMinusZero);
if (BitsetType::Is(mins[BitsetMinsSize()-1].bits, bits)) {
return +V8_INFINITY;
}
Contains(that->AsRange(), *this->AsConstant()->Value()));
}
if (this->IsRange()) return false;
+
return this->SimplyEquals(that);
}
template <class Config>
-void TypeImpl<Config>::BitsetType::Print(OStream& os, // NOLINT
+void TypeImpl<Config>::BitsetType::Print(std::ostream& os, // NOLINT
bitset bits) {
DisallowHeapAllocation no_allocation;
const char* name = Name(bits);
template <class Config>
-void TypeImpl<Config>::PrintTo(OStream& os, PrintDimension dim) { // NOLINT
+void TypeImpl<Config>::PrintTo(std::ostream& os, PrintDimension dim) {
DisallowHeapAllocation no_allocation;
if (dim != REPRESENTATION_DIM) {
if (this->IsBitset()) {
void TypeImpl<Config>::Print() {
OFStream os(stdout);
PrintTo(os);
- os << endl;
+ os << std::endl;
}
template <class Config>
void TypeImpl<Config>::BitsetType::Print(bitset bits) {
OFStream os(stdout);
Print(os, bits);
- os << endl;
+ os << std::endl;
}
#endif
V(Detectable, kDetectableReceiver | kNumber | kName) \
V(Object, kDetectableObject | kUndetectable) \
V(Receiver, kObject | kProxy) \
- V(NonNumber, kBoolean | kName | kNull | kReceiver | \
- kUndefined | kInternal) \
+ V(Unique, kBoolean | kUniqueName | kNull | kUndefined | \
+ kReceiver) \
+ V(NonNumber, kUnique | kString | kInternal) \
V(Any, 0xfffffffeu)
/*
*
* E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1.
*
+ * NOTE: OtherSigned32 (OS32) and OU31 (OtherUnsigned31) are empty if Smis are
+ * 32-bit wide. They should thus never be used directly, only indirectly
+ * via e.g. Number.
*/
#define PROPER_BITSET_TYPE_LIST(V) \
// typedef Struct;
// typedef Region;
// template<class> struct Handle { typedef type; } // No template typedefs...
+// template<class T> static Handle<T>::type null_handle();
// template<class T> static Handle<T>::type handle(T* t); // !is_bitset(t)
// template<class T> static Handle<T>::type cast(Handle<Type>::type);
// static bool is_bitset(Type*);
static TypeHandle Union(TypeHandle type1, TypeHandle type2, Region* reg);
static TypeHandle Intersect(TypeHandle type1, TypeHandle type2, Region* reg);
+ static TypeImpl* Union(TypeImpl* type1, TypeImpl* type2) {
+ return BitsetType::New(type1->AsBitset() | type2->AsBitset());
+ }
+ static TypeImpl* Intersect(TypeImpl* type1, TypeImpl* type2) {
+ return BitsetType::New(type1->AsBitset() & type2->AsBitset());
+ }
static TypeHandle Of(double value, Region* region) {
return Config::from_bitset(BitsetType::Lub(value), region);
enum PrintDimension { BOTH_DIMS, SEMANTIC_DIM, REPRESENTATION_DIM };
- void PrintTo(OStream& os, PrintDimension dim = BOTH_DIMS); // NOLINT
+ void PrintTo(std::ostream& os, PrintDimension dim = BOTH_DIMS); // NOLINT
#ifdef DEBUG
void Print();
static bitset Glb(TypeImpl* type); // greatest lower bound that's a bitset
static bitset Lub(TypeImpl* type); // least upper bound that's a bitset
+ static bitset Lub(i::Map* map);
static bitset Lub(i::Object* value);
static bitset Lub(double value);
- static bitset Lub(int32_t value);
- static bitset Lub(uint32_t value);
- static bitset Lub(i::Map* map);
- static bitset Lub(Limits lim);
+ static bitset Lub(double min, double max);
static const char* Name(bitset);
- static void Print(OStream& os, bitset); // NOLINT
+ static void Print(std::ostream& os, bitset); // NOLINT
#ifdef DEBUG
static void Print(bitset);
#endif
static RangeHandle New(
i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) {
+ DCHECK(IsInteger(min->Number()) && IsInteger(max->Number()));
DCHECK(min->Number() <= max->Number());
RangeHandle type = Config::template cast<RangeType>(
StructuralType::New(StructuralType::kRangeTag, 3, region));
- type->Set(0, BitsetType::New(BitsetType::Lub(Limits(min, max)), region));
+ type->Set(0, BitsetType::New(
+ BitsetType::Lub(min->Number(), max->Number()), region));
type->SetValue(1, min);
type->SetValue(2, max);
return type;
typedef i::Zone Region;
template<class T> struct Handle { typedef T* type; };
+ template<class T> static inline T* null_handle();
template<class T> static inline T* handle(T* type);
template<class T> static inline T* cast(Type* type);
typedef i::Isolate Region;
template<class T> struct Handle { typedef i::Handle<T> type; };
+ template<class T> static inline i::Handle<T> null_handle();
template<class T> static inline i::Handle<T> handle(T* type);
template<class T> static inline i::Handle<T> cast(i::Handle<Type> type);
TypeHandle lower;
TypeHandle upper;
- BoundsImpl() {}
+ BoundsImpl() : // Make sure accessing uninitialized bounds crashes big-time.
+ lower(Config::template null_handle<Type>()),
+ upper(Config::template null_handle<Type>()) {}
explicit BoundsImpl(TypeHandle t) : lower(t), upper(t) {}
BoundsImpl(TypeHandle l, TypeHandle u) : lower(l), upper(u) {
DCHECK(lower->Is(upper));
var->name()->Print(os);
os << " : " << Brief(value) << " -> ";
type->PrintTo(os);
- os << endl;
+ os << std::endl;
}
#endif // OBJECT_PRINT
oracle()->AssignmentReceiverTypes(id, name, expr->GetReceiverTypes());
} else {
KeyedAccessStoreMode store_mode;
- oracle()->KeyedAssignmentReceiverTypes(
- id, expr->GetReceiverTypes(), &store_mode);
+ IcCheckType key_type;
+ oracle()->KeyedAssignmentReceiverTypes(id, expr->GetReceiverTypes(),
+ &store_mode, &key_type);
expr->set_store_mode(store_mode);
+ expr->set_key_type(key_type);
}
}
}
void AstTyper::VisitCountOperation(CountOperation* expr) {
// Collect type feedback.
TypeFeedbackId store_id = expr->CountStoreFeedbackId();
- expr->set_store_mode(oracle()->GetStoreMode(store_id));
+ KeyedAccessStoreMode store_mode;
+ IcCheckType key_type;
+ oracle()->GetStoreModeAndKeyType(store_id, &store_mode, &key_type);
+ expr->set_store_mode(store_mode);
+ expr->set_key_type(key_type);
oracle()->CountReceiverTypes(store_id, expr->GetReceiverTypes());
expr->set_type(oracle()->CountType(expr->CountBinOpFeedbackId()));
// TODO(rossberg): merge the count type with the generic expression type.
var->IsParameter() ? parameter_index(var->index()) : kNoVar;
}
- void VisitDeclarations(ZoneList<Declaration*>* declarations);
- void VisitStatements(ZoneList<Statement*>* statements);
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
--- /dev/null
+// 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/unicode-inl.h"
+#include "src/unicode-decoder.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+namespace unibrow {
+
+void Utf8DecoderBase::Reset(uint16_t* buffer, unsigned buffer_length,
+ const uint8_t* stream, unsigned stream_length) {
+ // Assume everything will fit in the buffer and stream won't be needed.
+ last_byte_of_buffer_unused_ = false;
+ unbuffered_start_ = NULL;
+ bool writing_to_buffer = true;
+ // Loop until stream is read, writing to buffer as long as buffer has space.
+ unsigned utf16_length = 0;
+ while (stream_length != 0) {
+ unsigned cursor = 0;
+ uint32_t character = Utf8::ValueOf(stream, stream_length, &cursor);
+ DCHECK(cursor > 0 && cursor <= stream_length);
+ stream += cursor;
+ stream_length -= cursor;
+ bool is_two_characters = character > Utf16::kMaxNonSurrogateCharCode;
+ utf16_length += is_two_characters ? 2 : 1;
+ // Don't need to write to the buffer, but still need utf16_length.
+ if (!writing_to_buffer) continue;
+ // Write out the characters to the buffer.
+ // Must check for equality with buffer_length as we've already updated it.
+ if (utf16_length <= buffer_length) {
+ if (is_two_characters) {
+ *buffer++ = Utf16::LeadSurrogate(character);
+ *buffer++ = Utf16::TrailSurrogate(character);
+ } else {
+ *buffer++ = character;
+ }
+ if (utf16_length == buffer_length) {
+ // Just wrote last character of buffer
+ writing_to_buffer = false;
+ unbuffered_start_ = stream;
+ }
+ continue;
+ }
+ // Have gone over buffer.
+ // Last char of buffer is unused, set cursor back.
+ DCHECK(is_two_characters);
+ writing_to_buffer = false;
+ last_byte_of_buffer_unused_ = true;
+ unbuffered_start_ = stream - cursor;
+ }
+ utf16_length_ = utf16_length;
+}
+
+
+void Utf8DecoderBase::WriteUtf16Slow(const uint8_t* stream, uint16_t* data,
+ unsigned data_length) {
+ while (data_length != 0) {
+ unsigned cursor = 0;
+ uint32_t character = Utf8::ValueOf(stream, Utf8::kMaxEncodedSize, &cursor);
+ // There's a total lack of bounds checking for stream
+ // as it was already done in Reset.
+ stream += cursor;
+ if (character > unibrow::Utf16::kMaxNonSurrogateCharCode) {
+ *data++ = Utf16::LeadSurrogate(character);
+ *data++ = Utf16::TrailSurrogate(character);
+ DCHECK(data_length > 1);
+ data_length -= 2;
+ } else {
+ *data++ = character;
+ data_length -= 1;
+ }
+ }
+}
+
+} // namespace unibrow
--- /dev/null
+// 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.
+
+#ifndef V8_UNICODE_DECODER_H_
+#define V8_UNICODE_DECODER_H_
+
+#include <sys/types.h>
+#include "src/globals.h"
+
+namespace unibrow {
+
+class Utf8DecoderBase {
+ public:
+ // Initialization done in subclass.
+ inline Utf8DecoderBase();
+ inline Utf8DecoderBase(uint16_t* buffer, unsigned buffer_length,
+ const uint8_t* stream, unsigned stream_length);
+ inline unsigned Utf16Length() const { return utf16_length_; }
+
+ protected:
+ // This reads all characters and sets the utf16_length_.
+ // The first buffer_length utf16 chars are cached in the buffer.
+ void Reset(uint16_t* buffer, unsigned buffer_length, const uint8_t* stream,
+ unsigned stream_length);
+ static void WriteUtf16Slow(const uint8_t* stream, uint16_t* data,
+ unsigned length);
+ const uint8_t* unbuffered_start_;
+ unsigned utf16_length_;
+ bool last_byte_of_buffer_unused_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(Utf8DecoderBase);
+};
+
+template <unsigned kBufferSize>
+class Utf8Decoder : public Utf8DecoderBase {
+ public:
+ inline Utf8Decoder() {}
+ inline Utf8Decoder(const char* stream, unsigned length);
+ inline void Reset(const char* stream, unsigned length);
+ inline unsigned WriteUtf16(uint16_t* data, unsigned length) const;
+
+ private:
+ uint16_t buffer_[kBufferSize];
+};
+
+
+Utf8DecoderBase::Utf8DecoderBase()
+ : unbuffered_start_(NULL),
+ utf16_length_(0),
+ last_byte_of_buffer_unused_(false) {}
+
+
+Utf8DecoderBase::Utf8DecoderBase(uint16_t* buffer, unsigned buffer_length,
+ const uint8_t* stream,
+ unsigned stream_length) {
+ Reset(buffer, buffer_length, stream, stream_length);
+}
+
+
+template <unsigned kBufferSize>
+Utf8Decoder<kBufferSize>::Utf8Decoder(const char* stream, unsigned length)
+ : Utf8DecoderBase(buffer_, kBufferSize,
+ reinterpret_cast<const uint8_t*>(stream), length) {}
+
+
+template <unsigned kBufferSize>
+void Utf8Decoder<kBufferSize>::Reset(const char* stream, unsigned length) {
+ Utf8DecoderBase::Reset(buffer_, kBufferSize,
+ reinterpret_cast<const uint8_t*>(stream), length);
+}
+
+
+template <unsigned kBufferSize>
+unsigned Utf8Decoder<kBufferSize>::WriteUtf16(uint16_t* data,
+ unsigned length) const {
+ DCHECK(length > 0);
+ if (length > utf16_length_) length = utf16_length_;
+ // memcpy everything in buffer.
+ unsigned buffer_length =
+ last_byte_of_buffer_unused_ ? kBufferSize - 1 : kBufferSize;
+ unsigned memcpy_length = length <= buffer_length ? length : buffer_length;
+ v8::internal::MemCopy(data, buffer_, memcpy_length * sizeof(uint16_t));
+ if (length <= buffer_length) return length;
+ DCHECK(unbuffered_start_ != NULL);
+ // Copy the rest the slow way.
+ WriteUtf16Slow(unbuffered_start_, data + buffer_length,
+ length - buffer_length);
+ return length;
+}
+
+class Latin1 {
+ public:
+ static const unsigned kMaxChar = 0xff;
+ // Returns 0 if character does not convert to single latin-1 character
+ // or if the character doesn't not convert back to latin-1 via inverse
+ // operation (upper to lower, etc).
+ static inline uint16_t ConvertNonLatin1ToLatin1(uint16_t);
+};
+
+
+uint16_t Latin1::ConvertNonLatin1ToLatin1(uint16_t c) {
+ DCHECK(c > Latin1::kMaxChar);
+ switch (c) {
+ // This are equivalent characters in unicode.
+ case 0x39c:
+ case 0x3bc:
+ return 0xb5;
+ // This is an uppercase of a Latin-1 character
+ // outside of Latin-1.
+ case 0x178:
+ return 0xff;
+ }
+ return 0;
+}
+
+
+} // namespace unibrow
+
+#endif // V8_UNICODE_DECODER_H_
template <class T, int s> bool Predicate<T, s>::get(uchar code_point) {
CacheEntry entry = entries_[code_point & kMask];
- if (entry.code_point_ == code_point) return entry.value_;
+ if (entry.code_point() == code_point) return entry.value();
return CalculateValue(code_point);
}
}
-uint16_t Latin1::ConvertNonLatin1ToLatin1(uint16_t c) {
- DCHECK(c > Latin1::kMaxChar);
- switch (c) {
- // This are equivalent characters in unicode.
- case 0x39c:
- case 0x3bc:
- return 0xb5;
- // This is an uppercase of a Latin-1 character
- // outside of Latin-1.
- case 0x178:
- return 0xff;
- }
- return 0;
-}
-
-
unsigned Utf8::EncodeOneByte(char* str, uint8_t c) {
static const int kMask = ~(1 << 6);
if (c <= kMaxOneByteChar) {
}
}
-Utf8DecoderBase::Utf8DecoderBase()
- : unbuffered_start_(NULL),
- utf16_length_(0),
- last_byte_of_buffer_unused_(false) {}
-
-Utf8DecoderBase::Utf8DecoderBase(uint16_t* buffer,
- unsigned buffer_length,
- const uint8_t* stream,
- unsigned stream_length) {
- Reset(buffer, buffer_length, stream, stream_length);
-}
-
-template<unsigned kBufferSize>
-Utf8Decoder<kBufferSize>::Utf8Decoder(const char* stream, unsigned length)
- : Utf8DecoderBase(buffer_,
- kBufferSize,
- reinterpret_cast<const uint8_t*>(stream),
- length) {
-}
-
-template<unsigned kBufferSize>
-void Utf8Decoder<kBufferSize>::Reset(const char* stream, unsigned length) {
- Utf8DecoderBase::Reset(buffer_,
- kBufferSize,
- reinterpret_cast<const uint8_t*>(stream),
- length);
-}
-
-template <unsigned kBufferSize>
-unsigned Utf8Decoder<kBufferSize>::WriteUtf16(uint16_t* data,
- unsigned length) const {
- DCHECK(length > 0);
- if (length > utf16_length_) length = utf16_length_;
- // memcpy everything in buffer.
- unsigned buffer_length =
- last_byte_of_buffer_unused_ ? kBufferSize - 1 : kBufferSize;
- unsigned memcpy_length = length <= buffer_length ? length : buffer_length;
- v8::internal::MemCopy(data, buffer_, memcpy_length * sizeof(uint16_t));
- if (length <= buffer_length) return length;
- DCHECK(unbuffered_start_ != NULL);
- // Copy the rest the slow way.
- WriteUtf16Slow(unbuffered_start_,
- data + buffer_length,
- length - buffer_length);
- return length;
-}
-
} // namespace unibrow
#endif // V8_UNICODE_INL_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
-// This file was generated at 2014-02-07 15:31:16.733174
+// This file was generated at 2014-10-08 15:25:47.940335
#include "src/unicode-inl.h"
#include <stdio.h>
typedef unsigned short uint16_t; // NOLINT
typedef int int32_t; // NOLINT
+
// All access to the character table should go through this function.
template <int D>
static inline uchar TableGet(const int32_t* table, int index) {
}
}
+
uchar Utf8::CalculateValue(const byte* str,
unsigned length,
unsigned* cursor) {
}
-void Utf8DecoderBase::Reset(uint16_t* buffer,
- unsigned buffer_length,
- const uint8_t* stream,
- unsigned stream_length) {
- // Assume everything will fit in the buffer and stream won't be needed.
- last_byte_of_buffer_unused_ = false;
- unbuffered_start_ = NULL;
- bool writing_to_buffer = true;
- // Loop until stream is read, writing to buffer as long as buffer has space.
- unsigned utf16_length = 0;
- while (stream_length != 0) {
- unsigned cursor = 0;
- uint32_t character = Utf8::ValueOf(stream, stream_length, &cursor);
- DCHECK(cursor > 0 && cursor <= stream_length);
- stream += cursor;
- stream_length -= cursor;
- bool is_two_characters = character > Utf16::kMaxNonSurrogateCharCode;
- utf16_length += is_two_characters ? 2 : 1;
- // Don't need to write to the buffer, but still need utf16_length.
- if (!writing_to_buffer) continue;
- // Write out the characters to the buffer.
- // Must check for equality with buffer_length as we've already updated it.
- if (utf16_length <= buffer_length) {
- if (is_two_characters) {
- *buffer++ = Utf16::LeadSurrogate(character);
- *buffer++ = Utf16::TrailSurrogate(character);
- } else {
- *buffer++ = character;
- }
- if (utf16_length == buffer_length) {
- // Just wrote last character of buffer
- writing_to_buffer = false;
- unbuffered_start_ = stream;
- }
- continue;
- }
- // Have gone over buffer.
- // Last char of buffer is unused, set cursor back.
- DCHECK(is_two_characters);
- writing_to_buffer = false;
- last_byte_of_buffer_unused_ = true;
- unbuffered_start_ = stream - cursor;
- }
- utf16_length_ = utf16_length;
-}
-
-
-void Utf8DecoderBase::WriteUtf16Slow(const uint8_t* stream,
- uint16_t* data,
- unsigned data_length) {
- while (data_length != 0) {
- unsigned cursor = 0;
- uint32_t character = Utf8::ValueOf(stream, Utf8::kMaxEncodedSize, &cursor);
- // There's a total lack of bounds checking for stream
- // as it was already done in Reset.
- stream += cursor;
- if (character > unibrow::Utf16::kMaxNonSurrogateCharCode) {
- *data++ = Utf16::LeadSurrogate(character);
- *data++ = Utf16::TrailSurrogate(character);
- DCHECK(data_length > 1);
- data_length -= 2;
- } else {
- *data++ = character;
- data_length -= 1;
- }
- }
-}
-
-
// Uppercase: point.category == 'Lu'
-static const uint16_t kUppercaseTable0Size = 450;
-static const int32_t kUppercaseTable0[450] = {
- 1073741889, 90, 1073742016, 214, 1073742040, 222, 256, 258, // NOLINT
- 260, 262, 264, 266, 268, 270, 272, 274, // NOLINT
- 276, 278, 280, 282, 284, 286, 288, 290, // NOLINT
- 292, 294, 296, 298, 300, 302, 304, 306, // NOLINT
- 308, 310, 313, 315, 317, 319, 321, 323, // NOLINT
- 325, 327, 330, 332, 334, 336, 338, 340, // NOLINT
- 342, 344, 346, 348, 350, 352, 354, 356, // NOLINT
- 358, 360, 362, 364, 366, 368, 370, 372, // NOLINT
- 374, 1073742200, 377, 379, 381, 1073742209, 386, 388, // NOLINT
- 1073742214, 391, 1073742217, 395, 1073742222, 401, 1073742227, 404, // NOLINT
- 1073742230, 408, 1073742236, 413, 1073742239, 416, 418, 420, // NOLINT
- 1073742246, 423, 425, 428, 1073742254, 431, 1073742257, 435, // NOLINT
- 437, 1073742263, 440, 444, 452, 455, 458, 461, // NOLINT
- 463, 465, 467, 469, 471, 473, 475, 478, // NOLINT
- 480, 482, 484, 486, 488, 490, 492, 494, // NOLINT
- 497, 500, 1073742326, 504, 506, 508, 510, 512, // NOLINT
- 514, 516, 518, 520, 522, 524, 526, 528, // NOLINT
- 530, 532, 534, 536, 538, 540, 542, 544, // NOLINT
- 546, 548, 550, 552, 554, 556, 558, 560, // NOLINT
- 562, 1073742394, 571, 1073742397, 574, 577, 1073742403, 582, // NOLINT
- 584, 586, 588, 590, 880, 882, 886, 902, // NOLINT
- 1073742728, 906, 908, 1073742734, 911, 1073742737, 929, 1073742755, // NOLINT
- 939, 975, 1073742802, 980, 984, 986, 988, 990, // NOLINT
- 992, 994, 996, 998, 1000, 1002, 1004, 1006, // NOLINT
- 1012, 1015, 1073742841, 1018, 1073742845, 1071, 1120, 1122, // NOLINT
- 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, // NOLINT
- 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1162, // NOLINT
- 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, // NOLINT
- 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, // NOLINT
- 1196, 1198, 1200, 1202, 1204, 1206, 1208, 1210, // NOLINT
- 1212, 1214, 1073743040, 1217, 1219, 1221, 1223, 1225, // NOLINT
- 1227, 1229, 1232, 1234, 1236, 1238, 1240, 1242, // NOLINT
- 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, // NOLINT
- 1260, 1262, 1264, 1266, 1268, 1270, 1272, 1274, // NOLINT
- 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, // NOLINT
- 1292, 1294, 1296, 1298, 1300, 1302, 1304, 1306, // NOLINT
- 1308, 1310, 1312, 1314, 1316, 1318, 1073743153, 1366, // NOLINT
- 1073746080, 4293, 4295, 4301, 7680, 7682, 7684, 7686, // NOLINT
- 7688, 7690, 7692, 7694, 7696, 7698, 7700, 7702, // NOLINT
- 7704, 7706, 7708, 7710, 7712, 7714, 7716, 7718, // NOLINT
- 7720, 7722, 7724, 7726, 7728, 7730, 7732, 7734, // NOLINT
- 7736, 7738, 7740, 7742, 7744, 7746, 7748, 7750, // NOLINT
- 7752, 7754, 7756, 7758, 7760, 7762, 7764, 7766, // NOLINT
- 7768, 7770, 7772, 7774, 7776, 7778, 7780, 7782, // NOLINT
- 7784, 7786, 7788, 7790, 7792, 7794, 7796, 7798, // NOLINT
- 7800, 7802, 7804, 7806, 7808, 7810, 7812, 7814, // NOLINT
- 7816, 7818, 7820, 7822, 7824, 7826, 7828, 7838, // NOLINT
- 7840, 7842, 7844, 7846, 7848, 7850, 7852, 7854, // NOLINT
- 7856, 7858, 7860, 7862, 7864, 7866, 7868, 7870, // NOLINT
- 7872, 7874, 7876, 7878, 7880, 7882, 7884, 7886, // NOLINT
- 7888, 7890, 7892, 7894, 7896, 7898, 7900, 7902, // NOLINT
- 7904, 7906, 7908, 7910, 7912, 7914, 7916, 7918, // NOLINT
- 7920, 7922, 7924, 7926, 7928, 7930, 7932, 7934, // NOLINT
- 1073749768, 7951, 1073749784, 7965, 1073749800, 7983, 1073749816, 7999, // NOLINT
- 1073749832, 8013, 8025, 8027, 8029, 8031, 1073749864, 8047, // NOLINT
- 1073749944, 8123, 1073749960, 8139, 1073749976, 8155, 1073749992, 8172, // NOLINT
- 1073750008, 8187 }; // NOLINT
+static const uint16_t kUppercaseTable0Size = 455;
+static const int32_t kUppercaseTable0[455] = {
+ 1073741889, 90, 1073742016, 214,
+ 1073742040, 222, 256, 258, // NOLINT
+ 260, 262, 264, 266,
+ 268, 270, 272, 274, // NOLINT
+ 276, 278, 280, 282,
+ 284, 286, 288, 290, // NOLINT
+ 292, 294, 296, 298,
+ 300, 302, 304, 306, // NOLINT
+ 308, 310, 313, 315,
+ 317, 319, 321, 323, // NOLINT
+ 325, 327, 330, 332,
+ 334, 336, 338, 340, // NOLINT
+ 342, 344, 346, 348,
+ 350, 352, 354, 356, // NOLINT
+ 358, 360, 362, 364,
+ 366, 368, 370, 372, // NOLINT
+ 374, 1073742200, 377, 379,
+ 381, 1073742209, 386, 388, // NOLINT
+ 1073742214, 391, 1073742217, 395,
+ 1073742222, 401, 1073742227, 404, // NOLINT
+ 1073742230, 408, 1073742236, 413,
+ 1073742239, 416, 418, 420, // NOLINT
+ 1073742246, 423, 425, 428,
+ 1073742254, 431, 1073742257, 435, // NOLINT
+ 437, 1073742263, 440, 444,
+ 452, 455, 458, 461, // NOLINT
+ 463, 465, 467, 469,
+ 471, 473, 475, 478, // NOLINT
+ 480, 482, 484, 486,
+ 488, 490, 492, 494, // NOLINT
+ 497, 500, 1073742326, 504,
+ 506, 508, 510, 512, // NOLINT
+ 514, 516, 518, 520,
+ 522, 524, 526, 528, // NOLINT
+ 530, 532, 534, 536,
+ 538, 540, 542, 544, // NOLINT
+ 546, 548, 550, 552,
+ 554, 556, 558, 560, // NOLINT
+ 562, 1073742394, 571, 1073742397,
+ 574, 577, 1073742403, 582, // NOLINT
+ 584, 586, 588, 590,
+ 880, 882, 886, 895, // NOLINT
+ 902, 1073742728, 906, 908,
+ 1073742734, 911, 1073742737, 929, // NOLINT
+ 1073742755, 939, 975, 1073742802,
+ 980, 984, 986, 988, // NOLINT
+ 990, 992, 994, 996,
+ 998, 1000, 1002, 1004, // NOLINT
+ 1006, 1012, 1015, 1073742841,
+ 1018, 1073742845, 1071, 1120, // NOLINT
+ 1122, 1124, 1126, 1128,
+ 1130, 1132, 1134, 1136, // NOLINT
+ 1138, 1140, 1142, 1144,
+ 1146, 1148, 1150, 1152, // NOLINT
+ 1162, 1164, 1166, 1168,
+ 1170, 1172, 1174, 1176, // NOLINT
+ 1178, 1180, 1182, 1184,
+ 1186, 1188, 1190, 1192, // NOLINT
+ 1194, 1196, 1198, 1200,
+ 1202, 1204, 1206, 1208, // NOLINT
+ 1210, 1212, 1214, 1073743040,
+ 1217, 1219, 1221, 1223, // NOLINT
+ 1225, 1227, 1229, 1232,
+ 1234, 1236, 1238, 1240, // NOLINT
+ 1242, 1244, 1246, 1248,
+ 1250, 1252, 1254, 1256, // NOLINT
+ 1258, 1260, 1262, 1264,
+ 1266, 1268, 1270, 1272, // NOLINT
+ 1274, 1276, 1278, 1280,
+ 1282, 1284, 1286, 1288, // NOLINT
+ 1290, 1292, 1294, 1296,
+ 1298, 1300, 1302, 1304, // NOLINT
+ 1306, 1308, 1310, 1312,
+ 1314, 1316, 1318, 1320, // NOLINT
+ 1322, 1324, 1326, 1073743153,
+ 1366, 1073746080, 4293, 4295, // NOLINT
+ 4301, 7680, 7682, 7684,
+ 7686, 7688, 7690, 7692, // NOLINT
+ 7694, 7696, 7698, 7700,
+ 7702, 7704, 7706, 7708, // NOLINT
+ 7710, 7712, 7714, 7716,
+ 7718, 7720, 7722, 7724, // NOLINT
+ 7726, 7728, 7730, 7732,
+ 7734, 7736, 7738, 7740, // NOLINT
+ 7742, 7744, 7746, 7748,
+ 7750, 7752, 7754, 7756, // NOLINT
+ 7758, 7760, 7762, 7764,
+ 7766, 7768, 7770, 7772, // NOLINT
+ 7774, 7776, 7778, 7780,
+ 7782, 7784, 7786, 7788, // NOLINT
+ 7790, 7792, 7794, 7796,
+ 7798, 7800, 7802, 7804, // NOLINT
+ 7806, 7808, 7810, 7812,
+ 7814, 7816, 7818, 7820, // NOLINT
+ 7822, 7824, 7826, 7828,
+ 7838, 7840, 7842, 7844, // NOLINT
+ 7846, 7848, 7850, 7852,
+ 7854, 7856, 7858, 7860, // NOLINT
+ 7862, 7864, 7866, 7868,
+ 7870, 7872, 7874, 7876, // NOLINT
+ 7878, 7880, 7882, 7884,
+ 7886, 7888, 7890, 7892, // NOLINT
+ 7894, 7896, 7898, 7900,
+ 7902, 7904, 7906, 7908, // NOLINT
+ 7910, 7912, 7914, 7916,
+ 7918, 7920, 7922, 7924, // NOLINT
+ 7926, 7928, 7930, 7932,
+ 7934, 1073749768, 7951, 1073749784, // NOLINT
+ 7965, 1073749800, 7983, 1073749816,
+ 7999, 1073749832, 8013, 8025, // NOLINT
+ 8027, 8029, 8031, 1073749864,
+ 8047, 1073749944, 8123, 1073749960, // NOLINT
+ 8139, 1073749976, 8155, 1073749992,
+ 8172, 1073750008, 8187}; // NOLINT
static const uint16_t kUppercaseTable1Size = 86;
static const int32_t kUppercaseTable1[86] = {
258, 263, 1073742091, 269, 1073742096, 274, 277, 1073742105, // NOLINT
3262, 3264, 3266, 3268, 3270, 3272, 3274, 3276, // NOLINT
3278, 3280, 3282, 3284, 3286, 3288, 3290, 3292, // NOLINT
3294, 3296, 3298, 3307, 3309, 3314 }; // NOLINT
-static const uint16_t kUppercaseTable5Size = 91;
-static const int32_t kUppercaseTable5[91] = {
- 1600, 1602, 1604, 1606, 1608, 1610, 1612, 1614, // NOLINT
- 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, // NOLINT
- 1632, 1634, 1636, 1638, 1640, 1642, 1644, 1664, // NOLINT
- 1666, 1668, 1670, 1672, 1674, 1676, 1678, 1680, // NOLINT
- 1682, 1684, 1686, 1826, 1828, 1830, 1832, 1834, // NOLINT
- 1836, 1838, 1842, 1844, 1846, 1848, 1850, 1852, // NOLINT
- 1854, 1856, 1858, 1860, 1862, 1864, 1866, 1868, // NOLINT
- 1870, 1872, 1874, 1876, 1878, 1880, 1882, 1884, // NOLINT
- 1886, 1888, 1890, 1892, 1894, 1896, 1898, 1900, // NOLINT
- 1902, 1913, 1915, 1073743741, 1918, 1920, 1922, 1924, // NOLINT
- 1926, 1931, 1933, 1936, 1938, 1952, 1954, 1956, // NOLINT
- 1958, 1960, 1962 }; // NOLINT
+static const uint16_t kUppercaseTable5Size = 101;
+static const int32_t kUppercaseTable5[101] = {
+ 1600, 1602, 1604, 1606, 1608, 1610, 1612, 1614, // NOLINT
+ 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, // NOLINT
+ 1632, 1634, 1636, 1638, 1640, 1642, 1644, 1664, // NOLINT
+ 1666, 1668, 1670, 1672, 1674, 1676, 1678, 1680, // NOLINT
+ 1682, 1684, 1686, 1688, 1690, 1826, 1828, 1830, // NOLINT
+ 1832, 1834, 1836, 1838, 1842, 1844, 1846, 1848, // NOLINT
+ 1850, 1852, 1854, 1856, 1858, 1860, 1862, 1864, // NOLINT
+ 1866, 1868, 1870, 1872, 1874, 1876, 1878, 1880, // NOLINT
+ 1882, 1884, 1886, 1888, 1890, 1892, 1894, 1896, // NOLINT
+ 1898, 1900, 1902, 1913, 1915, 1073743741, 1918, 1920, // NOLINT
+ 1922, 1924, 1926, 1931, 1933, 1936, 1938, 1942, // NOLINT
+ 1944, 1946, 1948, 1950, 1952, 1954, 1956, 1958, // NOLINT
+ 1960, 1073743786, 1965, 1073743792, 1969}; // NOLINT
static const uint16_t kUppercaseTable7Size = 2;
static const int32_t kUppercaseTable7[2] = {
1073749793, 7994 }; // NOLINT
// Lowercase: point.category == 'Ll'
-static const uint16_t kLowercaseTable0Size = 463;
-static const int32_t kLowercaseTable0[463] = {
- 1073741921, 122, 181, 1073742047, 246, 1073742072, 255, 257, // NOLINT
- 259, 261, 263, 265, 267, 269, 271, 273, // NOLINT
- 275, 277, 279, 281, 283, 285, 287, 289, // NOLINT
- 291, 293, 295, 297, 299, 301, 303, 305, // NOLINT
- 307, 309, 1073742135, 312, 314, 316, 318, 320, // NOLINT
- 322, 324, 326, 1073742152, 329, 331, 333, 335, // NOLINT
- 337, 339, 341, 343, 345, 347, 349, 351, // NOLINT
- 353, 355, 357, 359, 361, 363, 365, 367, // NOLINT
- 369, 371, 373, 375, 378, 380, 1073742206, 384, // NOLINT
- 387, 389, 392, 1073742220, 397, 402, 405, 1073742233, // NOLINT
- 411, 414, 417, 419, 421, 424, 1073742250, 427, // NOLINT
- 429, 432, 436, 438, 1073742265, 442, 1073742269, 447, // NOLINT
- 454, 457, 460, 462, 464, 466, 468, 470, // NOLINT
- 472, 474, 1073742300, 477, 479, 481, 483, 485, // NOLINT
- 487, 489, 491, 493, 1073742319, 496, 499, 501, // NOLINT
- 505, 507, 509, 511, 513, 515, 517, 519, // NOLINT
- 521, 523, 525, 527, 529, 531, 533, 535, // NOLINT
- 537, 539, 541, 543, 545, 547, 549, 551, // NOLINT
- 553, 555, 557, 559, 561, 1073742387, 569, 572, // NOLINT
- 1073742399, 576, 578, 583, 585, 587, 589, 1073742415, // NOLINT
- 659, 1073742485, 687, 881, 883, 887, 1073742715, 893, // NOLINT
- 912, 1073742764, 974, 1073742800, 977, 1073742805, 983, 985, // NOLINT
- 987, 989, 991, 993, 995, 997, 999, 1001, // NOLINT
- 1003, 1005, 1073742831, 1011, 1013, 1016, 1073742843, 1020, // NOLINT
- 1073742896, 1119, 1121, 1123, 1125, 1127, 1129, 1131, // NOLINT
- 1133, 1135, 1137, 1139, 1141, 1143, 1145, 1147, // NOLINT
- 1149, 1151, 1153, 1163, 1165, 1167, 1169, 1171, // NOLINT
- 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187, // NOLINT
- 1189, 1191, 1193, 1195, 1197, 1199, 1201, 1203, // NOLINT
- 1205, 1207, 1209, 1211, 1213, 1215, 1218, 1220, // NOLINT
- 1222, 1224, 1226, 1228, 1073743054, 1231, 1233, 1235, // NOLINT
- 1237, 1239, 1241, 1243, 1245, 1247, 1249, 1251, // NOLINT
- 1253, 1255, 1257, 1259, 1261, 1263, 1265, 1267, // NOLINT
- 1269, 1271, 1273, 1275, 1277, 1279, 1281, 1283, // NOLINT
- 1285, 1287, 1289, 1291, 1293, 1295, 1297, 1299, // NOLINT
- 1301, 1303, 1305, 1307, 1309, 1311, 1313, 1315, // NOLINT
- 1317, 1319, 1073743201, 1415, 1073749248, 7467, 1073749355, 7543, // NOLINT
- 1073749369, 7578, 7681, 7683, 7685, 7687, 7689, 7691, // NOLINT
- 7693, 7695, 7697, 7699, 7701, 7703, 7705, 7707, // NOLINT
- 7709, 7711, 7713, 7715, 7717, 7719, 7721, 7723, // NOLINT
- 7725, 7727, 7729, 7731, 7733, 7735, 7737, 7739, // NOLINT
- 7741, 7743, 7745, 7747, 7749, 7751, 7753, 7755, // NOLINT
- 7757, 7759, 7761, 7763, 7765, 7767, 7769, 7771, // NOLINT
- 7773, 7775, 7777, 7779, 7781, 7783, 7785, 7787, // NOLINT
- 7789, 7791, 7793, 7795, 7797, 7799, 7801, 7803, // NOLINT
- 7805, 7807, 7809, 7811, 7813, 7815, 7817, 7819, // NOLINT
- 7821, 7823, 7825, 7827, 1073749653, 7837, 7839, 7841, // NOLINT
- 7843, 7845, 7847, 7849, 7851, 7853, 7855, 7857, // NOLINT
- 7859, 7861, 7863, 7865, 7867, 7869, 7871, 7873, // NOLINT
- 7875, 7877, 7879, 7881, 7883, 7885, 7887, 7889, // NOLINT
- 7891, 7893, 7895, 7897, 7899, 7901, 7903, 7905, // NOLINT
- 7907, 7909, 7911, 7913, 7915, 7917, 7919, 7921, // NOLINT
- 7923, 7925, 7927, 7929, 7931, 7933, 1073749759, 7943, // NOLINT
- 1073749776, 7957, 1073749792, 7975, 1073749808, 7991, 1073749824, 8005, // NOLINT
- 1073749840, 8023, 1073749856, 8039, 1073749872, 8061, 1073749888, 8071, // NOLINT
- 1073749904, 8087, 1073749920, 8103, 1073749936, 8116, 1073749942, 8119, // NOLINT
- 8126, 1073749954, 8132, 1073749958, 8135, 1073749968, 8147, 1073749974, // NOLINT
- 8151, 1073749984, 8167, 1073750002, 8180, 1073750006, 8183 }; // NOLINT
+static const uint16_t kLowercaseTable0Size = 467;
+static const int32_t kLowercaseTable0[467] = {
+ 1073741921, 122, 181, 1073742047,
+ 246, 1073742072, 255, 257, // NOLINT
+ 259, 261, 263, 265,
+ 267, 269, 271, 273, // NOLINT
+ 275, 277, 279, 281,
+ 283, 285, 287, 289, // NOLINT
+ 291, 293, 295, 297,
+ 299, 301, 303, 305, // NOLINT
+ 307, 309, 1073742135, 312,
+ 314, 316, 318, 320, // NOLINT
+ 322, 324, 326, 1073742152,
+ 329, 331, 333, 335, // NOLINT
+ 337, 339, 341, 343,
+ 345, 347, 349, 351, // NOLINT
+ 353, 355, 357, 359,
+ 361, 363, 365, 367, // NOLINT
+ 369, 371, 373, 375,
+ 378, 380, 1073742206, 384, // NOLINT
+ 387, 389, 392, 1073742220,
+ 397, 402, 405, 1073742233, // NOLINT
+ 411, 414, 417, 419,
+ 421, 424, 1073742250, 427, // NOLINT
+ 429, 432, 436, 438,
+ 1073742265, 442, 1073742269, 447, // NOLINT
+ 454, 457, 460, 462,
+ 464, 466, 468, 470, // NOLINT
+ 472, 474, 1073742300, 477,
+ 479, 481, 483, 485, // NOLINT
+ 487, 489, 491, 493,
+ 1073742319, 496, 499, 501, // NOLINT
+ 505, 507, 509, 511,
+ 513, 515, 517, 519, // NOLINT
+ 521, 523, 525, 527,
+ 529, 531, 533, 535, // NOLINT
+ 537, 539, 541, 543,
+ 545, 547, 549, 551, // NOLINT
+ 553, 555, 557, 559,
+ 561, 1073742387, 569, 572, // NOLINT
+ 1073742399, 576, 578, 583,
+ 585, 587, 589, 1073742415, // NOLINT
+ 659, 1073742485, 687, 881,
+ 883, 887, 1073742715, 893, // NOLINT
+ 912, 1073742764, 974, 1073742800,
+ 977, 1073742805, 983, 985, // NOLINT
+ 987, 989, 991, 993,
+ 995, 997, 999, 1001, // NOLINT
+ 1003, 1005, 1073742831, 1011,
+ 1013, 1016, 1073742843, 1020, // NOLINT
+ 1073742896, 1119, 1121, 1123,
+ 1125, 1127, 1129, 1131, // NOLINT
+ 1133, 1135, 1137, 1139,
+ 1141, 1143, 1145, 1147, // NOLINT
+ 1149, 1151, 1153, 1163,
+ 1165, 1167, 1169, 1171, // NOLINT
+ 1173, 1175, 1177, 1179,
+ 1181, 1183, 1185, 1187, // NOLINT
+ 1189, 1191, 1193, 1195,
+ 1197, 1199, 1201, 1203, // NOLINT
+ 1205, 1207, 1209, 1211,
+ 1213, 1215, 1218, 1220, // NOLINT
+ 1222, 1224, 1226, 1228,
+ 1073743054, 1231, 1233, 1235, // NOLINT
+ 1237, 1239, 1241, 1243,
+ 1245, 1247, 1249, 1251, // NOLINT
+ 1253, 1255, 1257, 1259,
+ 1261, 1263, 1265, 1267, // NOLINT
+ 1269, 1271, 1273, 1275,
+ 1277, 1279, 1281, 1283, // NOLINT
+ 1285, 1287, 1289, 1291,
+ 1293, 1295, 1297, 1299, // NOLINT
+ 1301, 1303, 1305, 1307,
+ 1309, 1311, 1313, 1315, // NOLINT
+ 1317, 1319, 1321, 1323,
+ 1325, 1327, 1073743201, 1415, // NOLINT
+ 1073749248, 7467, 1073749355, 7543,
+ 1073749369, 7578, 7681, 7683, // NOLINT
+ 7685, 7687, 7689, 7691,
+ 7693, 7695, 7697, 7699, // NOLINT
+ 7701, 7703, 7705, 7707,
+ 7709, 7711, 7713, 7715, // NOLINT
+ 7717, 7719, 7721, 7723,
+ 7725, 7727, 7729, 7731, // NOLINT
+ 7733, 7735, 7737, 7739,
+ 7741, 7743, 7745, 7747, // NOLINT
+ 7749, 7751, 7753, 7755,
+ 7757, 7759, 7761, 7763, // NOLINT
+ 7765, 7767, 7769, 7771,
+ 7773, 7775, 7777, 7779, // NOLINT
+ 7781, 7783, 7785, 7787,
+ 7789, 7791, 7793, 7795, // NOLINT
+ 7797, 7799, 7801, 7803,
+ 7805, 7807, 7809, 7811, // NOLINT
+ 7813, 7815, 7817, 7819,
+ 7821, 7823, 7825, 7827, // NOLINT
+ 1073749653, 7837, 7839, 7841,
+ 7843, 7845, 7847, 7849, // NOLINT
+ 7851, 7853, 7855, 7857,
+ 7859, 7861, 7863, 7865, // NOLINT
+ 7867, 7869, 7871, 7873,
+ 7875, 7877, 7879, 7881, // NOLINT
+ 7883, 7885, 7887, 7889,
+ 7891, 7893, 7895, 7897, // NOLINT
+ 7899, 7901, 7903, 7905,
+ 7907, 7909, 7911, 7913, // NOLINT
+ 7915, 7917, 7919, 7921,
+ 7923, 7925, 7927, 7929, // NOLINT
+ 7931, 7933, 1073749759, 7943,
+ 1073749776, 7957, 1073749792, 7975, // NOLINT
+ 1073749808, 7991, 1073749824, 8005,
+ 1073749840, 8023, 1073749856, 8039, // NOLINT
+ 1073749872, 8061, 1073749888, 8071,
+ 1073749904, 8087, 1073749920, 8103, // NOLINT
+ 1073749936, 8116, 1073749942, 8119,
+ 8126, 1073749954, 8132, 1073749958, // NOLINT
+ 8135, 1073749968, 8147, 1073749974,
+ 8151, 1073749984, 8167, 1073750002, // NOLINT
+ 8180, 1073750006, 8183}; // NOLINT
static const uint16_t kLowercaseTable1Size = 84;
static const int32_t kLowercaseTable1[84] = {
266, 1073742094, 271, 275, 303, 308, 313, 1073742140, // NOLINT
3277, 3279, 3281, 3283, 3285, 3287, 3289, 3291, // NOLINT
3293, 3295, 3297, 1073745123, 3300, 3308, 3310, 3315, // NOLINT
1073745152, 3365, 3367, 3373 }; // NOLINT
-static const uint16_t kLowercaseTable5Size = 93;
-static const int32_t kLowercaseTable5[93] = {
- 1601, 1603, 1605, 1607, 1609, 1611, 1613, 1615, // NOLINT
- 1617, 1619, 1621, 1623, 1625, 1627, 1629, 1631, // NOLINT
- 1633, 1635, 1637, 1639, 1641, 1643, 1645, 1665, // NOLINT
- 1667, 1669, 1671, 1673, 1675, 1677, 1679, 1681, // NOLINT
- 1683, 1685, 1687, 1827, 1829, 1831, 1833, 1835, // NOLINT
- 1837, 1073743663, 1841, 1843, 1845, 1847, 1849, 1851, // NOLINT
- 1853, 1855, 1857, 1859, 1861, 1863, 1865, 1867, // NOLINT
- 1869, 1871, 1873, 1875, 1877, 1879, 1881, 1883, // NOLINT
- 1885, 1887, 1889, 1891, 1893, 1895, 1897, 1899, // NOLINT
- 1901, 1903, 1073743729, 1912, 1914, 1916, 1919, 1921, // NOLINT
- 1923, 1925, 1927, 1932, 1934, 1937, 1939, 1953, // NOLINT
- 1955, 1957, 1959, 1961, 2042 }; // NOLINT
+static const uint16_t kLowercaseTable5Size = 105;
+static const int32_t kLowercaseTable5[105] = {
+ 1601, 1603, 1605, 1607,
+ 1609, 1611, 1613, 1615, // NOLINT
+ 1617, 1619, 1621, 1623,
+ 1625, 1627, 1629, 1631, // NOLINT
+ 1633, 1635, 1637, 1639,
+ 1641, 1643, 1645, 1665, // NOLINT
+ 1667, 1669, 1671, 1673,
+ 1675, 1677, 1679, 1681, // NOLINT
+ 1683, 1685, 1687, 1689,
+ 1691, 1827, 1829, 1831, // NOLINT
+ 1833, 1835, 1837, 1073743663,
+ 1841, 1843, 1845, 1847, // NOLINT
+ 1849, 1851, 1853, 1855,
+ 1857, 1859, 1861, 1863, // NOLINT
+ 1865, 1867, 1869, 1871,
+ 1873, 1875, 1877, 1879, // NOLINT
+ 1881, 1883, 1885, 1887,
+ 1889, 1891, 1893, 1895, // NOLINT
+ 1897, 1899, 1901, 1903,
+ 1073743729, 1912, 1914, 1916, // NOLINT
+ 1919, 1921, 1923, 1925,
+ 1927, 1932, 1934, 1937, // NOLINT
+ 1073743763, 1941, 1943, 1945,
+ 1947, 1949, 1951, 1953, // NOLINT
+ 1955, 1957, 1959, 1961,
+ 2042, 1073744688, 2906, 1073744740, // NOLINT
+ 2917}; // NOLINT
static const uint16_t kLowercaseTable7Size = 6;
static const int32_t kLowercaseTable7[6] = {
1073748736, 6918, 1073748755, 6935, 1073749825, 8026 }; // NOLINT
}
-// Letter: point.category in ['Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' ]
+// Letter: point.category in ['Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl']
-static const uint16_t kLetterTable0Size = 435;
-static const int32_t kLetterTable0[435] = {
- 1073741889, 90, 1073741921, 122, 170, 181, 186, 1073742016, // NOLINT
- 214, 1073742040, 246, 1073742072, 705, 1073742534, 721, 1073742560, // NOLINT
- 740, 748, 750, 1073742704, 884, 1073742710, 887, 1073742714, // NOLINT
- 893, 902, 1073742728, 906, 908, 1073742734, 929, 1073742755, // NOLINT
- 1013, 1073742839, 1153, 1073742986, 1319, 1073743153, 1366, 1369, // NOLINT
- 1073743201, 1415, 1073743312, 1514, 1073743344, 1522, 1073743392, 1610, // NOLINT
- 1073743470, 1647, 1073743473, 1747, 1749, 1073743589, 1766, 1073743598, // NOLINT
- 1775, 1073743610, 1788, 1791, 1808, 1073743634, 1839, 1073743693, // NOLINT
- 1957, 1969, 1073743818, 2026, 1073743860, 2037, 2042, 1073743872, // NOLINT
- 2069, 2074, 2084, 2088, 1073743936, 2136, 2208, 1073744034, // NOLINT
- 2220, 1073744132, 2361, 2365, 2384, 1073744216, 2401, 1073744241, // NOLINT
- 2423, 1073744249, 2431, 1073744261, 2444, 1073744271, 2448, 1073744275, // NOLINT
- 2472, 1073744298, 2480, 2482, 1073744310, 2489, 2493, 2510, // NOLINT
- 1073744348, 2525, 1073744351, 2529, 1073744368, 2545, 1073744389, 2570, // NOLINT
- 1073744399, 2576, 1073744403, 2600, 1073744426, 2608, 1073744434, 2611, // NOLINT
- 1073744437, 2614, 1073744440, 2617, 1073744473, 2652, 2654, 1073744498, // NOLINT
- 2676, 1073744517, 2701, 1073744527, 2705, 1073744531, 2728, 1073744554, // NOLINT
- 2736, 1073744562, 2739, 1073744565, 2745, 2749, 2768, 1073744608, // NOLINT
- 2785, 1073744645, 2828, 1073744655, 2832, 1073744659, 2856, 1073744682, // NOLINT
- 2864, 1073744690, 2867, 1073744693, 2873, 2877, 1073744732, 2909, // NOLINT
- 1073744735, 2913, 2929, 2947, 1073744773, 2954, 1073744782, 2960, // NOLINT
- 1073744786, 2965, 1073744793, 2970, 2972, 1073744798, 2975, 1073744803, // NOLINT
- 2980, 1073744808, 2986, 1073744814, 3001, 3024, 1073744901, 3084, // NOLINT
- 1073744910, 3088, 1073744914, 3112, 1073744938, 3123, 1073744949, 3129, // NOLINT
- 3133, 1073744984, 3161, 1073744992, 3169, 1073745029, 3212, 1073745038, // NOLINT
- 3216, 1073745042, 3240, 1073745066, 3251, 1073745077, 3257, 3261, // NOLINT
- 3294, 1073745120, 3297, 1073745137, 3314, 1073745157, 3340, 1073745166, // NOLINT
- 3344, 1073745170, 3386, 3389, 3406, 1073745248, 3425, 1073745274, // NOLINT
- 3455, 1073745285, 3478, 1073745306, 3505, 1073745331, 3515, 3517, // NOLINT
- 1073745344, 3526, 1073745409, 3632, 1073745458, 3635, 1073745472, 3654, // NOLINT
- 1073745537, 3714, 3716, 1073745543, 3720, 3722, 3725, 1073745556, // NOLINT
- 3735, 1073745561, 3743, 1073745569, 3747, 3749, 3751, 1073745578, // NOLINT
- 3755, 1073745581, 3760, 1073745586, 3763, 3773, 1073745600, 3780, // NOLINT
- 3782, 1073745628, 3807, 3840, 1073745728, 3911, 1073745737, 3948, // NOLINT
- 1073745800, 3980, 1073745920, 4138, 4159, 1073746000, 4181, 1073746010, // NOLINT
- 4189, 4193, 1073746021, 4198, 1073746030, 4208, 1073746037, 4225, // NOLINT
- 4238, 1073746080, 4293, 4295, 4301, 1073746128, 4346, 1073746172, // NOLINT
- 4680, 1073746506, 4685, 1073746512, 4694, 4696, 1073746522, 4701, // NOLINT
- 1073746528, 4744, 1073746570, 4749, 1073746576, 4784, 1073746610, 4789, // NOLINT
- 1073746616, 4798, 4800, 1073746626, 4805, 1073746632, 4822, 1073746648, // NOLINT
- 4880, 1073746706, 4885, 1073746712, 4954, 1073746816, 5007, 1073746848, // NOLINT
- 5108, 1073746945, 5740, 1073747567, 5759, 1073747585, 5786, 1073747616, // NOLINT
- 5866, 1073747694, 5872, 1073747712, 5900, 1073747726, 5905, 1073747744, // NOLINT
- 5937, 1073747776, 5969, 1073747808, 5996, 1073747822, 6000, 1073747840, // NOLINT
- 6067, 6103, 6108, 1073748000, 6263, 1073748096, 6312, 6314, // NOLINT
- 1073748144, 6389, 1073748224, 6428, 1073748304, 6509, 1073748336, 6516, // NOLINT
- 1073748352, 6571, 1073748417, 6599, 1073748480, 6678, 1073748512, 6740, // NOLINT
- 6823, 1073748741, 6963, 1073748805, 6987, 1073748867, 7072, 1073748910, // NOLINT
- 7087, 1073748922, 7141, 1073748992, 7203, 1073749069, 7247, 1073749082, // NOLINT
- 7293, 1073749225, 7404, 1073749230, 7409, 1073749237, 7414, 1073749248, // NOLINT
- 7615, 1073749504, 7957, 1073749784, 7965, 1073749792, 8005, 1073749832, // NOLINT
- 8013, 1073749840, 8023, 8025, 8027, 8029, 1073749855, 8061, // NOLINT
- 1073749888, 8116, 1073749942, 8124, 8126, 1073749954, 8132, 1073749958, // NOLINT
- 8140, 1073749968, 8147, 1073749974, 8155, 1073749984, 8172, 1073750002, // NOLINT
- 8180, 1073750006, 8188 }; // NOLINT
+static const uint16_t kLetterTable0Size = 431;
+static const int32_t kLetterTable0[431] = {
+ 1073741889, 90, 1073741921, 122,
+ 170, 181, 186, 1073742016, // NOLINT
+ 214, 1073742040, 246, 1073742072,
+ 705, 1073742534, 721, 1073742560, // NOLINT
+ 740, 748, 750, 1073742704,
+ 884, 1073742710, 887, 1073742714, // NOLINT
+ 893, 895, 902, 1073742728,
+ 906, 908, 1073742734, 929, // NOLINT
+ 1073742755, 1013, 1073742839, 1153,
+ 1073742986, 1327, 1073743153, 1366, // NOLINT
+ 1369, 1073743201, 1415, 1073743312,
+ 1514, 1073743344, 1522, 1073743392, // NOLINT
+ 1610, 1073743470, 1647, 1073743473,
+ 1747, 1749, 1073743589, 1766, // NOLINT
+ 1073743598, 1775, 1073743610, 1788,
+ 1791, 1808, 1073743634, 1839, // NOLINT
+ 1073743693, 1957, 1969, 1073743818,
+ 2026, 1073743860, 2037, 2042, // NOLINT
+ 1073743872, 2069, 2074, 2084,
+ 2088, 1073743936, 2136, 1073744032, // NOLINT
+ 2226, 1073744132, 2361, 2365,
+ 2384, 1073744216, 2401, 1073744241, // NOLINT
+ 2432, 1073744261, 2444, 1073744271,
+ 2448, 1073744275, 2472, 1073744298, // NOLINT
+ 2480, 2482, 1073744310, 2489,
+ 2493, 2510, 1073744348, 2525, // NOLINT
+ 1073744351, 2529, 1073744368, 2545,
+ 1073744389, 2570, 1073744399, 2576, // NOLINT
+ 1073744403, 2600, 1073744426, 2608,
+ 1073744434, 2611, 1073744437, 2614, // NOLINT
+ 1073744440, 2617, 1073744473, 2652,
+ 2654, 1073744498, 2676, 1073744517, // NOLINT
+ 2701, 1073744527, 2705, 1073744531,
+ 2728, 1073744554, 2736, 1073744562, // NOLINT
+ 2739, 1073744565, 2745, 2749,
+ 2768, 1073744608, 2785, 1073744645, // NOLINT
+ 2828, 1073744655, 2832, 1073744659,
+ 2856, 1073744682, 2864, 1073744690, // NOLINT
+ 2867, 1073744693, 2873, 2877,
+ 1073744732, 2909, 1073744735, 2913, // NOLINT
+ 2929, 2947, 1073744773, 2954,
+ 1073744782, 2960, 1073744786, 2965, // NOLINT
+ 1073744793, 2970, 2972, 1073744798,
+ 2975, 1073744803, 2980, 1073744808, // NOLINT
+ 2986, 1073744814, 3001, 3024,
+ 1073744901, 3084, 1073744910, 3088, // NOLINT
+ 1073744914, 3112, 1073744938, 3129,
+ 3133, 1073744984, 3161, 1073744992, // NOLINT
+ 3169, 1073745029, 3212, 1073745038,
+ 3216, 1073745042, 3240, 1073745066, // NOLINT
+ 3251, 1073745077, 3257, 3261,
+ 3294, 1073745120, 3297, 1073745137, // NOLINT
+ 3314, 1073745157, 3340, 1073745166,
+ 3344, 1073745170, 3386, 3389, // NOLINT
+ 3406, 1073745248, 3425, 1073745274,
+ 3455, 1073745285, 3478, 1073745306, // NOLINT
+ 3505, 1073745331, 3515, 3517,
+ 1073745344, 3526, 1073745409, 3632, // NOLINT
+ 1073745458, 3635, 1073745472, 3654,
+ 1073745537, 3714, 3716, 1073745543, // NOLINT
+ 3720, 3722, 3725, 1073745556,
+ 3735, 1073745561, 3743, 1073745569, // NOLINT
+ 3747, 3749, 3751, 1073745578,
+ 3755, 1073745581, 3760, 1073745586, // NOLINT
+ 3763, 3773, 1073745600, 3780,
+ 3782, 1073745628, 3807, 3840, // NOLINT
+ 1073745728, 3911, 1073745737, 3948,
+ 1073745800, 3980, 1073745920, 4138, // NOLINT
+ 4159, 1073746000, 4181, 1073746010,
+ 4189, 4193, 1073746021, 4198, // NOLINT
+ 1073746030, 4208, 1073746037, 4225,
+ 4238, 1073746080, 4293, 4295, // NOLINT
+ 4301, 1073746128, 4346, 1073746172,
+ 4680, 1073746506, 4685, 1073746512, // NOLINT
+ 4694, 4696, 1073746522, 4701,
+ 1073746528, 4744, 1073746570, 4749, // NOLINT
+ 1073746576, 4784, 1073746610, 4789,
+ 1073746616, 4798, 4800, 1073746626, // NOLINT
+ 4805, 1073746632, 4822, 1073746648,
+ 4880, 1073746706, 4885, 1073746712, // NOLINT
+ 4954, 1073746816, 5007, 1073746848,
+ 5108, 1073746945, 5740, 1073747567, // NOLINT
+ 5759, 1073747585, 5786, 1073747616,
+ 5866, 1073747694, 5880, 1073747712, // NOLINT
+ 5900, 1073747726, 5905, 1073747744,
+ 5937, 1073747776, 5969, 1073747808, // NOLINT
+ 5996, 1073747822, 6000, 1073747840,
+ 6067, 6103, 6108, 1073748000, // NOLINT
+ 6263, 1073748096, 6312, 6314,
+ 1073748144, 6389, 1073748224, 6430, // NOLINT
+ 1073748304, 6509, 1073748336, 6516,
+ 1073748352, 6571, 1073748417, 6599, // NOLINT
+ 1073748480, 6678, 1073748512, 6740,
+ 6823, 1073748741, 6963, 1073748805, // NOLINT
+ 6987, 1073748867, 7072, 1073748910,
+ 7087, 1073748922, 7141, 1073748992, // NOLINT
+ 7203, 1073749069, 7247, 1073749082,
+ 7293, 1073749225, 7404, 1073749230, // NOLINT
+ 7409, 1073749237, 7414, 1073749248,
+ 7615, 1073749504, 7957, 1073749784, // NOLINT
+ 7965, 1073749792, 8005, 1073749832,
+ 8013, 1073749840, 8023, 8025, // NOLINT
+ 8027, 8029, 1073749855, 8061,
+ 1073749888, 8116, 1073749942, 8124, // NOLINT
+ 8126, 1073749954, 8132, 1073749958,
+ 8140, 1073749968, 8147, 1073749974, // NOLINT
+ 8155, 1073749984, 8172, 1073750002,
+ 8180, 1073750006, 8188}; // NOLINT
static const uint16_t kLetterTable1Size = 87;
static const int32_t kLetterTable1[87] = {
113, 127, 1073741968, 156, 258, 263, 1073742090, 275, // NOLINT
static const uint16_t kLetterTable4Size = 2;
static const int32_t kLetterTable4[2] = {
1073741824, 8140 }; // NOLINT
-static const uint16_t kLetterTable5Size = 88;
-static const int32_t kLetterTable5[88] = {
- 1073741824, 1164, 1073743056, 1277, 1073743104, 1548, 1073743376, 1567, // NOLINT
- 1073743402, 1579, 1073743424, 1646, 1073743487, 1687, 1073743520, 1775, // NOLINT
- 1073743639, 1823, 1073743650, 1928, 1073743755, 1934, 1073743760, 1939, // NOLINT
- 1073743776, 1962, 1073743864, 2049, 1073743875, 2053, 1073743879, 2058, // NOLINT
- 1073743884, 2082, 1073743936, 2163, 1073744002, 2227, 1073744114, 2295, // NOLINT
- 2299, 1073744138, 2341, 1073744176, 2374, 1073744224, 2428, 1073744260, // NOLINT
- 2482, 2511, 1073744384, 2600, 1073744448, 2626, 1073744452, 2635, // NOLINT
- 1073744480, 2678, 2682, 1073744512, 2735, 2737, 1073744565, 2742, // NOLINT
- 1073744569, 2749, 2752, 2754, 1073744603, 2781, 1073744608, 2794, // NOLINT
- 1073744626, 2804, 1073744641, 2822, 1073744649, 2830, 1073744657, 2838, // NOLINT
- 1073744672, 2854, 1073744680, 2862, 1073744832, 3042, 1073744896, 8191 }; // NOLINT
+static const uint16_t kLetterTable5Size = 100;
+static const int32_t kLetterTable5[100] = {
+ 1073741824, 1164, 1073743056, 1277,
+ 1073743104, 1548, 1073743376, 1567, // NOLINT
+ 1073743402, 1579, 1073743424, 1646,
+ 1073743487, 1693, 1073743520, 1775, // NOLINT
+ 1073743639, 1823, 1073743650, 1928,
+ 1073743755, 1934, 1073743760, 1965, // NOLINT
+ 1073743792, 1969, 1073743863, 2049,
+ 1073743875, 2053, 1073743879, 2058, // NOLINT
+ 1073743884, 2082, 1073743936, 2163,
+ 1073744002, 2227, 1073744114, 2295, // NOLINT
+ 2299, 1073744138, 2341, 1073744176,
+ 2374, 1073744224, 2428, 1073744260, // NOLINT
+ 2482, 2511, 1073744352, 2532,
+ 1073744358, 2543, 1073744378, 2558, // NOLINT
+ 1073744384, 2600, 1073744448, 2626,
+ 1073744452, 2635, 1073744480, 2678, // NOLINT
+ 2682, 1073744510, 2735, 2737,
+ 1073744565, 2742, 1073744569, 2749, // NOLINT
+ 2752, 2754, 1073744603, 2781,
+ 1073744608, 2794, 1073744626, 2804, // NOLINT
+ 1073744641, 2822, 1073744649, 2830,
+ 1073744657, 2838, 1073744672, 2854, // NOLINT
+ 1073744680, 2862, 1073744688, 2906,
+ 1073744732, 2911, 1073744740, 2917, // NOLINT
+ 1073744832, 3042, 1073744896, 8191}; // NOLINT
static const uint16_t kLetterTable6Size = 6;
static const int32_t kLetterTable6[6] = {
1073741824, 6051, 1073747888, 6086, 1073747915, 6139 }; // NOLINT
}
-// Number: point.category == 'Nd'
+// ID_Start: ((point.category in ['Lu', 'Ll', 'Lt', 'Lm', 'Lo',
+// 'Nl'] or 'Other_ID_Start' in point.properties) and ('Pattern_Syntax' not in
+// point.properties) and ('Pattern_White_Space' not in point.properties)) or
+// ('JS_ID_Start' in point.properties)
-static const uint16_t kNumberTable0Size = 56;
-static const int32_t kNumberTable0[56] = {
- 1073741872, 57, 1073743456, 1641, 1073743600, 1785, 1073743808, 1993, // NOLINT
- 1073744230, 2415, 1073744358, 2543, 1073744486, 2671, 1073744614, 2799, // NOLINT
- 1073744742, 2927, 1073744870, 3055, 1073744998, 3183, 1073745126, 3311, // NOLINT
- 1073745254, 3439, 1073745488, 3673, 1073745616, 3801, 1073745696, 3881, // NOLINT
- 1073745984, 4169, 1073746064, 4249, 1073747936, 6121, 1073747984, 6169, // NOLINT
- 1073748294, 6479, 1073748432, 6617, 1073748608, 6793, 1073748624, 6809, // NOLINT
- 1073748816, 7001, 1073748912, 7097, 1073749056, 7241, 1073749072, 7257 }; // NOLINT
-static const uint16_t kNumberTable5Size = 12;
-static const int32_t kNumberTable5[12] = {
- 1073743392, 1577, 1073744080, 2265, 1073744128, 2313, 1073744336, 2521, // NOLINT
- 1073744464, 2649, 1073744880, 3065 }; // NOLINT
-static const uint16_t kNumberTable7Size = 2;
-static const int32_t kNumberTable7[2] = {
- 1073749776, 7961 }; // NOLINT
-bool Number::Is(uchar c) {
+static const uint16_t kID_StartTable0Size = 434;
+static const int32_t kID_StartTable0[434] = {
+ 36, 1073741889, 90, 92,
+ 95, 1073741921, 122, 170, // NOLINT
+ 181, 186, 1073742016, 214,
+ 1073742040, 246, 1073742072, 705, // NOLINT
+ 1073742534, 721, 1073742560, 740,
+ 748, 750, 1073742704, 884, // NOLINT
+ 1073742710, 887, 1073742714, 893,
+ 895, 902, 1073742728, 906, // NOLINT
+ 908, 1073742734, 929, 1073742755,
+ 1013, 1073742839, 1153, 1073742986, // NOLINT
+ 1327, 1073743153, 1366, 1369,
+ 1073743201, 1415, 1073743312, 1514, // NOLINT
+ 1073743344, 1522, 1073743392, 1610,
+ 1073743470, 1647, 1073743473, 1747, // NOLINT
+ 1749, 1073743589, 1766, 1073743598,
+ 1775, 1073743610, 1788, 1791, // NOLINT
+ 1808, 1073743634, 1839, 1073743693,
+ 1957, 1969, 1073743818, 2026, // NOLINT
+ 1073743860, 2037, 2042, 1073743872,
+ 2069, 2074, 2084, 2088, // NOLINT
+ 1073743936, 2136, 1073744032, 2226,
+ 1073744132, 2361, 2365, 2384, // NOLINT
+ 1073744216, 2401, 1073744241, 2432,
+ 1073744261, 2444, 1073744271, 2448, // NOLINT
+ 1073744275, 2472, 1073744298, 2480,
+ 2482, 1073744310, 2489, 2493, // NOLINT
+ 2510, 1073744348, 2525, 1073744351,
+ 2529, 1073744368, 2545, 1073744389, // NOLINT
+ 2570, 1073744399, 2576, 1073744403,
+ 2600, 1073744426, 2608, 1073744434, // NOLINT
+ 2611, 1073744437, 2614, 1073744440,
+ 2617, 1073744473, 2652, 2654, // NOLINT
+ 1073744498, 2676, 1073744517, 2701,
+ 1073744527, 2705, 1073744531, 2728, // NOLINT
+ 1073744554, 2736, 1073744562, 2739,
+ 1073744565, 2745, 2749, 2768, // NOLINT
+ 1073744608, 2785, 1073744645, 2828,
+ 1073744655, 2832, 1073744659, 2856, // NOLINT
+ 1073744682, 2864, 1073744690, 2867,
+ 1073744693, 2873, 2877, 1073744732, // NOLINT
+ 2909, 1073744735, 2913, 2929,
+ 2947, 1073744773, 2954, 1073744782, // NOLINT
+ 2960, 1073744786, 2965, 1073744793,
+ 2970, 2972, 1073744798, 2975, // NOLINT
+ 1073744803, 2980, 1073744808, 2986,
+ 1073744814, 3001, 3024, 1073744901, // NOLINT
+ 3084, 1073744910, 3088, 1073744914,
+ 3112, 1073744938, 3129, 3133, // NOLINT
+ 1073744984, 3161, 1073744992, 3169,
+ 1073745029, 3212, 1073745038, 3216, // NOLINT
+ 1073745042, 3240, 1073745066, 3251,
+ 1073745077, 3257, 3261, 3294, // NOLINT
+ 1073745120, 3297, 1073745137, 3314,
+ 1073745157, 3340, 1073745166, 3344, // NOLINT
+ 1073745170, 3386, 3389, 3406,
+ 1073745248, 3425, 1073745274, 3455, // NOLINT
+ 1073745285, 3478, 1073745306, 3505,
+ 1073745331, 3515, 3517, 1073745344, // NOLINT
+ 3526, 1073745409, 3632, 1073745458,
+ 3635, 1073745472, 3654, 1073745537, // NOLINT
+ 3714, 3716, 1073745543, 3720,
+ 3722, 3725, 1073745556, 3735, // NOLINT
+ 1073745561, 3743, 1073745569, 3747,
+ 3749, 3751, 1073745578, 3755, // NOLINT
+ 1073745581, 3760, 1073745586, 3763,
+ 3773, 1073745600, 3780, 3782, // NOLINT
+ 1073745628, 3807, 3840, 1073745728,
+ 3911, 1073745737, 3948, 1073745800, // NOLINT
+ 3980, 1073745920, 4138, 4159,
+ 1073746000, 4181, 1073746010, 4189, // NOLINT
+ 4193, 1073746021, 4198, 1073746030,
+ 4208, 1073746037, 4225, 4238, // NOLINT
+ 1073746080, 4293, 4295, 4301,
+ 1073746128, 4346, 1073746172, 4680, // NOLINT
+ 1073746506, 4685, 1073746512, 4694,
+ 4696, 1073746522, 4701, 1073746528, // NOLINT
+ 4744, 1073746570, 4749, 1073746576,
+ 4784, 1073746610, 4789, 1073746616, // NOLINT
+ 4798, 4800, 1073746626, 4805,
+ 1073746632, 4822, 1073746648, 4880, // NOLINT
+ 1073746706, 4885, 1073746712, 4954,
+ 1073746816, 5007, 1073746848, 5108, // NOLINT
+ 1073746945, 5740, 1073747567, 5759,
+ 1073747585, 5786, 1073747616, 5866, // NOLINT
+ 1073747694, 5880, 1073747712, 5900,
+ 1073747726, 5905, 1073747744, 5937, // NOLINT
+ 1073747776, 5969, 1073747808, 5996,
+ 1073747822, 6000, 1073747840, 6067, // NOLINT
+ 6103, 6108, 1073748000, 6263,
+ 1073748096, 6312, 6314, 1073748144, // NOLINT
+ 6389, 1073748224, 6430, 1073748304,
+ 6509, 1073748336, 6516, 1073748352, // NOLINT
+ 6571, 1073748417, 6599, 1073748480,
+ 6678, 1073748512, 6740, 6823, // NOLINT
+ 1073748741, 6963, 1073748805, 6987,
+ 1073748867, 7072, 1073748910, 7087, // NOLINT
+ 1073748922, 7141, 1073748992, 7203,
+ 1073749069, 7247, 1073749082, 7293, // NOLINT
+ 1073749225, 7404, 1073749230, 7409,
+ 1073749237, 7414, 1073749248, 7615, // NOLINT
+ 1073749504, 7957, 1073749784, 7965,
+ 1073749792, 8005, 1073749832, 8013, // NOLINT
+ 1073749840, 8023, 8025, 8027,
+ 8029, 1073749855, 8061, 1073749888, // NOLINT
+ 8116, 1073749942, 8124, 8126,
+ 1073749954, 8132, 1073749958, 8140, // NOLINT
+ 1073749968, 8147, 1073749974, 8155,
+ 1073749984, 8172, 1073750002, 8180, // NOLINT
+ 1073750006, 8188}; // NOLINT
+static const uint16_t kID_StartTable1Size = 84;
+static const int32_t kID_StartTable1[84] = {
+ 113, 127, 1073741968, 156,
+ 258, 263, 1073742090, 275, // NOLINT
+ 277, 1073742104, 285, 292,
+ 294, 296, 1073742122, 313, // NOLINT
+ 1073742140, 319, 1073742149, 329,
+ 334, 1073742176, 392, 1073744896, // NOLINT
+ 3118, 1073744944, 3166, 1073744992,
+ 3300, 1073745131, 3310, 1073745138, // NOLINT
+ 3315, 1073745152, 3365, 3367,
+ 3373, 1073745200, 3431, 3439, // NOLINT
+ 1073745280, 3478, 1073745312, 3494,
+ 1073745320, 3502, 1073745328, 3510, // NOLINT
+ 1073745336, 3518, 1073745344, 3526,
+ 1073745352, 3534, 1073745360, 3542, // NOLINT
+ 1073745368, 3550, 1073745925, 4103,
+ 1073745953, 4137, 1073745969, 4149, // NOLINT
+ 1073745976, 4156, 1073745985, 4246,
+ 1073746075, 4255, 1073746081, 4346, // NOLINT
+ 1073746172, 4351, 1073746181, 4397,
+ 1073746225, 4494, 1073746336, 4538, // NOLINT
+ 1073746416, 4607, 1073746944, 8191}; // NOLINT
+static const uint16_t kID_StartTable2Size = 4;
+static const int32_t kID_StartTable2[4] = {1073741824, 3509, 1073745408,
+ 8191}; // NOLINT
+static const uint16_t kID_StartTable3Size = 2;
+static const int32_t kID_StartTable3[2] = {1073741824, 8191}; // NOLINT
+static const uint16_t kID_StartTable4Size = 2;
+static const int32_t kID_StartTable4[2] = {1073741824, 8140}; // NOLINT
+static const uint16_t kID_StartTable5Size = 100;
+static const int32_t kID_StartTable5[100] = {
+ 1073741824, 1164, 1073743056, 1277,
+ 1073743104, 1548, 1073743376, 1567, // NOLINT
+ 1073743402, 1579, 1073743424, 1646,
+ 1073743487, 1693, 1073743520, 1775, // NOLINT
+ 1073743639, 1823, 1073743650, 1928,
+ 1073743755, 1934, 1073743760, 1965, // NOLINT
+ 1073743792, 1969, 1073743863, 2049,
+ 1073743875, 2053, 1073743879, 2058, // NOLINT
+ 1073743884, 2082, 1073743936, 2163,
+ 1073744002, 2227, 1073744114, 2295, // NOLINT
+ 2299, 1073744138, 2341, 1073744176,
+ 2374, 1073744224, 2428, 1073744260, // NOLINT
+ 2482, 2511, 1073744352, 2532,
+ 1073744358, 2543, 1073744378, 2558, // NOLINT
+ 1073744384, 2600, 1073744448, 2626,
+ 1073744452, 2635, 1073744480, 2678, // NOLINT
+ 2682, 1073744510, 2735, 2737,
+ 1073744565, 2742, 1073744569, 2749, // NOLINT
+ 2752, 2754, 1073744603, 2781,
+ 1073744608, 2794, 1073744626, 2804, // NOLINT
+ 1073744641, 2822, 1073744649, 2830,
+ 1073744657, 2838, 1073744672, 2854, // NOLINT
+ 1073744680, 2862, 1073744688, 2906,
+ 1073744732, 2911, 1073744740, 2917, // NOLINT
+ 1073744832, 3042, 1073744896, 8191}; // NOLINT
+static const uint16_t kID_StartTable6Size = 6;
+static const int32_t kID_StartTable6[6] = {1073741824, 6051, 1073747888, 6086,
+ 1073747915, 6139}; // NOLINT
+static const uint16_t kID_StartTable7Size = 48;
+static const int32_t kID_StartTable7[48] = {
+ 1073748224, 6765, 1073748592, 6873,
+ 1073748736, 6918, 1073748755, 6935, // NOLINT
+ 6941, 1073748767, 6952, 1073748778,
+ 6966, 1073748792, 6972, 6974, // NOLINT
+ 1073748800, 6977, 1073748803, 6980,
+ 1073748806, 7089, 1073748947, 7485, // NOLINT
+ 1073749328, 7567, 1073749394, 7623,
+ 1073749488, 7675, 1073749616, 7796, // NOLINT
+ 1073749622, 7932, 1073749793, 7994,
+ 1073749825, 8026, 1073749862, 8126, // NOLINT
+ 1073749954, 8135, 1073749962, 8143,
+ 1073749970, 8151, 1073749978, 8156}; // NOLINT
+bool ID_Start::Is(uchar c) {
int chunk_index = c >> 13;
switch (chunk_index) {
- case 0: return LookupPredicate(kNumberTable0,
- kNumberTable0Size,
- c);
- case 5: return LookupPredicate(kNumberTable5,
- kNumberTable5Size,
- c);
- case 7: return LookupPredicate(kNumberTable7,
- kNumberTable7Size,
- c);
+ case 0:
+ return LookupPredicate(kID_StartTable0, kID_StartTable0Size, c);
+ case 1:
+ return LookupPredicate(kID_StartTable1, kID_StartTable1Size, c);
+ case 2:
+ return LookupPredicate(kID_StartTable2, kID_StartTable2Size, c);
+ case 3:
+ return LookupPredicate(kID_StartTable3, kID_StartTable3Size, c);
+ case 4:
+ return LookupPredicate(kID_StartTable4, kID_StartTable4Size, c);
+ case 5:
+ return LookupPredicate(kID_StartTable5, kID_StartTable5Size, c);
+ case 6:
+ return LookupPredicate(kID_StartTable6, kID_StartTable6Size, c);
+ case 7:
+ return LookupPredicate(kID_StartTable7, kID_StartTable7Size, c);
+ default:
+ return false;
+ }
+}
+
+
+// ID_Continue: point.category in ['Nd', 'Mn', 'Mc', 'Pc'] or
+// 'Other_ID_Continue' in point.properties or 'JS_ID_Continue' in
+// point.properties
+
+static const uint16_t kID_ContinueTable0Size = 315;
+static const int32_t kID_ContinueTable0[315] = {
+ 1073741872, 57, 95, 183,
+ 1073742592, 879, 903, 1073742979, // NOLINT
+ 1159, 1073743249, 1469, 1471,
+ 1073743297, 1474, 1073743300, 1477, // NOLINT
+ 1479, 1073743376, 1562, 1073743435,
+ 1641, 1648, 1073743574, 1756, // NOLINT
+ 1073743583, 1764, 1073743591, 1768,
+ 1073743594, 1773, 1073743600, 1785, // NOLINT
+ 1809, 1073743664, 1866, 1073743782,
+ 1968, 1073743808, 1993, 1073743851, // NOLINT
+ 2035, 1073743894, 2073, 1073743899,
+ 2083, 1073743909, 2087, 1073743913, // NOLINT
+ 2093, 1073743961, 2139, 1073744100,
+ 2307, 1073744186, 2364, 1073744190, // NOLINT
+ 2383, 1073744209, 2391, 1073744226,
+ 2403, 1073744230, 2415, 1073744257, // NOLINT
+ 2435, 2492, 1073744318, 2500,
+ 1073744327, 2504, 1073744331, 2509, // NOLINT
+ 2519, 1073744354, 2531, 1073744358,
+ 2543, 1073744385, 2563, 2620, // NOLINT
+ 1073744446, 2626, 1073744455, 2632,
+ 1073744459, 2637, 2641, 1073744486, // NOLINT
+ 2673, 2677, 1073744513, 2691,
+ 2748, 1073744574, 2757, 1073744583, // NOLINT
+ 2761, 1073744587, 2765, 1073744610,
+ 2787, 1073744614, 2799, 1073744641, // NOLINT
+ 2819, 2876, 1073744702, 2884,
+ 1073744711, 2888, 1073744715, 2893, // NOLINT
+ 1073744726, 2903, 1073744738, 2915,
+ 1073744742, 2927, 2946, 1073744830, // NOLINT
+ 3010, 1073744838, 3016, 1073744842,
+ 3021, 3031, 1073744870, 3055, // NOLINT
+ 1073744896, 3075, 1073744958, 3140,
+ 1073744966, 3144, 1073744970, 3149, // NOLINT
+ 1073744981, 3158, 1073744994, 3171,
+ 1073744998, 3183, 1073745025, 3203, // NOLINT
+ 3260, 1073745086, 3268, 1073745094,
+ 3272, 1073745098, 3277, 1073745109, // NOLINT
+ 3286, 1073745122, 3299, 1073745126,
+ 3311, 1073745153, 3331, 1073745214, // NOLINT
+ 3396, 1073745222, 3400, 1073745226,
+ 3405, 3415, 1073745250, 3427, // NOLINT
+ 1073745254, 3439, 1073745282, 3459,
+ 3530, 1073745359, 3540, 3542, // NOLINT
+ 1073745368, 3551, 1073745382, 3567,
+ 1073745394, 3571, 3633, 1073745460, // NOLINT
+ 3642, 1073745479, 3662, 1073745488,
+ 3673, 3761, 1073745588, 3769, // NOLINT
+ 1073745595, 3772, 1073745608, 3789,
+ 1073745616, 3801, 1073745688, 3865, // NOLINT
+ 1073745696, 3881, 3893, 3895,
+ 3897, 1073745726, 3903, 1073745777, // NOLINT
+ 3972, 1073745798, 3975, 1073745805,
+ 3991, 1073745817, 4028, 4038, // NOLINT
+ 1073745963, 4158, 1073745984, 4169,
+ 1073746006, 4185, 1073746014, 4192, // NOLINT
+ 1073746018, 4196, 1073746023, 4205,
+ 1073746033, 4212, 1073746050, 4237, // NOLINT
+ 1073746063, 4253, 1073746781, 4959,
+ 1073746793, 4977, 1073747730, 5908, // NOLINT
+ 1073747762, 5940, 1073747794, 5971,
+ 1073747826, 6003, 1073747892, 6099, // NOLINT
+ 6109, 1073747936, 6121, 1073747979,
+ 6157, 1073747984, 6169, 6313, // NOLINT
+ 1073748256, 6443, 1073748272, 6459,
+ 1073748294, 6479, 1073748400, 6592, // NOLINT
+ 1073748424, 6601, 1073748432, 6618,
+ 1073748503, 6683, 1073748565, 6750, // NOLINT
+ 1073748576, 6780, 1073748607, 6793,
+ 1073748624, 6809, 1073748656, 6845, // NOLINT
+ 1073748736, 6916, 1073748788, 6980,
+ 1073748816, 7001, 1073748843, 7027, // NOLINT
+ 1073748864, 7042, 1073748897, 7085,
+ 1073748912, 7097, 1073748966, 7155, // NOLINT
+ 1073749028, 7223, 1073749056, 7241,
+ 1073749072, 7257, 1073749200, 7378, // NOLINT
+ 1073749204, 7400, 7405, 1073749234,
+ 7412, 1073749240, 7417, 1073749440, // NOLINT
+ 7669, 1073749500, 7679}; // NOLINT
+static const uint16_t kID_ContinueTable1Size = 19;
+static const int32_t kID_ContinueTable1[19] = {
+ 1073741836, 13, 1073741887, 64,
+ 84, 1073742032, 220, 225, // NOLINT
+ 1073742053, 240, 1073745135, 3313,
+ 3455, 1073745376, 3583, 1073745962, // NOLINT
+ 4143, 1073746073, 4250}; // NOLINT
+static const uint16_t kID_ContinueTable5Size = 63;
+static const int32_t kID_ContinueTable5[63] = {
+ 1073743392, 1577, 1647, 1073743476,
+ 1661, 1695, 1073743600, 1777, // NOLINT
+ 2050, 2054, 2059, 1073743907,
+ 2087, 1073744000, 2177, 1073744052, // NOLINT
+ 2244, 1073744080, 2265, 1073744096,
+ 2289, 1073744128, 2313, 1073744166, // NOLINT
+ 2349, 1073744199, 2387, 1073744256,
+ 2435, 1073744307, 2496, 1073744336, // NOLINT
+ 2521, 2533, 1073744368, 2553,
+ 1073744425, 2614, 2627, 1073744460, // NOLINT
+ 2637, 1073744464, 2649, 1073744507,
+ 2685, 2736, 1073744562, 2740, // NOLINT
+ 1073744567, 2744, 1073744574, 2751,
+ 2753, 1073744619, 2799, 1073744629, // NOLINT
+ 2806, 1073744867, 3050, 1073744876,
+ 3053, 1073744880, 3065}; // NOLINT
+static const uint16_t kID_ContinueTable7Size = 12;
+static const int32_t kID_ContinueTable7[12] = {
+ 6942, 1073749504, 7695, 1073749536,
+ 7725, 1073749555, 7732, 1073749581, // NOLINT
+ 7759, 1073749776, 7961, 7999}; // NOLINT
+bool ID_Continue::Is(uchar c) {
+ int chunk_index = c >> 13;
+ switch (chunk_index) {
+ case 0:
+ return LookupPredicate(kID_ContinueTable0, kID_ContinueTable0Size, c);
+ case 1:
+ return LookupPredicate(kID_ContinueTable1, kID_ContinueTable1Size, c);
+ case 5:
+ return LookupPredicate(kID_ContinueTable5, kID_ContinueTable5Size, c);
+ case 7:
+ return LookupPredicate(kID_ContinueTable7, kID_ContinueTable7Size, c);
default: return false;
}
}
-// WhiteSpace: point.category == 'Zs'
+// WhiteSpace: (point.category == 'Zs') or ('JS_White_Space' in
+// point.properties)
-static const uint16_t kWhiteSpaceTable0Size = 4;
-static const int32_t kWhiteSpaceTable0[4] = {
- 32, 160, 5760, 6158 }; // NOLINT
+static const uint16_t kWhiteSpaceTable0Size = 7;
+static const int32_t kWhiteSpaceTable0[7] = {9, 1073741835, 12, 32,
+ 160, 5760, 6158}; // NOLINT
static const uint16_t kWhiteSpaceTable1Size = 5;
static const int32_t kWhiteSpaceTable1[5] = {
1073741824, 10, 47, 95, 4096 }; // NOLINT
+static const uint16_t kWhiteSpaceTable7Size = 1;
+static const int32_t kWhiteSpaceTable7[1] = {7935}; // NOLINT
bool WhiteSpace::Is(uchar c) {
int chunk_index = c >> 13;
switch (chunk_index) {
case 1: return LookupPredicate(kWhiteSpaceTable1,
kWhiteSpaceTable1Size,
c);
+ case 7:
+ return LookupPredicate(kWhiteSpaceTable7, kWhiteSpaceTable7Size, c);
default: return false;
}
}
-// LineTerminator: 'Lt' in point.properties
+// LineTerminator: 'JS_Line_Terminator' in point.properties
static const uint16_t kLineTerminatorTable0Size = 2;
static const int32_t kLineTerminatorTable0[2] = {
}
}
-
-// CombiningMark: point.category in ['Mn', 'Mc']
-
-static const uint16_t kCombiningMarkTable0Size = 258;
-static const int32_t kCombiningMarkTable0[258] = {
- 1073742592, 879, 1073742979, 1159, 1073743249, 1469, 1471, 1073743297, // NOLINT
- 1474, 1073743300, 1477, 1479, 1073743376, 1562, 1073743435, 1631, // NOLINT
- 1648, 1073743574, 1756, 1073743583, 1764, 1073743591, 1768, 1073743594, // NOLINT
- 1773, 1809, 1073743664, 1866, 1073743782, 1968, 1073743851, 2035, // NOLINT
- 1073743894, 2073, 1073743899, 2083, 1073743909, 2087, 1073743913, 2093, // NOLINT
- 1073743961, 2139, 1073744100, 2302, 1073744128, 2307, 1073744186, 2364, // NOLINT
- 1073744190, 2383, 1073744209, 2391, 1073744226, 2403, 1073744257, 2435, // NOLINT
- 2492, 1073744318, 2500, 1073744327, 2504, 1073744331, 2509, 2519, // NOLINT
- 1073744354, 2531, 1073744385, 2563, 2620, 1073744446, 2626, 1073744455, // NOLINT
- 2632, 1073744459, 2637, 2641, 1073744496, 2673, 2677, 1073744513, // NOLINT
- 2691, 2748, 1073744574, 2757, 1073744583, 2761, 1073744587, 2765, // NOLINT
- 1073744610, 2787, 1073744641, 2819, 2876, 1073744702, 2884, 1073744711, // NOLINT
- 2888, 1073744715, 2893, 1073744726, 2903, 1073744738, 2915, 2946, // NOLINT
- 1073744830, 3010, 1073744838, 3016, 1073744842, 3021, 3031, 1073744897, // NOLINT
- 3075, 1073744958, 3140, 1073744966, 3144, 1073744970, 3149, 1073744981, // NOLINT
- 3158, 1073744994, 3171, 1073745026, 3203, 3260, 1073745086, 3268, // NOLINT
- 1073745094, 3272, 1073745098, 3277, 1073745109, 3286, 1073745122, 3299, // NOLINT
- 1073745154, 3331, 1073745214, 3396, 1073745222, 3400, 1073745226, 3405, // NOLINT
- 3415, 1073745250, 3427, 1073745282, 3459, 3530, 1073745359, 3540, // NOLINT
- 3542, 1073745368, 3551, 1073745394, 3571, 3633, 1073745460, 3642, // NOLINT
- 1073745479, 3662, 3761, 1073745588, 3769, 1073745595, 3772, 1073745608, // NOLINT
- 3789, 1073745688, 3865, 3893, 3895, 3897, 1073745726, 3903, // NOLINT
- 1073745777, 3972, 1073745798, 3975, 1073745805, 3991, 1073745817, 4028, // NOLINT
- 4038, 1073745963, 4158, 1073746006, 4185, 1073746014, 4192, 1073746018, // NOLINT
- 4196, 1073746023, 4205, 1073746033, 4212, 1073746050, 4237, 4239, // NOLINT
- 1073746074, 4253, 1073746781, 4959, 1073747730, 5908, 1073747762, 5940, // NOLINT
- 1073747794, 5971, 1073747826, 6003, 1073747892, 6099, 6109, 1073747979, // NOLINT
- 6157, 6313, 1073748256, 6443, 1073748272, 6459, 1073748400, 6592, // NOLINT
- 1073748424, 6601, 1073748503, 6683, 1073748565, 6750, 1073748576, 6780, // NOLINT
- 6783, 1073748736, 6916, 1073748788, 6980, 1073748843, 7027, 1073748864, // NOLINT
- 7042, 1073748897, 7085, 1073748966, 7155, 1073749028, 7223, 1073749200, // NOLINT
- 7378, 1073749204, 7400, 7405, 1073749234, 7412, 1073749440, 7654, // NOLINT
- 1073749500, 7679 }; // NOLINT
-static const uint16_t kCombiningMarkTable1Size = 14;
-static const int32_t kCombiningMarkTable1[14] = {
- 1073742032, 220, 225, 1073742053, 240, 1073745135, 3313, 3455, // NOLINT
- 1073745376, 3583, 1073745962, 4143, 1073746073, 4250 }; // NOLINT
-static const uint16_t kCombiningMarkTable5Size = 47;
-static const int32_t kCombiningMarkTable5[47] = {
- 1647, 1073743476, 1661, 1695, 1073743600, 1777, 2050, 2054, // NOLINT
- 2059, 1073743907, 2087, 1073744000, 2177, 1073744052, 2244, 1073744096, // NOLINT
- 2289, 1073744166, 2349, 1073744199, 2387, 1073744256, 2435, 1073744307, // NOLINT
- 2496, 1073744425, 2614, 2627, 1073744460, 2637, 2683, 2736, // NOLINT
- 1073744562, 2740, 1073744567, 2744, 1073744574, 2751, 2753, 1073744619, // NOLINT
- 2799, 1073744629, 2806, 1073744867, 3050, 1073744876, 3053 }; // NOLINT
-static const uint16_t kCombiningMarkTable7Size = 5;
-static const int32_t kCombiningMarkTable7[5] = {
- 6942, 1073749504, 7695, 1073749536, 7718 }; // NOLINT
-bool CombiningMark::Is(uchar c) {
- int chunk_index = c >> 13;
- switch (chunk_index) {
- case 0: return LookupPredicate(kCombiningMarkTable0,
- kCombiningMarkTable0Size,
- c);
- case 1: return LookupPredicate(kCombiningMarkTable1,
- kCombiningMarkTable1Size,
- c);
- case 5: return LookupPredicate(kCombiningMarkTable5,
- kCombiningMarkTable5Size,
- c);
- case 7: return LookupPredicate(kCombiningMarkTable7,
- kCombiningMarkTable7Size,
- c);
- default: return false;
- }
-}
-
-
-// ConnectorPunctuation: point.category == 'Pc'
-
-static const uint16_t kConnectorPunctuationTable0Size = 1;
-static const int32_t kConnectorPunctuationTable0[1] = {
- 95 }; // NOLINT
-static const uint16_t kConnectorPunctuationTable1Size = 3;
-static const int32_t kConnectorPunctuationTable1[3] = {
- 1073741887, 64, 84 }; // NOLINT
-static const uint16_t kConnectorPunctuationTable7Size = 5;
-static const int32_t kConnectorPunctuationTable7[5] = {
- 1073749555, 7732, 1073749581, 7759, 7999 }; // NOLINT
-bool ConnectorPunctuation::Is(uchar c) {
- int chunk_index = c >> 13;
- switch (chunk_index) {
- case 0: return LookupPredicate(kConnectorPunctuationTable0,
- kConnectorPunctuationTable0Size,
- c);
- case 1: return LookupPredicate(kConnectorPunctuationTable1,
- kConnectorPunctuationTable1Size,
- c);
- case 7: return LookupPredicate(kConnectorPunctuationTable7,
- kConnectorPunctuationTable7Size,
- c);
- default: return false;
- }
-}
-
static const MultiCharacterSpecialCase<2> kToLowercaseMultiStrings0[2] = { // NOLINT
{{105, 775}}, {{kSentinel}} }; // NOLINT
-static const uint16_t kToLowercaseTable0Size = 483; // NOLINT
-static const int32_t kToLowercaseTable0[966] = {
- 1073741889, 128, 90, 128, 1073742016, 128, 214, 128, 1073742040, 128, 222, 128, 256, 4, 258, 4, // NOLINT
- 260, 4, 262, 4, 264, 4, 266, 4, 268, 4, 270, 4, 272, 4, 274, 4, // NOLINT
- 276, 4, 278, 4, 280, 4, 282, 4, 284, 4, 286, 4, 288, 4, 290, 4, // NOLINT
- 292, 4, 294, 4, 296, 4, 298, 4, 300, 4, 302, 4, 304, 1, 306, 4, // NOLINT
- 308, 4, 310, 4, 313, 4, 315, 4, 317, 4, 319, 4, 321, 4, 323, 4, // NOLINT
- 325, 4, 327, 4, 330, 4, 332, 4, 334, 4, 336, 4, 338, 4, 340, 4, // NOLINT
- 342, 4, 344, 4, 346, 4, 348, 4, 350, 4, 352, 4, 354, 4, 356, 4, // NOLINT
- 358, 4, 360, 4, 362, 4, 364, 4, 366, 4, 368, 4, 370, 4, 372, 4, // NOLINT
- 374, 4, 376, -484, 377, 4, 379, 4, 381, 4, 385, 840, 386, 4, 388, 4, // NOLINT
- 390, 824, 391, 4, 1073742217, 820, 394, 820, 395, 4, 398, 316, 399, 808, 400, 812, // NOLINT
- 401, 4, 403, 820, 404, 828, 406, 844, 407, 836, 408, 4, 412, 844, 413, 852, // NOLINT
- 415, 856, 416, 4, 418, 4, 420, 4, 422, 872, 423, 4, 425, 872, 428, 4, // NOLINT
- 430, 872, 431, 4, 1073742257, 868, 434, 868, 435, 4, 437, 4, 439, 876, 440, 4, // NOLINT
- 444, 4, 452, 8, 453, 4, 455, 8, 456, 4, 458, 8, 459, 4, 461, 4, // NOLINT
- 463, 4, 465, 4, 467, 4, 469, 4, 471, 4, 473, 4, 475, 4, 478, 4, // NOLINT
- 480, 4, 482, 4, 484, 4, 486, 4, 488, 4, 490, 4, 492, 4, 494, 4, // NOLINT
- 497, 8, 498, 4, 500, 4, 502, -388, 503, -224, 504, 4, 506, 4, 508, 4, // NOLINT
- 510, 4, 512, 4, 514, 4, 516, 4, 518, 4, 520, 4, 522, 4, 524, 4, // NOLINT
- 526, 4, 528, 4, 530, 4, 532, 4, 534, 4, 536, 4, 538, 4, 540, 4, // NOLINT
- 542, 4, 544, -520, 546, 4, 548, 4, 550, 4, 552, 4, 554, 4, 556, 4, // NOLINT
- 558, 4, 560, 4, 562, 4, 570, 43180, 571, 4, 573, -652, 574, 43168, 577, 4, // NOLINT
- 579, -780, 580, 276, 581, 284, 582, 4, 584, 4, 586, 4, 588, 4, 590, 4, // NOLINT
- 880, 4, 882, 4, 886, 4, 902, 152, 1073742728, 148, 906, 148, 908, 256, 1073742734, 252, // NOLINT
- 911, 252, 1073742737, 128, 929, 128, 931, 6, 1073742756, 128, 939, 128, 975, 32, 984, 4, // NOLINT
- 986, 4, 988, 4, 990, 4, 992, 4, 994, 4, 996, 4, 998, 4, 1000, 4, // NOLINT
- 1002, 4, 1004, 4, 1006, 4, 1012, -240, 1015, 4, 1017, -28, 1018, 4, 1073742845, -520, // NOLINT
- 1023, -520, 1073742848, 320, 1039, 320, 1073742864, 128, 1071, 128, 1120, 4, 1122, 4, 1124, 4, // NOLINT
- 1126, 4, 1128, 4, 1130, 4, 1132, 4, 1134, 4, 1136, 4, 1138, 4, 1140, 4, // NOLINT
- 1142, 4, 1144, 4, 1146, 4, 1148, 4, 1150, 4, 1152, 4, 1162, 4, 1164, 4, // NOLINT
- 1166, 4, 1168, 4, 1170, 4, 1172, 4, 1174, 4, 1176, 4, 1178, 4, 1180, 4, // NOLINT
- 1182, 4, 1184, 4, 1186, 4, 1188, 4, 1190, 4, 1192, 4, 1194, 4, 1196, 4, // NOLINT
- 1198, 4, 1200, 4, 1202, 4, 1204, 4, 1206, 4, 1208, 4, 1210, 4, 1212, 4, // NOLINT
- 1214, 4, 1216, 60, 1217, 4, 1219, 4, 1221, 4, 1223, 4, 1225, 4, 1227, 4, // NOLINT
- 1229, 4, 1232, 4, 1234, 4, 1236, 4, 1238, 4, 1240, 4, 1242, 4, 1244, 4, // NOLINT
- 1246, 4, 1248, 4, 1250, 4, 1252, 4, 1254, 4, 1256, 4, 1258, 4, 1260, 4, // NOLINT
- 1262, 4, 1264, 4, 1266, 4, 1268, 4, 1270, 4, 1272, 4, 1274, 4, 1276, 4, // NOLINT
- 1278, 4, 1280, 4, 1282, 4, 1284, 4, 1286, 4, 1288, 4, 1290, 4, 1292, 4, // NOLINT
- 1294, 4, 1296, 4, 1298, 4, 1300, 4, 1302, 4, 1304, 4, 1306, 4, 1308, 4, // NOLINT
- 1310, 4, 1312, 4, 1314, 4, 1316, 4, 1318, 4, 1073743153, 192, 1366, 192, 1073746080, 29056, // NOLINT
- 4293, 29056, 4295, 29056, 4301, 29056, 7680, 4, 7682, 4, 7684, 4, 7686, 4, 7688, 4, // NOLINT
- 7690, 4, 7692, 4, 7694, 4, 7696, 4, 7698, 4, 7700, 4, 7702, 4, 7704, 4, // NOLINT
- 7706, 4, 7708, 4, 7710, 4, 7712, 4, 7714, 4, 7716, 4, 7718, 4, 7720, 4, // NOLINT
- 7722, 4, 7724, 4, 7726, 4, 7728, 4, 7730, 4, 7732, 4, 7734, 4, 7736, 4, // NOLINT
- 7738, 4, 7740, 4, 7742, 4, 7744, 4, 7746, 4, 7748, 4, 7750, 4, 7752, 4, // NOLINT
- 7754, 4, 7756, 4, 7758, 4, 7760, 4, 7762, 4, 7764, 4, 7766, 4, 7768, 4, // NOLINT
- 7770, 4, 7772, 4, 7774, 4, 7776, 4, 7778, 4, 7780, 4, 7782, 4, 7784, 4, // NOLINT
- 7786, 4, 7788, 4, 7790, 4, 7792, 4, 7794, 4, 7796, 4, 7798, 4, 7800, 4, // NOLINT
- 7802, 4, 7804, 4, 7806, 4, 7808, 4, 7810, 4, 7812, 4, 7814, 4, 7816, 4, // NOLINT
- 7818, 4, 7820, 4, 7822, 4, 7824, 4, 7826, 4, 7828, 4, 7838, -30460, 7840, 4, // NOLINT
- 7842, 4, 7844, 4, 7846, 4, 7848, 4, 7850, 4, 7852, 4, 7854, 4, 7856, 4, // NOLINT
- 7858, 4, 7860, 4, 7862, 4, 7864, 4, 7866, 4, 7868, 4, 7870, 4, 7872, 4, // NOLINT
- 7874, 4, 7876, 4, 7878, 4, 7880, 4, 7882, 4, 7884, 4, 7886, 4, 7888, 4, // NOLINT
- 7890, 4, 7892, 4, 7894, 4, 7896, 4, 7898, 4, 7900, 4, 7902, 4, 7904, 4, // NOLINT
- 7906, 4, 7908, 4, 7910, 4, 7912, 4, 7914, 4, 7916, 4, 7918, 4, 7920, 4, // NOLINT
- 7922, 4, 7924, 4, 7926, 4, 7928, 4, 7930, 4, 7932, 4, 7934, 4, 1073749768, -32, // NOLINT
- 7951, -32, 1073749784, -32, 7965, -32, 1073749800, -32, 7983, -32, 1073749816, -32, 7999, -32, 1073749832, -32, // NOLINT
- 8013, -32, 8025, -32, 8027, -32, 8029, -32, 8031, -32, 1073749864, -32, 8047, -32, 1073749896, -32, // NOLINT
- 8079, -32, 1073749912, -32, 8095, -32, 1073749928, -32, 8111, -32, 1073749944, -32, 8121, -32, 1073749946, -296, // NOLINT
- 8123, -296, 8124, -36, 1073749960, -344, 8139, -344, 8140, -36, 1073749976, -32, 8153, -32, 1073749978, -400, // NOLINT
- 8155, -400, 1073749992, -32, 8169, -32, 1073749994, -448, 8171, -448, 8172, -28, 1073750008, -512, 8185, -512, // NOLINT
- 1073750010, -504, 8187, -504, 8188, -36 }; // NOLINT
+static const uint16_t kToLowercaseTable0Size = 488; // NOLINT
+static const int32_t kToLowercaseTable0[976] = {
+ 1073741889, 128, 90, 128, 1073742016, 128,
+ 214, 128, 1073742040, 128, 222, 128,
+ 256, 4, 258, 4, // NOLINT
+ 260, 4, 262, 4, 264, 4,
+ 266, 4, 268, 4, 270, 4,
+ 272, 4, 274, 4, // NOLINT
+ 276, 4, 278, 4, 280, 4,
+ 282, 4, 284, 4, 286, 4,
+ 288, 4, 290, 4, // NOLINT
+ 292, 4, 294, 4, 296, 4,
+ 298, 4, 300, 4, 302, 4,
+ 304, 1, 306, 4, // NOLINT
+ 308, 4, 310, 4, 313, 4,
+ 315, 4, 317, 4, 319, 4,
+ 321, 4, 323, 4, // NOLINT
+ 325, 4, 327, 4, 330, 4,
+ 332, 4, 334, 4, 336, 4,
+ 338, 4, 340, 4, // NOLINT
+ 342, 4, 344, 4, 346, 4,
+ 348, 4, 350, 4, 352, 4,
+ 354, 4, 356, 4, // NOLINT
+ 358, 4, 360, 4, 362, 4,
+ 364, 4, 366, 4, 368, 4,
+ 370, 4, 372, 4, // NOLINT
+ 374, 4, 376, -484, 377, 4,
+ 379, 4, 381, 4, 385, 840,
+ 386, 4, 388, 4, // NOLINT
+ 390, 824, 391, 4, 1073742217, 820,
+ 394, 820, 395, 4, 398, 316,
+ 399, 808, 400, 812, // NOLINT
+ 401, 4, 403, 820, 404, 828,
+ 406, 844, 407, 836, 408, 4,
+ 412, 844, 413, 852, // NOLINT
+ 415, 856, 416, 4, 418, 4,
+ 420, 4, 422, 872, 423, 4,
+ 425, 872, 428, 4, // NOLINT
+ 430, 872, 431, 4, 1073742257, 868,
+ 434, 868, 435, 4, 437, 4,
+ 439, 876, 440, 4, // NOLINT
+ 444, 4, 452, 8, 453, 4,
+ 455, 8, 456, 4, 458, 8,
+ 459, 4, 461, 4, // NOLINT
+ 463, 4, 465, 4, 467, 4,
+ 469, 4, 471, 4, 473, 4,
+ 475, 4, 478, 4, // NOLINT
+ 480, 4, 482, 4, 484, 4,
+ 486, 4, 488, 4, 490, 4,
+ 492, 4, 494, 4, // NOLINT
+ 497, 8, 498, 4, 500, 4,
+ 502, -388, 503, -224, 504, 4,
+ 506, 4, 508, 4, // NOLINT
+ 510, 4, 512, 4, 514, 4,
+ 516, 4, 518, 4, 520, 4,
+ 522, 4, 524, 4, // NOLINT
+ 526, 4, 528, 4, 530, 4,
+ 532, 4, 534, 4, 536, 4,
+ 538, 4, 540, 4, // NOLINT
+ 542, 4, 544, -520, 546, 4,
+ 548, 4, 550, 4, 552, 4,
+ 554, 4, 556, 4, // NOLINT
+ 558, 4, 560, 4, 562, 4,
+ 570, 43180, 571, 4, 573, -652,
+ 574, 43168, 577, 4, // NOLINT
+ 579, -780, 580, 276, 581, 284,
+ 582, 4, 584, 4, 586, 4,
+ 588, 4, 590, 4, // NOLINT
+ 880, 4, 882, 4, 886, 4,
+ 895, 464, 902, 152, 1073742728, 148,
+ 906, 148, 908, 256, // NOLINT
+ 1073742734, 252, 911, 252, 1073742737, 128,
+ 929, 128, 931, 6, 1073742756, 128,
+ 939, 128, 975, 32, // NOLINT
+ 984, 4, 986, 4, 988, 4,
+ 990, 4, 992, 4, 994, 4,
+ 996, 4, 998, 4, // NOLINT
+ 1000, 4, 1002, 4, 1004, 4,
+ 1006, 4, 1012, -240, 1015, 4,
+ 1017, -28, 1018, 4, // NOLINT
+ 1073742845, -520, 1023, -520, 1073742848, 320,
+ 1039, 320, 1073742864, 128, 1071, 128,
+ 1120, 4, 1122, 4, // NOLINT
+ 1124, 4, 1126, 4, 1128, 4,
+ 1130, 4, 1132, 4, 1134, 4,
+ 1136, 4, 1138, 4, // NOLINT
+ 1140, 4, 1142, 4, 1144, 4,
+ 1146, 4, 1148, 4, 1150, 4,
+ 1152, 4, 1162, 4, // NOLINT
+ 1164, 4, 1166, 4, 1168, 4,
+ 1170, 4, 1172, 4, 1174, 4,
+ 1176, 4, 1178, 4, // NOLINT
+ 1180, 4, 1182, 4, 1184, 4,
+ 1186, 4, 1188, 4, 1190, 4,
+ 1192, 4, 1194, 4, // NOLINT
+ 1196, 4, 1198, 4, 1200, 4,
+ 1202, 4, 1204, 4, 1206, 4,
+ 1208, 4, 1210, 4, // NOLINT
+ 1212, 4, 1214, 4, 1216, 60,
+ 1217, 4, 1219, 4, 1221, 4,
+ 1223, 4, 1225, 4, // NOLINT
+ 1227, 4, 1229, 4, 1232, 4,
+ 1234, 4, 1236, 4, 1238, 4,
+ 1240, 4, 1242, 4, // NOLINT
+ 1244, 4, 1246, 4, 1248, 4,
+ 1250, 4, 1252, 4, 1254, 4,
+ 1256, 4, 1258, 4, // NOLINT
+ 1260, 4, 1262, 4, 1264, 4,
+ 1266, 4, 1268, 4, 1270, 4,
+ 1272, 4, 1274, 4, // NOLINT
+ 1276, 4, 1278, 4, 1280, 4,
+ 1282, 4, 1284, 4, 1286, 4,
+ 1288, 4, 1290, 4, // NOLINT
+ 1292, 4, 1294, 4, 1296, 4,
+ 1298, 4, 1300, 4, 1302, 4,
+ 1304, 4, 1306, 4, // NOLINT
+ 1308, 4, 1310, 4, 1312, 4,
+ 1314, 4, 1316, 4, 1318, 4,
+ 1320, 4, 1322, 4, // NOLINT
+ 1324, 4, 1326, 4, 1073743153, 192,
+ 1366, 192, 1073746080, 29056, 4293, 29056,
+ 4295, 29056, 4301, 29056, // NOLINT
+ 7680, 4, 7682, 4, 7684, 4,
+ 7686, 4, 7688, 4, 7690, 4,
+ 7692, 4, 7694, 4, // NOLINT
+ 7696, 4, 7698, 4, 7700, 4,
+ 7702, 4, 7704, 4, 7706, 4,
+ 7708, 4, 7710, 4, // NOLINT
+ 7712, 4, 7714, 4, 7716, 4,
+ 7718, 4, 7720, 4, 7722, 4,
+ 7724, 4, 7726, 4, // NOLINT
+ 7728, 4, 7730, 4, 7732, 4,
+ 7734, 4, 7736, 4, 7738, 4,
+ 7740, 4, 7742, 4, // NOLINT
+ 7744, 4, 7746, 4, 7748, 4,
+ 7750, 4, 7752, 4, 7754, 4,
+ 7756, 4, 7758, 4, // NOLINT
+ 7760, 4, 7762, 4, 7764, 4,
+ 7766, 4, 7768, 4, 7770, 4,
+ 7772, 4, 7774, 4, // NOLINT
+ 7776, 4, 7778, 4, 7780, 4,
+ 7782, 4, 7784, 4, 7786, 4,
+ 7788, 4, 7790, 4, // NOLINT
+ 7792, 4, 7794, 4, 7796, 4,
+ 7798, 4, 7800, 4, 7802, 4,
+ 7804, 4, 7806, 4, // NOLINT
+ 7808, 4, 7810, 4, 7812, 4,
+ 7814, 4, 7816, 4, 7818, 4,
+ 7820, 4, 7822, 4, // NOLINT
+ 7824, 4, 7826, 4, 7828, 4,
+ 7838, -30460, 7840, 4, 7842, 4,
+ 7844, 4, 7846, 4, // NOLINT
+ 7848, 4, 7850, 4, 7852, 4,
+ 7854, 4, 7856, 4, 7858, 4,
+ 7860, 4, 7862, 4, // NOLINT
+ 7864, 4, 7866, 4, 7868, 4,
+ 7870, 4, 7872, 4, 7874, 4,
+ 7876, 4, 7878, 4, // NOLINT
+ 7880, 4, 7882, 4, 7884, 4,
+ 7886, 4, 7888, 4, 7890, 4,
+ 7892, 4, 7894, 4, // NOLINT
+ 7896, 4, 7898, 4, 7900, 4,
+ 7902, 4, 7904, 4, 7906, 4,
+ 7908, 4, 7910, 4, // NOLINT
+ 7912, 4, 7914, 4, 7916, 4,
+ 7918, 4, 7920, 4, 7922, 4,
+ 7924, 4, 7926, 4, // NOLINT
+ 7928, 4, 7930, 4, 7932, 4,
+ 7934, 4, 1073749768, -32, 7951, -32,
+ 1073749784, -32, 7965, -32, // NOLINT
+ 1073749800, -32, 7983, -32, 1073749816, -32,
+ 7999, -32, 1073749832, -32, 8013, -32,
+ 8025, -32, 8027, -32, // NOLINT
+ 8029, -32, 8031, -32, 1073749864, -32,
+ 8047, -32, 1073749896, -32, 8079, -32,
+ 1073749912, -32, 8095, -32, // NOLINT
+ 1073749928, -32, 8111, -32, 1073749944, -32,
+ 8121, -32, 1073749946, -296, 8123, -296,
+ 8124, -36, 1073749960, -344, // NOLINT
+ 8139, -344, 8140, -36, 1073749976, -32,
+ 8153, -32, 1073749978, -400, 8155, -400,
+ 1073749992, -32, 8169, -32, // NOLINT
+ 1073749994, -448, 8171, -448, 8172, -28,
+ 1073750008, -512, 8185, -512, 1073750010, -504,
+ 8187, -504, 8188, -36}; // NOLINT
static const uint16_t kToLowercaseMultiStrings0Size = 2; // NOLINT
static const MultiCharacterSpecialCase<1> kToLowercaseMultiStrings1[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
static const uint16_t kToLowercaseMultiStrings1Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kToLowercaseMultiStrings5[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
-static const uint16_t kToLowercaseTable5Size = 91; // NOLINT
-static const int32_t kToLowercaseTable5[182] = {
- 1600, 4, 1602, 4, 1604, 4, 1606, 4, 1608, 4, 1610, 4, 1612, 4, 1614, 4, // NOLINT
- 1616, 4, 1618, 4, 1620, 4, 1622, 4, 1624, 4, 1626, 4, 1628, 4, 1630, 4, // NOLINT
- 1632, 4, 1634, 4, 1636, 4, 1638, 4, 1640, 4, 1642, 4, 1644, 4, 1664, 4, // NOLINT
- 1666, 4, 1668, 4, 1670, 4, 1672, 4, 1674, 4, 1676, 4, 1678, 4, 1680, 4, // NOLINT
- 1682, 4, 1684, 4, 1686, 4, 1826, 4, 1828, 4, 1830, 4, 1832, 4, 1834, 4, // NOLINT
- 1836, 4, 1838, 4, 1842, 4, 1844, 4, 1846, 4, 1848, 4, 1850, 4, 1852, 4, // NOLINT
- 1854, 4, 1856, 4, 1858, 4, 1860, 4, 1862, 4, 1864, 4, 1866, 4, 1868, 4, // NOLINT
- 1870, 4, 1872, 4, 1874, 4, 1876, 4, 1878, 4, 1880, 4, 1882, 4, 1884, 4, // NOLINT
- 1886, 4, 1888, 4, 1890, 4, 1892, 4, 1894, 4, 1896, 4, 1898, 4, 1900, 4, // NOLINT
- 1902, 4, 1913, 4, 1915, 4, 1917, -141328, 1918, 4, 1920, 4, 1922, 4, 1924, 4, // NOLINT
- 1926, 4, 1931, 4, 1933, -169120, 1936, 4, 1938, 4, 1952, 4, 1954, 4, 1956, 4, // NOLINT
- 1958, 4, 1960, 4, 1962, -169232 }; // NOLINT
+static const uint16_t kToLowercaseTable5Size = 103; // NOLINT
+static const int32_t kToLowercaseTable5[206] = {
+ 1600, 4, 1602, 4, 1604, 4, 1606, 4,
+ 1608, 4, 1610, 4, 1612, 4, 1614, 4, // NOLINT
+ 1616, 4, 1618, 4, 1620, 4, 1622, 4,
+ 1624, 4, 1626, 4, 1628, 4, 1630, 4, // NOLINT
+ 1632, 4, 1634, 4, 1636, 4, 1638, 4,
+ 1640, 4, 1642, 4, 1644, 4, 1664, 4, // NOLINT
+ 1666, 4, 1668, 4, 1670, 4, 1672, 4,
+ 1674, 4, 1676, 4, 1678, 4, 1680, 4, // NOLINT
+ 1682, 4, 1684, 4, 1686, 4, 1688, 4,
+ 1690, 4, 1826, 4, 1828, 4, 1830, 4, // NOLINT
+ 1832, 4, 1834, 4, 1836, 4, 1838, 4,
+ 1842, 4, 1844, 4, 1846, 4, 1848, 4, // NOLINT
+ 1850, 4, 1852, 4, 1854, 4, 1856, 4,
+ 1858, 4, 1860, 4, 1862, 4, 1864, 4, // NOLINT
+ 1866, 4, 1868, 4, 1870, 4, 1872, 4,
+ 1874, 4, 1876, 4, 1878, 4, 1880, 4, // NOLINT
+ 1882, 4, 1884, 4, 1886, 4, 1888, 4,
+ 1890, 4, 1892, 4, 1894, 4, 1896, 4, // NOLINT
+ 1898, 4, 1900, 4, 1902, 4, 1913, 4,
+ 1915, 4, 1917, -141328, 1918, 4, 1920, 4, // NOLINT
+ 1922, 4, 1924, 4, 1926, 4, 1931, 4,
+ 1933, -169120, 1936, 4, 1938, 4, 1942, 4, // NOLINT
+ 1944, 4, 1946, 4, 1948, 4, 1950, 4,
+ 1952, 4, 1954, 4, 1956, 4, 1958, 4, // NOLINT
+ 1960, 4, 1962, -169232, 1963, -169276, 1964, -169260,
+ 1965, -169220, 1968, -169032, 1969, -169128}; // NOLINT
static const uint16_t kToLowercaseMultiStrings5Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kToLowercaseMultiStrings7[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
{{933, 776, 768}}, {{929, 787, kSentinel}}, {{933, 834, kSentinel}}, {{933, 776, 834}}, // NOLINT
{{8186, 921, kSentinel}}, {{937, 921, kSentinel}}, {{911, 921, kSentinel}}, {{937, 834, kSentinel}}, // NOLINT
{{937, 834, 921}}, {{kSentinel}} }; // NOLINT
-static const uint16_t kToUppercaseTable0Size = 580; // NOLINT
-static const int32_t kToUppercaseTable0[1160] = {
- 1073741921, -128, 122, -128, 181, 2972, 223, 1, 1073742048, -128, 246, -128, 1073742072, -128, 254, -128, // NOLINT
- 255, 484, 257, -4, 259, -4, 261, -4, 263, -4, 265, -4, 267, -4, 269, -4, // NOLINT
- 271, -4, 273, -4, 275, -4, 277, -4, 279, -4, 281, -4, 283, -4, 285, -4, // NOLINT
- 287, -4, 289, -4, 291, -4, 293, -4, 295, -4, 297, -4, 299, -4, 301, -4, // NOLINT
- 303, -4, 305, -928, 307, -4, 309, -4, 311, -4, 314, -4, 316, -4, 318, -4, // NOLINT
- 320, -4, 322, -4, 324, -4, 326, -4, 328, -4, 329, 5, 331, -4, 333, -4, // NOLINT
- 335, -4, 337, -4, 339, -4, 341, -4, 343, -4, 345, -4, 347, -4, 349, -4, // NOLINT
- 351, -4, 353, -4, 355, -4, 357, -4, 359, -4, 361, -4, 363, -4, 365, -4, // NOLINT
- 367, -4, 369, -4, 371, -4, 373, -4, 375, -4, 378, -4, 380, -4, 382, -4, // NOLINT
- 383, -1200, 384, 780, 387, -4, 389, -4, 392, -4, 396, -4, 402, -4, 405, 388, // NOLINT
- 409, -4, 410, 652, 414, 520, 417, -4, 419, -4, 421, -4, 424, -4, 429, -4, // NOLINT
- 432, -4, 436, -4, 438, -4, 441, -4, 445, -4, 447, 224, 453, -4, 454, -8, // NOLINT
- 456, -4, 457, -8, 459, -4, 460, -8, 462, -4, 464, -4, 466, -4, 468, -4, // NOLINT
- 470, -4, 472, -4, 474, -4, 476, -4, 477, -316, 479, -4, 481, -4, 483, -4, // NOLINT
- 485, -4, 487, -4, 489, -4, 491, -4, 493, -4, 495, -4, 496, 9, 498, -4, // NOLINT
- 499, -8, 501, -4, 505, -4, 507, -4, 509, -4, 511, -4, 513, -4, 515, -4, // NOLINT
- 517, -4, 519, -4, 521, -4, 523, -4, 525, -4, 527, -4, 529, -4, 531, -4, // NOLINT
- 533, -4, 535, -4, 537, -4, 539, -4, 541, -4, 543, -4, 547, -4, 549, -4, // NOLINT
- 551, -4, 553, -4, 555, -4, 557, -4, 559, -4, 561, -4, 563, -4, 572, -4, // NOLINT
- 1073742399, 43260, 576, 43260, 578, -4, 583, -4, 585, -4, 587, -4, 589, -4, 591, -4, // NOLINT
- 592, 43132, 593, 43120, 594, 43128, 595, -840, 596, -824, 1073742422, -820, 599, -820, 601, -808, // NOLINT
- 603, -812, 608, -820, 611, -828, 613, 169120, 614, 169232, 616, -836, 617, -844, 619, 42972, // NOLINT
- 623, -844, 625, 42996, 626, -852, 629, -856, 637, 42908, 640, -872, 643, -872, 648, -872, // NOLINT
- 649, -276, 1073742474, -868, 651, -868, 652, -284, 658, -876, 837, 336, 881, -4, 883, -4, // NOLINT
- 887, -4, 1073742715, 520, 893, 520, 912, 13, 940, -152, 1073742765, -148, 943, -148, 944, 17, // NOLINT
- 1073742769, -128, 961, -128, 962, -124, 1073742787, -128, 971, -128, 972, -256, 1073742797, -252, 974, -252, // NOLINT
- 976, -248, 977, -228, 981, -188, 982, -216, 983, -32, 985, -4, 987, -4, 989, -4, // NOLINT
- 991, -4, 993, -4, 995, -4, 997, -4, 999, -4, 1001, -4, 1003, -4, 1005, -4, // NOLINT
- 1007, -4, 1008, -344, 1009, -320, 1010, 28, 1013, -384, 1016, -4, 1019, -4, 1073742896, -128, // NOLINT
- 1103, -128, 1073742928, -320, 1119, -320, 1121, -4, 1123, -4, 1125, -4, 1127, -4, 1129, -4, // NOLINT
- 1131, -4, 1133, -4, 1135, -4, 1137, -4, 1139, -4, 1141, -4, 1143, -4, 1145, -4, // NOLINT
- 1147, -4, 1149, -4, 1151, -4, 1153, -4, 1163, -4, 1165, -4, 1167, -4, 1169, -4, // NOLINT
- 1171, -4, 1173, -4, 1175, -4, 1177, -4, 1179, -4, 1181, -4, 1183, -4, 1185, -4, // NOLINT
- 1187, -4, 1189, -4, 1191, -4, 1193, -4, 1195, -4, 1197, -4, 1199, -4, 1201, -4, // NOLINT
- 1203, -4, 1205, -4, 1207, -4, 1209, -4, 1211, -4, 1213, -4, 1215, -4, 1218, -4, // NOLINT
- 1220, -4, 1222, -4, 1224, -4, 1226, -4, 1228, -4, 1230, -4, 1231, -60, 1233, -4, // NOLINT
- 1235, -4, 1237, -4, 1239, -4, 1241, -4, 1243, -4, 1245, -4, 1247, -4, 1249, -4, // NOLINT
- 1251, -4, 1253, -4, 1255, -4, 1257, -4, 1259, -4, 1261, -4, 1263, -4, 1265, -4, // NOLINT
- 1267, -4, 1269, -4, 1271, -4, 1273, -4, 1275, -4, 1277, -4, 1279, -4, 1281, -4, // NOLINT
- 1283, -4, 1285, -4, 1287, -4, 1289, -4, 1291, -4, 1293, -4, 1295, -4, 1297, -4, // NOLINT
- 1299, -4, 1301, -4, 1303, -4, 1305, -4, 1307, -4, 1309, -4, 1311, -4, 1313, -4, // NOLINT
- 1315, -4, 1317, -4, 1319, -4, 1073743201, -192, 1414, -192, 1415, 21, 7545, 141328, 7549, 15256, // NOLINT
- 7681, -4, 7683, -4, 7685, -4, 7687, -4, 7689, -4, 7691, -4, 7693, -4, 7695, -4, // NOLINT
- 7697, -4, 7699, -4, 7701, -4, 7703, -4, 7705, -4, 7707, -4, 7709, -4, 7711, -4, // NOLINT
- 7713, -4, 7715, -4, 7717, -4, 7719, -4, 7721, -4, 7723, -4, 7725, -4, 7727, -4, // NOLINT
- 7729, -4, 7731, -4, 7733, -4, 7735, -4, 7737, -4, 7739, -4, 7741, -4, 7743, -4, // NOLINT
- 7745, -4, 7747, -4, 7749, -4, 7751, -4, 7753, -4, 7755, -4, 7757, -4, 7759, -4, // NOLINT
- 7761, -4, 7763, -4, 7765, -4, 7767, -4, 7769, -4, 7771, -4, 7773, -4, 7775, -4, // NOLINT
- 7777, -4, 7779, -4, 7781, -4, 7783, -4, 7785, -4, 7787, -4, 7789, -4, 7791, -4, // NOLINT
- 7793, -4, 7795, -4, 7797, -4, 7799, -4, 7801, -4, 7803, -4, 7805, -4, 7807, -4, // NOLINT
- 7809, -4, 7811, -4, 7813, -4, 7815, -4, 7817, -4, 7819, -4, 7821, -4, 7823, -4, // NOLINT
- 7825, -4, 7827, -4, 7829, -4, 7830, 25, 7831, 29, 7832, 33, 7833, 37, 7834, 41, // NOLINT
- 7835, -236, 7841, -4, 7843, -4, 7845, -4, 7847, -4, 7849, -4, 7851, -4, 7853, -4, // NOLINT
- 7855, -4, 7857, -4, 7859, -4, 7861, -4, 7863, -4, 7865, -4, 7867, -4, 7869, -4, // NOLINT
- 7871, -4, 7873, -4, 7875, -4, 7877, -4, 7879, -4, 7881, -4, 7883, -4, 7885, -4, // NOLINT
- 7887, -4, 7889, -4, 7891, -4, 7893, -4, 7895, -4, 7897, -4, 7899, -4, 7901, -4, // NOLINT
- 7903, -4, 7905, -4, 7907, -4, 7909, -4, 7911, -4, 7913, -4, 7915, -4, 7917, -4, // NOLINT
- 7919, -4, 7921, -4, 7923, -4, 7925, -4, 7927, -4, 7929, -4, 7931, -4, 7933, -4, // NOLINT
- 7935, -4, 1073749760, 32, 7943, 32, 1073749776, 32, 7957, 32, 1073749792, 32, 7975, 32, 1073749808, 32, // NOLINT
- 7991, 32, 1073749824, 32, 8005, 32, 8016, 45, 8017, 32, 8018, 49, 8019, 32, 8020, 53, // NOLINT
- 8021, 32, 8022, 57, 8023, 32, 1073749856, 32, 8039, 32, 1073749872, 296, 8049, 296, 1073749874, 344, // NOLINT
- 8053, 344, 1073749878, 400, 8055, 400, 1073749880, 512, 8057, 512, 1073749882, 448, 8059, 448, 1073749884, 504, // NOLINT
- 8061, 504, 8064, 61, 8065, 65, 8066, 69, 8067, 73, 8068, 77, 8069, 81, 8070, 85, // NOLINT
- 8071, 89, 8072, 61, 8073, 65, 8074, 69, 8075, 73, 8076, 77, 8077, 81, 8078, 85, // NOLINT
- 8079, 89, 8080, 93, 8081, 97, 8082, 101, 8083, 105, 8084, 109, 8085, 113, 8086, 117, // NOLINT
- 8087, 121, 8088, 93, 8089, 97, 8090, 101, 8091, 105, 8092, 109, 8093, 113, 8094, 117, // NOLINT
- 8095, 121, 8096, 125, 8097, 129, 8098, 133, 8099, 137, 8100, 141, 8101, 145, 8102, 149, // NOLINT
- 8103, 153, 8104, 125, 8105, 129, 8106, 133, 8107, 137, 8108, 141, 8109, 145, 8110, 149, // NOLINT
- 8111, 153, 1073749936, 32, 8113, 32, 8114, 157, 8115, 161, 8116, 165, 8118, 169, 8119, 173, // NOLINT
- 8124, 161, 8126, -28820, 8130, 177, 8131, 181, 8132, 185, 8134, 189, 8135, 193, 8140, 181, // NOLINT
- 1073749968, 32, 8145, 32, 8146, 197, 8147, 13, 8150, 201, 8151, 205, 1073749984, 32, 8161, 32, // NOLINT
- 8162, 209, 8163, 17, 8164, 213, 8165, 28, 8166, 217, 8167, 221, 8178, 225, 8179, 229, // NOLINT
- 8180, 233, 8182, 237, 8183, 241, 8188, 229 }; // NOLINT
+static const uint16_t kToUppercaseTable0Size = 590; // NOLINT
+static const int32_t kToUppercaseTable0[1180] = {
+ 1073741921, -128, 122, -128, 181, 2972,
+ 223, 1, 1073742048, -128, 246, -128,
+ 1073742072, -128, 254, -128, // NOLINT
+ 255, 484, 257, -4, 259, -4,
+ 261, -4, 263, -4, 265, -4,
+ 267, -4, 269, -4, // NOLINT
+ 271, -4, 273, -4, 275, -4,
+ 277, -4, 279, -4, 281, -4,
+ 283, -4, 285, -4, // NOLINT
+ 287, -4, 289, -4, 291, -4,
+ 293, -4, 295, -4, 297, -4,
+ 299, -4, 301, -4, // NOLINT
+ 303, -4, 305, -928, 307, -4,
+ 309, -4, 311, -4, 314, -4,
+ 316, -4, 318, -4, // NOLINT
+ 320, -4, 322, -4, 324, -4,
+ 326, -4, 328, -4, 329, 5,
+ 331, -4, 333, -4, // NOLINT
+ 335, -4, 337, -4, 339, -4,
+ 341, -4, 343, -4, 345, -4,
+ 347, -4, 349, -4, // NOLINT
+ 351, -4, 353, -4, 355, -4,
+ 357, -4, 359, -4, 361, -4,
+ 363, -4, 365, -4, // NOLINT
+ 367, -4, 369, -4, 371, -4,
+ 373, -4, 375, -4, 378, -4,
+ 380, -4, 382, -4, // NOLINT
+ 383, -1200, 384, 780, 387, -4,
+ 389, -4, 392, -4, 396, -4,
+ 402, -4, 405, 388, // NOLINT
+ 409, -4, 410, 652, 414, 520,
+ 417, -4, 419, -4, 421, -4,
+ 424, -4, 429, -4, // NOLINT
+ 432, -4, 436, -4, 438, -4,
+ 441, -4, 445, -4, 447, 224,
+ 453, -4, 454, -8, // NOLINT
+ 456, -4, 457, -8, 459, -4,
+ 460, -8, 462, -4, 464, -4,
+ 466, -4, 468, -4, // NOLINT
+ 470, -4, 472, -4, 474, -4,
+ 476, -4, 477, -316, 479, -4,
+ 481, -4, 483, -4, // NOLINT
+ 485, -4, 487, -4, 489, -4,
+ 491, -4, 493, -4, 495, -4,
+ 496, 9, 498, -4, // NOLINT
+ 499, -8, 501, -4, 505, -4,
+ 507, -4, 509, -4, 511, -4,
+ 513, -4, 515, -4, // NOLINT
+ 517, -4, 519, -4, 521, -4,
+ 523, -4, 525, -4, 527, -4,
+ 529, -4, 531, -4, // NOLINT
+ 533, -4, 535, -4, 537, -4,
+ 539, -4, 541, -4, 543, -4,
+ 547, -4, 549, -4, // NOLINT
+ 551, -4, 553, -4, 555, -4,
+ 557, -4, 559, -4, 561, -4,
+ 563, -4, 572, -4, // NOLINT
+ 1073742399, 43260, 576, 43260, 578, -4,
+ 583, -4, 585, -4, 587, -4,
+ 589, -4, 591, -4, // NOLINT
+ 592, 43132, 593, 43120, 594, 43128,
+ 595, -840, 596, -824, 1073742422, -820,
+ 599, -820, 601, -808, // NOLINT
+ 603, -812, 604, 169276, 608, -820,
+ 609, 169260, 611, -828, 613, 169120,
+ 614, 169232, 616, -836, // NOLINT
+ 617, -844, 619, 42972, 620, 169220,
+ 623, -844, 625, 42996, 626, -852,
+ 629, -856, 637, 42908, // NOLINT
+ 640, -872, 643, -872, 647, 169128,
+ 648, -872, 649, -276, 1073742474, -868,
+ 651, -868, 652, -284, // NOLINT
+ 658, -876, 670, 169032, 837, 336,
+ 881, -4, 883, -4, 887, -4,
+ 1073742715, 520, 893, 520, // NOLINT
+ 912, 13, 940, -152, 1073742765, -148,
+ 943, -148, 944, 17, 1073742769, -128,
+ 961, -128, 962, -124, // NOLINT
+ 1073742787, -128, 971, -128, 972, -256,
+ 1073742797, -252, 974, -252, 976, -248,
+ 977, -228, 981, -188, // NOLINT
+ 982, -216, 983, -32, 985, -4,
+ 987, -4, 989, -4, 991, -4,
+ 993, -4, 995, -4, // NOLINT
+ 997, -4, 999, -4, 1001, -4,
+ 1003, -4, 1005, -4, 1007, -4,
+ 1008, -344, 1009, -320, // NOLINT
+ 1010, 28, 1011, -464, 1013, -384,
+ 1016, -4, 1019, -4, 1073742896, -128,
+ 1103, -128, 1073742928, -320, // NOLINT
+ 1119, -320, 1121, -4, 1123, -4,
+ 1125, -4, 1127, -4, 1129, -4,
+ 1131, -4, 1133, -4, // NOLINT
+ 1135, -4, 1137, -4, 1139, -4,
+ 1141, -4, 1143, -4, 1145, -4,
+ 1147, -4, 1149, -4, // NOLINT
+ 1151, -4, 1153, -4, 1163, -4,
+ 1165, -4, 1167, -4, 1169, -4,
+ 1171, -4, 1173, -4, // NOLINT
+ 1175, -4, 1177, -4, 1179, -4,
+ 1181, -4, 1183, -4, 1185, -4,
+ 1187, -4, 1189, -4, // NOLINT
+ 1191, -4, 1193, -4, 1195, -4,
+ 1197, -4, 1199, -4, 1201, -4,
+ 1203, -4, 1205, -4, // NOLINT
+ 1207, -4, 1209, -4, 1211, -4,
+ 1213, -4, 1215, -4, 1218, -4,
+ 1220, -4, 1222, -4, // NOLINT
+ 1224, -4, 1226, -4, 1228, -4,
+ 1230, -4, 1231, -60, 1233, -4,
+ 1235, -4, 1237, -4, // NOLINT
+ 1239, -4, 1241, -4, 1243, -4,
+ 1245, -4, 1247, -4, 1249, -4,
+ 1251, -4, 1253, -4, // NOLINT
+ 1255, -4, 1257, -4, 1259, -4,
+ 1261, -4, 1263, -4, 1265, -4,
+ 1267, -4, 1269, -4, // NOLINT
+ 1271, -4, 1273, -4, 1275, -4,
+ 1277, -4, 1279, -4, 1281, -4,
+ 1283, -4, 1285, -4, // NOLINT
+ 1287, -4, 1289, -4, 1291, -4,
+ 1293, -4, 1295, -4, 1297, -4,
+ 1299, -4, 1301, -4, // NOLINT
+ 1303, -4, 1305, -4, 1307, -4,
+ 1309, -4, 1311, -4, 1313, -4,
+ 1315, -4, 1317, -4, // NOLINT
+ 1319, -4, 1321, -4, 1323, -4,
+ 1325, -4, 1327, -4, 1073743201, -192,
+ 1414, -192, 1415, 21, // NOLINT
+ 7545, 141328, 7549, 15256, 7681, -4,
+ 7683, -4, 7685, -4, 7687, -4,
+ 7689, -4, 7691, -4, // NOLINT
+ 7693, -4, 7695, -4, 7697, -4,
+ 7699, -4, 7701, -4, 7703, -4,
+ 7705, -4, 7707, -4, // NOLINT
+ 7709, -4, 7711, -4, 7713, -4,
+ 7715, -4, 7717, -4, 7719, -4,
+ 7721, -4, 7723, -4, // NOLINT
+ 7725, -4, 7727, -4, 7729, -4,
+ 7731, -4, 7733, -4, 7735, -4,
+ 7737, -4, 7739, -4, // NOLINT
+ 7741, -4, 7743, -4, 7745, -4,
+ 7747, -4, 7749, -4, 7751, -4,
+ 7753, -4, 7755, -4, // NOLINT
+ 7757, -4, 7759, -4, 7761, -4,
+ 7763, -4, 7765, -4, 7767, -4,
+ 7769, -4, 7771, -4, // NOLINT
+ 7773, -4, 7775, -4, 7777, -4,
+ 7779, -4, 7781, -4, 7783, -4,
+ 7785, -4, 7787, -4, // NOLINT
+ 7789, -4, 7791, -4, 7793, -4,
+ 7795, -4, 7797, -4, 7799, -4,
+ 7801, -4, 7803, -4, // NOLINT
+ 7805, -4, 7807, -4, 7809, -4,
+ 7811, -4, 7813, -4, 7815, -4,
+ 7817, -4, 7819, -4, // NOLINT
+ 7821, -4, 7823, -4, 7825, -4,
+ 7827, -4, 7829, -4, 7830, 25,
+ 7831, 29, 7832, 33, // NOLINT
+ 7833, 37, 7834, 41, 7835, -236,
+ 7841, -4, 7843, -4, 7845, -4,
+ 7847, -4, 7849, -4, // NOLINT
+ 7851, -4, 7853, -4, 7855, -4,
+ 7857, -4, 7859, -4, 7861, -4,
+ 7863, -4, 7865, -4, // NOLINT
+ 7867, -4, 7869, -4, 7871, -4,
+ 7873, -4, 7875, -4, 7877, -4,
+ 7879, -4, 7881, -4, // NOLINT
+ 7883, -4, 7885, -4, 7887, -4,
+ 7889, -4, 7891, -4, 7893, -4,
+ 7895, -4, 7897, -4, // NOLINT
+ 7899, -4, 7901, -4, 7903, -4,
+ 7905, -4, 7907, -4, 7909, -4,
+ 7911, -4, 7913, -4, // NOLINT
+ 7915, -4, 7917, -4, 7919, -4,
+ 7921, -4, 7923, -4, 7925, -4,
+ 7927, -4, 7929, -4, // NOLINT
+ 7931, -4, 7933, -4, 7935, -4,
+ 1073749760, 32, 7943, 32, 1073749776, 32,
+ 7957, 32, 1073749792, 32, // NOLINT
+ 7975, 32, 1073749808, 32, 7991, 32,
+ 1073749824, 32, 8005, 32, 8016, 45,
+ 8017, 32, 8018, 49, // NOLINT
+ 8019, 32, 8020, 53, 8021, 32,
+ 8022, 57, 8023, 32, 1073749856, 32,
+ 8039, 32, 1073749872, 296, // NOLINT
+ 8049, 296, 1073749874, 344, 8053, 344,
+ 1073749878, 400, 8055, 400, 1073749880, 512,
+ 8057, 512, 1073749882, 448, // NOLINT
+ 8059, 448, 1073749884, 504, 8061, 504,
+ 8064, 61, 8065, 65, 8066, 69,
+ 8067, 73, 8068, 77, // NOLINT
+ 8069, 81, 8070, 85, 8071, 89,
+ 8072, 61, 8073, 65, 8074, 69,
+ 8075, 73, 8076, 77, // NOLINT
+ 8077, 81, 8078, 85, 8079, 89,
+ 8080, 93, 8081, 97, 8082, 101,
+ 8083, 105, 8084, 109, // NOLINT
+ 8085, 113, 8086, 117, 8087, 121,
+ 8088, 93, 8089, 97, 8090, 101,
+ 8091, 105, 8092, 109, // NOLINT
+ 8093, 113, 8094, 117, 8095, 121,
+ 8096, 125, 8097, 129, 8098, 133,
+ 8099, 137, 8100, 141, // NOLINT
+ 8101, 145, 8102, 149, 8103, 153,
+ 8104, 125, 8105, 129, 8106, 133,
+ 8107, 137, 8108, 141, // NOLINT
+ 8109, 145, 8110, 149, 8111, 153,
+ 1073749936, 32, 8113, 32, 8114, 157,
+ 8115, 161, 8116, 165, // NOLINT
+ 8118, 169, 8119, 173, 8124, 161,
+ 8126, -28820, 8130, 177, 8131, 181,
+ 8132, 185, 8134, 189, // NOLINT
+ 8135, 193, 8140, 181, 1073749968, 32,
+ 8145, 32, 8146, 197, 8147, 13,
+ 8150, 201, 8151, 205, // NOLINT
+ 1073749984, 32, 8161, 32, 8162, 209,
+ 8163, 17, 8164, 213, 8165, 28,
+ 8166, 217, 8167, 221, // NOLINT
+ 8178, 225, 8179, 229, 8180, 233,
+ 8182, 237, 8183, 241, 8188, 229}; // NOLINT
static const uint16_t kToUppercaseMultiStrings0Size = 62; // NOLINT
static const MultiCharacterSpecialCase<1> kToUppercaseMultiStrings1[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
static const uint16_t kToUppercaseMultiStrings1Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kToUppercaseMultiStrings5[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
-static const uint16_t kToUppercaseTable5Size = 88; // NOLINT
-static const int32_t kToUppercaseTable5[176] = {
- 1601, -4, 1603, -4, 1605, -4, 1607, -4, 1609, -4, 1611, -4, 1613, -4, 1615, -4, // NOLINT
- 1617, -4, 1619, -4, 1621, -4, 1623, -4, 1625, -4, 1627, -4, 1629, -4, 1631, -4, // NOLINT
- 1633, -4, 1635, -4, 1637, -4, 1639, -4, 1641, -4, 1643, -4, 1645, -4, 1665, -4, // NOLINT
- 1667, -4, 1669, -4, 1671, -4, 1673, -4, 1675, -4, 1677, -4, 1679, -4, 1681, -4, // NOLINT
- 1683, -4, 1685, -4, 1687, -4, 1827, -4, 1829, -4, 1831, -4, 1833, -4, 1835, -4, // NOLINT
- 1837, -4, 1839, -4, 1843, -4, 1845, -4, 1847, -4, 1849, -4, 1851, -4, 1853, -4, // NOLINT
- 1855, -4, 1857, -4, 1859, -4, 1861, -4, 1863, -4, 1865, -4, 1867, -4, 1869, -4, // NOLINT
- 1871, -4, 1873, -4, 1875, -4, 1877, -4, 1879, -4, 1881, -4, 1883, -4, 1885, -4, // NOLINT
- 1887, -4, 1889, -4, 1891, -4, 1893, -4, 1895, -4, 1897, -4, 1899, -4, 1901, -4, // NOLINT
- 1903, -4, 1914, -4, 1916, -4, 1919, -4, 1921, -4, 1923, -4, 1925, -4, 1927, -4, // NOLINT
- 1932, -4, 1937, -4, 1939, -4, 1953, -4, 1955, -4, 1957, -4, 1959, -4, 1961, -4 }; // NOLINT
+static const uint16_t kToUppercaseTable5Size = 95; // NOLINT
+static const int32_t
+ kToUppercaseTable5[190] = {1601, -4, 1603, -4, 1605, -4, 1607, -4, 1609, -4,
+ 1611, -4, 1613, -4, 1615, -4, // NOLINT
+ 1617, -4, 1619, -4, 1621, -4, 1623, -4, 1625, -4,
+ 1627, -4, 1629, -4, 1631, -4, // NOLINT
+ 1633, -4, 1635, -4, 1637, -4, 1639, -4, 1641, -4,
+ 1643, -4, 1645, -4, 1665, -4, // NOLINT
+ 1667, -4, 1669, -4, 1671, -4, 1673, -4, 1675, -4,
+ 1677, -4, 1679, -4, 1681, -4, // NOLINT
+ 1683, -4, 1685, -4, 1687, -4, 1689, -4, 1691, -4,
+ 1827, -4, 1829, -4, 1831, -4, // NOLINT
+ 1833, -4, 1835, -4, 1837, -4, 1839, -4, 1843, -4,
+ 1845, -4, 1847, -4, 1849, -4, // NOLINT
+ 1851, -4, 1853, -4, 1855, -4, 1857, -4, 1859, -4,
+ 1861, -4, 1863, -4, 1865, -4, // NOLINT
+ 1867, -4, 1869, -4, 1871, -4, 1873, -4, 1875, -4,
+ 1877, -4, 1879, -4, 1881, -4, // NOLINT
+ 1883, -4, 1885, -4, 1887, -4, 1889, -4, 1891, -4,
+ 1893, -4, 1895, -4, 1897, -4, // NOLINT
+ 1899, -4, 1901, -4, 1903, -4, 1914, -4, 1916, -4,
+ 1919, -4, 1921, -4, 1923, -4, // NOLINT
+ 1925, -4, 1927, -4, 1932, -4, 1937, -4, 1939, -4,
+ 1943, -4, 1945, -4, 1947, -4, // NOLINT
+ 1949, -4, 1951, -4, 1953, -4, 1955, -4, 1957, -4,
+ 1959, -4, 1961, -4}; // NOLINT
static const uint16_t kToUppercaseMultiStrings5Size = 1; // NOLINT
static const MultiCharacterSpecialCase<3> kToUppercaseMultiStrings7[12] = { // NOLINT
{{70, 70, kSentinel}}, {{70, 73, kSentinel}}, {{70, 76, kSentinel}}, {{70, 70, 73}}, // NOLINT
static const MultiCharacterSpecialCase<1> kEcma262CanonicalizeMultiStrings0[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
-static const uint16_t kEcma262CanonicalizeTable0Size = 488; // NOLINT
-static const int32_t kEcma262CanonicalizeTable0[976] = {
- 1073741921, -128, 122, -128, 181, 2972, 1073742048, -128, 246, -128, 1073742072, -128, 254, -128, 255, 484, // NOLINT
- 257, -4, 259, -4, 261, -4, 263, -4, 265, -4, 267, -4, 269, -4, 271, -4, // NOLINT
- 273, -4, 275, -4, 277, -4, 279, -4, 281, -4, 283, -4, 285, -4, 287, -4, // NOLINT
- 289, -4, 291, -4, 293, -4, 295, -4, 297, -4, 299, -4, 301, -4, 303, -4, // NOLINT
- 307, -4, 309, -4, 311, -4, 314, -4, 316, -4, 318, -4, 320, -4, 322, -4, // NOLINT
- 324, -4, 326, -4, 328, -4, 331, -4, 333, -4, 335, -4, 337, -4, 339, -4, // NOLINT
- 341, -4, 343, -4, 345, -4, 347, -4, 349, -4, 351, -4, 353, -4, 355, -4, // NOLINT
- 357, -4, 359, -4, 361, -4, 363, -4, 365, -4, 367, -4, 369, -4, 371, -4, // NOLINT
- 373, -4, 375, -4, 378, -4, 380, -4, 382, -4, 384, 780, 387, -4, 389, -4, // NOLINT
- 392, -4, 396, -4, 402, -4, 405, 388, 409, -4, 410, 652, 414, 520, 417, -4, // NOLINT
- 419, -4, 421, -4, 424, -4, 429, -4, 432, -4, 436, -4, 438, -4, 441, -4, // NOLINT
- 445, -4, 447, 224, 453, -4, 454, -8, 456, -4, 457, -8, 459, -4, 460, -8, // NOLINT
- 462, -4, 464, -4, 466, -4, 468, -4, 470, -4, 472, -4, 474, -4, 476, -4, // NOLINT
- 477, -316, 479, -4, 481, -4, 483, -4, 485, -4, 487, -4, 489, -4, 491, -4, // NOLINT
- 493, -4, 495, -4, 498, -4, 499, -8, 501, -4, 505, -4, 507, -4, 509, -4, // NOLINT
- 511, -4, 513, -4, 515, -4, 517, -4, 519, -4, 521, -4, 523, -4, 525, -4, // NOLINT
- 527, -4, 529, -4, 531, -4, 533, -4, 535, -4, 537, -4, 539, -4, 541, -4, // NOLINT
- 543, -4, 547, -4, 549, -4, 551, -4, 553, -4, 555, -4, 557, -4, 559, -4, // NOLINT
- 561, -4, 563, -4, 572, -4, 1073742399, 43260, 576, 43260, 578, -4, 583, -4, 585, -4, // NOLINT
- 587, -4, 589, -4, 591, -4, 592, 43132, 593, 43120, 594, 43128, 595, -840, 596, -824, // NOLINT
- 1073742422, -820, 599, -820, 601, -808, 603, -812, 608, -820, 611, -828, 613, 169120, 614, 169232, // NOLINT
- 616, -836, 617, -844, 619, 42972, 623, -844, 625, 42996, 626, -852, 629, -856, 637, 42908, // NOLINT
- 640, -872, 643, -872, 648, -872, 649, -276, 1073742474, -868, 651, -868, 652, -284, 658, -876, // NOLINT
- 837, 336, 881, -4, 883, -4, 887, -4, 1073742715, 520, 893, 520, 940, -152, 1073742765, -148, // NOLINT
- 943, -148, 1073742769, -128, 961, -128, 962, -124, 1073742787, -128, 971, -128, 972, -256, 1073742797, -252, // NOLINT
- 974, -252, 976, -248, 977, -228, 981, -188, 982, -216, 983, -32, 985, -4, 987, -4, // NOLINT
- 989, -4, 991, -4, 993, -4, 995, -4, 997, -4, 999, -4, 1001, -4, 1003, -4, // NOLINT
- 1005, -4, 1007, -4, 1008, -344, 1009, -320, 1010, 28, 1013, -384, 1016, -4, 1019, -4, // NOLINT
- 1073742896, -128, 1103, -128, 1073742928, -320, 1119, -320, 1121, -4, 1123, -4, 1125, -4, 1127, -4, // NOLINT
- 1129, -4, 1131, -4, 1133, -4, 1135, -4, 1137, -4, 1139, -4, 1141, -4, 1143, -4, // NOLINT
- 1145, -4, 1147, -4, 1149, -4, 1151, -4, 1153, -4, 1163, -4, 1165, -4, 1167, -4, // NOLINT
- 1169, -4, 1171, -4, 1173, -4, 1175, -4, 1177, -4, 1179, -4, 1181, -4, 1183, -4, // NOLINT
- 1185, -4, 1187, -4, 1189, -4, 1191, -4, 1193, -4, 1195, -4, 1197, -4, 1199, -4, // NOLINT
- 1201, -4, 1203, -4, 1205, -4, 1207, -4, 1209, -4, 1211, -4, 1213, -4, 1215, -4, // NOLINT
- 1218, -4, 1220, -4, 1222, -4, 1224, -4, 1226, -4, 1228, -4, 1230, -4, 1231, -60, // NOLINT
- 1233, -4, 1235, -4, 1237, -4, 1239, -4, 1241, -4, 1243, -4, 1245, -4, 1247, -4, // NOLINT
- 1249, -4, 1251, -4, 1253, -4, 1255, -4, 1257, -4, 1259, -4, 1261, -4, 1263, -4, // NOLINT
- 1265, -4, 1267, -4, 1269, -4, 1271, -4, 1273, -4, 1275, -4, 1277, -4, 1279, -4, // NOLINT
- 1281, -4, 1283, -4, 1285, -4, 1287, -4, 1289, -4, 1291, -4, 1293, -4, 1295, -4, // NOLINT
- 1297, -4, 1299, -4, 1301, -4, 1303, -4, 1305, -4, 1307, -4, 1309, -4, 1311, -4, // NOLINT
- 1313, -4, 1315, -4, 1317, -4, 1319, -4, 1073743201, -192, 1414, -192, 7545, 141328, 7549, 15256, // NOLINT
- 7681, -4, 7683, -4, 7685, -4, 7687, -4, 7689, -4, 7691, -4, 7693, -4, 7695, -4, // NOLINT
- 7697, -4, 7699, -4, 7701, -4, 7703, -4, 7705, -4, 7707, -4, 7709, -4, 7711, -4, // NOLINT
- 7713, -4, 7715, -4, 7717, -4, 7719, -4, 7721, -4, 7723, -4, 7725, -4, 7727, -4, // NOLINT
- 7729, -4, 7731, -4, 7733, -4, 7735, -4, 7737, -4, 7739, -4, 7741, -4, 7743, -4, // NOLINT
- 7745, -4, 7747, -4, 7749, -4, 7751, -4, 7753, -4, 7755, -4, 7757, -4, 7759, -4, // NOLINT
- 7761, -4, 7763, -4, 7765, -4, 7767, -4, 7769, -4, 7771, -4, 7773, -4, 7775, -4, // NOLINT
- 7777, -4, 7779, -4, 7781, -4, 7783, -4, 7785, -4, 7787, -4, 7789, -4, 7791, -4, // NOLINT
- 7793, -4, 7795, -4, 7797, -4, 7799, -4, 7801, -4, 7803, -4, 7805, -4, 7807, -4, // NOLINT
- 7809, -4, 7811, -4, 7813, -4, 7815, -4, 7817, -4, 7819, -4, 7821, -4, 7823, -4, // NOLINT
- 7825, -4, 7827, -4, 7829, -4, 7835, -236, 7841, -4, 7843, -4, 7845, -4, 7847, -4, // NOLINT
- 7849, -4, 7851, -4, 7853, -4, 7855, -4, 7857, -4, 7859, -4, 7861, -4, 7863, -4, // NOLINT
- 7865, -4, 7867, -4, 7869, -4, 7871, -4, 7873, -4, 7875, -4, 7877, -4, 7879, -4, // NOLINT
- 7881, -4, 7883, -4, 7885, -4, 7887, -4, 7889, -4, 7891, -4, 7893, -4, 7895, -4, // NOLINT
- 7897, -4, 7899, -4, 7901, -4, 7903, -4, 7905, -4, 7907, -4, 7909, -4, 7911, -4, // NOLINT
- 7913, -4, 7915, -4, 7917, -4, 7919, -4, 7921, -4, 7923, -4, 7925, -4, 7927, -4, // NOLINT
- 7929, -4, 7931, -4, 7933, -4, 7935, -4, 1073749760, 32, 7943, 32, 1073749776, 32, 7957, 32, // NOLINT
- 1073749792, 32, 7975, 32, 1073749808, 32, 7991, 32, 1073749824, 32, 8005, 32, 8017, 32, 8019, 32, // NOLINT
- 8021, 32, 8023, 32, 1073749856, 32, 8039, 32, 1073749872, 296, 8049, 296, 1073749874, 344, 8053, 344, // NOLINT
- 1073749878, 400, 8055, 400, 1073749880, 512, 8057, 512, 1073749882, 448, 8059, 448, 1073749884, 504, 8061, 504, // NOLINT
- 1073749936, 32, 8113, 32, 8126, -28820, 1073749968, 32, 8145, 32, 1073749984, 32, 8161, 32, 8165, 28 }; // NOLINT
+static const uint16_t kEcma262CanonicalizeTable0Size = 498; // NOLINT
+static const int32_t kEcma262CanonicalizeTable0[996] = {
+ 1073741921, -128, 122, -128, 181, 2972,
+ 1073742048, -128, 246, -128, 1073742072, -128,
+ 254, -128, 255, 484, // NOLINT
+ 257, -4, 259, -4, 261, -4,
+ 263, -4, 265, -4, 267, -4,
+ 269, -4, 271, -4, // NOLINT
+ 273, -4, 275, -4, 277, -4,
+ 279, -4, 281, -4, 283, -4,
+ 285, -4, 287, -4, // NOLINT
+ 289, -4, 291, -4, 293, -4,
+ 295, -4, 297, -4, 299, -4,
+ 301, -4, 303, -4, // NOLINT
+ 307, -4, 309, -4, 311, -4,
+ 314, -4, 316, -4, 318, -4,
+ 320, -4, 322, -4, // NOLINT
+ 324, -4, 326, -4, 328, -4,
+ 331, -4, 333, -4, 335, -4,
+ 337, -4, 339, -4, // NOLINT
+ 341, -4, 343, -4, 345, -4,
+ 347, -4, 349, -4, 351, -4,
+ 353, -4, 355, -4, // NOLINT
+ 357, -4, 359, -4, 361, -4,
+ 363, -4, 365, -4, 367, -4,
+ 369, -4, 371, -4, // NOLINT
+ 373, -4, 375, -4, 378, -4,
+ 380, -4, 382, -4, 384, 780,
+ 387, -4, 389, -4, // NOLINT
+ 392, -4, 396, -4, 402, -4,
+ 405, 388, 409, -4, 410, 652,
+ 414, 520, 417, -4, // NOLINT
+ 419, -4, 421, -4, 424, -4,
+ 429, -4, 432, -4, 436, -4,
+ 438, -4, 441, -4, // NOLINT
+ 445, -4, 447, 224, 453, -4,
+ 454, -8, 456, -4, 457, -8,
+ 459, -4, 460, -8, // NOLINT
+ 462, -4, 464, -4, 466, -4,
+ 468, -4, 470, -4, 472, -4,
+ 474, -4, 476, -4, // NOLINT
+ 477, -316, 479, -4, 481, -4,
+ 483, -4, 485, -4, 487, -4,
+ 489, -4, 491, -4, // NOLINT
+ 493, -4, 495, -4, 498, -4,
+ 499, -8, 501, -4, 505, -4,
+ 507, -4, 509, -4, // NOLINT
+ 511, -4, 513, -4, 515, -4,
+ 517, -4, 519, -4, 521, -4,
+ 523, -4, 525, -4, // NOLINT
+ 527, -4, 529, -4, 531, -4,
+ 533, -4, 535, -4, 537, -4,
+ 539, -4, 541, -4, // NOLINT
+ 543, -4, 547, -4, 549, -4,
+ 551, -4, 553, -4, 555, -4,
+ 557, -4, 559, -4, // NOLINT
+ 561, -4, 563, -4, 572, -4,
+ 1073742399, 43260, 576, 43260, 578, -4,
+ 583, -4, 585, -4, // NOLINT
+ 587, -4, 589, -4, 591, -4,
+ 592, 43132, 593, 43120, 594, 43128,
+ 595, -840, 596, -824, // NOLINT
+ 1073742422, -820, 599, -820, 601, -808,
+ 603, -812, 604, 169276, 608, -820,
+ 609, 169260, 611, -828, // NOLINT
+ 613, 169120, 614, 169232, 616, -836,
+ 617, -844, 619, 42972, 620, 169220,
+ 623, -844, 625, 42996, // NOLINT
+ 626, -852, 629, -856, 637, 42908,
+ 640, -872, 643, -872, 647, 169128,
+ 648, -872, 649, -276, // NOLINT
+ 1073742474, -868, 651, -868, 652, -284,
+ 658, -876, 670, 169032, 837, 336,
+ 881, -4, 883, -4, // NOLINT
+ 887, -4, 1073742715, 520, 893, 520,
+ 940, -152, 1073742765, -148, 943, -148,
+ 1073742769, -128, 961, -128, // NOLINT
+ 962, -124, 1073742787, -128, 971, -128,
+ 972, -256, 1073742797, -252, 974, -252,
+ 976, -248, 977, -228, // NOLINT
+ 981, -188, 982, -216, 983, -32,
+ 985, -4, 987, -4, 989, -4,
+ 991, -4, 993, -4, // NOLINT
+ 995, -4, 997, -4, 999, -4,
+ 1001, -4, 1003, -4, 1005, -4,
+ 1007, -4, 1008, -344, // NOLINT
+ 1009, -320, 1010, 28, 1011, -464,
+ 1013, -384, 1016, -4, 1019, -4,
+ 1073742896, -128, 1103, -128, // NOLINT
+ 1073742928, -320, 1119, -320, 1121, -4,
+ 1123, -4, 1125, -4, 1127, -4,
+ 1129, -4, 1131, -4, // NOLINT
+ 1133, -4, 1135, -4, 1137, -4,
+ 1139, -4, 1141, -4, 1143, -4,
+ 1145, -4, 1147, -4, // NOLINT
+ 1149, -4, 1151, -4, 1153, -4,
+ 1163, -4, 1165, -4, 1167, -4,
+ 1169, -4, 1171, -4, // NOLINT
+ 1173, -4, 1175, -4, 1177, -4,
+ 1179, -4, 1181, -4, 1183, -4,
+ 1185, -4, 1187, -4, // NOLINT
+ 1189, -4, 1191, -4, 1193, -4,
+ 1195, -4, 1197, -4, 1199, -4,
+ 1201, -4, 1203, -4, // NOLINT
+ 1205, -4, 1207, -4, 1209, -4,
+ 1211, -4, 1213, -4, 1215, -4,
+ 1218, -4, 1220, -4, // NOLINT
+ 1222, -4, 1224, -4, 1226, -4,
+ 1228, -4, 1230, -4, 1231, -60,
+ 1233, -4, 1235, -4, // NOLINT
+ 1237, -4, 1239, -4, 1241, -4,
+ 1243, -4, 1245, -4, 1247, -4,
+ 1249, -4, 1251, -4, // NOLINT
+ 1253, -4, 1255, -4, 1257, -4,
+ 1259, -4, 1261, -4, 1263, -4,
+ 1265, -4, 1267, -4, // NOLINT
+ 1269, -4, 1271, -4, 1273, -4,
+ 1275, -4, 1277, -4, 1279, -4,
+ 1281, -4, 1283, -4, // NOLINT
+ 1285, -4, 1287, -4, 1289, -4,
+ 1291, -4, 1293, -4, 1295, -4,
+ 1297, -4, 1299, -4, // NOLINT
+ 1301, -4, 1303, -4, 1305, -4,
+ 1307, -4, 1309, -4, 1311, -4,
+ 1313, -4, 1315, -4, // NOLINT
+ 1317, -4, 1319, -4, 1321, -4,
+ 1323, -4, 1325, -4, 1327, -4,
+ 1073743201, -192, 1414, -192, // NOLINT
+ 7545, 141328, 7549, 15256, 7681, -4,
+ 7683, -4, 7685, -4, 7687, -4,
+ 7689, -4, 7691, -4, // NOLINT
+ 7693, -4, 7695, -4, 7697, -4,
+ 7699, -4, 7701, -4, 7703, -4,
+ 7705, -4, 7707, -4, // NOLINT
+ 7709, -4, 7711, -4, 7713, -4,
+ 7715, -4, 7717, -4, 7719, -4,
+ 7721, -4, 7723, -4, // NOLINT
+ 7725, -4, 7727, -4, 7729, -4,
+ 7731, -4, 7733, -4, 7735, -4,
+ 7737, -4, 7739, -4, // NOLINT
+ 7741, -4, 7743, -4, 7745, -4,
+ 7747, -4, 7749, -4, 7751, -4,
+ 7753, -4, 7755, -4, // NOLINT
+ 7757, -4, 7759, -4, 7761, -4,
+ 7763, -4, 7765, -4, 7767, -4,
+ 7769, -4, 7771, -4, // NOLINT
+ 7773, -4, 7775, -4, 7777, -4,
+ 7779, -4, 7781, -4, 7783, -4,
+ 7785, -4, 7787, -4, // NOLINT
+ 7789, -4, 7791, -4, 7793, -4,
+ 7795, -4, 7797, -4, 7799, -4,
+ 7801, -4, 7803, -4, // NOLINT
+ 7805, -4, 7807, -4, 7809, -4,
+ 7811, -4, 7813, -4, 7815, -4,
+ 7817, -4, 7819, -4, // NOLINT
+ 7821, -4, 7823, -4, 7825, -4,
+ 7827, -4, 7829, -4, 7835, -236,
+ 7841, -4, 7843, -4, // NOLINT
+ 7845, -4, 7847, -4, 7849, -4,
+ 7851, -4, 7853, -4, 7855, -4,
+ 7857, -4, 7859, -4, // NOLINT
+ 7861, -4, 7863, -4, 7865, -4,
+ 7867, -4, 7869, -4, 7871, -4,
+ 7873, -4, 7875, -4, // NOLINT
+ 7877, -4, 7879, -4, 7881, -4,
+ 7883, -4, 7885, -4, 7887, -4,
+ 7889, -4, 7891, -4, // NOLINT
+ 7893, -4, 7895, -4, 7897, -4,
+ 7899, -4, 7901, -4, 7903, -4,
+ 7905, -4, 7907, -4, // NOLINT
+ 7909, -4, 7911, -4, 7913, -4,
+ 7915, -4, 7917, -4, 7919, -4,
+ 7921, -4, 7923, -4, // NOLINT
+ 7925, -4, 7927, -4, 7929, -4,
+ 7931, -4, 7933, -4, 7935, -4,
+ 1073749760, 32, 7943, 32, // NOLINT
+ 1073749776, 32, 7957, 32, 1073749792, 32,
+ 7975, 32, 1073749808, 32, 7991, 32,
+ 1073749824, 32, 8005, 32, // NOLINT
+ 8017, 32, 8019, 32, 8021, 32,
+ 8023, 32, 1073749856, 32, 8039, 32,
+ 1073749872, 296, 8049, 296, // NOLINT
+ 1073749874, 344, 8053, 344, 1073749878, 400,
+ 8055, 400, 1073749880, 512, 8057, 512,
+ 1073749882, 448, 8059, 448, // NOLINT
+ 1073749884, 504, 8061, 504, 1073749936, 32,
+ 8113, 32, 8126, -28820, 1073749968, 32,
+ 8145, 32, 1073749984, 32, // NOLINT
+ 8161, 32, 8165, 28}; // NOLINT
static const uint16_t kEcma262CanonicalizeMultiStrings0Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kEcma262CanonicalizeMultiStrings1[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
static const uint16_t kEcma262CanonicalizeMultiStrings1Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kEcma262CanonicalizeMultiStrings5[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
-static const uint16_t kEcma262CanonicalizeTable5Size = 88; // NOLINT
-static const int32_t kEcma262CanonicalizeTable5[176] = {
- 1601, -4, 1603, -4, 1605, -4, 1607, -4, 1609, -4, 1611, -4, 1613, -4, 1615, -4, // NOLINT
- 1617, -4, 1619, -4, 1621, -4, 1623, -4, 1625, -4, 1627, -4, 1629, -4, 1631, -4, // NOLINT
- 1633, -4, 1635, -4, 1637, -4, 1639, -4, 1641, -4, 1643, -4, 1645, -4, 1665, -4, // NOLINT
- 1667, -4, 1669, -4, 1671, -4, 1673, -4, 1675, -4, 1677, -4, 1679, -4, 1681, -4, // NOLINT
- 1683, -4, 1685, -4, 1687, -4, 1827, -4, 1829, -4, 1831, -4, 1833, -4, 1835, -4, // NOLINT
- 1837, -4, 1839, -4, 1843, -4, 1845, -4, 1847, -4, 1849, -4, 1851, -4, 1853, -4, // NOLINT
- 1855, -4, 1857, -4, 1859, -4, 1861, -4, 1863, -4, 1865, -4, 1867, -4, 1869, -4, // NOLINT
- 1871, -4, 1873, -4, 1875, -4, 1877, -4, 1879, -4, 1881, -4, 1883, -4, 1885, -4, // NOLINT
- 1887, -4, 1889, -4, 1891, -4, 1893, -4, 1895, -4, 1897, -4, 1899, -4, 1901, -4, // NOLINT
- 1903, -4, 1914, -4, 1916, -4, 1919, -4, 1921, -4, 1923, -4, 1925, -4, 1927, -4, // NOLINT
- 1932, -4, 1937, -4, 1939, -4, 1953, -4, 1955, -4, 1957, -4, 1959, -4, 1961, -4 }; // NOLINT
+static const uint16_t kEcma262CanonicalizeTable5Size = 95; // NOLINT
+static const int32_t kEcma262CanonicalizeTable5
+ [190] = {1601, -4, 1603, -4, 1605, -4, 1607, -4,
+ 1609, -4, 1611, -4, 1613, -4, 1615, -4, // NOLINT
+ 1617, -4, 1619, -4, 1621, -4, 1623, -4,
+ 1625, -4, 1627, -4, 1629, -4, 1631, -4, // NOLINT
+ 1633, -4, 1635, -4, 1637, -4, 1639, -4,
+ 1641, -4, 1643, -4, 1645, -4, 1665, -4, // NOLINT
+ 1667, -4, 1669, -4, 1671, -4, 1673, -4,
+ 1675, -4, 1677, -4, 1679, -4, 1681, -4, // NOLINT
+ 1683, -4, 1685, -4, 1687, -4, 1689, -4,
+ 1691, -4, 1827, -4, 1829, -4, 1831, -4, // NOLINT
+ 1833, -4, 1835, -4, 1837, -4, 1839, -4,
+ 1843, -4, 1845, -4, 1847, -4, 1849, -4, // NOLINT
+ 1851, -4, 1853, -4, 1855, -4, 1857, -4,
+ 1859, -4, 1861, -4, 1863, -4, 1865, -4, // NOLINT
+ 1867, -4, 1869, -4, 1871, -4, 1873, -4,
+ 1875, -4, 1877, -4, 1879, -4, 1881, -4, // NOLINT
+ 1883, -4, 1885, -4, 1887, -4, 1889, -4,
+ 1891, -4, 1893, -4, 1895, -4, 1897, -4, // NOLINT
+ 1899, -4, 1901, -4, 1903, -4, 1914, -4,
+ 1916, -4, 1919, -4, 1921, -4, 1923, -4, // NOLINT
+ 1925, -4, 1927, -4, 1932, -4, 1937, -4,
+ 1939, -4, 1943, -4, 1945, -4, 1947, -4, // NOLINT
+ 1949, -4, 1951, -4, 1953, -4, 1955, -4,
+ 1957, -4, 1959, -4, 1961, -4}; // NOLINT
static const uint16_t kEcma262CanonicalizeMultiStrings5Size = 1; // NOLINT
static const MultiCharacterSpecialCase<1> kEcma262CanonicalizeMultiStrings7[1] = { // NOLINT
{{kSentinel}} }; // NOLINT
}
}
-static const MultiCharacterSpecialCase<4> kEcma262UnCanonicalizeMultiStrings0[497] = { // NOLINT
- {{65, 97, kSentinel}}, {{90, 122, kSentinel}}, {{181, 924, 956, kSentinel}}, {{192, 224, kSentinel}}, // NOLINT
- {{214, 246, kSentinel}}, {{216, 248, kSentinel}}, {{222, 254, kSentinel}}, {{255, 376, kSentinel}}, // NOLINT
- {{256, 257, kSentinel}}, {{258, 259, kSentinel}}, {{260, 261, kSentinel}}, {{262, 263, kSentinel}}, // NOLINT
- {{264, 265, kSentinel}}, {{266, 267, kSentinel}}, {{268, 269, kSentinel}}, {{270, 271, kSentinel}}, // NOLINT
- {{272, 273, kSentinel}}, {{274, 275, kSentinel}}, {{276, 277, kSentinel}}, {{278, 279, kSentinel}}, // NOLINT
- {{280, 281, kSentinel}}, {{282, 283, kSentinel}}, {{284, 285, kSentinel}}, {{286, 287, kSentinel}}, // NOLINT
- {{288, 289, kSentinel}}, {{290, 291, kSentinel}}, {{292, 293, kSentinel}}, {{294, 295, kSentinel}}, // NOLINT
- {{296, 297, kSentinel}}, {{298, 299, kSentinel}}, {{300, 301, kSentinel}}, {{302, 303, kSentinel}}, // NOLINT
- {{306, 307, kSentinel}}, {{308, 309, kSentinel}}, {{310, 311, kSentinel}}, {{313, 314, kSentinel}}, // NOLINT
- {{315, 316, kSentinel}}, {{317, 318, kSentinel}}, {{319, 320, kSentinel}}, {{321, 322, kSentinel}}, // NOLINT
- {{323, 324, kSentinel}}, {{325, 326, kSentinel}}, {{327, 328, kSentinel}}, {{330, 331, kSentinel}}, // NOLINT
- {{332, 333, kSentinel}}, {{334, 335, kSentinel}}, {{336, 337, kSentinel}}, {{338, 339, kSentinel}}, // NOLINT
- {{340, 341, kSentinel}}, {{342, 343, kSentinel}}, {{344, 345, kSentinel}}, {{346, 347, kSentinel}}, // NOLINT
- {{348, 349, kSentinel}}, {{350, 351, kSentinel}}, {{352, 353, kSentinel}}, {{354, 355, kSentinel}}, // NOLINT
- {{356, 357, kSentinel}}, {{358, 359, kSentinel}}, {{360, 361, kSentinel}}, {{362, 363, kSentinel}}, // NOLINT
- {{364, 365, kSentinel}}, {{366, 367, kSentinel}}, {{368, 369, kSentinel}}, {{370, 371, kSentinel}}, // NOLINT
- {{372, 373, kSentinel}}, {{374, 375, kSentinel}}, {{377, 378, kSentinel}}, {{379, 380, kSentinel}}, // NOLINT
- {{381, 382, kSentinel}}, {{384, 579, kSentinel}}, {{385, 595, kSentinel}}, {{386, 387, kSentinel}}, // NOLINT
- {{388, 389, kSentinel}}, {{390, 596, kSentinel}}, {{391, 392, kSentinel}}, {{393, 598, kSentinel}}, // NOLINT
- {{394, 599, kSentinel}}, {{395, 396, kSentinel}}, {{398, 477, kSentinel}}, {{399, 601, kSentinel}}, // NOLINT
- {{400, 603, kSentinel}}, {{401, 402, kSentinel}}, {{403, 608, kSentinel}}, {{404, 611, kSentinel}}, // NOLINT
- {{405, 502, kSentinel}}, {{406, 617, kSentinel}}, {{407, 616, kSentinel}}, {{408, 409, kSentinel}}, // NOLINT
- {{410, 573, kSentinel}}, {{412, 623, kSentinel}}, {{413, 626, kSentinel}}, {{414, 544, kSentinel}}, // NOLINT
- {{415, 629, kSentinel}}, {{416, 417, kSentinel}}, {{418, 419, kSentinel}}, {{420, 421, kSentinel}}, // NOLINT
- {{422, 640, kSentinel}}, {{423, 424, kSentinel}}, {{425, 643, kSentinel}}, {{428, 429, kSentinel}}, // NOLINT
- {{430, 648, kSentinel}}, {{431, 432, kSentinel}}, {{433, 650, kSentinel}}, {{434, 651, kSentinel}}, // NOLINT
- {{435, 436, kSentinel}}, {{437, 438, kSentinel}}, {{439, 658, kSentinel}}, {{440, 441, kSentinel}}, // NOLINT
- {{444, 445, kSentinel}}, {{447, 503, kSentinel}}, {{452, 453, 454, kSentinel}}, {{455, 456, 457, kSentinel}}, // NOLINT
- {{458, 459, 460, kSentinel}}, {{461, 462, kSentinel}}, {{463, 464, kSentinel}}, {{465, 466, kSentinel}}, // NOLINT
- {{467, 468, kSentinel}}, {{469, 470, kSentinel}}, {{471, 472, kSentinel}}, {{473, 474, kSentinel}}, // NOLINT
- {{475, 476, kSentinel}}, {{478, 479, kSentinel}}, {{480, 481, kSentinel}}, {{482, 483, kSentinel}}, // NOLINT
- {{484, 485, kSentinel}}, {{486, 487, kSentinel}}, {{488, 489, kSentinel}}, {{490, 491, kSentinel}}, // NOLINT
- {{492, 493, kSentinel}}, {{494, 495, kSentinel}}, {{497, 498, 499, kSentinel}}, {{500, 501, kSentinel}}, // NOLINT
- {{504, 505, kSentinel}}, {{506, 507, kSentinel}}, {{508, 509, kSentinel}}, {{510, 511, kSentinel}}, // NOLINT
- {{512, 513, kSentinel}}, {{514, 515, kSentinel}}, {{516, 517, kSentinel}}, {{518, 519, kSentinel}}, // NOLINT
- {{520, 521, kSentinel}}, {{522, 523, kSentinel}}, {{524, 525, kSentinel}}, {{526, 527, kSentinel}}, // NOLINT
- {{528, 529, kSentinel}}, {{530, 531, kSentinel}}, {{532, 533, kSentinel}}, {{534, 535, kSentinel}}, // NOLINT
- {{536, 537, kSentinel}}, {{538, 539, kSentinel}}, {{540, 541, kSentinel}}, {{542, 543, kSentinel}}, // NOLINT
- {{546, 547, kSentinel}}, {{548, 549, kSentinel}}, {{550, 551, kSentinel}}, {{552, 553, kSentinel}}, // NOLINT
- {{554, 555, kSentinel}}, {{556, 557, kSentinel}}, {{558, 559, kSentinel}}, {{560, 561, kSentinel}}, // NOLINT
- {{562, 563, kSentinel}}, {{570, 11365, kSentinel}}, {{571, 572, kSentinel}}, {{574, 11366, kSentinel}}, // NOLINT
- {{575, 11390, kSentinel}}, {{576, 11391, kSentinel}}, {{577, 578, kSentinel}}, {{580, 649, kSentinel}}, // NOLINT
- {{581, 652, kSentinel}}, {{582, 583, kSentinel}}, {{584, 585, kSentinel}}, {{586, 587, kSentinel}}, // NOLINT
- {{588, 589, kSentinel}}, {{590, 591, kSentinel}}, {{592, 11375, kSentinel}}, {{593, 11373, kSentinel}}, // NOLINT
- {{594, 11376, kSentinel}}, {{613, 42893, kSentinel}}, {{614, 42922, kSentinel}}, {{619, 11362, kSentinel}}, // NOLINT
- {{625, 11374, kSentinel}}, {{637, 11364, kSentinel}}, {{837, 921, 953, 8126}}, {{880, 881, kSentinel}}, // NOLINT
- {{882, 883, kSentinel}}, {{886, 887, kSentinel}}, {{891, 1021, kSentinel}}, {{893, 1023, kSentinel}}, // NOLINT
- {{902, 940, kSentinel}}, {{904, 941, kSentinel}}, {{906, 943, kSentinel}}, {{908, 972, kSentinel}}, // NOLINT
- {{910, 973, kSentinel}}, {{911, 974, kSentinel}}, {{913, 945, kSentinel}}, {{914, 946, 976, kSentinel}}, // NOLINT
- {{915, 947, kSentinel}}, {{916, 948, kSentinel}}, {{917, 949, 1013, kSentinel}}, {{918, 950, kSentinel}}, // NOLINT
- {{919, 951, kSentinel}}, {{920, 952, 977, kSentinel}}, {{922, 954, 1008, kSentinel}}, {{923, 955, kSentinel}}, // NOLINT
- {{925, 957, kSentinel}}, {{927, 959, kSentinel}}, {{928, 960, 982, kSentinel}}, {{929, 961, 1009, kSentinel}}, // NOLINT
- {{931, 962, 963, kSentinel}}, {{932, 964, kSentinel}}, {{933, 965, kSentinel}}, {{934, 966, 981, kSentinel}}, // NOLINT
- {{935, 967, kSentinel}}, {{939, 971, kSentinel}}, {{975, 983, kSentinel}}, {{984, 985, kSentinel}}, // NOLINT
- {{986, 987, kSentinel}}, {{988, 989, kSentinel}}, {{990, 991, kSentinel}}, {{992, 993, kSentinel}}, // NOLINT
- {{994, 995, kSentinel}}, {{996, 997, kSentinel}}, {{998, 999, kSentinel}}, {{1000, 1001, kSentinel}}, // NOLINT
- {{1002, 1003, kSentinel}}, {{1004, 1005, kSentinel}}, {{1006, 1007, kSentinel}}, {{1010, 1017, kSentinel}}, // NOLINT
- {{1015, 1016, kSentinel}}, {{1018, 1019, kSentinel}}, {{1024, 1104, kSentinel}}, {{1039, 1119, kSentinel}}, // NOLINT
- {{1040, 1072, kSentinel}}, {{1071, 1103, kSentinel}}, {{1120, 1121, kSentinel}}, {{1122, 1123, kSentinel}}, // NOLINT
- {{1124, 1125, kSentinel}}, {{1126, 1127, kSentinel}}, {{1128, 1129, kSentinel}}, {{1130, 1131, kSentinel}}, // NOLINT
- {{1132, 1133, kSentinel}}, {{1134, 1135, kSentinel}}, {{1136, 1137, kSentinel}}, {{1138, 1139, kSentinel}}, // NOLINT
- {{1140, 1141, kSentinel}}, {{1142, 1143, kSentinel}}, {{1144, 1145, kSentinel}}, {{1146, 1147, kSentinel}}, // NOLINT
- {{1148, 1149, kSentinel}}, {{1150, 1151, kSentinel}}, {{1152, 1153, kSentinel}}, {{1162, 1163, kSentinel}}, // NOLINT
- {{1164, 1165, kSentinel}}, {{1166, 1167, kSentinel}}, {{1168, 1169, kSentinel}}, {{1170, 1171, kSentinel}}, // NOLINT
- {{1172, 1173, kSentinel}}, {{1174, 1175, kSentinel}}, {{1176, 1177, kSentinel}}, {{1178, 1179, kSentinel}}, // NOLINT
- {{1180, 1181, kSentinel}}, {{1182, 1183, kSentinel}}, {{1184, 1185, kSentinel}}, {{1186, 1187, kSentinel}}, // NOLINT
- {{1188, 1189, kSentinel}}, {{1190, 1191, kSentinel}}, {{1192, 1193, kSentinel}}, {{1194, 1195, kSentinel}}, // NOLINT
- {{1196, 1197, kSentinel}}, {{1198, 1199, kSentinel}}, {{1200, 1201, kSentinel}}, {{1202, 1203, kSentinel}}, // NOLINT
- {{1204, 1205, kSentinel}}, {{1206, 1207, kSentinel}}, {{1208, 1209, kSentinel}}, {{1210, 1211, kSentinel}}, // NOLINT
- {{1212, 1213, kSentinel}}, {{1214, 1215, kSentinel}}, {{1216, 1231, kSentinel}}, {{1217, 1218, kSentinel}}, // NOLINT
- {{1219, 1220, kSentinel}}, {{1221, 1222, kSentinel}}, {{1223, 1224, kSentinel}}, {{1225, 1226, kSentinel}}, // NOLINT
- {{1227, 1228, kSentinel}}, {{1229, 1230, kSentinel}}, {{1232, 1233, kSentinel}}, {{1234, 1235, kSentinel}}, // NOLINT
- {{1236, 1237, kSentinel}}, {{1238, 1239, kSentinel}}, {{1240, 1241, kSentinel}}, {{1242, 1243, kSentinel}}, // NOLINT
- {{1244, 1245, kSentinel}}, {{1246, 1247, kSentinel}}, {{1248, 1249, kSentinel}}, {{1250, 1251, kSentinel}}, // NOLINT
- {{1252, 1253, kSentinel}}, {{1254, 1255, kSentinel}}, {{1256, 1257, kSentinel}}, {{1258, 1259, kSentinel}}, // NOLINT
- {{1260, 1261, kSentinel}}, {{1262, 1263, kSentinel}}, {{1264, 1265, kSentinel}}, {{1266, 1267, kSentinel}}, // NOLINT
- {{1268, 1269, kSentinel}}, {{1270, 1271, kSentinel}}, {{1272, 1273, kSentinel}}, {{1274, 1275, kSentinel}}, // NOLINT
- {{1276, 1277, kSentinel}}, {{1278, 1279, kSentinel}}, {{1280, 1281, kSentinel}}, {{1282, 1283, kSentinel}}, // NOLINT
- {{1284, 1285, kSentinel}}, {{1286, 1287, kSentinel}}, {{1288, 1289, kSentinel}}, {{1290, 1291, kSentinel}}, // NOLINT
- {{1292, 1293, kSentinel}}, {{1294, 1295, kSentinel}}, {{1296, 1297, kSentinel}}, {{1298, 1299, kSentinel}}, // NOLINT
- {{1300, 1301, kSentinel}}, {{1302, 1303, kSentinel}}, {{1304, 1305, kSentinel}}, {{1306, 1307, kSentinel}}, // NOLINT
- {{1308, 1309, kSentinel}}, {{1310, 1311, kSentinel}}, {{1312, 1313, kSentinel}}, {{1314, 1315, kSentinel}}, // NOLINT
- {{1316, 1317, kSentinel}}, {{1318, 1319, kSentinel}}, {{1329, 1377, kSentinel}}, {{1366, 1414, kSentinel}}, // NOLINT
- {{4256, 11520, kSentinel}}, {{4293, 11557, kSentinel}}, {{4295, 11559, kSentinel}}, {{4301, 11565, kSentinel}}, // NOLINT
- {{7545, 42877, kSentinel}}, {{7549, 11363, kSentinel}}, {{7680, 7681, kSentinel}}, {{7682, 7683, kSentinel}}, // NOLINT
- {{7684, 7685, kSentinel}}, {{7686, 7687, kSentinel}}, {{7688, 7689, kSentinel}}, {{7690, 7691, kSentinel}}, // NOLINT
- {{7692, 7693, kSentinel}}, {{7694, 7695, kSentinel}}, {{7696, 7697, kSentinel}}, {{7698, 7699, kSentinel}}, // NOLINT
- {{7700, 7701, kSentinel}}, {{7702, 7703, kSentinel}}, {{7704, 7705, kSentinel}}, {{7706, 7707, kSentinel}}, // NOLINT
- {{7708, 7709, kSentinel}}, {{7710, 7711, kSentinel}}, {{7712, 7713, kSentinel}}, {{7714, 7715, kSentinel}}, // NOLINT
- {{7716, 7717, kSentinel}}, {{7718, 7719, kSentinel}}, {{7720, 7721, kSentinel}}, {{7722, 7723, kSentinel}}, // NOLINT
- {{7724, 7725, kSentinel}}, {{7726, 7727, kSentinel}}, {{7728, 7729, kSentinel}}, {{7730, 7731, kSentinel}}, // NOLINT
- {{7732, 7733, kSentinel}}, {{7734, 7735, kSentinel}}, {{7736, 7737, kSentinel}}, {{7738, 7739, kSentinel}}, // NOLINT
- {{7740, 7741, kSentinel}}, {{7742, 7743, kSentinel}}, {{7744, 7745, kSentinel}}, {{7746, 7747, kSentinel}}, // NOLINT
- {{7748, 7749, kSentinel}}, {{7750, 7751, kSentinel}}, {{7752, 7753, kSentinel}}, {{7754, 7755, kSentinel}}, // NOLINT
- {{7756, 7757, kSentinel}}, {{7758, 7759, kSentinel}}, {{7760, 7761, kSentinel}}, {{7762, 7763, kSentinel}}, // NOLINT
- {{7764, 7765, kSentinel}}, {{7766, 7767, kSentinel}}, {{7768, 7769, kSentinel}}, {{7770, 7771, kSentinel}}, // NOLINT
- {{7772, 7773, kSentinel}}, {{7774, 7775, kSentinel}}, {{7776, 7777, 7835, kSentinel}}, {{7778, 7779, kSentinel}}, // NOLINT
- {{7780, 7781, kSentinel}}, {{7782, 7783, kSentinel}}, {{7784, 7785, kSentinel}}, {{7786, 7787, kSentinel}}, // NOLINT
- {{7788, 7789, kSentinel}}, {{7790, 7791, kSentinel}}, {{7792, 7793, kSentinel}}, {{7794, 7795, kSentinel}}, // NOLINT
- {{7796, 7797, kSentinel}}, {{7798, 7799, kSentinel}}, {{7800, 7801, kSentinel}}, {{7802, 7803, kSentinel}}, // NOLINT
- {{7804, 7805, kSentinel}}, {{7806, 7807, kSentinel}}, {{7808, 7809, kSentinel}}, {{7810, 7811, kSentinel}}, // NOLINT
- {{7812, 7813, kSentinel}}, {{7814, 7815, kSentinel}}, {{7816, 7817, kSentinel}}, {{7818, 7819, kSentinel}}, // NOLINT
- {{7820, 7821, kSentinel}}, {{7822, 7823, kSentinel}}, {{7824, 7825, kSentinel}}, {{7826, 7827, kSentinel}}, // NOLINT
- {{7828, 7829, kSentinel}}, {{7840, 7841, kSentinel}}, {{7842, 7843, kSentinel}}, {{7844, 7845, kSentinel}}, // NOLINT
- {{7846, 7847, kSentinel}}, {{7848, 7849, kSentinel}}, {{7850, 7851, kSentinel}}, {{7852, 7853, kSentinel}}, // NOLINT
- {{7854, 7855, kSentinel}}, {{7856, 7857, kSentinel}}, {{7858, 7859, kSentinel}}, {{7860, 7861, kSentinel}}, // NOLINT
- {{7862, 7863, kSentinel}}, {{7864, 7865, kSentinel}}, {{7866, 7867, kSentinel}}, {{7868, 7869, kSentinel}}, // NOLINT
- {{7870, 7871, kSentinel}}, {{7872, 7873, kSentinel}}, {{7874, 7875, kSentinel}}, {{7876, 7877, kSentinel}}, // NOLINT
- {{7878, 7879, kSentinel}}, {{7880, 7881, kSentinel}}, {{7882, 7883, kSentinel}}, {{7884, 7885, kSentinel}}, // NOLINT
- {{7886, 7887, kSentinel}}, {{7888, 7889, kSentinel}}, {{7890, 7891, kSentinel}}, {{7892, 7893, kSentinel}}, // NOLINT
- {{7894, 7895, kSentinel}}, {{7896, 7897, kSentinel}}, {{7898, 7899, kSentinel}}, {{7900, 7901, kSentinel}}, // NOLINT
- {{7902, 7903, kSentinel}}, {{7904, 7905, kSentinel}}, {{7906, 7907, kSentinel}}, {{7908, 7909, kSentinel}}, // NOLINT
- {{7910, 7911, kSentinel}}, {{7912, 7913, kSentinel}}, {{7914, 7915, kSentinel}}, {{7916, 7917, kSentinel}}, // NOLINT
- {{7918, 7919, kSentinel}}, {{7920, 7921, kSentinel}}, {{7922, 7923, kSentinel}}, {{7924, 7925, kSentinel}}, // NOLINT
- {{7926, 7927, kSentinel}}, {{7928, 7929, kSentinel}}, {{7930, 7931, kSentinel}}, {{7932, 7933, kSentinel}}, // NOLINT
- {{7934, 7935, kSentinel}}, {{7936, 7944, kSentinel}}, {{7943, 7951, kSentinel}}, {{7952, 7960, kSentinel}}, // NOLINT
- {{7957, 7965, kSentinel}}, {{7968, 7976, kSentinel}}, {{7975, 7983, kSentinel}}, {{7984, 7992, kSentinel}}, // NOLINT
- {{7991, 7999, kSentinel}}, {{8000, 8008, kSentinel}}, {{8005, 8013, kSentinel}}, {{8017, 8025, kSentinel}}, // NOLINT
- {{8019, 8027, kSentinel}}, {{8021, 8029, kSentinel}}, {{8023, 8031, kSentinel}}, {{8032, 8040, kSentinel}}, // NOLINT
- {{8039, 8047, kSentinel}}, {{8048, 8122, kSentinel}}, {{8049, 8123, kSentinel}}, {{8050, 8136, kSentinel}}, // NOLINT
- {{8053, 8139, kSentinel}}, {{8054, 8154, kSentinel}}, {{8055, 8155, kSentinel}}, {{8056, 8184, kSentinel}}, // NOLINT
- {{8057, 8185, kSentinel}}, {{8058, 8170, kSentinel}}, {{8059, 8171, kSentinel}}, {{8060, 8186, kSentinel}}, // NOLINT
- {{8061, 8187, kSentinel}}, {{8112, 8120, kSentinel}}, {{8113, 8121, kSentinel}}, {{8144, 8152, kSentinel}}, // NOLINT
- {{8145, 8153, kSentinel}}, {{8160, 8168, kSentinel}}, {{8161, 8169, kSentinel}}, {{8165, 8172, kSentinel}}, // NOLINT
- {{kSentinel}} }; // NOLINT
-static const uint16_t kEcma262UnCanonicalizeTable0Size = 990; // NOLINT
-static const int32_t kEcma262UnCanonicalizeTable0[1980] = {
- 1073741889, 1, 90, 5, 1073741921, 1, 122, 5, 181, 9, 1073742016, 13, 214, 17, 1073742040, 21, // NOLINT
- 222, 25, 1073742048, 13, 246, 17, 1073742072, 21, 254, 25, 255, 29, 256, 33, 257, 33, // NOLINT
- 258, 37, 259, 37, 260, 41, 261, 41, 262, 45, 263, 45, 264, 49, 265, 49, // NOLINT
- 266, 53, 267, 53, 268, 57, 269, 57, 270, 61, 271, 61, 272, 65, 273, 65, // NOLINT
- 274, 69, 275, 69, 276, 73, 277, 73, 278, 77, 279, 77, 280, 81, 281, 81, // NOLINT
- 282, 85, 283, 85, 284, 89, 285, 89, 286, 93, 287, 93, 288, 97, 289, 97, // NOLINT
- 290, 101, 291, 101, 292, 105, 293, 105, 294, 109, 295, 109, 296, 113, 297, 113, // NOLINT
- 298, 117, 299, 117, 300, 121, 301, 121, 302, 125, 303, 125, 306, 129, 307, 129, // NOLINT
- 308, 133, 309, 133, 310, 137, 311, 137, 313, 141, 314, 141, 315, 145, 316, 145, // NOLINT
- 317, 149, 318, 149, 319, 153, 320, 153, 321, 157, 322, 157, 323, 161, 324, 161, // NOLINT
- 325, 165, 326, 165, 327, 169, 328, 169, 330, 173, 331, 173, 332, 177, 333, 177, // NOLINT
- 334, 181, 335, 181, 336, 185, 337, 185, 338, 189, 339, 189, 340, 193, 341, 193, // NOLINT
- 342, 197, 343, 197, 344, 201, 345, 201, 346, 205, 347, 205, 348, 209, 349, 209, // NOLINT
- 350, 213, 351, 213, 352, 217, 353, 217, 354, 221, 355, 221, 356, 225, 357, 225, // NOLINT
- 358, 229, 359, 229, 360, 233, 361, 233, 362, 237, 363, 237, 364, 241, 365, 241, // NOLINT
- 366, 245, 367, 245, 368, 249, 369, 249, 370, 253, 371, 253, 372, 257, 373, 257, // NOLINT
- 374, 261, 375, 261, 376, 29, 377, 265, 378, 265, 379, 269, 380, 269, 381, 273, // NOLINT
- 382, 273, 384, 277, 385, 281, 386, 285, 387, 285, 388, 289, 389, 289, 390, 293, // NOLINT
- 391, 297, 392, 297, 1073742217, 301, 394, 305, 395, 309, 396, 309, 398, 313, 399, 317, // NOLINT
- 400, 321, 401, 325, 402, 325, 403, 329, 404, 333, 405, 337, 406, 341, 407, 345, // NOLINT
- 408, 349, 409, 349, 410, 353, 412, 357, 413, 361, 414, 365, 415, 369, 416, 373, // NOLINT
- 417, 373, 418, 377, 419, 377, 420, 381, 421, 381, 422, 385, 423, 389, 424, 389, // NOLINT
- 425, 393, 428, 397, 429, 397, 430, 401, 431, 405, 432, 405, 1073742257, 409, 434, 413, // NOLINT
- 435, 417, 436, 417, 437, 421, 438, 421, 439, 425, 440, 429, 441, 429, 444, 433, // NOLINT
- 445, 433, 447, 437, 452, 441, 453, 441, 454, 441, 455, 445, 456, 445, 457, 445, // NOLINT
- 458, 449, 459, 449, 460, 449, 461, 453, 462, 453, 463, 457, 464, 457, 465, 461, // NOLINT
- 466, 461, 467, 465, 468, 465, 469, 469, 470, 469, 471, 473, 472, 473, 473, 477, // NOLINT
- 474, 477, 475, 481, 476, 481, 477, 313, 478, 485, 479, 485, 480, 489, 481, 489, // NOLINT
- 482, 493, 483, 493, 484, 497, 485, 497, 486, 501, 487, 501, 488, 505, 489, 505, // NOLINT
- 490, 509, 491, 509, 492, 513, 493, 513, 494, 517, 495, 517, 497, 521, 498, 521, // NOLINT
- 499, 521, 500, 525, 501, 525, 502, 337, 503, 437, 504, 529, 505, 529, 506, 533, // NOLINT
- 507, 533, 508, 537, 509, 537, 510, 541, 511, 541, 512, 545, 513, 545, 514, 549, // NOLINT
- 515, 549, 516, 553, 517, 553, 518, 557, 519, 557, 520, 561, 521, 561, 522, 565, // NOLINT
- 523, 565, 524, 569, 525, 569, 526, 573, 527, 573, 528, 577, 529, 577, 530, 581, // NOLINT
- 531, 581, 532, 585, 533, 585, 534, 589, 535, 589, 536, 593, 537, 593, 538, 597, // NOLINT
- 539, 597, 540, 601, 541, 601, 542, 605, 543, 605, 544, 365, 546, 609, 547, 609, // NOLINT
- 548, 613, 549, 613, 550, 617, 551, 617, 552, 621, 553, 621, 554, 625, 555, 625, // NOLINT
- 556, 629, 557, 629, 558, 633, 559, 633, 560, 637, 561, 637, 562, 641, 563, 641, // NOLINT
- 570, 645, 571, 649, 572, 649, 573, 353, 574, 653, 1073742399, 657, 576, 661, 577, 665, // NOLINT
- 578, 665, 579, 277, 580, 669, 581, 673, 582, 677, 583, 677, 584, 681, 585, 681, // NOLINT
- 586, 685, 587, 685, 588, 689, 589, 689, 590, 693, 591, 693, 592, 697, 593, 701, // NOLINT
- 594, 705, 595, 281, 596, 293, 1073742422, 301, 599, 305, 601, 317, 603, 321, 608, 329, // NOLINT
- 611, 333, 613, 709, 614, 713, 616, 345, 617, 341, 619, 717, 623, 357, 625, 721, // NOLINT
- 626, 361, 629, 369, 637, 725, 640, 385, 643, 393, 648, 401, 649, 669, 1073742474, 409, // NOLINT
- 651, 413, 652, 673, 658, 425, 837, 729, 880, 733, 881, 733, 882, 737, 883, 737, // NOLINT
- 886, 741, 887, 741, 1073742715, 745, 893, 749, 902, 753, 1073742728, 757, 906, 761, 908, 765, // NOLINT
- 1073742734, 769, 911, 773, 913, 777, 914, 781, 1073742739, 785, 916, 789, 917, 793, 1073742742, 797, // NOLINT
- 919, 801, 920, 805, 921, 729, 922, 809, 923, 813, 924, 9, 1073742749, 817, 927, 821, // NOLINT
- 928, 825, 929, 829, 931, 833, 1073742756, 837, 933, 841, 934, 845, 1073742759, 849, 939, 853, // NOLINT
- 940, 753, 1073742765, 757, 943, 761, 945, 777, 946, 781, 1073742771, 785, 948, 789, 949, 793, // NOLINT
- 1073742774, 797, 951, 801, 952, 805, 953, 729, 954, 809, 955, 813, 956, 9, 1073742781, 817, // NOLINT
- 959, 821, 960, 825, 961, 829, 962, 833, 963, 833, 1073742788, 837, 965, 841, 966, 845, // NOLINT
- 1073742791, 849, 971, 853, 972, 765, 1073742797, 769, 974, 773, 975, 857, 976, 781, 977, 805, // NOLINT
- 981, 845, 982, 825, 983, 857, 984, 861, 985, 861, 986, 865, 987, 865, 988, 869, // NOLINT
- 989, 869, 990, 873, 991, 873, 992, 877, 993, 877, 994, 881, 995, 881, 996, 885, // NOLINT
- 997, 885, 998, 889, 999, 889, 1000, 893, 1001, 893, 1002, 897, 1003, 897, 1004, 901, // NOLINT
- 1005, 901, 1006, 905, 1007, 905, 1008, 809, 1009, 829, 1010, 909, 1013, 793, 1015, 913, // NOLINT
- 1016, 913, 1017, 909, 1018, 917, 1019, 917, 1073742845, 745, 1023, 749, 1073742848, 921, 1039, 925, // NOLINT
- 1073742864, 929, 1071, 933, 1073742896, 929, 1103, 933, 1073742928, 921, 1119, 925, 1120, 937, 1121, 937, // NOLINT
- 1122, 941, 1123, 941, 1124, 945, 1125, 945, 1126, 949, 1127, 949, 1128, 953, 1129, 953, // NOLINT
- 1130, 957, 1131, 957, 1132, 961, 1133, 961, 1134, 965, 1135, 965, 1136, 969, 1137, 969, // NOLINT
- 1138, 973, 1139, 973, 1140, 977, 1141, 977, 1142, 981, 1143, 981, 1144, 985, 1145, 985, // NOLINT
- 1146, 989, 1147, 989, 1148, 993, 1149, 993, 1150, 997, 1151, 997, 1152, 1001, 1153, 1001, // NOLINT
- 1162, 1005, 1163, 1005, 1164, 1009, 1165, 1009, 1166, 1013, 1167, 1013, 1168, 1017, 1169, 1017, // NOLINT
- 1170, 1021, 1171, 1021, 1172, 1025, 1173, 1025, 1174, 1029, 1175, 1029, 1176, 1033, 1177, 1033, // NOLINT
- 1178, 1037, 1179, 1037, 1180, 1041, 1181, 1041, 1182, 1045, 1183, 1045, 1184, 1049, 1185, 1049, // NOLINT
- 1186, 1053, 1187, 1053, 1188, 1057, 1189, 1057, 1190, 1061, 1191, 1061, 1192, 1065, 1193, 1065, // NOLINT
- 1194, 1069, 1195, 1069, 1196, 1073, 1197, 1073, 1198, 1077, 1199, 1077, 1200, 1081, 1201, 1081, // NOLINT
- 1202, 1085, 1203, 1085, 1204, 1089, 1205, 1089, 1206, 1093, 1207, 1093, 1208, 1097, 1209, 1097, // NOLINT
- 1210, 1101, 1211, 1101, 1212, 1105, 1213, 1105, 1214, 1109, 1215, 1109, 1216, 1113, 1217, 1117, // NOLINT
- 1218, 1117, 1219, 1121, 1220, 1121, 1221, 1125, 1222, 1125, 1223, 1129, 1224, 1129, 1225, 1133, // NOLINT
- 1226, 1133, 1227, 1137, 1228, 1137, 1229, 1141, 1230, 1141, 1231, 1113, 1232, 1145, 1233, 1145, // NOLINT
- 1234, 1149, 1235, 1149, 1236, 1153, 1237, 1153, 1238, 1157, 1239, 1157, 1240, 1161, 1241, 1161, // NOLINT
- 1242, 1165, 1243, 1165, 1244, 1169, 1245, 1169, 1246, 1173, 1247, 1173, 1248, 1177, 1249, 1177, // NOLINT
- 1250, 1181, 1251, 1181, 1252, 1185, 1253, 1185, 1254, 1189, 1255, 1189, 1256, 1193, 1257, 1193, // NOLINT
- 1258, 1197, 1259, 1197, 1260, 1201, 1261, 1201, 1262, 1205, 1263, 1205, 1264, 1209, 1265, 1209, // NOLINT
- 1266, 1213, 1267, 1213, 1268, 1217, 1269, 1217, 1270, 1221, 1271, 1221, 1272, 1225, 1273, 1225, // NOLINT
- 1274, 1229, 1275, 1229, 1276, 1233, 1277, 1233, 1278, 1237, 1279, 1237, 1280, 1241, 1281, 1241, // NOLINT
- 1282, 1245, 1283, 1245, 1284, 1249, 1285, 1249, 1286, 1253, 1287, 1253, 1288, 1257, 1289, 1257, // NOLINT
- 1290, 1261, 1291, 1261, 1292, 1265, 1293, 1265, 1294, 1269, 1295, 1269, 1296, 1273, 1297, 1273, // NOLINT
- 1298, 1277, 1299, 1277, 1300, 1281, 1301, 1281, 1302, 1285, 1303, 1285, 1304, 1289, 1305, 1289, // NOLINT
- 1306, 1293, 1307, 1293, 1308, 1297, 1309, 1297, 1310, 1301, 1311, 1301, 1312, 1305, 1313, 1305, // NOLINT
- 1314, 1309, 1315, 1309, 1316, 1313, 1317, 1313, 1318, 1317, 1319, 1317, 1073743153, 1321, 1366, 1325, // NOLINT
- 1073743201, 1321, 1414, 1325, 1073746080, 1329, 4293, 1333, 4295, 1337, 4301, 1341, 7545, 1345, 7549, 1349, // NOLINT
- 7680, 1353, 7681, 1353, 7682, 1357, 7683, 1357, 7684, 1361, 7685, 1361, 7686, 1365, 7687, 1365, // NOLINT
- 7688, 1369, 7689, 1369, 7690, 1373, 7691, 1373, 7692, 1377, 7693, 1377, 7694, 1381, 7695, 1381, // NOLINT
- 7696, 1385, 7697, 1385, 7698, 1389, 7699, 1389, 7700, 1393, 7701, 1393, 7702, 1397, 7703, 1397, // NOLINT
- 7704, 1401, 7705, 1401, 7706, 1405, 7707, 1405, 7708, 1409, 7709, 1409, 7710, 1413, 7711, 1413, // NOLINT
- 7712, 1417, 7713, 1417, 7714, 1421, 7715, 1421, 7716, 1425, 7717, 1425, 7718, 1429, 7719, 1429, // NOLINT
- 7720, 1433, 7721, 1433, 7722, 1437, 7723, 1437, 7724, 1441, 7725, 1441, 7726, 1445, 7727, 1445, // NOLINT
- 7728, 1449, 7729, 1449, 7730, 1453, 7731, 1453, 7732, 1457, 7733, 1457, 7734, 1461, 7735, 1461, // NOLINT
- 7736, 1465, 7737, 1465, 7738, 1469, 7739, 1469, 7740, 1473, 7741, 1473, 7742, 1477, 7743, 1477, // NOLINT
- 7744, 1481, 7745, 1481, 7746, 1485, 7747, 1485, 7748, 1489, 7749, 1489, 7750, 1493, 7751, 1493, // NOLINT
- 7752, 1497, 7753, 1497, 7754, 1501, 7755, 1501, 7756, 1505, 7757, 1505, 7758, 1509, 7759, 1509, // NOLINT
- 7760, 1513, 7761, 1513, 7762, 1517, 7763, 1517, 7764, 1521, 7765, 1521, 7766, 1525, 7767, 1525, // NOLINT
- 7768, 1529, 7769, 1529, 7770, 1533, 7771, 1533, 7772, 1537, 7773, 1537, 7774, 1541, 7775, 1541, // NOLINT
- 7776, 1545, 7777, 1545, 7778, 1549, 7779, 1549, 7780, 1553, 7781, 1553, 7782, 1557, 7783, 1557, // NOLINT
- 7784, 1561, 7785, 1561, 7786, 1565, 7787, 1565, 7788, 1569, 7789, 1569, 7790, 1573, 7791, 1573, // NOLINT
- 7792, 1577, 7793, 1577, 7794, 1581, 7795, 1581, 7796, 1585, 7797, 1585, 7798, 1589, 7799, 1589, // NOLINT
- 7800, 1593, 7801, 1593, 7802, 1597, 7803, 1597, 7804, 1601, 7805, 1601, 7806, 1605, 7807, 1605, // NOLINT
- 7808, 1609, 7809, 1609, 7810, 1613, 7811, 1613, 7812, 1617, 7813, 1617, 7814, 1621, 7815, 1621, // NOLINT
- 7816, 1625, 7817, 1625, 7818, 1629, 7819, 1629, 7820, 1633, 7821, 1633, 7822, 1637, 7823, 1637, // NOLINT
- 7824, 1641, 7825, 1641, 7826, 1645, 7827, 1645, 7828, 1649, 7829, 1649, 7835, 1545, 7840, 1653, // NOLINT
- 7841, 1653, 7842, 1657, 7843, 1657, 7844, 1661, 7845, 1661, 7846, 1665, 7847, 1665, 7848, 1669, // NOLINT
- 7849, 1669, 7850, 1673, 7851, 1673, 7852, 1677, 7853, 1677, 7854, 1681, 7855, 1681, 7856, 1685, // NOLINT
- 7857, 1685, 7858, 1689, 7859, 1689, 7860, 1693, 7861, 1693, 7862, 1697, 7863, 1697, 7864, 1701, // NOLINT
- 7865, 1701, 7866, 1705, 7867, 1705, 7868, 1709, 7869, 1709, 7870, 1713, 7871, 1713, 7872, 1717, // NOLINT
- 7873, 1717, 7874, 1721, 7875, 1721, 7876, 1725, 7877, 1725, 7878, 1729, 7879, 1729, 7880, 1733, // NOLINT
- 7881, 1733, 7882, 1737, 7883, 1737, 7884, 1741, 7885, 1741, 7886, 1745, 7887, 1745, 7888, 1749, // NOLINT
- 7889, 1749, 7890, 1753, 7891, 1753, 7892, 1757, 7893, 1757, 7894, 1761, 7895, 1761, 7896, 1765, // NOLINT
- 7897, 1765, 7898, 1769, 7899, 1769, 7900, 1773, 7901, 1773, 7902, 1777, 7903, 1777, 7904, 1781, // NOLINT
- 7905, 1781, 7906, 1785, 7907, 1785, 7908, 1789, 7909, 1789, 7910, 1793, 7911, 1793, 7912, 1797, // NOLINT
- 7913, 1797, 7914, 1801, 7915, 1801, 7916, 1805, 7917, 1805, 7918, 1809, 7919, 1809, 7920, 1813, // NOLINT
- 7921, 1813, 7922, 1817, 7923, 1817, 7924, 1821, 7925, 1821, 7926, 1825, 7927, 1825, 7928, 1829, // NOLINT
- 7929, 1829, 7930, 1833, 7931, 1833, 7932, 1837, 7933, 1837, 7934, 1841, 7935, 1841, 1073749760, 1845, // NOLINT
- 7943, 1849, 1073749768, 1845, 7951, 1849, 1073749776, 1853, 7957, 1857, 1073749784, 1853, 7965, 1857, 1073749792, 1861, // NOLINT
- 7975, 1865, 1073749800, 1861, 7983, 1865, 1073749808, 1869, 7991, 1873, 1073749816, 1869, 7999, 1873, 1073749824, 1877, // NOLINT
- 8005, 1881, 1073749832, 1877, 8013, 1881, 8017, 1885, 8019, 1889, 8021, 1893, 8023, 1897, 8025, 1885, // NOLINT
- 8027, 1889, 8029, 1893, 8031, 1897, 1073749856, 1901, 8039, 1905, 1073749864, 1901, 8047, 1905, 1073749872, 1909, // NOLINT
- 8049, 1913, 1073749874, 1917, 8053, 1921, 1073749878, 1925, 8055, 1929, 1073749880, 1933, 8057, 1937, 1073749882, 1941, // NOLINT
- 8059, 1945, 1073749884, 1949, 8061, 1953, 1073749936, 1957, 8113, 1961, 1073749944, 1957, 8121, 1961, 1073749946, 1909, // NOLINT
- 8123, 1913, 8126, 729, 1073749960, 1917, 8139, 1921, 1073749968, 1965, 8145, 1969, 1073749976, 1965, 8153, 1969, // NOLINT
- 1073749978, 1925, 8155, 1929, 1073749984, 1973, 8161, 1977, 8165, 1981, 1073749992, 1973, 8169, 1977, 1073749994, 1941, // NOLINT
- 8171, 1945, 8172, 1981, 1073750008, 1933, 8185, 1937, 1073750010, 1949, 8187, 1953 }; // NOLINT
-static const uint16_t kEcma262UnCanonicalizeMultiStrings0Size = 497; // NOLINT
+static const MultiCharacterSpecialCase<4>
+ kEcma262UnCanonicalizeMultiStrings0[507] = { // NOLINT
+ {{65, 97, kSentinel}},
+ {{90, 122, kSentinel}},
+ {{181, 924, 956, kSentinel}},
+ {{192, 224, kSentinel}}, // NOLINT
+ {{214, 246, kSentinel}},
+ {{216, 248, kSentinel}},
+ {{222, 254, kSentinel}},
+ {{255, 376, kSentinel}}, // NOLINT
+ {{256, 257, kSentinel}},
+ {{258, 259, kSentinel}},
+ {{260, 261, kSentinel}},
+ {{262, 263, kSentinel}}, // NOLINT
+ {{264, 265, kSentinel}},
+ {{266, 267, kSentinel}},
+ {{268, 269, kSentinel}},
+ {{270, 271, kSentinel}}, // NOLINT
+ {{272, 273, kSentinel}},
+ {{274, 275, kSentinel}},
+ {{276, 277, kSentinel}},
+ {{278, 279, kSentinel}}, // NOLINT
+ {{280, 281, kSentinel}},
+ {{282, 283, kSentinel}},
+ {{284, 285, kSentinel}},
+ {{286, 287, kSentinel}}, // NOLINT
+ {{288, 289, kSentinel}},
+ {{290, 291, kSentinel}},
+ {{292, 293, kSentinel}},
+ {{294, 295, kSentinel}}, // NOLINT
+ {{296, 297, kSentinel}},
+ {{298, 299, kSentinel}},
+ {{300, 301, kSentinel}},
+ {{302, 303, kSentinel}}, // NOLINT
+ {{306, 307, kSentinel}},
+ {{308, 309, kSentinel}},
+ {{310, 311, kSentinel}},
+ {{313, 314, kSentinel}}, // NOLINT
+ {{315, 316, kSentinel}},
+ {{317, 318, kSentinel}},
+ {{319, 320, kSentinel}},
+ {{321, 322, kSentinel}}, // NOLINT
+ {{323, 324, kSentinel}},
+ {{325, 326, kSentinel}},
+ {{327, 328, kSentinel}},
+ {{330, 331, kSentinel}}, // NOLINT
+ {{332, 333, kSentinel}},
+ {{334, 335, kSentinel}},
+ {{336, 337, kSentinel}},
+ {{338, 339, kSentinel}}, // NOLINT
+ {{340, 341, kSentinel}},
+ {{342, 343, kSentinel}},
+ {{344, 345, kSentinel}},
+ {{346, 347, kSentinel}}, // NOLINT
+ {{348, 349, kSentinel}},
+ {{350, 351, kSentinel}},
+ {{352, 353, kSentinel}},
+ {{354, 355, kSentinel}}, // NOLINT
+ {{356, 357, kSentinel}},
+ {{358, 359, kSentinel}},
+ {{360, 361, kSentinel}},
+ {{362, 363, kSentinel}}, // NOLINT
+ {{364, 365, kSentinel}},
+ {{366, 367, kSentinel}},
+ {{368, 369, kSentinel}},
+ {{370, 371, kSentinel}}, // NOLINT
+ {{372, 373, kSentinel}},
+ {{374, 375, kSentinel}},
+ {{377, 378, kSentinel}},
+ {{379, 380, kSentinel}}, // NOLINT
+ {{381, 382, kSentinel}},
+ {{384, 579, kSentinel}},
+ {{385, 595, kSentinel}},
+ {{386, 387, kSentinel}}, // NOLINT
+ {{388, 389, kSentinel}},
+ {{390, 596, kSentinel}},
+ {{391, 392, kSentinel}},
+ {{393, 598, kSentinel}}, // NOLINT
+ {{394, 599, kSentinel}},
+ {{395, 396, kSentinel}},
+ {{398, 477, kSentinel}},
+ {{399, 601, kSentinel}}, // NOLINT
+ {{400, 603, kSentinel}},
+ {{401, 402, kSentinel}},
+ {{403, 608, kSentinel}},
+ {{404, 611, kSentinel}}, // NOLINT
+ {{405, 502, kSentinel}},
+ {{406, 617, kSentinel}},
+ {{407, 616, kSentinel}},
+ {{408, 409, kSentinel}}, // NOLINT
+ {{410, 573, kSentinel}},
+ {{412, 623, kSentinel}},
+ {{413, 626, kSentinel}},
+ {{414, 544, kSentinel}}, // NOLINT
+ {{415, 629, kSentinel}},
+ {{416, 417, kSentinel}},
+ {{418, 419, kSentinel}},
+ {{420, 421, kSentinel}}, // NOLINT
+ {{422, 640, kSentinel}},
+ {{423, 424, kSentinel}},
+ {{425, 643, kSentinel}},
+ {{428, 429, kSentinel}}, // NOLINT
+ {{430, 648, kSentinel}},
+ {{431, 432, kSentinel}},
+ {{433, 650, kSentinel}},
+ {{434, 651, kSentinel}}, // NOLINT
+ {{435, 436, kSentinel}},
+ {{437, 438, kSentinel}},
+ {{439, 658, kSentinel}},
+ {{440, 441, kSentinel}}, // NOLINT
+ {{444, 445, kSentinel}},
+ {{447, 503, kSentinel}},
+ {{452, 453, 454, kSentinel}},
+ {{455, 456, 457, kSentinel}}, // NOLINT
+ {{458, 459, 460, kSentinel}},
+ {{461, 462, kSentinel}},
+ {{463, 464, kSentinel}},
+ {{465, 466, kSentinel}}, // NOLINT
+ {{467, 468, kSentinel}},
+ {{469, 470, kSentinel}},
+ {{471, 472, kSentinel}},
+ {{473, 474, kSentinel}}, // NOLINT
+ {{475, 476, kSentinel}},
+ {{478, 479, kSentinel}},
+ {{480, 481, kSentinel}},
+ {{482, 483, kSentinel}}, // NOLINT
+ {{484, 485, kSentinel}},
+ {{486, 487, kSentinel}},
+ {{488, 489, kSentinel}},
+ {{490, 491, kSentinel}}, // NOLINT
+ {{492, 493, kSentinel}},
+ {{494, 495, kSentinel}},
+ {{497, 498, 499, kSentinel}},
+ {{500, 501, kSentinel}}, // NOLINT
+ {{504, 505, kSentinel}},
+ {{506, 507, kSentinel}},
+ {{508, 509, kSentinel}},
+ {{510, 511, kSentinel}}, // NOLINT
+ {{512, 513, kSentinel}},
+ {{514, 515, kSentinel}},
+ {{516, 517, kSentinel}},
+ {{518, 519, kSentinel}}, // NOLINT
+ {{520, 521, kSentinel}},
+ {{522, 523, kSentinel}},
+ {{524, 525, kSentinel}},
+ {{526, 527, kSentinel}}, // NOLINT
+ {{528, 529, kSentinel}},
+ {{530, 531, kSentinel}},
+ {{532, 533, kSentinel}},
+ {{534, 535, kSentinel}}, // NOLINT
+ {{536, 537, kSentinel}},
+ {{538, 539, kSentinel}},
+ {{540, 541, kSentinel}},
+ {{542, 543, kSentinel}}, // NOLINT
+ {{546, 547, kSentinel}},
+ {{548, 549, kSentinel}},
+ {{550, 551, kSentinel}},
+ {{552, 553, kSentinel}}, // NOLINT
+ {{554, 555, kSentinel}},
+ {{556, 557, kSentinel}},
+ {{558, 559, kSentinel}},
+ {{560, 561, kSentinel}}, // NOLINT
+ {{562, 563, kSentinel}},
+ {{570, 11365, kSentinel}},
+ {{571, 572, kSentinel}},
+ {{574, 11366, kSentinel}}, // NOLINT
+ {{575, 11390, kSentinel}},
+ {{576, 11391, kSentinel}},
+ {{577, 578, kSentinel}},
+ {{580, 649, kSentinel}}, // NOLINT
+ {{581, 652, kSentinel}},
+ {{582, 583, kSentinel}},
+ {{584, 585, kSentinel}},
+ {{586, 587, kSentinel}}, // NOLINT
+ {{588, 589, kSentinel}},
+ {{590, 591, kSentinel}},
+ {{592, 11375, kSentinel}},
+ {{593, 11373, kSentinel}}, // NOLINT
+ {{594, 11376, kSentinel}},
+ {{604, 42923, kSentinel}},
+ {{609, 42924, kSentinel}},
+ {{613, 42893, kSentinel}}, // NOLINT
+ {{614, 42922, kSentinel}},
+ {{619, 11362, kSentinel}},
+ {{620, 42925, kSentinel}},
+ {{625, 11374, kSentinel}}, // NOLINT
+ {{637, 11364, kSentinel}},
+ {{647, 42929, kSentinel}},
+ {{670, 42928, kSentinel}},
+ {{837, 921, 953, 8126}}, // NOLINT
+ {{880, 881, kSentinel}},
+ {{882, 883, kSentinel}},
+ {{886, 887, kSentinel}},
+ {{891, 1021, kSentinel}}, // NOLINT
+ {{893, 1023, kSentinel}},
+ {{895, 1011, kSentinel}},
+ {{902, 940, kSentinel}},
+ {{904, 941, kSentinel}}, // NOLINT
+ {{906, 943, kSentinel}},
+ {{908, 972, kSentinel}},
+ {{910, 973, kSentinel}},
+ {{911, 974, kSentinel}}, // NOLINT
+ {{913, 945, kSentinel}},
+ {{914, 946, 976, kSentinel}},
+ {{915, 947, kSentinel}},
+ {{916, 948, kSentinel}}, // NOLINT
+ {{917, 949, 1013, kSentinel}},
+ {{918, 950, kSentinel}},
+ {{919, 951, kSentinel}},
+ {{920, 952, 977, kSentinel}}, // NOLINT
+ {{922, 954, 1008, kSentinel}},
+ {{923, 955, kSentinel}},
+ {{925, 957, kSentinel}},
+ {{927, 959, kSentinel}}, // NOLINT
+ {{928, 960, 982, kSentinel}},
+ {{929, 961, 1009, kSentinel}},
+ {{931, 962, 963, kSentinel}},
+ {{932, 964, kSentinel}}, // NOLINT
+ {{933, 965, kSentinel}},
+ {{934, 966, 981, kSentinel}},
+ {{935, 967, kSentinel}},
+ {{939, 971, kSentinel}}, // NOLINT
+ {{975, 983, kSentinel}},
+ {{984, 985, kSentinel}},
+ {{986, 987, kSentinel}},
+ {{988, 989, kSentinel}}, // NOLINT
+ {{990, 991, kSentinel}},
+ {{992, 993, kSentinel}},
+ {{994, 995, kSentinel}},
+ {{996, 997, kSentinel}}, // NOLINT
+ {{998, 999, kSentinel}},
+ {{1000, 1001, kSentinel}},
+ {{1002, 1003, kSentinel}},
+ {{1004, 1005, kSentinel}}, // NOLINT
+ {{1006, 1007, kSentinel}},
+ {{1010, 1017, kSentinel}},
+ {{1015, 1016, kSentinel}},
+ {{1018, 1019, kSentinel}}, // NOLINT
+ {{1024, 1104, kSentinel}},
+ {{1039, 1119, kSentinel}},
+ {{1040, 1072, kSentinel}},
+ {{1071, 1103, kSentinel}}, // NOLINT
+ {{1120, 1121, kSentinel}},
+ {{1122, 1123, kSentinel}},
+ {{1124, 1125, kSentinel}},
+ {{1126, 1127, kSentinel}}, // NOLINT
+ {{1128, 1129, kSentinel}},
+ {{1130, 1131, kSentinel}},
+ {{1132, 1133, kSentinel}},
+ {{1134, 1135, kSentinel}}, // NOLINT
+ {{1136, 1137, kSentinel}},
+ {{1138, 1139, kSentinel}},
+ {{1140, 1141, kSentinel}},
+ {{1142, 1143, kSentinel}}, // NOLINT
+ {{1144, 1145, kSentinel}},
+ {{1146, 1147, kSentinel}},
+ {{1148, 1149, kSentinel}},
+ {{1150, 1151, kSentinel}}, // NOLINT
+ {{1152, 1153, kSentinel}},
+ {{1162, 1163, kSentinel}},
+ {{1164, 1165, kSentinel}},
+ {{1166, 1167, kSentinel}}, // NOLINT
+ {{1168, 1169, kSentinel}},
+ {{1170, 1171, kSentinel}},
+ {{1172, 1173, kSentinel}},
+ {{1174, 1175, kSentinel}}, // NOLINT
+ {{1176, 1177, kSentinel}},
+ {{1178, 1179, kSentinel}},
+ {{1180, 1181, kSentinel}},
+ {{1182, 1183, kSentinel}}, // NOLINT
+ {{1184, 1185, kSentinel}},
+ {{1186, 1187, kSentinel}},
+ {{1188, 1189, kSentinel}},
+ {{1190, 1191, kSentinel}}, // NOLINT
+ {{1192, 1193, kSentinel}},
+ {{1194, 1195, kSentinel}},
+ {{1196, 1197, kSentinel}},
+ {{1198, 1199, kSentinel}}, // NOLINT
+ {{1200, 1201, kSentinel}},
+ {{1202, 1203, kSentinel}},
+ {{1204, 1205, kSentinel}},
+ {{1206, 1207, kSentinel}}, // NOLINT
+ {{1208, 1209, kSentinel}},
+ {{1210, 1211, kSentinel}},
+ {{1212, 1213, kSentinel}},
+ {{1214, 1215, kSentinel}}, // NOLINT
+ {{1216, 1231, kSentinel}},
+ {{1217, 1218, kSentinel}},
+ {{1219, 1220, kSentinel}},
+ {{1221, 1222, kSentinel}}, // NOLINT
+ {{1223, 1224, kSentinel}},
+ {{1225, 1226, kSentinel}},
+ {{1227, 1228, kSentinel}},
+ {{1229, 1230, kSentinel}}, // NOLINT
+ {{1232, 1233, kSentinel}},
+ {{1234, 1235, kSentinel}},
+ {{1236, 1237, kSentinel}},
+ {{1238, 1239, kSentinel}}, // NOLINT
+ {{1240, 1241, kSentinel}},
+ {{1242, 1243, kSentinel}},
+ {{1244, 1245, kSentinel}},
+ {{1246, 1247, kSentinel}}, // NOLINT
+ {{1248, 1249, kSentinel}},
+ {{1250, 1251, kSentinel}},
+ {{1252, 1253, kSentinel}},
+ {{1254, 1255, kSentinel}}, // NOLINT
+ {{1256, 1257, kSentinel}},
+ {{1258, 1259, kSentinel}},
+ {{1260, 1261, kSentinel}},
+ {{1262, 1263, kSentinel}}, // NOLINT
+ {{1264, 1265, kSentinel}},
+ {{1266, 1267, kSentinel}},
+ {{1268, 1269, kSentinel}},
+ {{1270, 1271, kSentinel}}, // NOLINT
+ {{1272, 1273, kSentinel}},
+ {{1274, 1275, kSentinel}},
+ {{1276, 1277, kSentinel}},
+ {{1278, 1279, kSentinel}}, // NOLINT
+ {{1280, 1281, kSentinel}},
+ {{1282, 1283, kSentinel}},
+ {{1284, 1285, kSentinel}},
+ {{1286, 1287, kSentinel}}, // NOLINT
+ {{1288, 1289, kSentinel}},
+ {{1290, 1291, kSentinel}},
+ {{1292, 1293, kSentinel}},
+ {{1294, 1295, kSentinel}}, // NOLINT
+ {{1296, 1297, kSentinel}},
+ {{1298, 1299, kSentinel}},
+ {{1300, 1301, kSentinel}},
+ {{1302, 1303, kSentinel}}, // NOLINT
+ {{1304, 1305, kSentinel}},
+ {{1306, 1307, kSentinel}},
+ {{1308, 1309, kSentinel}},
+ {{1310, 1311, kSentinel}}, // NOLINT
+ {{1312, 1313, kSentinel}},
+ {{1314, 1315, kSentinel}},
+ {{1316, 1317, kSentinel}},
+ {{1318, 1319, kSentinel}}, // NOLINT
+ {{1320, 1321, kSentinel}},
+ {{1322, 1323, kSentinel}},
+ {{1324, 1325, kSentinel}},
+ {{1326, 1327, kSentinel}}, // NOLINT
+ {{1329, 1377, kSentinel}},
+ {{1366, 1414, kSentinel}},
+ {{4256, 11520, kSentinel}},
+ {{4293, 11557, kSentinel}}, // NOLINT
+ {{4295, 11559, kSentinel}},
+ {{4301, 11565, kSentinel}},
+ {{7545, 42877, kSentinel}},
+ {{7549, 11363, kSentinel}}, // NOLINT
+ {{7680, 7681, kSentinel}},
+ {{7682, 7683, kSentinel}},
+ {{7684, 7685, kSentinel}},
+ {{7686, 7687, kSentinel}}, // NOLINT
+ {{7688, 7689, kSentinel}},
+ {{7690, 7691, kSentinel}},
+ {{7692, 7693, kSentinel}},
+ {{7694, 7695, kSentinel}}, // NOLINT
+ {{7696, 7697, kSentinel}},
+ {{7698, 7699, kSentinel}},
+ {{7700, 7701, kSentinel}},
+ {{7702, 7703, kSentinel}}, // NOLINT
+ {{7704, 7705, kSentinel}},
+ {{7706, 7707, kSentinel}},
+ {{7708, 7709, kSentinel}},
+ {{7710, 7711, kSentinel}}, // NOLINT
+ {{7712, 7713, kSentinel}},
+ {{7714, 7715, kSentinel}},
+ {{7716, 7717, kSentinel}},
+ {{7718, 7719, kSentinel}}, // NOLINT
+ {{7720, 7721, kSentinel}},
+ {{7722, 7723, kSentinel}},
+ {{7724, 7725, kSentinel}},
+ {{7726, 7727, kSentinel}}, // NOLINT
+ {{7728, 7729, kSentinel}},
+ {{7730, 7731, kSentinel}},
+ {{7732, 7733, kSentinel}},
+ {{7734, 7735, kSentinel}}, // NOLINT
+ {{7736, 7737, kSentinel}},
+ {{7738, 7739, kSentinel}},
+ {{7740, 7741, kSentinel}},
+ {{7742, 7743, kSentinel}}, // NOLINT
+ {{7744, 7745, kSentinel}},
+ {{7746, 7747, kSentinel}},
+ {{7748, 7749, kSentinel}},
+ {{7750, 7751, kSentinel}}, // NOLINT
+ {{7752, 7753, kSentinel}},
+ {{7754, 7755, kSentinel}},
+ {{7756, 7757, kSentinel}},
+ {{7758, 7759, kSentinel}}, // NOLINT
+ {{7760, 7761, kSentinel}},
+ {{7762, 7763, kSentinel}},
+ {{7764, 7765, kSentinel}},
+ {{7766, 7767, kSentinel}}, // NOLINT
+ {{7768, 7769, kSentinel}},
+ {{7770, 7771, kSentinel}},
+ {{7772, 7773, kSentinel}},
+ {{7774, 7775, kSentinel}}, // NOLINT
+ {{7776, 7777, 7835, kSentinel}},
+ {{7778, 7779, kSentinel}},
+ {{7780, 7781, kSentinel}},
+ {{7782, 7783, kSentinel}}, // NOLINT
+ {{7784, 7785, kSentinel}},
+ {{7786, 7787, kSentinel}},
+ {{7788, 7789, kSentinel}},
+ {{7790, 7791, kSentinel}}, // NOLINT
+ {{7792, 7793, kSentinel}},
+ {{7794, 7795, kSentinel}},
+ {{7796, 7797, kSentinel}},
+ {{7798, 7799, kSentinel}}, // NOLINT
+ {{7800, 7801, kSentinel}},
+ {{7802, 7803, kSentinel}},
+ {{7804, 7805, kSentinel}},
+ {{7806, 7807, kSentinel}}, // NOLINT
+ {{7808, 7809, kSentinel}},
+ {{7810, 7811, kSentinel}},
+ {{7812, 7813, kSentinel}},
+ {{7814, 7815, kSentinel}}, // NOLINT
+ {{7816, 7817, kSentinel}},
+ {{7818, 7819, kSentinel}},
+ {{7820, 7821, kSentinel}},
+ {{7822, 7823, kSentinel}}, // NOLINT
+ {{7824, 7825, kSentinel}},
+ {{7826, 7827, kSentinel}},
+ {{7828, 7829, kSentinel}},
+ {{7840, 7841, kSentinel}}, // NOLINT
+ {{7842, 7843, kSentinel}},
+ {{7844, 7845, kSentinel}},
+ {{7846, 7847, kSentinel}},
+ {{7848, 7849, kSentinel}}, // NOLINT
+ {{7850, 7851, kSentinel}},
+ {{7852, 7853, kSentinel}},
+ {{7854, 7855, kSentinel}},
+ {{7856, 7857, kSentinel}}, // NOLINT
+ {{7858, 7859, kSentinel}},
+ {{7860, 7861, kSentinel}},
+ {{7862, 7863, kSentinel}},
+ {{7864, 7865, kSentinel}}, // NOLINT
+ {{7866, 7867, kSentinel}},
+ {{7868, 7869, kSentinel}},
+ {{7870, 7871, kSentinel}},
+ {{7872, 7873, kSentinel}}, // NOLINT
+ {{7874, 7875, kSentinel}},
+ {{7876, 7877, kSentinel}},
+ {{7878, 7879, kSentinel}},
+ {{7880, 7881, kSentinel}}, // NOLINT
+ {{7882, 7883, kSentinel}},
+ {{7884, 7885, kSentinel}},
+ {{7886, 7887, kSentinel}},
+ {{7888, 7889, kSentinel}}, // NOLINT
+ {{7890, 7891, kSentinel}},
+ {{7892, 7893, kSentinel}},
+ {{7894, 7895, kSentinel}},
+ {{7896, 7897, kSentinel}}, // NOLINT
+ {{7898, 7899, kSentinel}},
+ {{7900, 7901, kSentinel}},
+ {{7902, 7903, kSentinel}},
+ {{7904, 7905, kSentinel}}, // NOLINT
+ {{7906, 7907, kSentinel}},
+ {{7908, 7909, kSentinel}},
+ {{7910, 7911, kSentinel}},
+ {{7912, 7913, kSentinel}}, // NOLINT
+ {{7914, 7915, kSentinel}},
+ {{7916, 7917, kSentinel}},
+ {{7918, 7919, kSentinel}},
+ {{7920, 7921, kSentinel}}, // NOLINT
+ {{7922, 7923, kSentinel}},
+ {{7924, 7925, kSentinel}},
+ {{7926, 7927, kSentinel}},
+ {{7928, 7929, kSentinel}}, // NOLINT
+ {{7930, 7931, kSentinel}},
+ {{7932, 7933, kSentinel}},
+ {{7934, 7935, kSentinel}},
+ {{7936, 7944, kSentinel}}, // NOLINT
+ {{7943, 7951, kSentinel}},
+ {{7952, 7960, kSentinel}},
+ {{7957, 7965, kSentinel}},
+ {{7968, 7976, kSentinel}}, // NOLINT
+ {{7975, 7983, kSentinel}},
+ {{7984, 7992, kSentinel}},
+ {{7991, 7999, kSentinel}},
+ {{8000, 8008, kSentinel}}, // NOLINT
+ {{8005, 8013, kSentinel}},
+ {{8017, 8025, kSentinel}},
+ {{8019, 8027, kSentinel}},
+ {{8021, 8029, kSentinel}}, // NOLINT
+ {{8023, 8031, kSentinel}},
+ {{8032, 8040, kSentinel}},
+ {{8039, 8047, kSentinel}},
+ {{8048, 8122, kSentinel}}, // NOLINT
+ {{8049, 8123, kSentinel}},
+ {{8050, 8136, kSentinel}},
+ {{8053, 8139, kSentinel}},
+ {{8054, 8154, kSentinel}}, // NOLINT
+ {{8055, 8155, kSentinel}},
+ {{8056, 8184, kSentinel}},
+ {{8057, 8185, kSentinel}},
+ {{8058, 8170, kSentinel}}, // NOLINT
+ {{8059, 8171, kSentinel}},
+ {{8060, 8186, kSentinel}},
+ {{8061, 8187, kSentinel}},
+ {{8112, 8120, kSentinel}}, // NOLINT
+ {{8113, 8121, kSentinel}},
+ {{8144, 8152, kSentinel}},
+ {{8145, 8153, kSentinel}},
+ {{8160, 8168, kSentinel}}, // NOLINT
+ {{8161, 8169, kSentinel}},
+ {{8165, 8172, kSentinel}},
+ {{kSentinel}}}; // NOLINT
+static const uint16_t kEcma262UnCanonicalizeTable0Size = 1005; // NOLINT
+static const int32_t kEcma262UnCanonicalizeTable0[2010] = {
+ 1073741889, 1, 90, 5, 1073741921, 1,
+ 122, 5, 181, 9, 1073742016, 13,
+ 214, 17, 1073742040, 21, // NOLINT
+ 222, 25, 1073742048, 13, 246, 17,
+ 1073742072, 21, 254, 25, 255, 29,
+ 256, 33, 257, 33, // NOLINT
+ 258, 37, 259, 37, 260, 41,
+ 261, 41, 262, 45, 263, 45,
+ 264, 49, 265, 49, // NOLINT
+ 266, 53, 267, 53, 268, 57,
+ 269, 57, 270, 61, 271, 61,
+ 272, 65, 273, 65, // NOLINT
+ 274, 69, 275, 69, 276, 73,
+ 277, 73, 278, 77, 279, 77,
+ 280, 81, 281, 81, // NOLINT
+ 282, 85, 283, 85, 284, 89,
+ 285, 89, 286, 93, 287, 93,
+ 288, 97, 289, 97, // NOLINT
+ 290, 101, 291, 101, 292, 105,
+ 293, 105, 294, 109, 295, 109,
+ 296, 113, 297, 113, // NOLINT
+ 298, 117, 299, 117, 300, 121,
+ 301, 121, 302, 125, 303, 125,
+ 306, 129, 307, 129, // NOLINT
+ 308, 133, 309, 133, 310, 137,
+ 311, 137, 313, 141, 314, 141,
+ 315, 145, 316, 145, // NOLINT
+ 317, 149, 318, 149, 319, 153,
+ 320, 153, 321, 157, 322, 157,
+ 323, 161, 324, 161, // NOLINT
+ 325, 165, 326, 165, 327, 169,
+ 328, 169, 330, 173, 331, 173,
+ 332, 177, 333, 177, // NOLINT
+ 334, 181, 335, 181, 336, 185,
+ 337, 185, 338, 189, 339, 189,
+ 340, 193, 341, 193, // NOLINT
+ 342, 197, 343, 197, 344, 201,
+ 345, 201, 346, 205, 347, 205,
+ 348, 209, 349, 209, // NOLINT
+ 350, 213, 351, 213, 352, 217,
+ 353, 217, 354, 221, 355, 221,
+ 356, 225, 357, 225, // NOLINT
+ 358, 229, 359, 229, 360, 233,
+ 361, 233, 362, 237, 363, 237,
+ 364, 241, 365, 241, // NOLINT
+ 366, 245, 367, 245, 368, 249,
+ 369, 249, 370, 253, 371, 253,
+ 372, 257, 373, 257, // NOLINT
+ 374, 261, 375, 261, 376, 29,
+ 377, 265, 378, 265, 379, 269,
+ 380, 269, 381, 273, // NOLINT
+ 382, 273, 384, 277, 385, 281,
+ 386, 285, 387, 285, 388, 289,
+ 389, 289, 390, 293, // NOLINT
+ 391, 297, 392, 297, 1073742217, 301,
+ 394, 305, 395, 309, 396, 309,
+ 398, 313, 399, 317, // NOLINT
+ 400, 321, 401, 325, 402, 325,
+ 403, 329, 404, 333, 405, 337,
+ 406, 341, 407, 345, // NOLINT
+ 408, 349, 409, 349, 410, 353,
+ 412, 357, 413, 361, 414, 365,
+ 415, 369, 416, 373, // NOLINT
+ 417, 373, 418, 377, 419, 377,
+ 420, 381, 421, 381, 422, 385,
+ 423, 389, 424, 389, // NOLINT
+ 425, 393, 428, 397, 429, 397,
+ 430, 401, 431, 405, 432, 405,
+ 1073742257, 409, 434, 413, // NOLINT
+ 435, 417, 436, 417, 437, 421,
+ 438, 421, 439, 425, 440, 429,
+ 441, 429, 444, 433, // NOLINT
+ 445, 433, 447, 437, 452, 441,
+ 453, 441, 454, 441, 455, 445,
+ 456, 445, 457, 445, // NOLINT
+ 458, 449, 459, 449, 460, 449,
+ 461, 453, 462, 453, 463, 457,
+ 464, 457, 465, 461, // NOLINT
+ 466, 461, 467, 465, 468, 465,
+ 469, 469, 470, 469, 471, 473,
+ 472, 473, 473, 477, // NOLINT
+ 474, 477, 475, 481, 476, 481,
+ 477, 313, 478, 485, 479, 485,
+ 480, 489, 481, 489, // NOLINT
+ 482, 493, 483, 493, 484, 497,
+ 485, 497, 486, 501, 487, 501,
+ 488, 505, 489, 505, // NOLINT
+ 490, 509, 491, 509, 492, 513,
+ 493, 513, 494, 517, 495, 517,
+ 497, 521, 498, 521, // NOLINT
+ 499, 521, 500, 525, 501, 525,
+ 502, 337, 503, 437, 504, 529,
+ 505, 529, 506, 533, // NOLINT
+ 507, 533, 508, 537, 509, 537,
+ 510, 541, 511, 541, 512, 545,
+ 513, 545, 514, 549, // NOLINT
+ 515, 549, 516, 553, 517, 553,
+ 518, 557, 519, 557, 520, 561,
+ 521, 561, 522, 565, // NOLINT
+ 523, 565, 524, 569, 525, 569,
+ 526, 573, 527, 573, 528, 577,
+ 529, 577, 530, 581, // NOLINT
+ 531, 581, 532, 585, 533, 585,
+ 534, 589, 535, 589, 536, 593,
+ 537, 593, 538, 597, // NOLINT
+ 539, 597, 540, 601, 541, 601,
+ 542, 605, 543, 605, 544, 365,
+ 546, 609, 547, 609, // NOLINT
+ 548, 613, 549, 613, 550, 617,
+ 551, 617, 552, 621, 553, 621,
+ 554, 625, 555, 625, // NOLINT
+ 556, 629, 557, 629, 558, 633,
+ 559, 633, 560, 637, 561, 637,
+ 562, 641, 563, 641, // NOLINT
+ 570, 645, 571, 649, 572, 649,
+ 573, 353, 574, 653, 1073742399, 657,
+ 576, 661, 577, 665, // NOLINT
+ 578, 665, 579, 277, 580, 669,
+ 581, 673, 582, 677, 583, 677,
+ 584, 681, 585, 681, // NOLINT
+ 586, 685, 587, 685, 588, 689,
+ 589, 689, 590, 693, 591, 693,
+ 592, 697, 593, 701, // NOLINT
+ 594, 705, 595, 281, 596, 293,
+ 1073742422, 301, 599, 305, 601, 317,
+ 603, 321, 604, 709, // NOLINT
+ 608, 329, 609, 713, 611, 333,
+ 613, 717, 614, 721, 616, 345,
+ 617, 341, 619, 725, // NOLINT
+ 620, 729, 623, 357, 625, 733,
+ 626, 361, 629, 369, 637, 737,
+ 640, 385, 643, 393, // NOLINT
+ 647, 741, 648, 401, 649, 669,
+ 1073742474, 409, 651, 413, 652, 673,
+ 658, 425, 670, 745, // NOLINT
+ 837, 749, 880, 753, 881, 753,
+ 882, 757, 883, 757, 886, 761,
+ 887, 761, 1073742715, 765, // NOLINT
+ 893, 769, 895, 773, 902, 777,
+ 1073742728, 781, 906, 785, 908, 789,
+ 1073742734, 793, 911, 797, // NOLINT
+ 913, 801, 914, 805, 1073742739, 809,
+ 916, 813, 917, 817, 1073742742, 821,
+ 919, 825, 920, 829, // NOLINT
+ 921, 749, 922, 833, 923, 837,
+ 924, 9, 1073742749, 841, 927, 845,
+ 928, 849, 929, 853, // NOLINT
+ 931, 857, 1073742756, 861, 933, 865,
+ 934, 869, 1073742759, 873, 939, 877,
+ 940, 777, 1073742765, 781, // NOLINT
+ 943, 785, 945, 801, 946, 805,
+ 1073742771, 809, 948, 813, 949, 817,
+ 1073742774, 821, 951, 825, // NOLINT
+ 952, 829, 953, 749, 954, 833,
+ 955, 837, 956, 9, 1073742781, 841,
+ 959, 845, 960, 849, // NOLINT
+ 961, 853, 962, 857, 963, 857,
+ 1073742788, 861, 965, 865, 966, 869,
+ 1073742791, 873, 971, 877, // NOLINT
+ 972, 789, 1073742797, 793, 974, 797,
+ 975, 881, 976, 805, 977, 829,
+ 981, 869, 982, 849, // NOLINT
+ 983, 881, 984, 885, 985, 885,
+ 986, 889, 987, 889, 988, 893,
+ 989, 893, 990, 897, // NOLINT
+ 991, 897, 992, 901, 993, 901,
+ 994, 905, 995, 905, 996, 909,
+ 997, 909, 998, 913, // NOLINT
+ 999, 913, 1000, 917, 1001, 917,
+ 1002, 921, 1003, 921, 1004, 925,
+ 1005, 925, 1006, 929, // NOLINT
+ 1007, 929, 1008, 833, 1009, 853,
+ 1010, 933, 1011, 773, 1013, 817,
+ 1015, 937, 1016, 937, // NOLINT
+ 1017, 933, 1018, 941, 1019, 941,
+ 1073742845, 765, 1023, 769, 1073742848, 945,
+ 1039, 949, 1073742864, 953, // NOLINT
+ 1071, 957, 1073742896, 953, 1103, 957,
+ 1073742928, 945, 1119, 949, 1120, 961,
+ 1121, 961, 1122, 965, // NOLINT
+ 1123, 965, 1124, 969, 1125, 969,
+ 1126, 973, 1127, 973, 1128, 977,
+ 1129, 977, 1130, 981, // NOLINT
+ 1131, 981, 1132, 985, 1133, 985,
+ 1134, 989, 1135, 989, 1136, 993,
+ 1137, 993, 1138, 997, // NOLINT
+ 1139, 997, 1140, 1001, 1141, 1001,
+ 1142, 1005, 1143, 1005, 1144, 1009,
+ 1145, 1009, 1146, 1013, // NOLINT
+ 1147, 1013, 1148, 1017, 1149, 1017,
+ 1150, 1021, 1151, 1021, 1152, 1025,
+ 1153, 1025, 1162, 1029, // NOLINT
+ 1163, 1029, 1164, 1033, 1165, 1033,
+ 1166, 1037, 1167, 1037, 1168, 1041,
+ 1169, 1041, 1170, 1045, // NOLINT
+ 1171, 1045, 1172, 1049, 1173, 1049,
+ 1174, 1053, 1175, 1053, 1176, 1057,
+ 1177, 1057, 1178, 1061, // NOLINT
+ 1179, 1061, 1180, 1065, 1181, 1065,
+ 1182, 1069, 1183, 1069, 1184, 1073,
+ 1185, 1073, 1186, 1077, // NOLINT
+ 1187, 1077, 1188, 1081, 1189, 1081,
+ 1190, 1085, 1191, 1085, 1192, 1089,
+ 1193, 1089, 1194, 1093, // NOLINT
+ 1195, 1093, 1196, 1097, 1197, 1097,
+ 1198, 1101, 1199, 1101, 1200, 1105,
+ 1201, 1105, 1202, 1109, // NOLINT
+ 1203, 1109, 1204, 1113, 1205, 1113,
+ 1206, 1117, 1207, 1117, 1208, 1121,
+ 1209, 1121, 1210, 1125, // NOLINT
+ 1211, 1125, 1212, 1129, 1213, 1129,
+ 1214, 1133, 1215, 1133, 1216, 1137,
+ 1217, 1141, 1218, 1141, // NOLINT
+ 1219, 1145, 1220, 1145, 1221, 1149,
+ 1222, 1149, 1223, 1153, 1224, 1153,
+ 1225, 1157, 1226, 1157, // NOLINT
+ 1227, 1161, 1228, 1161, 1229, 1165,
+ 1230, 1165, 1231, 1137, 1232, 1169,
+ 1233, 1169, 1234, 1173, // NOLINT
+ 1235, 1173, 1236, 1177, 1237, 1177,
+ 1238, 1181, 1239, 1181, 1240, 1185,
+ 1241, 1185, 1242, 1189, // NOLINT
+ 1243, 1189, 1244, 1193, 1245, 1193,
+ 1246, 1197, 1247, 1197, 1248, 1201,
+ 1249, 1201, 1250, 1205, // NOLINT
+ 1251, 1205, 1252, 1209, 1253, 1209,
+ 1254, 1213, 1255, 1213, 1256, 1217,
+ 1257, 1217, 1258, 1221, // NOLINT
+ 1259, 1221, 1260, 1225, 1261, 1225,
+ 1262, 1229, 1263, 1229, 1264, 1233,
+ 1265, 1233, 1266, 1237, // NOLINT
+ 1267, 1237, 1268, 1241, 1269, 1241,
+ 1270, 1245, 1271, 1245, 1272, 1249,
+ 1273, 1249, 1274, 1253, // NOLINT
+ 1275, 1253, 1276, 1257, 1277, 1257,
+ 1278, 1261, 1279, 1261, 1280, 1265,
+ 1281, 1265, 1282, 1269, // NOLINT
+ 1283, 1269, 1284, 1273, 1285, 1273,
+ 1286, 1277, 1287, 1277, 1288, 1281,
+ 1289, 1281, 1290, 1285, // NOLINT
+ 1291, 1285, 1292, 1289, 1293, 1289,
+ 1294, 1293, 1295, 1293, 1296, 1297,
+ 1297, 1297, 1298, 1301, // NOLINT
+ 1299, 1301, 1300, 1305, 1301, 1305,
+ 1302, 1309, 1303, 1309, 1304, 1313,
+ 1305, 1313, 1306, 1317, // NOLINT
+ 1307, 1317, 1308, 1321, 1309, 1321,
+ 1310, 1325, 1311, 1325, 1312, 1329,
+ 1313, 1329, 1314, 1333, // NOLINT
+ 1315, 1333, 1316, 1337, 1317, 1337,
+ 1318, 1341, 1319, 1341, 1320, 1345,
+ 1321, 1345, 1322, 1349, // NOLINT
+ 1323, 1349, 1324, 1353, 1325, 1353,
+ 1326, 1357, 1327, 1357, 1073743153, 1361,
+ 1366, 1365, 1073743201, 1361, // NOLINT
+ 1414, 1365, 1073746080, 1369, 4293, 1373,
+ 4295, 1377, 4301, 1381, 7545, 1385,
+ 7549, 1389, 7680, 1393, // NOLINT
+ 7681, 1393, 7682, 1397, 7683, 1397,
+ 7684, 1401, 7685, 1401, 7686, 1405,
+ 7687, 1405, 7688, 1409, // NOLINT
+ 7689, 1409, 7690, 1413, 7691, 1413,
+ 7692, 1417, 7693, 1417, 7694, 1421,
+ 7695, 1421, 7696, 1425, // NOLINT
+ 7697, 1425, 7698, 1429, 7699, 1429,
+ 7700, 1433, 7701, 1433, 7702, 1437,
+ 7703, 1437, 7704, 1441, // NOLINT
+ 7705, 1441, 7706, 1445, 7707, 1445,
+ 7708, 1449, 7709, 1449, 7710, 1453,
+ 7711, 1453, 7712, 1457, // NOLINT
+ 7713, 1457, 7714, 1461, 7715, 1461,
+ 7716, 1465, 7717, 1465, 7718, 1469,
+ 7719, 1469, 7720, 1473, // NOLINT
+ 7721, 1473, 7722, 1477, 7723, 1477,
+ 7724, 1481, 7725, 1481, 7726, 1485,
+ 7727, 1485, 7728, 1489, // NOLINT
+ 7729, 1489, 7730, 1493, 7731, 1493,
+ 7732, 1497, 7733, 1497, 7734, 1501,
+ 7735, 1501, 7736, 1505, // NOLINT
+ 7737, 1505, 7738, 1509, 7739, 1509,
+ 7740, 1513, 7741, 1513, 7742, 1517,
+ 7743, 1517, 7744, 1521, // NOLINT
+ 7745, 1521, 7746, 1525, 7747, 1525,
+ 7748, 1529, 7749, 1529, 7750, 1533,
+ 7751, 1533, 7752, 1537, // NOLINT
+ 7753, 1537, 7754, 1541, 7755, 1541,
+ 7756, 1545, 7757, 1545, 7758, 1549,
+ 7759, 1549, 7760, 1553, // NOLINT
+ 7761, 1553, 7762, 1557, 7763, 1557,
+ 7764, 1561, 7765, 1561, 7766, 1565,
+ 7767, 1565, 7768, 1569, // NOLINT
+ 7769, 1569, 7770, 1573, 7771, 1573,
+ 7772, 1577, 7773, 1577, 7774, 1581,
+ 7775, 1581, 7776, 1585, // NOLINT
+ 7777, 1585, 7778, 1589, 7779, 1589,
+ 7780, 1593, 7781, 1593, 7782, 1597,
+ 7783, 1597, 7784, 1601, // NOLINT
+ 7785, 1601, 7786, 1605, 7787, 1605,
+ 7788, 1609, 7789, 1609, 7790, 1613,
+ 7791, 1613, 7792, 1617, // NOLINT
+ 7793, 1617, 7794, 1621, 7795, 1621,
+ 7796, 1625, 7797, 1625, 7798, 1629,
+ 7799, 1629, 7800, 1633, // NOLINT
+ 7801, 1633, 7802, 1637, 7803, 1637,
+ 7804, 1641, 7805, 1641, 7806, 1645,
+ 7807, 1645, 7808, 1649, // NOLINT
+ 7809, 1649, 7810, 1653, 7811, 1653,
+ 7812, 1657, 7813, 1657, 7814, 1661,
+ 7815, 1661, 7816, 1665, // NOLINT
+ 7817, 1665, 7818, 1669, 7819, 1669,
+ 7820, 1673, 7821, 1673, 7822, 1677,
+ 7823, 1677, 7824, 1681, // NOLINT
+ 7825, 1681, 7826, 1685, 7827, 1685,
+ 7828, 1689, 7829, 1689, 7835, 1585,
+ 7840, 1693, 7841, 1693, // NOLINT
+ 7842, 1697, 7843, 1697, 7844, 1701,
+ 7845, 1701, 7846, 1705, 7847, 1705,
+ 7848, 1709, 7849, 1709, // NOLINT
+ 7850, 1713, 7851, 1713, 7852, 1717,
+ 7853, 1717, 7854, 1721, 7855, 1721,
+ 7856, 1725, 7857, 1725, // NOLINT
+ 7858, 1729, 7859, 1729, 7860, 1733,
+ 7861, 1733, 7862, 1737, 7863, 1737,
+ 7864, 1741, 7865, 1741, // NOLINT
+ 7866, 1745, 7867, 1745, 7868, 1749,
+ 7869, 1749, 7870, 1753, 7871, 1753,
+ 7872, 1757, 7873, 1757, // NOLINT
+ 7874, 1761, 7875, 1761, 7876, 1765,
+ 7877, 1765, 7878, 1769, 7879, 1769,
+ 7880, 1773, 7881, 1773, // NOLINT
+ 7882, 1777, 7883, 1777, 7884, 1781,
+ 7885, 1781, 7886, 1785, 7887, 1785,
+ 7888, 1789, 7889, 1789, // NOLINT
+ 7890, 1793, 7891, 1793, 7892, 1797,
+ 7893, 1797, 7894, 1801, 7895, 1801,
+ 7896, 1805, 7897, 1805, // NOLINT
+ 7898, 1809, 7899, 1809, 7900, 1813,
+ 7901, 1813, 7902, 1817, 7903, 1817,
+ 7904, 1821, 7905, 1821, // NOLINT
+ 7906, 1825, 7907, 1825, 7908, 1829,
+ 7909, 1829, 7910, 1833, 7911, 1833,
+ 7912, 1837, 7913, 1837, // NOLINT
+ 7914, 1841, 7915, 1841, 7916, 1845,
+ 7917, 1845, 7918, 1849, 7919, 1849,
+ 7920, 1853, 7921, 1853, // NOLINT
+ 7922, 1857, 7923, 1857, 7924, 1861,
+ 7925, 1861, 7926, 1865, 7927, 1865,
+ 7928, 1869, 7929, 1869, // NOLINT
+ 7930, 1873, 7931, 1873, 7932, 1877,
+ 7933, 1877, 7934, 1881, 7935, 1881,
+ 1073749760, 1885, 7943, 1889, // NOLINT
+ 1073749768, 1885, 7951, 1889, 1073749776, 1893,
+ 7957, 1897, 1073749784, 1893, 7965, 1897,
+ 1073749792, 1901, 7975, 1905, // NOLINT
+ 1073749800, 1901, 7983, 1905, 1073749808, 1909,
+ 7991, 1913, 1073749816, 1909, 7999, 1913,
+ 1073749824, 1917, 8005, 1921, // NOLINT
+ 1073749832, 1917, 8013, 1921, 8017, 1925,
+ 8019, 1929, 8021, 1933, 8023, 1937,
+ 8025, 1925, 8027, 1929, // NOLINT
+ 8029, 1933, 8031, 1937, 1073749856, 1941,
+ 8039, 1945, 1073749864, 1941, 8047, 1945,
+ 1073749872, 1949, 8049, 1953, // NOLINT
+ 1073749874, 1957, 8053, 1961, 1073749878, 1965,
+ 8055, 1969, 1073749880, 1973, 8057, 1977,
+ 1073749882, 1981, 8059, 1985, // NOLINT
+ 1073749884, 1989, 8061, 1993, 1073749936, 1997,
+ 8113, 2001, 1073749944, 1997, 8121, 2001,
+ 1073749946, 1949, 8123, 1953, // NOLINT
+ 8126, 749, 1073749960, 1957, 8139, 1961,
+ 1073749968, 2005, 8145, 2009, 1073749976, 2005,
+ 8153, 2009, 1073749978, 1965, // NOLINT
+ 8155, 1969, 1073749984, 2013, 8161, 2017,
+ 8165, 2021, 1073749992, 2013, 8169, 2017,
+ 1073749994, 1981, 8171, 1985, // NOLINT
+ 8172, 2021, 1073750008, 1973, 8185, 1977,
+ 1073750010, 1989, 8187, 1993}; // NOLINT
+static const uint16_t kEcma262UnCanonicalizeMultiStrings0Size = 507; // NOLINT
static const MultiCharacterSpecialCase<2> kEcma262UnCanonicalizeMultiStrings1[83] = { // NOLINT
{{8498, 8526}}, {{8544, 8560}}, {{8559, 8575}}, {{8579, 8580}}, // NOLINT
{{9398, 9424}}, {{9423, 9449}}, {{11264, 11312}}, {{11310, 11358}}, // NOLINT
3297, 293, 3298, 297, 3299, 297, 3307, 301, 3308, 301, 3309, 305, 3310, 305, 3314, 309, // NOLINT
3315, 309, 1073745152, 313, 3365, 317, 3367, 321, 3373, 325 }; // NOLINT
static const uint16_t kEcma262UnCanonicalizeMultiStrings1Size = 83; // NOLINT
-static const MultiCharacterSpecialCase<2> kEcma262UnCanonicalizeMultiStrings5[92] = { // NOLINT
- {{42560, 42561}}, {{42562, 42563}}, {{42564, 42565}}, {{42566, 42567}}, // NOLINT
- {{42568, 42569}}, {{42570, 42571}}, {{42572, 42573}}, {{42574, 42575}}, // NOLINT
- {{42576, 42577}}, {{42578, 42579}}, {{42580, 42581}}, {{42582, 42583}}, // NOLINT
- {{42584, 42585}}, {{42586, 42587}}, {{42588, 42589}}, {{42590, 42591}}, // NOLINT
- {{42592, 42593}}, {{42594, 42595}}, {{42596, 42597}}, {{42598, 42599}}, // NOLINT
- {{42600, 42601}}, {{42602, 42603}}, {{42604, 42605}}, {{42624, 42625}}, // NOLINT
- {{42626, 42627}}, {{42628, 42629}}, {{42630, 42631}}, {{42632, 42633}}, // NOLINT
- {{42634, 42635}}, {{42636, 42637}}, {{42638, 42639}}, {{42640, 42641}}, // NOLINT
- {{42642, 42643}}, {{42644, 42645}}, {{42646, 42647}}, {{42786, 42787}}, // NOLINT
- {{42788, 42789}}, {{42790, 42791}}, {{42792, 42793}}, {{42794, 42795}}, // NOLINT
- {{42796, 42797}}, {{42798, 42799}}, {{42802, 42803}}, {{42804, 42805}}, // NOLINT
- {{42806, 42807}}, {{42808, 42809}}, {{42810, 42811}}, {{42812, 42813}}, // NOLINT
- {{42814, 42815}}, {{42816, 42817}}, {{42818, 42819}}, {{42820, 42821}}, // NOLINT
- {{42822, 42823}}, {{42824, 42825}}, {{42826, 42827}}, {{42828, 42829}}, // NOLINT
- {{42830, 42831}}, {{42832, 42833}}, {{42834, 42835}}, {{42836, 42837}}, // NOLINT
- {{42838, 42839}}, {{42840, 42841}}, {{42842, 42843}}, {{42844, 42845}}, // NOLINT
- {{42846, 42847}}, {{42848, 42849}}, {{42850, 42851}}, {{42852, 42853}}, // NOLINT
- {{42854, 42855}}, {{42856, 42857}}, {{42858, 42859}}, {{42860, 42861}}, // NOLINT
- {{42862, 42863}}, {{42873, 42874}}, {{42875, 42876}}, {{7545, 42877}}, // NOLINT
- {{42878, 42879}}, {{42880, 42881}}, {{42882, 42883}}, {{42884, 42885}}, // NOLINT
- {{42886, 42887}}, {{42891, 42892}}, {{613, 42893}}, {{42896, 42897}}, // NOLINT
- {{42898, 42899}}, {{42912, 42913}}, {{42914, 42915}}, {{42916, 42917}}, // NOLINT
- {{42918, 42919}}, {{42920, 42921}}, {{614, 42922}}, {{kSentinel}} }; // NOLINT
-static const uint16_t kEcma262UnCanonicalizeTable5Size = 179; // NOLINT
-static const int32_t kEcma262UnCanonicalizeTable5[358] = {
- 1600, 1, 1601, 1, 1602, 5, 1603, 5, 1604, 9, 1605, 9, 1606, 13, 1607, 13, // NOLINT
- 1608, 17, 1609, 17, 1610, 21, 1611, 21, 1612, 25, 1613, 25, 1614, 29, 1615, 29, // NOLINT
- 1616, 33, 1617, 33, 1618, 37, 1619, 37, 1620, 41, 1621, 41, 1622, 45, 1623, 45, // NOLINT
- 1624, 49, 1625, 49, 1626, 53, 1627, 53, 1628, 57, 1629, 57, 1630, 61, 1631, 61, // NOLINT
- 1632, 65, 1633, 65, 1634, 69, 1635, 69, 1636, 73, 1637, 73, 1638, 77, 1639, 77, // NOLINT
- 1640, 81, 1641, 81, 1642, 85, 1643, 85, 1644, 89, 1645, 89, 1664, 93, 1665, 93, // NOLINT
- 1666, 97, 1667, 97, 1668, 101, 1669, 101, 1670, 105, 1671, 105, 1672, 109, 1673, 109, // NOLINT
- 1674, 113, 1675, 113, 1676, 117, 1677, 117, 1678, 121, 1679, 121, 1680, 125, 1681, 125, // NOLINT
- 1682, 129, 1683, 129, 1684, 133, 1685, 133, 1686, 137, 1687, 137, 1826, 141, 1827, 141, // NOLINT
- 1828, 145, 1829, 145, 1830, 149, 1831, 149, 1832, 153, 1833, 153, 1834, 157, 1835, 157, // NOLINT
- 1836, 161, 1837, 161, 1838, 165, 1839, 165, 1842, 169, 1843, 169, 1844, 173, 1845, 173, // NOLINT
- 1846, 177, 1847, 177, 1848, 181, 1849, 181, 1850, 185, 1851, 185, 1852, 189, 1853, 189, // NOLINT
- 1854, 193, 1855, 193, 1856, 197, 1857, 197, 1858, 201, 1859, 201, 1860, 205, 1861, 205, // NOLINT
- 1862, 209, 1863, 209, 1864, 213, 1865, 213, 1866, 217, 1867, 217, 1868, 221, 1869, 221, // NOLINT
- 1870, 225, 1871, 225, 1872, 229, 1873, 229, 1874, 233, 1875, 233, 1876, 237, 1877, 237, // NOLINT
- 1878, 241, 1879, 241, 1880, 245, 1881, 245, 1882, 249, 1883, 249, 1884, 253, 1885, 253, // NOLINT
- 1886, 257, 1887, 257, 1888, 261, 1889, 261, 1890, 265, 1891, 265, 1892, 269, 1893, 269, // NOLINT
- 1894, 273, 1895, 273, 1896, 277, 1897, 277, 1898, 281, 1899, 281, 1900, 285, 1901, 285, // NOLINT
- 1902, 289, 1903, 289, 1913, 293, 1914, 293, 1915, 297, 1916, 297, 1917, 301, 1918, 305, // NOLINT
- 1919, 305, 1920, 309, 1921, 309, 1922, 313, 1923, 313, 1924, 317, 1925, 317, 1926, 321, // NOLINT
- 1927, 321, 1931, 325, 1932, 325, 1933, 329, 1936, 333, 1937, 333, 1938, 337, 1939, 337, // NOLINT
- 1952, 341, 1953, 341, 1954, 345, 1955, 345, 1956, 349, 1957, 349, 1958, 353, 1959, 353, // NOLINT
- 1960, 357, 1961, 357, 1962, 361 }; // NOLINT
-static const uint16_t kEcma262UnCanonicalizeMultiStrings5Size = 92; // NOLINT
+static const MultiCharacterSpecialCase<2>
+ kEcma262UnCanonicalizeMultiStrings5[104] = { // NOLINT
+ {{42560, 42561}},
+ {{42562, 42563}},
+ {{42564, 42565}},
+ {{42566, 42567}}, // NOLINT
+ {{42568, 42569}},
+ {{42570, 42571}},
+ {{42572, 42573}},
+ {{42574, 42575}}, // NOLINT
+ {{42576, 42577}},
+ {{42578, 42579}},
+ {{42580, 42581}},
+ {{42582, 42583}}, // NOLINT
+ {{42584, 42585}},
+ {{42586, 42587}},
+ {{42588, 42589}},
+ {{42590, 42591}}, // NOLINT
+ {{42592, 42593}},
+ {{42594, 42595}},
+ {{42596, 42597}},
+ {{42598, 42599}}, // NOLINT
+ {{42600, 42601}},
+ {{42602, 42603}},
+ {{42604, 42605}},
+ {{42624, 42625}}, // NOLINT
+ {{42626, 42627}},
+ {{42628, 42629}},
+ {{42630, 42631}},
+ {{42632, 42633}}, // NOLINT
+ {{42634, 42635}},
+ {{42636, 42637}},
+ {{42638, 42639}},
+ {{42640, 42641}}, // NOLINT
+ {{42642, 42643}},
+ {{42644, 42645}},
+ {{42646, 42647}},
+ {{42648, 42649}}, // NOLINT
+ {{42650, 42651}},
+ {{42786, 42787}},
+ {{42788, 42789}},
+ {{42790, 42791}}, // NOLINT
+ {{42792, 42793}},
+ {{42794, 42795}},
+ {{42796, 42797}},
+ {{42798, 42799}}, // NOLINT
+ {{42802, 42803}},
+ {{42804, 42805}},
+ {{42806, 42807}},
+ {{42808, 42809}}, // NOLINT
+ {{42810, 42811}},
+ {{42812, 42813}},
+ {{42814, 42815}},
+ {{42816, 42817}}, // NOLINT
+ {{42818, 42819}},
+ {{42820, 42821}},
+ {{42822, 42823}},
+ {{42824, 42825}}, // NOLINT
+ {{42826, 42827}},
+ {{42828, 42829}},
+ {{42830, 42831}},
+ {{42832, 42833}}, // NOLINT
+ {{42834, 42835}},
+ {{42836, 42837}},
+ {{42838, 42839}},
+ {{42840, 42841}}, // NOLINT
+ {{42842, 42843}},
+ {{42844, 42845}},
+ {{42846, 42847}},
+ {{42848, 42849}}, // NOLINT
+ {{42850, 42851}},
+ {{42852, 42853}},
+ {{42854, 42855}},
+ {{42856, 42857}}, // NOLINT
+ {{42858, 42859}},
+ {{42860, 42861}},
+ {{42862, 42863}},
+ {{42873, 42874}}, // NOLINT
+ {{42875, 42876}},
+ {{7545, 42877}},
+ {{42878, 42879}},
+ {{42880, 42881}}, // NOLINT
+ {{42882, 42883}},
+ {{42884, 42885}},
+ {{42886, 42887}},
+ {{42891, 42892}}, // NOLINT
+ {{613, 42893}},
+ {{42896, 42897}},
+ {{42898, 42899}},
+ {{42902, 42903}}, // NOLINT
+ {{42904, 42905}},
+ {{42906, 42907}},
+ {{42908, 42909}},
+ {{42910, 42911}}, // NOLINT
+ {{42912, 42913}},
+ {{42914, 42915}},
+ {{42916, 42917}},
+ {{42918, 42919}}, // NOLINT
+ {{42920, 42921}},
+ {{614, 42922}},
+ {{604, 42923}},
+ {{609, 42924}}, // NOLINT
+ {{620, 42925}},
+ {{670, 42928}},
+ {{647, 42929}},
+ {{kSentinel}}}; // NOLINT
+static const uint16_t kEcma262UnCanonicalizeTable5Size = 198; // NOLINT
+static const int32_t kEcma262UnCanonicalizeTable5
+ [396] = {1600, 1, 1601, 1, 1602, 5, 1603, 5,
+ 1604, 9, 1605, 9, 1606, 13, 1607, 13, // NOLINT
+ 1608, 17, 1609, 17, 1610, 21, 1611, 21,
+ 1612, 25, 1613, 25, 1614, 29, 1615, 29, // NOLINT
+ 1616, 33, 1617, 33, 1618, 37, 1619, 37,
+ 1620, 41, 1621, 41, 1622, 45, 1623, 45, // NOLINT
+ 1624, 49, 1625, 49, 1626, 53, 1627, 53,
+ 1628, 57, 1629, 57, 1630, 61, 1631, 61, // NOLINT
+ 1632, 65, 1633, 65, 1634, 69, 1635, 69,
+ 1636, 73, 1637, 73, 1638, 77, 1639, 77, // NOLINT
+ 1640, 81, 1641, 81, 1642, 85, 1643, 85,
+ 1644, 89, 1645, 89, 1664, 93, 1665, 93, // NOLINT
+ 1666, 97, 1667, 97, 1668, 101, 1669, 101,
+ 1670, 105, 1671, 105, 1672, 109, 1673, 109, // NOLINT
+ 1674, 113, 1675, 113, 1676, 117, 1677, 117,
+ 1678, 121, 1679, 121, 1680, 125, 1681, 125, // NOLINT
+ 1682, 129, 1683, 129, 1684, 133, 1685, 133,
+ 1686, 137, 1687, 137, 1688, 141, 1689, 141, // NOLINT
+ 1690, 145, 1691, 145, 1826, 149, 1827, 149,
+ 1828, 153, 1829, 153, 1830, 157, 1831, 157, // NOLINT
+ 1832, 161, 1833, 161, 1834, 165, 1835, 165,
+ 1836, 169, 1837, 169, 1838, 173, 1839, 173, // NOLINT
+ 1842, 177, 1843, 177, 1844, 181, 1845, 181,
+ 1846, 185, 1847, 185, 1848, 189, 1849, 189, // NOLINT
+ 1850, 193, 1851, 193, 1852, 197, 1853, 197,
+ 1854, 201, 1855, 201, 1856, 205, 1857, 205, // NOLINT
+ 1858, 209, 1859, 209, 1860, 213, 1861, 213,
+ 1862, 217, 1863, 217, 1864, 221, 1865, 221, // NOLINT
+ 1866, 225, 1867, 225, 1868, 229, 1869, 229,
+ 1870, 233, 1871, 233, 1872, 237, 1873, 237, // NOLINT
+ 1874, 241, 1875, 241, 1876, 245, 1877, 245,
+ 1878, 249, 1879, 249, 1880, 253, 1881, 253, // NOLINT
+ 1882, 257, 1883, 257, 1884, 261, 1885, 261,
+ 1886, 265, 1887, 265, 1888, 269, 1889, 269, // NOLINT
+ 1890, 273, 1891, 273, 1892, 277, 1893, 277,
+ 1894, 281, 1895, 281, 1896, 285, 1897, 285, // NOLINT
+ 1898, 289, 1899, 289, 1900, 293, 1901, 293,
+ 1902, 297, 1903, 297, 1913, 301, 1914, 301, // NOLINT
+ 1915, 305, 1916, 305, 1917, 309, 1918, 313,
+ 1919, 313, 1920, 317, 1921, 317, 1922, 321, // NOLINT
+ 1923, 321, 1924, 325, 1925, 325, 1926, 329,
+ 1927, 329, 1931, 333, 1932, 333, 1933, 337, // NOLINT
+ 1936, 341, 1937, 341, 1938, 345, 1939, 345,
+ 1942, 349, 1943, 349, 1944, 353, 1945, 353, // NOLINT
+ 1946, 357, 1947, 357, 1948, 361, 1949, 361,
+ 1950, 365, 1951, 365, 1952, 369, 1953, 369, // NOLINT
+ 1954, 373, 1955, 373, 1956, 377, 1957, 377,
+ 1958, 381, 1959, 381, 1960, 385, 1961, 385, // NOLINT
+ 1962, 389, 1963, 393, 1964, 397, 1965, 401,
+ 1968, 405, 1969, 409}; // NOLINT
+static const uint16_t kEcma262UnCanonicalizeMultiStrings5Size = 104; // NOLINT
static const MultiCharacterSpecialCase<2> kEcma262UnCanonicalizeMultiStrings7[3] = { // NOLINT
{{65313, 65345}}, {{65338, 65370}}, {{kSentinel}} }; // NOLINT
static const uint16_t kEcma262UnCanonicalizeTable7Size = 4; // NOLINT
const uchar UnicodeData::kMaxCodePoint = 65533;
int UnicodeData::GetByteCount() {
- return kUppercaseTable0Size * sizeof(int32_t) // NOLINT
- + kUppercaseTable1Size * sizeof(int32_t) // NOLINT
- + kUppercaseTable5Size * sizeof(int32_t) // NOLINT
- + kUppercaseTable7Size * sizeof(int32_t) // NOLINT
- + kLowercaseTable0Size * sizeof(int32_t) // NOLINT
- + kLowercaseTable1Size * sizeof(int32_t) // NOLINT
- + kLowercaseTable5Size * sizeof(int32_t) // NOLINT
- + kLowercaseTable7Size * sizeof(int32_t) // NOLINT
- + kLetterTable0Size * sizeof(int32_t) // NOLINT
- + kLetterTable1Size * sizeof(int32_t) // NOLINT
- + kLetterTable2Size * sizeof(int32_t) // NOLINT
- + kLetterTable3Size * sizeof(int32_t) // NOLINT
- + kLetterTable4Size * sizeof(int32_t) // NOLINT
- + kLetterTable5Size * sizeof(int32_t) // NOLINT
- + kLetterTable6Size * sizeof(int32_t) // NOLINT
- + kLetterTable7Size * sizeof(int32_t) // NOLINT
- + kNumberTable0Size * sizeof(int32_t) // NOLINT
- + kNumberTable5Size * sizeof(int32_t) // NOLINT
- + kNumberTable7Size * sizeof(int32_t) // NOLINT
- + kWhiteSpaceTable0Size * sizeof(int32_t) // NOLINT
- + kWhiteSpaceTable1Size * sizeof(int32_t) // NOLINT
- + kLineTerminatorTable0Size * sizeof(int32_t) // NOLINT
- + kLineTerminatorTable1Size * sizeof(int32_t) // NOLINT
- + kCombiningMarkTable0Size * sizeof(int32_t) // NOLINT
- + kCombiningMarkTable1Size * sizeof(int32_t) // NOLINT
- + kCombiningMarkTable5Size * sizeof(int32_t) // NOLINT
- + kCombiningMarkTable7Size * sizeof(int32_t) // NOLINT
- + kConnectorPunctuationTable0Size * sizeof(int32_t) // NOLINT
- + kConnectorPunctuationTable1Size * sizeof(int32_t) // NOLINT
- + kConnectorPunctuationTable7Size * sizeof(int32_t) // NOLINT
- + kToLowercaseMultiStrings0Size * sizeof(MultiCharacterSpecialCase<2>) // NOLINT
- + kToLowercaseMultiStrings1Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kToLowercaseMultiStrings5Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kToLowercaseMultiStrings7Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kToUppercaseMultiStrings0Size * sizeof(MultiCharacterSpecialCase<3>) // NOLINT
- + kToUppercaseMultiStrings1Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kToUppercaseMultiStrings5Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kToUppercaseMultiStrings7Size * sizeof(MultiCharacterSpecialCase<3>) // NOLINT
- + kEcma262CanonicalizeMultiStrings0Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kEcma262CanonicalizeMultiStrings1Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kEcma262CanonicalizeMultiStrings5Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kEcma262CanonicalizeMultiStrings7Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kEcma262UnCanonicalizeMultiStrings0Size * sizeof(MultiCharacterSpecialCase<4>) // NOLINT
- + kEcma262UnCanonicalizeMultiStrings1Size * sizeof(MultiCharacterSpecialCase<2>) // NOLINT
- + kEcma262UnCanonicalizeMultiStrings5Size * sizeof(MultiCharacterSpecialCase<2>) // NOLINT
- + kEcma262UnCanonicalizeMultiStrings7Size * sizeof(MultiCharacterSpecialCase<2>) // NOLINT
- + kCanonicalizationRangeMultiStrings0Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kCanonicalizationRangeMultiStrings1Size * sizeof(MultiCharacterSpecialCase<1>) // NOLINT
- + kCanonicalizationRangeMultiStrings7Size * sizeof(MultiCharacterSpecialCase<1>); // NOLINT
+ return kUppercaseTable0Size * sizeof(int32_t) // NOLINT
+ + kUppercaseTable1Size * sizeof(int32_t) // NOLINT
+ + kUppercaseTable5Size * sizeof(int32_t) // NOLINT
+ + kUppercaseTable7Size * sizeof(int32_t) // NOLINT
+ + kLowercaseTable0Size * sizeof(int32_t) // NOLINT
+ + kLowercaseTable1Size * sizeof(int32_t) // NOLINT
+ + kLowercaseTable5Size * sizeof(int32_t) // NOLINT
+ + kLowercaseTable7Size * sizeof(int32_t) // NOLINT
+ + kLetterTable0Size * sizeof(int32_t) // NOLINT
+ + kLetterTable1Size * sizeof(int32_t) // NOLINT
+ + kLetterTable2Size * sizeof(int32_t) // NOLINT
+ + kLetterTable3Size * sizeof(int32_t) // NOLINT
+ + kLetterTable4Size * sizeof(int32_t) // NOLINT
+ + kLetterTable5Size * sizeof(int32_t) // NOLINT
+ + kLetterTable6Size * sizeof(int32_t) // NOLINT
+ + kLetterTable7Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable0Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable1Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable2Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable3Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable4Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable5Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable6Size * sizeof(int32_t) // NOLINT
+ + kID_StartTable7Size * sizeof(int32_t) // NOLINT
+ + kID_ContinueTable0Size * sizeof(int32_t) // NOLINT
+ + kID_ContinueTable1Size * sizeof(int32_t) // NOLINT
+ + kID_ContinueTable5Size * sizeof(int32_t) // NOLINT
+ + kID_ContinueTable7Size * sizeof(int32_t) // NOLINT
+ + kWhiteSpaceTable0Size * sizeof(int32_t) // NOLINT
+ + kWhiteSpaceTable1Size * sizeof(int32_t) // NOLINT
+ + kWhiteSpaceTable7Size * sizeof(int32_t) // NOLINT
+ + kLineTerminatorTable0Size * sizeof(int32_t) // NOLINT
+ + kLineTerminatorTable1Size * sizeof(int32_t) // NOLINT
+ +
+ kToLowercaseMultiStrings0Size *
+ sizeof(MultiCharacterSpecialCase<2>) // NOLINT
+ +
+ kToLowercaseMultiStrings1Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kToLowercaseMultiStrings5Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kToLowercaseMultiStrings7Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kToUppercaseMultiStrings0Size *
+ sizeof(MultiCharacterSpecialCase<3>) // NOLINT
+ +
+ kToUppercaseMultiStrings1Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kToUppercaseMultiStrings5Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kToUppercaseMultiStrings7Size *
+ sizeof(MultiCharacterSpecialCase<3>) // NOLINT
+ +
+ kEcma262CanonicalizeMultiStrings0Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kEcma262CanonicalizeMultiStrings1Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kEcma262CanonicalizeMultiStrings5Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kEcma262CanonicalizeMultiStrings7Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kEcma262UnCanonicalizeMultiStrings0Size *
+ sizeof(MultiCharacterSpecialCase<4>) // NOLINT
+ +
+ kEcma262UnCanonicalizeMultiStrings1Size *
+ sizeof(MultiCharacterSpecialCase<2>) // NOLINT
+ +
+ kEcma262UnCanonicalizeMultiStrings5Size *
+ sizeof(MultiCharacterSpecialCase<2>) // NOLINT
+ +
+ kEcma262UnCanonicalizeMultiStrings7Size *
+ sizeof(MultiCharacterSpecialCase<2>) // NOLINT
+ +
+ kCanonicalizationRangeMultiStrings0Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kCanonicalizationRangeMultiStrings1Size *
+ sizeof(MultiCharacterSpecialCase<1>) // NOLINT
+ +
+ kCanonicalizationRangeMultiStrings7Size *
+ sizeof(MultiCharacterSpecialCase<1>); // NOLINT
}
-} // namespace unicode
+} // namespace unibrow
#include <sys/types.h>
#include "src/globals.h"
+#include "src/utils.h"
/**
* \file
* Definitions and convenience functions for working with unicode.
public:
inline Predicate() { }
inline bool get(uchar c);
+
private:
friend class Test;
bool CalculateValue(uchar c);
- struct CacheEntry {
- inline CacheEntry() : code_point_(0), value_(0) { }
+ class CacheEntry {
+ public:
+ inline CacheEntry()
+ : bit_field_(CodePointField::encode(0) | ValueField::encode(0)) {}
inline CacheEntry(uchar code_point, bool value)
- : code_point_(code_point),
- value_(value) { }
- uchar code_point_ : 21;
- bool value_ : 1;
+ : bit_field_(CodePointField::encode(code_point) |
+ ValueField::encode(value)) {}
+
+ uchar code_point() const { return CodePointField::decode(bit_field_); }
+ bool value() const { return ValueField::decode(bit_field_); }
+
+ private:
+ class CodePointField : public v8::internal::BitField<uchar, 0, 21> {};
+ class ValueField : public v8::internal::BitField<bool, 21, 1> {};
+
+ uint32_t bit_field_;
};
static const int kSize = size;
static const int kMask = kSize - 1;
CacheEntry entries_[kSize];
};
+
// A cache used in case conversion. It caches the value for characters
// that either have no mapping or map to a single character independent
// of context. Characters that map to more than one character or that
CacheEntry entries_[kSize];
};
+
class UnicodeData {
private:
friend class Test;
static const uchar kMaxCodePoint;
};
+
class Utf16 {
public:
static inline bool IsSurrogatePair(int lead, int trail) {
}
};
-class Latin1 {
- public:
- static const unsigned kMaxChar = 0xff;
- // Returns 0 if character does not convert to single latin-1 character
- // or if the character doesn't not convert back to latin-1 via inverse
- // operation (upper to lower, etc).
- static inline uint16_t ConvertNonLatin1ToLatin1(uint16_t);
-};
class Utf8 {
public:
unsigned* cursor);
};
-
-class Utf8DecoderBase {
- public:
- // Initialization done in subclass.
- inline Utf8DecoderBase();
- inline Utf8DecoderBase(uint16_t* buffer,
- unsigned buffer_length,
- const uint8_t* stream,
- unsigned stream_length);
- inline unsigned Utf16Length() const { return utf16_length_; }
- protected:
- // This reads all characters and sets the utf16_length_.
- // The first buffer_length utf16 chars are cached in the buffer.
- void Reset(uint16_t* buffer,
- unsigned buffer_length,
- const uint8_t* stream,
- unsigned stream_length);
- static void WriteUtf16Slow(const uint8_t* stream,
- uint16_t* data,
- unsigned length);
- const uint8_t* unbuffered_start_;
- unsigned utf16_length_;
- bool last_byte_of_buffer_unused_;
- private:
- DISALLOW_COPY_AND_ASSIGN(Utf8DecoderBase);
-};
-
-template <unsigned kBufferSize>
-class Utf8Decoder : public Utf8DecoderBase {
- public:
- inline Utf8Decoder() {}
- inline Utf8Decoder(const char* stream, unsigned length);
- inline void Reset(const char* stream, unsigned length);
- inline unsigned WriteUtf16(uint16_t* data, unsigned length) const;
- private:
- uint16_t buffer_[kBufferSize];
-};
-
-
struct Uppercase {
static bool Is(uchar c);
};
struct Letter {
static bool Is(uchar c);
};
-struct Number {
+struct ID_Start {
static bool Is(uchar c);
};
-struct WhiteSpace {
- static bool Is(uchar c);
-};
-struct LineTerminator {
+struct ID_Continue {
static bool Is(uchar c);
};
-struct CombiningMark {
+struct WhiteSpace {
static bool Is(uchar c);
};
-struct ConnectorPunctuation {
+struct LineTerminator {
static bool Is(uchar c);
};
struct ToLowercase {
#ifndef V8_HYDROGEN_UNIQUE_H_
#define V8_HYDROGEN_UNIQUE_H_
+#include <ostream> // NOLINT(readability/streams)
+
+#include "src/base/functional.h"
#include "src/handles-inl.h" // TODO(everyone): Fix our inl.h crap
#include "src/objects-inl.h" // TODO(everyone): Fix our inl.h crap
-#include "src/string-stream.h"
#include "src/utils.h"
#include "src/zone.h"
return raw_address_ != other.raw_address_;
}
+ friend inline size_t hash_value(Unique<T> const& unique) {
+ DCHECK(unique.IsInitialized());
+ return base::hash<void*>()(unique.raw_address_);
+ }
+
inline intptr_t Hashcode() const {
DCHECK(IsInitialized());
return reinterpret_cast<intptr_t>(raw_address_);
friend class SideEffectsTracker;
};
+template <typename T>
+inline std::ostream& operator<<(std::ostream& os, Unique<T> uniq) {
+ return os << Brief(*uniq.handle());
+}
+
template <typename T>
class UniqueSet FINAL : public ZoneObject {
#include "src/v8.h"
+#include "src/base/functional.h"
#include "src/base/logging.h"
#include "src/base/platform/platform.h"
#include "src/utils.h"
}
+size_t hash_value(BailoutId id) {
+ base::hash<int> h;
+ return h(id.id_);
+}
+
+
+std::ostream& operator<<(std::ostream& os, BailoutId id) {
+ return os << id.id_;
+}
+
+
void PrintF(const char* format, ...) {
va_list arguments;
va_start(arguments, format);
}
DCHECK_EQ(1 << bits, original_x);
return bits;
- return 0;
}
// Floor(-0.0) == 0.0
inline double Floor(double x) {
-#ifdef _MSC_VER
+#if V8_CC_MSVC
if (x == 0) return x; // Fix for issue 3477.
#endif
return std::floor(x);
};
+template <class T, int shift, int size>
+class BitField8 : public BitFieldBase<T, shift, size, uint8_t> {};
+
+
+template <class T, int shift, int size>
+class BitField16 : public BitFieldBase<T, shift, size, uint16_t> {};
+
+
template<class T, int shift, int size>
class BitField : public BitFieldBase<T, shift, size, uint32_t> { };
// ----------------------------------------------------------------------------
+// BitSetComputer is a help template for encoding and decoding information for
+// a variable number of items in an array.
+//
+// To encode boolean data in a smi array you would use:
+// typedef BitSetComputer<bool, 1, kSmiValueSize, uint32_t> BoolComputer;
+//
+template <class T, int kBitsPerItem, int kBitsPerWord, class U>
+class BitSetComputer {
+ public:
+ static const int kItemsPerWord = kBitsPerWord / kBitsPerItem;
+ static const int kMask = (1 << kBitsPerItem) - 1;
+
+ // The number of array elements required to embed T information for each item.
+ static int word_count(int items) {
+ if (items == 0) return 0;
+ return (items - 1) / kItemsPerWord + 1;
+ }
+
+ // The array index to look at for item.
+ static int index(int base_index, int item) {
+ return base_index + item / kItemsPerWord;
+ }
+
+ // Extract T data for a given item from data.
+ static T decode(U data, int item) {
+ return static_cast<T>((data >> shift(item)) & kMask);
+ }
+
+ // Return the encoding for a store of value for item in previous.
+ static U encode(U previous, int item, T value) {
+ int shift_value = shift(item);
+ int set_bits = (static_cast<int>(value) << shift_value);
+ return (previous & ~(kMask << shift_value)) | set_bits;
+ }
+
+ static int shift(int item) { return (item % kItemsPerWord) * kBitsPerItem; }
+};
+
+
+// ----------------------------------------------------------------------------
// Hash function.
static const uint32_t kZeroHashSeed = 0;
};
+template <int dummy_parameter>
+class VectorSlot {
+ public:
+ explicit VectorSlot(int id) : id_(id) {}
+ int ToInt() const { return id_; }
+
+ static VectorSlot Invalid() { return VectorSlot(kInvalidSlot); }
+ bool IsInvalid() const { return id_ == kInvalidSlot; }
+
+ VectorSlot next() const {
+ DCHECK(id_ != kInvalidSlot);
+ return VectorSlot(id_ + 1);
+ }
+
+ bool operator==(const VectorSlot& other) const { return id_ == other.id_; }
+
+ private:
+ static const int kInvalidSlot = -1;
+
+ int id_;
+};
+
+
+typedef VectorSlot<0> FeedbackVectorSlot;
+typedef VectorSlot<1> FeedbackVectorICSlot;
+
+
class BailoutId {
public:
explicit BailoutId(int id) : id_(id) { }
bool IsNone() const { return id_ == kNoneId; }
bool operator==(const BailoutId& other) const { return id_ == other.id_; }
bool operator!=(const BailoutId& other) const { return id_ != other.id_; }
+ friend size_t hash_value(BailoutId);
+ friend std::ostream& operator<<(std::ostream&, BailoutId);
private:
static const int kNoneId = -1;
// ----------------------------------------------------------------------------
// Object
+var DefaultObjectToString = NoSideEffectsObjectToString;
// ECMA-262 - 15.2.4.2
-function ObjectToString() {
+function NoSideEffectsObjectToString() {
if (IS_UNDEFINED(this) && !IS_UNDETECTABLE(this)) return "[object Undefined]";
if (IS_NULL(this)) return "[object Null]";
return "[object " + %_ClassOf(ToObject(this)) + "]";
// ECMA-262 - 15.2.4.5
function ObjectHasOwnProperty(V) {
- if (%IsJSProxy(this)) {
+ if (%_IsJSProxy(this)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(V)) return false;
// ECMA-262 - 15.2.4.6
function ObjectIsPrototypeOf(V) {
- CHECK_OBJECT_COERCIBLE(this, "Object.prototype.isPrototypeOf");
if (!IS_SPEC_OBJECT(V)) return false;
+ CHECK_OBJECT_COERCIBLE(this, "Object.prototype.isPrototypeOf");
return %IsInPrototypeChain(this, V);
}
// ECMA-262 - 15.2.4.6
function ObjectPropertyIsEnumerable(V) {
var P = ToName(V);
- if (%IsJSProxy(this)) {
+ if (%_IsJSProxy(this)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(V)) return false;
function ObjectKeys(obj) {
- if (!IS_SPEC_OBJECT(obj)) {
- throw MakeTypeError("called_on_non_object", ["Object.keys"]);
- }
- if (%IsJSProxy(obj)) {
+ obj = ToObject(obj);
+ if (%_IsJSProxy(obj)) {
var handler = %GetHandler(obj);
var names = CallTrap0(handler, "keys", DerivedKeysTrap);
return ToNameArray(names, "keys", false);
"set_",
"hasSetter_"
), $Array(
- "toString", function() {
+ "toString", function PropertyDescriptor_ToString() {
return "[object PropertyDescriptor]";
},
- "setValue", function(value) {
+ "setValue", function PropertyDescriptor_SetValue(value) {
this.value_ = value;
this.hasValue_ = true;
},
- "getValue", function() {
+ "getValue", function PropertyDescriptor_GetValue() {
return this.value_;
},
- "hasValue", function() {
+ "hasValue", function PropertyDescriptor_HasValue() {
return this.hasValue_;
},
- "setEnumerable", function(enumerable) {
+ "setEnumerable", function PropertyDescriptor_SetEnumerable(enumerable) {
this.enumerable_ = enumerable;
this.hasEnumerable_ = true;
},
- "isEnumerable", function () {
+ "isEnumerable", function PropertyDescriptor_IsEnumerable() {
return this.enumerable_;
},
- "hasEnumerable", function() {
+ "hasEnumerable", function PropertyDescriptor_HasEnumerable() {
return this.hasEnumerable_;
},
- "setWritable", function(writable) {
+ "setWritable", function PropertyDescriptor_SetWritable(writable) {
this.writable_ = writable;
this.hasWritable_ = true;
},
- "isWritable", function() {
+ "isWritable", function PropertyDescriptor_IsWritable() {
return this.writable_;
},
- "hasWritable", function() {
+ "hasWritable", function PropertyDescriptor_HasWritable() {
return this.hasWritable_;
},
- "setConfigurable", function(configurable) {
+ "setConfigurable",
+ function PropertyDescriptor_SetConfigurable(configurable) {
this.configurable_ = configurable;
this.hasConfigurable_ = true;
},
- "hasConfigurable", function() {
+ "hasConfigurable", function PropertyDescriptor_HasConfigurable() {
return this.hasConfigurable_;
},
- "isConfigurable", function() {
+ "isConfigurable", function PropertyDescriptor_IsConfigurable() {
return this.configurable_;
},
- "setGet", function(get) {
+ "setGet", function PropertyDescriptor_SetGetter(get) {
this.get_ = get;
- this.hasGetter_ = true;
+ this.hasGetter_ = true;
},
- "getGet", function() {
+ "getGet", function PropertyDescriptor_GetGetter() {
return this.get_;
},
- "hasGetter", function() {
+ "hasGetter", function PropertyDescriptor_HasGetter() {
return this.hasGetter_;
},
- "setSet", function(set) {
+ "setSet", function PropertyDescriptor_SetSetter(set) {
this.set_ = set;
this.hasSetter_ = true;
},
- "getSet", function() {
+ "getSet", function PropertyDescriptor_GetSetter() {
return this.set_;
},
- "hasSetter", function() {
+ "hasSetter", function PropertyDescriptor_HasSetter() {
return this.hasSetter_;
}));
// ES5 section 8.12.1.
function GetOwnPropertyJS(obj, v) {
var p = ToName(v);
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(v)) return UNDEFINED;
// ES5 section 8.12.9, ES5 section 15.4.5.1 and Harmony proxies.
function DefineOwnProperty(obj, p, desc, should_throw) {
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(p)) return false;
}
-function ObjectGetOwnPropertyKeys(obj, symbolsOnly) {
+function ObjectGetOwnPropertyKeys(obj, filter) {
var nameArrays = new InternalArray();
- var filter = symbolsOnly ?
- PROPERTY_ATTRIBUTES_STRING | PROPERTY_ATTRIBUTES_PRIVATE_SYMBOL :
- PROPERTY_ATTRIBUTES_SYMBOLIC;
+ filter |= PROPERTY_ATTRIBUTES_PRIVATE_SYMBOL;
// Find all the indexed properties.
// Only get own element names if we want to include string keys.
- if (!symbolsOnly) {
+ if ((filter & PROPERTY_ATTRIBUTES_STRING) === 0) {
var ownElementNames = %GetOwnElementNames(obj);
for (var i = 0; i < ownElementNames.length; ++i) {
ownElementNames[i] = %_NumberToString(ownElementNames[i]);
var j = 0;
for (var i = 0; i < propertyNames.length; ++i) {
var name = propertyNames[i];
- if (symbolsOnly) {
- if (!IS_SYMBOL(name) || IS_PRIVATE(name)) continue;
+ if (IS_SYMBOL(name)) {
+ if ((filter & PROPERTY_ATTRIBUTES_SYMBOLIC) || IS_PRIVATE(name)) {
+ continue;
+ }
} else {
- if (IS_SYMBOL(name)) continue;
+ if (filter & PROPERTY_ATTRIBUTES_STRING) continue;
name = ToString(name);
}
if (seenKeys[name]) continue;
// ES5 section 15.2.3.4.
function ObjectGetOwnPropertyNames(obj) {
- if (!IS_SPEC_OBJECT(obj)) {
- throw MakeTypeError("called_on_non_object", ["Object.getOwnPropertyNames"]);
- }
+ obj = ToObject(obj);
// Special handling for proxies.
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
var handler = %GetHandler(obj);
var names = CallTrap0(handler, "getOwnPropertyNames", UNDEFINED);
return ToNameArray(names, "getOwnPropertyNames", false);
}
- return ObjectGetOwnPropertyKeys(obj, false);
+ return ObjectGetOwnPropertyKeys(obj, PROPERTY_ATTRIBUTES_SYMBOLIC);
}
throw MakeTypeError("called_on_non_object", ["Object.defineProperty"]);
}
var name = ToName(p);
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
// Clone the attributes object for protection.
// TODO(rossberg): not spec'ed yet, so not sure if this should involve
// non-own properties as it does (or non-enumerable ones, as it doesn't?).
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.seal"]);
}
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
ProxyFix(obj);
}
var names = ObjectGetOwnPropertyNames(obj);
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.freeze"]);
}
- var isProxy = %IsJSProxy(obj);
+ var isProxy = %_IsJSProxy(obj);
if (isProxy || %HasSloppyArgumentsElements(obj) || %IsObserved(obj)) {
if (isProxy) {
ProxyFix(obj);
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.preventExtension"]);
}
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
ProxyFix(obj);
}
%PreventExtensions(obj);
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.isSealed"]);
}
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
return false;
}
if (%IsExtensible(obj)) {
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.isFrozen"]);
}
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
return false;
}
if (%IsExtensible(obj)) {
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError("called_on_non_object", ["Object.isExtensible"]);
}
- if (%IsJSProxy(obj)) {
+ if (%_IsJSProxy(obj)) {
return true;
}
return %IsExtensible(obj);
}
-// Harmony egal.
+// ECMA-262, Edition 6, section 19.1.2.10
function ObjectIs(obj1, obj2) {
- if (obj1 === obj2) {
- return (obj1 !== 0) || (1 / obj1 === 1 / obj2);
- } else {
- return (obj1 !== obj1) && (obj2 !== obj2);
- }
+ return SameValue(obj1, obj2);
}
// Set up non-enumerable functions on the Object.prototype object.
InstallFunctions($Object.prototype, DONT_ENUM, $Array(
- "toString", ObjectToString,
+ "toString", NoSideEffectsObjectToString,
"toLocaleString", ObjectToLocaleString,
"valueOf", ObjectValueOf,
"hasOwnProperty", ObjectHasOwnProperty,
throw new $TypeError('Function.prototype.toString is not generic');
}
+ var classSource = %ClassGetSourceCode(func);
+ if (IS_STRING(classSource)) {
+ return classSource;
+ }
+
var source = %FunctionGetSourceCode(func);
if (!IS_STRING(source) || %FunctionIsBuiltin(func)) {
var name = %FunctionGetName(func);
namespace v8 {
+namespace {
+
// Track whether this V8 instance has ever called v8::Locker. This allows the
// API code to verify that the lock is always held when V8 is being entered.
-bool Locker::active_ = false;
+base::Atomic32 g_locker_was_ever_used_ = 0;
+
+} // namespace
// Once the Locker is initialized, the current thread will be guaranteed to have
top_level_ = true;
isolate_ = reinterpret_cast<i::Isolate*>(isolate);
// Record that the Locker has been used at least once.
- active_ = true;
+ base::NoBarrier_Store(&g_locker_was_ever_used_, 1);
// Get the big lock if necessary.
if (!isolate_->thread_manager()->IsLockedByCurrentThread()) {
isolate_->thread_manager()->Lock();
has_lock_ = true;
- // Make sure that V8 is initialized. Archiving of threads interferes
- // with deserialization by adding additional root pointers, so we must
- // initialize here, before anyone can call ~Locker() or Unlocker().
- if (!isolate_->IsInitialized()) {
- isolate_->Enter();
- V8::Initialize();
- isolate_->Exit();
- }
-
// This may be a locker within an unlocker in which case we have to
// get the saved state for this thread and restore it.
if (isolate_->thread_manager()->RestoreThread()) {
bool Locker::IsActive() {
- return active_;
+ return !!base::NoBarrier_Load(&g_locker_was_ever_used_);
}
T& last() { return start_[length_ - 1]; }
+ typedef T* iterator;
+ inline iterator begin() const { return &start_[0]; }
+ inline iterator end() const { return &start_[length_]; }
+
// Returns a clone of this vector with a new backing store.
Vector<T> Clone() const {
T* result = NewArray<T>(length_);
// NOTE these macros are used by some of the tool scripts and the build
// system so their names cannot be changed without changing the scripts.
#define MAJOR_VERSION 3
-#define MINOR_VERSION 29
-#define BUILD_NUMBER 93
-#define PATCH_LEVEL 1
+#define MINOR_VERSION 30
+#define BUILD_NUMBER 37
+#define PATCH_LEVEL 0
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
#define IS_CANDIDATE_VERSION 0
namespace v8 {
namespace internal {
+// Logging and profiling. A StateTag represents a possible state of
+// the VM. The logger maintains a stack of these. Creating a VMState
+// object enters a state by pushing on the stack, and destroying a
+// VMState object leaves a state by popping the current state from the
+// stack.
template <StateTag Tag>
class VMState BASE_EMBEDDED {
public:
%SetCode($WeakMap, WeakMapConstructor);
%FunctionSetPrototype($WeakMap, new $Object());
%AddNamedProperty($WeakMap.prototype, "constructor", $WeakMap, DONT_ENUM);
+ %AddNamedProperty(
+ $WeakMap.prototype, symbolToStringTag, "WeakMap", DONT_ENUM | READ_ONLY);
// Set up the non-enumerable functions on the WeakMap prototype object.
InstallFunctions($WeakMap.prototype, DONT_ENUM, $Array(
%SetCode($WeakSet, WeakSetConstructor);
%FunctionSetPrototype($WeakSet, new $Object());
%AddNamedProperty($WeakSet.prototype, "constructor", $WeakSet, DONT_ENUM);
+ %AddNamedProperty(
+ $WeakSet.prototype, symbolToStringTag, "WeakSet", DONT_ENUM | READ_ONLY);
// Set up the non-enumerable functions on the WeakSet prototype object.
InstallFunctions($WeakSet.prototype, DONT_ENUM, $Array(
}
+void Assembler::emit_optional_rex_32(XMMRegister rm_reg) {
+ if (rm_reg.high_bit()) emit(0x41);
+}
+
+
void Assembler::emit_optional_rex_32(const Operand& op) {
if (op.rex_ != 0) emit(0x40 | op.rex_);
}
}
+void Assembler::shift(Operand dst, Immediate shift_amount, int subcode,
+ int size) {
+ EnsureSpace ensure_space(this);
+ DCHECK(size == kInt64Size ? is_uint6(shift_amount.value_)
+ : is_uint5(shift_amount.value_));
+ if (shift_amount.value_ == 1) {
+ emit_rex(dst, size);
+ emit(0xD1);
+ emit_operand(subcode, dst);
+ } else {
+ emit_rex(dst, size);
+ emit(0xC1);
+ emit_operand(subcode, dst);
+ emit(shift_amount.value_);
+ }
+}
+
+
void Assembler::shift(Register dst, int subcode, int size) {
EnsureSpace ensure_space(this);
emit_rex(dst, size);
}
+void Assembler::shift(Operand dst, int subcode, int size) {
+ EnsureSpace ensure_space(this);
+ emit_rex(dst, size);
+ emit(0xD3);
+ emit_operand(subcode, dst);
+}
+
+
void Assembler::bt(const Operand& dst, Register src) {
EnsureSpace ensure_space(this);
emit_rex_64(src, dst);
}
+void Assembler::emit_imul(const Operand& src, int size) {
+ EnsureSpace ensure_space(this);
+ emit_rex(src, size);
+ emit(0xF7);
+ emit_operand(0x5, src);
+}
+
+
void Assembler::emit_imul(Register dst, Register src, int size) {
EnsureSpace ensure_space(this);
emit_rex(dst, src, size);
emit_rex(dst, src, size);
if (is_int8(imm.value_)) {
emit(0x6B);
+ emit_operand(dst, src);
+ emit(imm.value_);
} else {
emit(0x69);
+ emit_operand(dst, src);
+ emitl(imm.value_);
}
- emit_operand(dst, src);
- emit(imm.value_);
}
}
-void Assembler::mul(Register src) {
+void Assembler::mull(Register src) {
+ EnsureSpace ensure_space(this);
+ emit_optional_rex_32(src);
+ emit(0xF7);
+ emit_modrm(0x4, src);
+}
+
+
+void Assembler::mull(const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit_optional_rex_32(src);
+ emit(0xF7);
+ emit_operand(0x4, src);
+}
+
+
+void Assembler::mulq(Register src) {
EnsureSpace ensure_space(this);
emit_rex_64(src);
emit(0xF7);
void Assembler::psllq(XMMRegister reg, byte imm8) {
EnsureSpace ensure_space(this);
emit(0x66);
+ emit_optional_rex_32(reg);
emit(0x0F);
emit(0x73);
emit_sse_operand(rsi, reg); // rsi == 6
}
+void Assembler::psrlq(XMMRegister reg, byte imm8) {
+ EnsureSpace ensure_space(this);
+ emit(0x66);
+ emit_optional_rex_32(reg);
+ emit(0x0F);
+ emit(0x73);
+ emit_sse_operand(rdx, reg); // rdx == 2
+ emit(imm8);
+}
+
+
+void Assembler::pslld(XMMRegister reg, byte imm8) {
+ EnsureSpace ensure_space(this);
+ emit(0x66);
+ emit_optional_rex_32(reg);
+ emit(0x0F);
+ emit(0x72);
+ emit_sse_operand(rsi, reg); // rsi == 6
+ emit(imm8);
+}
+
+
+void Assembler::psrld(XMMRegister reg, byte imm8) {
+ EnsureSpace ensure_space(this);
+ emit(0x66);
+ emit_optional_rex_32(reg);
+ emit(0x0F);
+ emit(0x72);
+ emit_sse_operand(rdx, reg); // rdx == 2
+ emit(imm8);
+}
+
+
void Assembler::cvttss2si(Register dst, const Operand& src) {
EnsureSpace ensure_space(this);
emit(0xF3);
}
+void Assembler::cvtqsi2sd(XMMRegister dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit(0xF2);
+ emit_rex_64(dst, src);
+ emit(0x0F);
+ emit(0x2A);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::cvtqsi2sd(XMMRegister dst, Register src) {
EnsureSpace ensure_space(this);
emit(0xF2);
}
+void Assembler::cvtsd2ss(XMMRegister dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit(0xF2);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0x5A);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::cvtsd2si(Register dst, XMMRegister src) {
EnsureSpace ensure_space(this);
emit(0xF2);
}
+void Assembler::subsd(XMMRegister dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit(0xF2);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0x5C);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::divsd(XMMRegister dst, XMMRegister src) {
EnsureSpace ensure_space(this);
emit(0xF2);
}
+void Assembler::divsd(XMMRegister dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ emit(0xF2);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0x5E);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::andpd(XMMRegister dst, XMMRegister src) {
EnsureSpace ensure_space(this);
emit(0x66);
}
+void Assembler::pcmpeqd(XMMRegister dst, XMMRegister src) {
+ EnsureSpace ensure_space(this);
+ emit(0x66);
+ emit_optional_rex_32(dst, src);
+ emit(0x0F);
+ emit(0x76);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::emit_sse_operand(XMMRegister reg, const Operand& adr) {
Register ireg = { reg.code() };
emit_operand(ireg, adr);
// Sign-extends eax into edx:eax.
void cdq();
+ // Multiply eax by src, put the result in edx:eax.
+ void mull(Register src);
+ void mull(const Operand& src);
// Multiply rax by src, put the result in rdx:rax.
- void mul(Register src);
-
-#define DECLARE_SHIFT_INSTRUCTION(instruction, subcode) \
- void instruction##p(Register dst, Immediate imm8) { \
- shift(dst, imm8, subcode, kPointerSize); \
- } \
- \
- void instruction##l(Register dst, Immediate imm8) { \
- shift(dst, imm8, subcode, kInt32Size); \
- } \
- \
- void instruction##q(Register dst, Immediate imm8) { \
- shift(dst, imm8, subcode, kInt64Size); \
- } \
- \
- void instruction##p_cl(Register dst) { \
- shift(dst, subcode, kPointerSize); \
- } \
- \
- void instruction##l_cl(Register dst) { \
- shift(dst, subcode, kInt32Size); \
- } \
- \
- void instruction##q_cl(Register dst) { \
- shift(dst, subcode, kInt64Size); \
- }
+ void mulq(Register src);
+
+#define DECLARE_SHIFT_INSTRUCTION(instruction, subcode) \
+ void instruction##p(Register dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kPointerSize); \
+ } \
+ \
+ void instruction##l(Register dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kInt32Size); \
+ } \
+ \
+ void instruction##q(Register dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kInt64Size); \
+ } \
+ \
+ void instruction##p(Operand dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kPointerSize); \
+ } \
+ \
+ void instruction##l(Operand dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kInt32Size); \
+ } \
+ \
+ void instruction##q(Operand dst, Immediate imm8) { \
+ shift(dst, imm8, subcode, kInt64Size); \
+ } \
+ \
+ void instruction##p_cl(Register dst) { shift(dst, subcode, kPointerSize); } \
+ \
+ void instruction##l_cl(Register dst) { shift(dst, subcode, kInt32Size); } \
+ \
+ void instruction##q_cl(Register dst) { shift(dst, subcode, kInt64Size); } \
+ \
+ void instruction##p_cl(Operand dst) { shift(dst, subcode, kPointerSize); } \
+ \
+ void instruction##l_cl(Operand dst) { shift(dst, subcode, kInt32Size); } \
+ \
+ void instruction##q_cl(Operand dst) { shift(dst, subcode, kInt64Size); }
SHIFT_INSTRUCTION_LIST(DECLARE_SHIFT_INSTRUCTION)
#undef DECLARE_SHIFT_INSTRUCTION
void movapd(XMMRegister dst, XMMRegister src);
void psllq(XMMRegister reg, byte imm8);
+ void psrlq(XMMRegister reg, byte imm8);
+ void pslld(XMMRegister reg, byte imm8);
+ void psrld(XMMRegister reg, byte imm8);
void cvttsd2si(Register dst, const Operand& src);
void cvttsd2si(Register dst, XMMRegister src);
void cvtss2sd(XMMRegister dst, XMMRegister src);
void cvtss2sd(XMMRegister dst, const Operand& src);
void cvtsd2ss(XMMRegister dst, XMMRegister src);
+ void cvtsd2ss(XMMRegister dst, const Operand& src);
void cvtsd2si(Register dst, XMMRegister src);
void cvtsd2siq(Register dst, XMMRegister src);
void addsd(XMMRegister dst, XMMRegister src);
void addsd(XMMRegister dst, const Operand& src);
void subsd(XMMRegister dst, XMMRegister src);
+ void subsd(XMMRegister dst, const Operand& src);
void mulsd(XMMRegister dst, XMMRegister src);
void mulsd(XMMRegister dst, const Operand& src);
void divsd(XMMRegister dst, XMMRegister src);
+ void divsd(XMMRegister dst, const Operand& src);
void andpd(XMMRegister dst, XMMRegister src);
void orpd(XMMRegister dst, XMMRegister src);
void ucomisd(XMMRegister dst, XMMRegister src);
void ucomisd(XMMRegister dst, const Operand& src);
void cmpltsd(XMMRegister dst, XMMRegister src);
+ void pcmpeqd(XMMRegister dst, XMMRegister src);
void movmskpd(Register dst, XMMRegister src);
// Optionally do as emit_rex_32(Register) if the register number has
// the high bit set.
inline void emit_optional_rex_32(Register rm_reg);
+ inline void emit_optional_rex_32(XMMRegister rm_reg);
// Optionally do as emit_rex_32(const Operand&) if the operand register
// numbers have a high bit set.
int size);
// Emit machine code for a shift operation.
+ void shift(Operand dst, Immediate shift_amount, int subcode, int size);
void shift(Register dst, Immediate shift_amount, int subcode, int size);
// Shift dst by cl % 64 bits.
void shift(Register dst, int subcode, int size);
+ void shift(Operand dst, int subcode, int size);
void emit_farith(int b1, int b2, int i);
// Signed multiply instructions.
// rdx:rax = rax * src when size is 64 or edx:eax = eax * src when size is 32.
void emit_imul(Register src, int size);
+ void emit_imul(const Operand& src, int size);
void emit_imul(Register dst, Register src, int size);
void emit_imul(Register dst, const Operand& src, int size);
void emit_imul(Register dst, Register src, Immediate imm, int size);
// Use inline caching to speed up access to arguments.
if (FLAG_vector_ics) {
- __ Move(VectorLoadICDescriptor::SlotRegister(), Smi::FromInt(0));
+ // TODO(mvstanton): Vector-based ics need additional infrastructure to
+ // be embedded here. For now, just call the runtime.
+ __ Push(receiver);
+ __ Push(key);
+ __ CallRuntime(Runtime::kGetProperty, 2);
+ } else {
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
+ __ Call(ic, RelocInfo::CODE_TARGET);
+ // It is important that we do not have a test instruction after the
+ // call. A test instruction after the call is used to indicate that
+ // we have generated an inline version of the keyed load. In this
+ // case, we know that we are not generating a test instruction next.
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
- __ Call(ic, RelocInfo::CODE_TARGET);
- // It is important that we do not have a test instruction after the
- // call. A test instruction after the call is used to indicate that
- // we have generated an inline version of the keyed load. In this
- // case, we know that we are not generating a test instruction next.
// Push the nth argument.
__ Push(rax);
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is on the stack.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = rbx;
+ Register result = rax;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ ret(0);
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
// rsp[0] : return address
// rsp[8] : number of parameters
__ j(not_equal, &miss);
__ Move(FieldOperand(rbx, rdx, times_pointer_size, FixedArray::kHeaderSize),
TypeFeedbackVector::MegamorphicSentinel(isolate));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ SmiAddConstant(FieldOperand(rbx, with_types_offset), Smi::FromInt(-1));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ SmiAddConstant(FieldOperand(rbx, generic_offset), Smi::FromInt(1));
__ jmp(&slow_start);
}
void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
// If the receiver is a smi trigger the non-string case.
- __ JumpIfSmi(object_, receiver_not_string_);
-
- // Fetch the instance type of the receiver into result register.
- __ movp(result_, FieldOperand(object_, HeapObject::kMapOffset));
- __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
- // If the receiver is not a string trigger the non-string case.
- __ testb(result_, Immediate(kIsNotStringMask));
- __ j(not_zero, receiver_not_string_);
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ movp(result_, FieldOperand(object_, HeapObject::kMapOffset));
+ __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ testb(result_, Immediate(kIsNotStringMask));
+ __ j(not_zero, receiver_not_string_);
+ }
// If the index is non-smi trigger the non-smi case.
__ JumpIfNotSmi(index_, &index_not_smi_);
// rbx: instance type
// rcx: sub string length (smi)
// rdx: from index (smi)
- StringCharAtGenerator generator(
- rax, rdx, rcx, rax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(rax, rdx, rcx, rax, &runtime, &runtime,
+ &runtime, STRING_INDEX_IS_NUMBER,
+ RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ ret(SUB_STRING_ARGUMENT_COUNT * kPointerSize);
generator.SkipSlow(masm, &runtime);
}
+void ToNumberStub::Generate(MacroAssembler* masm) {
+ // The ToNumber stub takes one argument in rax.
+ Label check_heap_number, call_builtin;
+ __ JumpIfNotSmi(rax, &check_heap_number, Label::kNear);
+ __ Ret();
+
+ __ bind(&check_heap_number);
+ __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
+ Heap::kHeapNumberMapRootIndex);
+ __ j(not_equal, &call_builtin, Label::kNear);
+ __ Ret();
+
+ __ bind(&call_builtin);
+ __ popq(rcx); // Pop return address.
+ __ pushq(rax);
+ __ pushq(rcx); // Push return address.
+ __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
+}
+
+
void StringHelper::GenerateFlatOneByteStringEquals(MacroAssembler* masm,
Register left,
Register right,
__ LoadRoot(rdi, Heap::kTheHoleValueRootIndex);
// rsi: the-hole NaN
// rdi: pointer to the-hole
+
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ jmp(&initialization_loop_entry, Label::kNear);
+ __ bind(&initialization_loop);
+ __ movp(FieldOperand(r11, r9, times_pointer_size, FixedArray::kHeaderSize),
+ rdi);
+ __ bind(&initialization_loop_entry);
+ __ decp(r9);
+ __ j(not_sign, &initialization_loop);
+
+ __ SmiToInteger32(r9, FieldOperand(r8, FixedDoubleArray::kLengthOffset));
__ jmp(&entry);
// Call into runtime if GC is required.
// Register state for IC load call (from ic-x64.cc).
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0, false);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0, false);
}
LAZY_INSTANCE_INITIALIZER;
-static InstructionDesc cmov_instructions[16] = {
+static const InstructionDesc cmov_instructions[16] = {
{"cmovo", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
{"cmovno", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
{"cmovc", TWO_OPERANDS_INSTR, REG_OPER_OP_ORDER, false},
int DisassemblerX64::ShiftInstruction(byte* data) {
byte op = *data & (~1);
+ int count = 1;
if (op != 0xD0 && op != 0xD2 && op != 0xC0) {
UnimplementedInstruction();
- return 1;
+ return count;
}
- byte modrm = *(data + 1);
- int mod, regop, rm;
- get_modrm(modrm, &mod, ®op, &rm);
- regop &= 0x7; // The REX.R bit does not affect the operation.
- int imm8 = -1;
- int num_bytes = 2;
- if (mod != 3) {
- UnimplementedInstruction();
- return num_bytes;
- }
- const char* mnem = NULL;
- switch (regop) {
- case 0:
- mnem = "rol";
- break;
- case 1:
- mnem = "ror";
- break;
- case 2:
- mnem = "rcl";
- break;
- case 3:
- mnem = "rcr";
- break;
- case 4:
- mnem = "shl";
- break;
- case 5:
- mnem = "shr";
- break;
- case 7:
- mnem = "sar";
- break;
- default:
- UnimplementedInstruction();
- return num_bytes;
- }
- DCHECK_NE(NULL, mnem);
- if (op == 0xD0) {
- imm8 = 1;
- } else if (op == 0xC0) {
- imm8 = *(data + 2);
- num_bytes = 3;
+ // Print mneumonic.
+ {
+ byte modrm = *(data + count);
+ int mod, regop, rm;
+ get_modrm(modrm, &mod, ®op, &rm);
+ regop &= 0x7; // The REX.R bit does not affect the operation.
+ const char* mnem = NULL;
+ switch (regop) {
+ case 0:
+ mnem = "rol";
+ break;
+ case 1:
+ mnem = "ror";
+ break;
+ case 2:
+ mnem = "rcl";
+ break;
+ case 3:
+ mnem = "rcr";
+ break;
+ case 4:
+ mnem = "shl";
+ break;
+ case 5:
+ mnem = "shr";
+ break;
+ case 7:
+ mnem = "sar";
+ break;
+ default:
+ UnimplementedInstruction();
+ return count + 1;
+ }
+ DCHECK_NE(NULL, mnem);
+ AppendToBuffer("%s%c ", mnem, operand_size_code());
}
- AppendToBuffer("%s%c %s,",
- mnem,
- operand_size_code(),
- byte_size_operand_ ? NameOfByteCPURegister(rm)
- : NameOfCPURegister(rm));
+ count += PrintRightOperand(data + count);
if (op == 0xD2) {
- AppendToBuffer("cl");
+ AppendToBuffer(", cl");
} else {
- AppendToBuffer("%d", imm8);
+ int imm8 = -1;
+ if (op == 0xD0) {
+ imm8 = 1;
+ } else {
+ DCHECK_EQ(0xC0, op);
+ imm8 = *(data + count);
+ count++;
+ }
+ AppendToBuffer(", %d", imm8);
}
- return num_bytes;
+ return count;
}
} else if (opcode == 0x50) {
AppendToBuffer("movmskpd %s,", NameOfCPURegister(regop));
current += PrintRightXMMOperand(current);
+ } else if (opcode == 0x72) {
+ current += 1;
+ AppendToBuffer("%s,%s,%d", (regop == 6) ? "pslld" : "psrld",
+ NameOfXMMRegister(rm), *current & 0x7f);
+ current += 1;
} else if (opcode == 0x73) {
current += 1;
- DCHECK(regop == 6);
- AppendToBuffer("psllq,%s,%d", NameOfXMMRegister(rm), *current & 0x7f);
+ AppendToBuffer("%s,%s,%d", (regop == 6) ? "psllq" : "psrlq",
+ NameOfXMMRegister(rm), *current & 0x7f);
current += 1;
} else {
const char* mnemonic = "?";
mnemonic = "ucomisd";
} else if (opcode == 0x2F) {
mnemonic = "comisd";
+ } else if (opcode == 0x76) {
+ mnemonic = "pcmpeqd";
} else {
UnimplementedInstruction();
}
case 0x69: // fall through
case 0x6B: {
- int mod, regop, rm;
- get_modrm(*(data + 1), &mod, ®op, &rm);
- int32_t imm = *data == 0x6B ? *(data + 2)
- : *reinterpret_cast<int32_t*>(data + 2);
- AppendToBuffer("imul%c %s,%s,0x%x",
- operand_size_code(),
- NameOfCPURegister(regop),
- NameOfCPURegister(rm), imm);
- data += 2 + (*data == 0x6B ? 1 : 4);
+ int count = 1;
+ count += PrintOperands("imul", REG_OPER_OP_ORDER, data + count);
+ AppendToBuffer(",0x");
+ if (*data == 0x69) {
+ count += PrintImmediate(data + count, operand_size());
+ } else {
+ count += PrintImmediate(data + count, OPERAND_BYTE_SIZE);
+ }
+ data += count;
break;
}
//------------------------------------------------------------------------------
-static const char* cpu_regs[16] = {
+static const char* const cpu_regs[16] = {
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
};
-static const char* byte_cpu_regs[16] = {
+static const char* const byte_cpu_regs[16] = {
"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
"r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l"
};
-static const char* xmm_regs[16] = {
+static const char* const xmm_regs[16] = {
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
};
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
Label loop, exit;
__ Push(rax);
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ Push(rax);
// Check for proxies.
__ bind(&call_runtime);
__ Push(rax); // Duplicate the enumerable object on the stack.
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
// If we got a map from the runtime call, we can do a fast
// modification check. Otherwise, we got a fixed array, and we have
// No need for a write barrier, we are storing a Smi in the feedback vector.
__ Move(rbx, FeedbackVector());
- __ Move(FieldOperand(rbx, FixedArray::OffsetOfElementAt(slot)),
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ Move(FieldOperand(rbx, FixedArray::OffsetOfElementAt(vector_index)),
TypeFeedbackVector::MegamorphicSentinel(isolate()));
__ Move(rbx, Smi::FromInt(1)); // Smi indicates slow check
__ movp(rcx, Operand(rsp, 0 * kPointerSize)); // Get enumerated object
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ Move(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ Move(VectorLoadICDescriptor::SlotRegister(),
+ SmiFromSlot(expr->HomeObjectFeedbackSlot()));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
+
__ Cmp(rax, isolate()->factory()->undefined_value());
Label done;
__ Move(LoadDescriptor::NameRegister(), proxy->var()->name());
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ movp(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(rax);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in rax.
DCHECK(!CompileTimeValue::IsCompileTimeValue(value));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ Push(Operand(rsp, 0)); // Duplicate receiver.
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
__ Push(result_register());
}
break;
+ case KEYED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ __ Push(MemOperand(rsp, 2 * kPointerSize));
+ __ Push(MemOperand(rsp, 2 * kPointerSize));
+ __ Push(result_register());
+ }
+ break;
case KEYED_PROPERTY: {
if (expr->is_compound()) {
VisitForStackValue(property->obj());
EmitNamedSuperPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(rax);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(rax);
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ movp(load_receiver, Operand(rsp, kPointerSize));
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->KeyedLoadFeedbackSlot()));
+ SmiFromSlot(expr->KeyedLoadFeedbackSlot()));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
__ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->DoneFeedbackSlot()));
+ SmiFromSlot(expr->DoneFeedbackSlot()));
}
CallLoadIC(NOT_CONTEXTUAL); // rax=result.done
Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
__ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->ValueFeedbackSlot()));
+ SmiFromSlot(expr->ValueFeedbackSlot()));
}
CallLoadIC(NOT_CONTEXTUAL); // result.value in rax
context()->DropAndPlug(2, rax); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), rax, rcx, rdx, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, rax, rcx, rdx, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ movp(context_register(),
Operand(rbp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ Move(rbx, map);
+ __ movp(rbx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ movp(rbx, FieldOperand(rbx, GlobalObject::kNativeContextOffset));
+ __ movp(rbx, ContextOperand(rbx, Context::ITERATOR_RESULT_MAP_INDEX));
__ Pop(rcx);
__ Move(rdx, isolate()->factory()->ToBoolean(done));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ movp(FieldOperand(rax, HeapObject::kMapOffset), rbx);
__ Move(FieldOperand(rax, JSObject::kPropertiesOffset),
isolate()->factory()->empty_fixed_array());
__ Move(LoadDescriptor::NameRegister(), key->value());
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(prop->PropertyFeedbackSlot()));
+ SmiFromSlot(prop->PropertyFeedbackSlot()));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(prop->PropertyFeedbackSlot()));
+ SmiFromSlot(prop->PropertyFeedbackSlot()));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in rax.
+ DCHECK(lit != NULL);
+ __ Push(rax);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = rbx;
+ __ movp(scratch, FieldOperand(rax, JSFunction::kPrototypeOrInitialMapOffset));
+ __ Push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ Push(Operand(rsp, kPointerSize)); // constructor
+ } else {
+ __ Push(Operand(rsp, 0)); // prototype
+ }
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(rax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; rax: home_object
+ Register scratch = rcx;
+ Register scratch2 = rdx;
+ __ Move(scratch, result_register()); // home_object
+ __ movp(rax, MemOperand(rsp, kPointerSize)); // value
+ __ movp(scratch2, MemOperand(rsp, 0)); // this
+ __ movp(MemOperand(rsp, kPointerSize), scratch2); // this
+ __ movp(MemOperand(rsp, 0), scratch); // home_object
+ // stack: this, home_object; rax: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(rax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = rcx;
+ Register scratch2 = rdx;
+ __ movp(scratch2, MemOperand(rsp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; rax: key, rdx: value
+ __ movp(scratch, MemOperand(rsp, kPointerSize)); // this
+ __ movp(MemOperand(rsp, 2 * kPointerSize), scratch);
+ __ movp(scratch, MemOperand(rsp, 0)); // home_object
+ __ movp(MemOperand(rsp, kPointerSize), scratch);
+ __ movp(MemOperand(rsp, 0), rax);
+ __ Move(rax, scratch2);
+ // stack: this, home_object, key; rax: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ Push(rax); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// rax : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ Push(rax);
__ Push(key->value());
+ __ Push(rax);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(rax);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // rax : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(rax);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(rax);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ Move(LoadDescriptor::NameRegister(), rax);
- __ Pop(LoadDescriptor::ReceiverRegister());
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), rax);
+ __ Pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(rax);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Push(rax);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(rax);
+ __ Push(rax);
+ __ Push(Operand(rsp, kPointerSize * 2));
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ movp(Operand(rsp, kPointerSize), rax);
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ Move(rdx, Smi::FromInt(expr->CallFeedbackSlot()));
+ __ Move(rdx, SmiFromSlot(expr->CallFeedbackSlot()));
__ movp(rdi, Operand(rsp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
__ PushRoot(Heap::kUndefinedValueRootIndex);
}
+ // Push the enclosing function.
+ __ Push(Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
+
// Push the receiver of the enclosing function and do runtime call.
StackArgumentsAccessor args(rbp, info_->scope()->num_parameters());
__ Push(args.GetReceiverOperand());
__ Push(Smi::FromInt(scope()->start_position()));
// Do the runtime call.
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ Push(Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// rdx (receiver). Touch up the stack with the right values.
__ movp(Operand(rsp, (arg_count + 0) * kPointerSize), rdx);
__ movp(Operand(rsp, (arg_count + 1) * kPointerSize), rax);
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
SetSourcePosition(expr->position());
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ Push(rax); // Function.
__ Push(rdx); // Receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the function
// and receiver and have the slow path jump around this code.
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code, but not in the snapshot.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ Move(rbx, FeedbackVector());
- __ Move(rdx, Smi::FromInt(expr->CallNewFeedbackSlot()));
+ __ Move(rdx, SmiFromSlot(expr->CallNewFeedbackSlot()));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(rax, if_false);
+ Register map = rbx;
+ __ movp(map, FieldOperand(rax, HeapObject::kMapOffset));
+ __ CmpInstanceType(map, FIRST_JS_PROXY_TYPE);
+ __ j(less, if_false);
+ __ CmpInstanceType(map, LAST_JS_PROXY_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(less_equal, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ Move(LoadDescriptor::NameRegister(), expr->name());
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(expr->CallRuntimeFeedbackSlot()));
+ SmiFromSlot(expr->CallRuntimeFeedbackSlot()));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
if (expr->is_postfix() && !context()->IsEffect()) {
__ Push(Smi::FromInt(0));
}
- if (assign_type == NAMED_PROPERTY) {
- VisitForStackValue(prop->obj());
- __ movp(LoadDescriptor::ReceiverRegister(), Operand(rsp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- // Leave receiver on stack
- __ movp(LoadDescriptor::ReceiverRegister(), Operand(rsp, kPointerSize));
- // Copy of key, needed for later store.
- __ movp(LoadDescriptor::NameRegister(), Operand(rsp, 0));
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ __ movp(LoadDescriptor::ReceiverRegister(), Operand(rsp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ __ Push(MemOperand(rsp, kPointerSize));
+ __ Push(result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(result_register());
+ __ Push(MemOperand(rsp, 2 * kPointerSize));
+ __ Push(MemOperand(rsp, 2 * kPointerSize));
+ __ Push(result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ // Leave receiver on stack
+ __ movp(LoadDescriptor::ReceiverRegister(), Operand(rsp, kPointerSize));
+ // Copy of key, needed for later store.
+ __ movp(LoadDescriptor::NameRegister(), Operand(rsp, 0));
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ movp(Operand(rsp, kPointerSize), rax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ movp(Operand(rsp, 2 * kPointerSize), rax);
+ break;
case KEYED_PROPERTY:
__ movp(Operand(rsp, 2 * kPointerSize), rax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ movp(Operand(rsp, 3 * kPointerSize), rax);
+ break;
}
}
}
case NAMED_PROPERTY:
__ movp(Operand(rsp, kPointerSize), rax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ movp(Operand(rsp, 2 * kPointerSize), rax);
+ break;
case KEYED_PROPERTY:
__ movp(Operand(rsp, 2 * kPointerSize), rax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ movp(Operand(rsp, 3 * kPointerSize), rax);
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(rax);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(rax);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ Pop(StoreDescriptor::NameRegister());
__ Pop(StoreDescriptor::ReceiverRegister());
__ movp(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
if (FLAG_vector_ics) {
__ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(proxy->VariableFeedbackSlot()));
+ SmiFromSlot(proxy->VariableFeedbackSlot()));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return rax; }
+const Register StoreTransitionDescriptor::MapRegister() { return rbx; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() {
return rbx;
}
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // rsi -- context
+ Register registers[] = {rsi};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ Move(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ Move(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(rax));
- __ Move(VectorLoadICDescriptor::SlotRegister(),
- Smi::FromInt(instr->hydrogen()->slot()));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
+ __ Move(VectorLoadICDescriptor::SlotRegister(), Smi::FromInt(index));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#if V8_TARGET_ARCH_X64
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift by 0 and
// the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
}
+void MacroAssembler::Move(XMMRegister dst, uint32_t src) {
+ if (src == 0) {
+ xorps(dst, dst);
+ } else {
+ unsigned cnt = base::bits::CountPopulation32(src);
+ unsigned nlz = base::bits::CountLeadingZeros32(src);
+ unsigned ntz = base::bits::CountTrailingZeros32(src);
+ if (nlz + cnt + ntz == 32) {
+ pcmpeqd(dst, dst);
+ if (ntz == 0) {
+ psrld(dst, 32 - cnt);
+ } else {
+ pslld(dst, 32 - cnt);
+ if (nlz != 0) psrld(dst, nlz);
+ }
+ } else {
+ movl(kScratchRegister, Immediate(src));
+ movq(dst, kScratchRegister);
+ }
+ }
+}
+
+
+void MacroAssembler::Move(XMMRegister dst, uint64_t src) {
+ uint32_t lower = static_cast<uint32_t>(src);
+ uint32_t upper = static_cast<uint32_t>(src >> 32);
+ if (upper == 0) {
+ Move(dst, lower);
+ } else {
+ unsigned cnt = base::bits::CountPopulation64(src);
+ unsigned nlz = base::bits::CountLeadingZeros64(src);
+ unsigned ntz = base::bits::CountTrailingZeros64(src);
+ if (nlz + cnt + ntz == 64) {
+ pcmpeqd(dst, dst);
+ if (ntz == 0) {
+ psrlq(dst, 64 - cnt);
+ } else {
+ psllq(dst, 64 - cnt);
+ if (nlz != 0) psrlq(dst, nlz);
+ }
+ } else if (lower == 0) {
+ Move(dst, upper);
+ psllq(dst, 32);
+ } else {
+ movq(kScratchRegister, src);
+ movq(dst, kScratchRegister);
+ }
+ }
+}
+
+
void MacroAssembler::Cmp(Register dst, Handle<Object> source) {
AllowDeferredHandleDereference smi_check;
if (source->IsSmi()) {
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on x64.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
pushq(rbp);
movp(rbp, rsp);
Store(ExternalReference(Isolate::kCEntryFPAddress, isolate()), rbp);
Store(ExternalReference(Isolate::kContextAddress, isolate()), rsi);
+ Store(ExternalReference(Isolate::kCFunctionAddress, isolate()), rbx);
}
movp(dst, reinterpret_cast<void*>(value.location()), rmode);
}
+ void Move(XMMRegister dst, uint32_t src);
+ void Move(XMMRegister dst, uint64_t src);
+
// Control Flow
void Jump(Address destination, RelocInfo::Mode rmode);
void Jump(ExternalReference ext);
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Expects object in rax and returns map with validated enum cache
}
-void Assembler::ror(Register dst, uint8_t imm8) {
+void Assembler::ror(const Operand& dst, uint8_t imm8) {
EnsureSpace ensure_space(this);
DCHECK(is_uint5(imm8)); // illegal shift count
if (imm8 == 1) {
EMIT(0xD1);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
} else {
EMIT(0xC1);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
EMIT(imm8);
}
}
-void Assembler::ror_cl(Register dst) {
+void Assembler::ror_cl(const Operand& dst) {
EnsureSpace ensure_space(this);
EMIT(0xD3);
- EMIT(0xC8 | dst.code());
+ emit_operand(ecx, dst);
}
void rcl(Register dst, uint8_t imm8);
void rcr(Register dst, uint8_t imm8);
- void ror(Register dst, uint8_t imm8);
- void ror_cl(Register dst);
+
+ void ror(Register dst, uint8_t imm8) { ror(Operand(dst), imm8); }
+ void ror(const Operand& dst, uint8_t imm8);
+ void ror_cl(Register dst) { ror_cl(Operand(dst)); }
+ void ror_cl(const Operand& dst);
void sar(Register dst, uint8_t imm8) { sar(Operand(dst), imm8); }
void sar(const Operand& dst, uint8_t imm8);
__ bind(&loop);
__ mov(receiver, Operand(ebp, kArgumentsOffset)); // load arguments
- // Use inline caching to speed up access to arguments.
if (FLAG_vector_ics) {
- __ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(0)));
+ // TODO(mvstanton): Vector-based ics need additional infrastructure to
+ // be embedded here. For now, just call the runtime.
+ __ push(receiver);
+ __ push(key);
+ __ CallRuntime(Runtime::kGetProperty, 2);
+ } else {
+ // Use inline caching to speed up access to arguments.
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
+ __ call(ic, RelocInfo::CODE_TARGET);
+ // It is important that we do not have a test instruction after the
+ // call. A test instruction after the call is used to indicate that
+ // we have generated an inline version of the keyed load. In this
+ // case, we know that we are not generating a test instruction next.
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(masm->isolate()).code();
- __ call(ic, RelocInfo::CODE_TARGET);
- // It is important that we do not have a test instruction after the
- // call. A test instruction after the call is used to indicate that
- // we have generated an inline version of the keyed load. In this
- // case, we know that we are not generating a test instruction next.
// Push the nth argument.
__ push(eax);
}
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is on the stack.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = ebx;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+ Register result = eax;
+ DCHECK(!result.is(scratch));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ ret(0);
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
// The key is in edx and the parameter count is in eax.
DCHECK(edx.is(ArgumentsAccessReadDescriptor::index()));
__ mov(FieldOperand(ebx, edx, times_half_pointer_size,
FixedArray::kHeaderSize),
Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate)));
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ sub(FieldOperand(ebx, with_types_offset), Immediate(Smi::FromInt(1)));
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ add(FieldOperand(ebx, generic_offset), Immediate(Smi::FromInt(1)));
__ jmp(&slow_start);
}
// ebx: instance type
// ecx: sub string length (smi)
// edx: from index (smi)
- StringCharAtGenerator generator(
- eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
+ StringCharAtGenerator generator(eax, edx, ecx, eax, &runtime, &runtime,
+ &runtime, STRING_INDEX_IS_NUMBER,
+ RECEIVER_IS_STRING);
generator.GenerateFast(masm);
__ ret(3 * kPointerSize);
generator.SkipSlow(masm, &runtime);
__ mov(FieldOperand(eax, FixedArray::kLengthOffset), ebx);
__ mov(edi, FieldOperand(edx, JSObject::kElementsOffset));
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ Label initialization_loop, initialization_loop_entry;
+ __ jmp(&initialization_loop_entry, Label::kNear);
+ __ bind(&initialization_loop);
+ __ mov(FieldOperand(eax, ebx, times_2, FixedArray::kHeaderSize),
+ masm->isolate()->factory()->the_hole_value());
+ __ bind(&initialization_loop_entry);
+ __ sub(ebx, Immediate(Smi::FromInt(1)));
+ __ j(not_sign, &initialization_loop);
+
+ __ mov(ebx, FieldOperand(edi, FixedDoubleArray::kLengthOffset));
__ jmp(&entry);
// ebx: target map
// Register state for IC load call (from ic-x87.cc).
Register receiver = LoadDescriptor::ReceiverRegister();
Register name = LoadDescriptor::NameRegister();
- Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit(), 0, false);
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0, false);
}
//------------------------------------------------------------------------------
-static const char* cpu_regs[8] = {
+static const char* const cpu_regs[8] = {
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
};
-static const char* byte_cpu_regs[8] = {
+static const char* const byte_cpu_regs[8] = {
"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"
};
-static const char* xmm_regs[8] = {
+static const char* const xmm_regs[8] = {
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
};
void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
Comment cmnt(masm_, "[ ForInStatement");
- int slot = stmt->ForInFeedbackSlot();
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
SetStatementPosition(stmt);
__ push(eax);
__ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
__ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
__ push(eax);
// Check for proxies.
__ bind(&call_runtime);
__ push(eax);
__ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
__ cmp(FieldOperand(eax, HeapObject::kMapOffset),
isolate()->factory()->meta_map());
__ j(not_equal, &fixed_array);
// No need for a write barrier, we are storing a Smi in the feedback vector.
__ LoadHeapObject(ebx, FeedbackVector());
- __ mov(FieldOperand(ebx, FixedArray::OffsetOfElementAt(slot)),
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ mov(FieldOperand(ebx, FixedArray::OffsetOfElementAt(vector_index)),
Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate())));
__ mov(ebx, Immediate(Smi::FromInt(1))); // Smi indicates slow check
Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
__ mov(LoadDescriptor::NameRegister(), home_object_symbol);
- CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Immediate(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
__ cmp(eax, isolate()->factory()->undefined_value());
Label done;
__ mov(LoadDescriptor::NameRegister(), proxy->var()->name());
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
ContextualMode mode = (typeof_state == INSIDE_TYPEOF)
__ mov(LoadDescriptor::NameRegister(), var->name());
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
CallLoadIC(CONTEXTUAL);
context()->Plug(eax);
FastCloneShallowObjectStub stub(isolate(), properties_count);
__ CallStub(&stub);
}
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
// If result_saved is true the result is on top of the stack. If
// result_saved is false the result is in eax.
DCHECK(!CompileTimeValue::IsCompileTimeValue(value));
// Fall through.
case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
if (key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(value);
__ push(Operand(esp, 0)); // Duplicate receiver.
VisitForStackValue(value);
if (property->emit_store()) {
- __ CallRuntime(Runtime::kSetPrototype, 2);
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
} else {
__ Drop(2);
}
Comment cmnt(masm_, "[ Assignment");
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind {
- VARIABLE,
- NAMED_PROPERTY,
- KEYED_PROPERTY,
- NAMED_SUPER_PROPERTY
- };
- LhsKind assign_type = VARIABLE;
Property* property = expr->target()->AsProperty();
- if (property != NULL) {
- assign_type = (property->key()->IsPropertyName())
- ? (property->IsSuperAccess() ? NAMED_SUPER_PROPERTY
- : NAMED_PROPERTY)
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(property);
// Evaluate LHS expression.
switch (assign_type) {
VisitForStackValue(property->obj());
}
break;
+ case KEYED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(result_register());
+ }
+ break;
case KEYED_PROPERTY: {
if (expr->is_compound()) {
VisitForStackValue(property->obj());
EmitNamedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
case KEYED_PROPERTY:
EmitKeyedPropertyLoad(property);
PrepareForBailoutForId(property->LoadId(), TOS_REG);
EmitNamedPropertyAssignment(expr);
break;
case NAMED_SUPER_PROPERTY:
- EmitNamedSuperPropertyAssignment(expr);
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(result_register());
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(result_register());
break;
case KEYED_PROPERTY:
EmitKeyedPropertyAssignment(expr);
__ mov(load_receiver, Operand(esp, kPointerSize));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->KeyedLoadFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
}
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
CallIC(ic, TypeFeedbackId::None());
isolate()->factory()->done_string()); // "done"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->DoneFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->DoneFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // result.done in eax
Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
isolate()->factory()->value_string()); // "value"
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->ValueFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->ValueFeedbackSlot())));
}
CallLoadIC(NOT_CONTEXTUAL); // result.value in eax
context()->DropAndPlug(2, eax); // drop iter and g
Label gc_required;
Label allocated;
- Handle<Map> map(isolate()->native_context()->iterator_result_map());
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
- __ Allocate(map->instance_size(), eax, ecx, edx, &gc_required, TAG_OBJECT);
+ __ Allocate(instance_size, eax, ecx, edx, &gc_required, TAG_OBJECT);
__ jmp(&allocated);
__ bind(&gc_required);
- __ Push(Smi::FromInt(map->instance_size()));
+ __ Push(Smi::FromInt(instance_size));
__ CallRuntime(Runtime::kAllocateInNewSpace, 1);
__ mov(context_register(),
Operand(ebp, StandardFrameConstants::kContextOffset));
__ bind(&allocated);
- __ mov(ebx, map);
+ __ mov(ebx, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ mov(ebx, FieldOperand(ebx, GlobalObject::kNativeContextOffset));
+ __ mov(ebx, ContextOperand(ebx, Context::ITERATOR_RESULT_MAP_INDEX));
__ pop(ecx);
__ mov(edx, isolate()->factory()->ToBoolean(done));
- DCHECK_EQ(map->instance_size(), 5 * kPointerSize);
__ mov(FieldOperand(eax, HeapObject::kMapOffset), ebx);
__ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
isolate()->factory()->empty_fixed_array());
__ mov(LoadDescriptor::NameRegister(), Immediate(key->value()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Immediate(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(prop->PropertyFeedbackSlot())));
+ Immediate(SmiFromSlot(prop->PropertyFeedbackSlot())));
CallIC(ic);
} else {
CallIC(ic, prop->PropertyFeedbackId());
}
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode,
}
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in eax.
+ DCHECK(lit != NULL);
+ __ push(eax);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = ebx;
+ __ mov(scratch, FieldOperand(eax, JSFunction::kPrototypeOrInitialMapOffset));
+ __ Push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ push(Operand(esp, kPointerSize)); // constructor
+ } else {
+ __ push(Operand(esp, 0)); // prototype
+ }
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr,
Token::Value op,
OverwriteMode mode) {
void FullCodeGenerator::EmitAssignment(Expression* expr) {
DCHECK(expr->IsValidReferenceExpression());
- // Left-hand side can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->AsProperty();
- if (prop != NULL) {
- assign_type = (prop->key()->IsPropertyName())
- ? NAMED_PROPERTY
- : KEYED_PROPERTY;
- }
+ LhsKind assign_type = GetAssignType(prop);
switch (assign_type) {
case VARIABLE: {
CallStoreIC();
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ __ push(eax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; eax: home_object
+ Register scratch = ecx;
+ Register scratch2 = edx;
+ __ mov(scratch, result_register()); // home_object
+ __ mov(eax, MemOperand(esp, kPointerSize)); // value
+ __ mov(scratch2, MemOperand(esp, 0)); // this
+ __ mov(MemOperand(esp, kPointerSize), scratch2); // this
+ __ mov(MemOperand(esp, 0), scratch); // home_object
+ // stack: this, home_object. eax: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ push(eax);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = ecx;
+ Register scratch2 = edx;
+ __ mov(scratch2, MemOperand(esp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; eax: key, edx: value
+ __ mov(scratch, MemOperand(esp, kPointerSize)); // this
+ __ mov(MemOperand(esp, 2 * kPointerSize), scratch);
+ __ mov(scratch, MemOperand(esp, 0)); // home_object
+ __ mov(MemOperand(esp, kPointerSize), scratch);
+ __ mov(MemOperand(esp, 0), eax);
+ __ mov(eax, scratch2);
+ // stack: this, home_object, key; eax: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
case KEYED_PROPERTY: {
__ push(eax); // Preserve value.
VisitForStackValue(prop->obj());
}
-void FullCodeGenerator::EmitNamedSuperPropertyAssignment(Assignment* expr) {
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
// Assignment to named property of super.
// eax : value
// stack : receiver ('this'), home_object
- Property* prop = expr->target()->AsProperty();
DCHECK(prop != NULL);
Literal* key = prop->key()->AsLiteral();
DCHECK(key != NULL);
- __ push(eax);
__ push(Immediate(key->value()));
+ __ push(eax);
__ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
: Runtime::kStoreToSuper_Sloppy),
4);
- context()->Plug(eax);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // eax : value
+ // stack : receiver ('this'), home_object, key
+
+ __ push(eax);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
}
PrepareForBailoutForId(expr->LoadId(), TOS_REG);
context()->Plug(eax);
} else {
- VisitForStackValue(expr->obj());
- VisitForAccumulatorValue(expr->key());
- __ pop(LoadDescriptor::ReceiverRegister()); // Object.
- __ Move(LoadDescriptor::NameRegister(), result_register()); // Key.
- EmitKeyedPropertyLoad(expr);
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ pop(LoadDescriptor::ReceiverRegister()); // Object.
+ __ Move(LoadDescriptor::NameRegister(), result_register()); // Key.
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
context()->Plug(eax);
}
}
}
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ SuperReference* super_ref = callee->AsProperty()->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ push(eax);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ push(eax);
+ __ push(eax);
+ __ push(Operand(esp, kPointerSize * 2));
+ VisitForStackValue(prop->key());
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ mov(Operand(esp, kPointerSize), eax);
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
// Load the arguments.
ZoneList<Expression*>* args = expr->arguments();
SetSourcePosition(expr->position());
Handle<Code> ic = CallIC::initialize_stub(
isolate(), arg_count, call_type);
- __ Move(edx, Immediate(Smi::FromInt(expr->CallFeedbackSlot())));
+ __ Move(edx, Immediate(SmiFromSlot(expr->CallFeedbackSlot())));
__ mov(edi, Operand(esp, (arg_count + 1) * kPointerSize));
// Don't assign a type feedback id to the IC, since type feedback is provided
// by the vector above.
__ push(Immediate(isolate()->factory()->undefined_value()));
}
+ // Push the enclosing function.
+ __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
// Push the receiver of the enclosing function.
__ push(Operand(ebp, (2 + info_->scope()->num_parameters()) * kPointerSize));
// Push the language mode.
__ push(Immediate(Smi::FromInt(scope()->start_position())));
// Do the runtime call.
- __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 5);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
+ __ CallRuntime(Runtime::kGetPrototype, 1);
}
// edx (receiver). Touch up the stack with the right values.
__ mov(Operand(esp, (arg_count + 0) * kPointerSize), edx);
__ mov(Operand(esp, (arg_count + 1) * kPointerSize), eax);
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
}
// Record source position for debugger.
SetSourcePosition(expr->position());
__ CallRuntime(Runtime::kLoadLookupSlot, 2);
__ push(eax); // Function.
__ push(edx); // Receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
// If fast case code has been generated, emit code to push the function
// and receiver and have the slow path jump around this code.
} else if (call_type == Call::PROPERTY_CALL) {
Property* property = callee->AsProperty();
bool is_named_call = property->key()->IsPropertyName();
- // super.x() is handled in EmitCallWithLoadIC.
- if (property->IsSuperAccess() && is_named_call) {
- EmitSuperCallWithLoadIC(expr);
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
} else {
{
PreservePositionScope scope(masm()->positions_recorder());
EmitKeyedCallWithLoadIC(expr, property->key());
}
}
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
} else {
DCHECK(call_type == Call::OTHER_CALL);
// Call to an arbitrary expression not handled specially above.
// Push constructor on the stack. If it's not a function it's used as
// receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
// ignored.
- VisitForStackValue(expr->expression());
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
// Push the arguments ("left-to-right") on the stack.
ZoneList<Expression*>* args = expr->arguments();
// Record call targets in unoptimized code.
if (FLAG_pretenuring_call_new) {
EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
- DCHECK(expr->AllocationSiteFeedbackSlot() ==
- expr->CallNewFeedbackSlot() + 1);
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
}
__ LoadHeapObject(ebx, FeedbackVector());
- __ mov(edx, Immediate(Smi::FromInt(expr->CallNewFeedbackSlot())));
+ __ mov(edx, Immediate(SmiFromSlot(expr->CallNewFeedbackSlot())));
CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
__ call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
}
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(eax, if_false);
+ Register map = ebx;
+ __ mov(map, FieldOperand(eax, HeapObject::kMapOffset));
+ __ CmpInstanceType(map, FIRST_JS_PROXY_TYPE);
+ __ j(less, if_false);
+ __ CmpInstanceType(map, LAST_JS_PROXY_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(less_equal, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
DCHECK(expr->arguments()->length() == 0);
__ mov(LoadDescriptor::NameRegister(), Immediate(expr->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(expr->CallRuntimeFeedbackSlot())));
+ Immediate(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
CallLoadIC(NOT_CONTEXTUAL);
} else {
CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
Comment cmnt(masm_, "[ CountOperation");
SetSourcePosition(expr->position());
- // Expression can only be a property, a global or a (parameter or local)
- // slot.
- enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
- LhsKind assign_type = VARIABLE;
Property* prop = expr->expression()->AsProperty();
- // In case of a property we use the uninitialized expression context
- // of the key to detect a named property.
- if (prop != NULL) {
- assign_type =
- (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
- if (prop->IsSuperAccess()) {
- // throw exception.
- VisitSuperReference(prop->obj()->AsSuperReference());
- return;
- }
- }
+ LhsKind assign_type = GetAssignType(prop);
// Evaluate expression and get value.
if (assign_type == VARIABLE) {
if (expr->is_postfix() && !context()->IsEffect()) {
__ push(Immediate(Smi::FromInt(0)));
}
- if (assign_type == NAMED_PROPERTY) {
- // Put the object both on the stack and in the register.
- VisitForStackValue(prop->obj());
- __ mov(LoadDescriptor::ReceiverRegister(), Operand(esp, 0));
- EmitNamedPropertyLoad(prop);
- } else {
- VisitForStackValue(prop->obj());
- VisitForStackValue(prop->key());
- __ mov(LoadDescriptor::ReceiverRegister(),
- Operand(esp, kPointerSize)); // Object.
- __ mov(LoadDescriptor::NameRegister(), Operand(esp, 0)); // Key.
- EmitKeyedPropertyLoad(prop);
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ mov(LoadDescriptor::ReceiverRegister(), Operand(esp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ __ push(MemOperand(esp, kPointerSize));
+ __ push(result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ push(result_register());
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(MemOperand(esp, 2 * kPointerSize));
+ __ push(result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ mov(LoadDescriptor::ReceiverRegister(),
+ Operand(esp, kPointerSize)); // Object.
+ __ mov(LoadDescriptor::NameRegister(), Operand(esp, 0)); // Key.
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
}
}
case NAMED_PROPERTY:
__ mov(Operand(esp, kPointerSize), eax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 2 * kPointerSize), eax);
+ break;
case KEYED_PROPERTY:
__ mov(Operand(esp, 2 * kPointerSize), eax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 3 * kPointerSize), eax);
+ break;
}
}
}
case NAMED_PROPERTY:
__ mov(Operand(esp, kPointerSize), eax);
break;
+ case NAMED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 2 * kPointerSize), eax);
+ break;
case KEYED_PROPERTY:
__ mov(Operand(esp, 2 * kPointerSize), eax);
break;
+ case KEYED_SUPER_PROPERTY:
+ __ mov(Operand(esp, 3 * kPointerSize), eax);
+ break;
}
}
}
}
break;
}
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(eax);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(eax);
+ }
+ break;
+ }
case KEYED_PROPERTY: {
__ pop(StoreDescriptor::NameRegister());
__ pop(StoreDescriptor::ReceiverRegister());
__ mov(LoadDescriptor::NameRegister(), Immediate(proxy->name()));
if (FLAG_vector_ics) {
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(proxy->VariableFeedbackSlot())));
+ Immediate(SmiFromSlot(proxy->VariableFeedbackSlot())));
}
// Use a regular load, not a contextual load, to avoid a reference
// error.
const Register StoreDescriptor::ValueRegister() { return eax; }
+const Register StoreTransitionDescriptor::MapRegister() { return ebx; }
+
+
const Register ElementTransitionAndStoreDescriptor::MapRegister() {
return ebx;
}
}
+void AllocateHeapNumberDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // esi -- context
+ Register registers[] = {esi};
+ data->Initialize(arraysize(registers), registers, nullptr);
+}
+
+
void ArrayConstructorConstantArgCountDescriptor::Initialize(
CallInterfaceDescriptorData* data) {
// register state
if (instr->op() != Token::MOD) {
X87PrepareBinaryOp(left, right, result);
}
+ // Set the precision control to double-precision.
+ __ X87SetFPUCW(0x027F);
switch (instr->op()) {
case Token::ADD:
__ fadd_i(1);
break;
}
- // Only always explicitly storing to memory to force the round-down for double
- // arithmetic.
- __ lea(esp, Operand(esp, -kDoubleSize));
- __ fstp_d(Operand(esp, 0));
- __ fld_d(Operand(esp, 0));
- __ lea(esp, Operand(esp, kDoubleSize));
+ // Restore the default value of control word.
+ __ X87SetFPUCW(0x037F);
}
template <class T>
void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
DCHECK(FLAG_vector_ics);
- Register vector = ToRegister(instr->temp_vector());
- DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
- __ mov(vector, instr->hydrogen()->feedback_vector());
+ Register vector_register = ToRegister(instr->temp_vector());
+ DCHECK(vector_register.is(VectorLoadICDescriptor::VectorRegister()));
+ Handle<TypeFeedbackVector> vector = instr->hydrogen()->feedback_vector();
+ __ mov(vector_register, vector);
// No need to allocate this register.
DCHECK(VectorLoadICDescriptor::SlotRegister().is(eax));
+ int index = vector->GetIndex(instr->hydrogen()->slot());
__ mov(VectorLoadICDescriptor::SlotRegister(),
- Immediate(Smi::FromInt(instr->hydrogen()->slot())));
+ Immediate(Smi::FromInt(index)));
}
EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
}
ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ Handle<Code> ic = CodeFactory::LoadICInOptimizedCode(isolate(), mode).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
if (FLAG_vector_ics) {
EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ Handle<Code> ic =
+ CodeFactory::LoadICInOptimizedCode(isolate(), NOT_CONTEXTUAL).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
}
- Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ Handle<Code> ic = CodeFactory::KeyedLoadICInOptimizedCode(isolate()).code();
CallCode(ic, RelocInfo::CODE_TARGET, instr);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#if V8_TARGET_ARCH_X87
void LStoreNamedField::PrintDataTo(StringStream* stream) {
object()->PrintTo(stream);
- OStringStream os;
+ std::ostringstream os;
os << hydrogen()->access() << " <- ";
- stream->Add(os.c_str());
+ stream->Add(os.str().c_str());
value()->PrintTo(stream);
}
// Shift operations can only deoptimize if we do a logical shift by 0 and
// the result cannot be truncated to int32.
if (op == Token::SHR && constant_value == 0) {
- if (FLAG_opt_safe_uint32_operations) {
- does_deopt = !instr->CheckFlag(HInstruction::kUint32);
- } else {
- does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToInt32);
- }
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
}
LInstruction* result =
}
-void MacroAssembler::LoadUint32NoSSE2(Register src) {
+void MacroAssembler::LoadUint32NoSSE2(const Operand& src) {
Label done;
push(src);
fild_s(Operand(esp, 0));
}
+void MacroAssembler::X87SetFPUCW(int cw) {
+ push(Immediate(cw));
+ fldcw(MemOperand(esp, 0));
+ add(esp, Immediate(kPointerSize));
+}
+
+
void MacroAssembler::AssertNumber(Register object) {
if (emit_debug_code()) {
Label ok;
}
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ // Out-of-line constant pool not implemented on x87.
+ UNREACHABLE();
+}
+
+
void MacroAssembler::EnterFrame(StackFrame::Type type) {
push(ebp);
mov(ebp, esp);
// Save the frame pointer and the context in top.
ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress, isolate());
ExternalReference context_address(Isolate::kContextAddress, isolate());
+ ExternalReference c_function_address(Isolate::kCFunctionAddress, isolate());
mov(Operand::StaticVariable(c_entry_fp_address), ebp);
mov(Operand::StaticVariable(context_address), esi);
+ mov(Operand::StaticVariable(c_function_address), ebx);
}
void FXamSign();
void X87CheckIA();
void X87SetRC(int rc);
+ void X87SetFPUCW(int cw);
void ClampUint8(Register reg);
void ClampTOSToUint8(Register result_reg);
j(not_carry, is_smi);
}
- void LoadUint32NoSSE2(Register src);
+ void LoadUint32NoSSE2(Register src) {
+ LoadUint32NoSSE2(Operand(src));
+ }
+ void LoadUint32NoSSE2(const Operand& src);
// Jump the register contains a smi.
inline void JumpIfSmi(Register value,
// Activation support.
void EnterFrame(StackFrame::Type type);
+ void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg);
void LeaveFrame(StackFrame::Type type);
// Expects object in eax and returns map with validated enum cache
: std::vector<T, zone_allocator<T> >(zone_allocator<T>(zone)) {}
// Constructs a new vector and fills it with {size} elements, each
+ // constructed via the default constructor.
+ ZoneVector(int size, Zone* zone)
+ : std::vector<T, zone_allocator<T> >(size, T(), zone_allocator<T>(zone)) {
+ }
+
+ // Constructs a new vector and fills it with {size} elements, each
// having the value {def}.
ZoneVector(int size, T def, Zone* zone)
: std::vector<T, zone_allocator<T> >(size, def, zone_allocator<T>(zone)) {
position_ = limit_ = 0;
}
+ allocation_size_ = 0;
// Update the head segment to be the kept segment (if any).
segment_head_ = keep;
}
+++ /dev/null
-# 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.
-
-[
-]
# Both --nocrankshaft and --stressopt are very slow. Add TF but without
# always opt to match the way the benchmarks are run for performance
# testing.
- return [[], ["--turbo-filter=*"]]
+ return [[], ["--turbo-asm", "--turbo-filter=*"]]
def GetSuite(name, root):
#include "test/cctest/profiler-extension.h"
#include "test/cctest/trace-extension.h"
-#if (defined(_WIN32) || defined(_WIN64))
+#if V8_OS_WIN
#include <windows.h> // NOLINT
-#if defined(_MSC_VER)
+#if V8_CC_MSVC
#include <crtdbg.h>
-#endif // defined(_MSC_VER)
-#endif // defined(_WIN32) || defined(_WIN64)
+#endif
+#endif
enum InitializationState {kUnset, kUnintialized, kInitialized};
static InitializationState initialization_state_ = kUnset;
CcTest* CcTest::last_ = NULL;
bool CcTest::initialize_called_ = false;
-bool CcTest::isolate_used_ = false;
+v8::base::Atomic32 CcTest::isolate_used_ = 0;
v8::Isolate* CcTest::isolate_ = NULL;
int main(int argc, char* argv[]) {
-#if (defined(_WIN32) || defined(_WIN64))
+#if V8_OS_WIN
UINT new_flags =
SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX;
UINT existing_flags = SetErrorMode(new_flags);
SetErrorMode(existing_flags | new_flags);
-#if defined(_MSC_VER)
+#if V8_CC_MSVC
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_set_error_mode(_OUT_TO_STDERR);
-#endif // _MSC_VER
-#endif // defined(_WIN32) || defined(_WIN64)
+#endif // V8_CC_MSVC
+#endif // V8_OS_WIN
v8::V8::InitializeICU();
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
'compiler/test-branch-combine.cc',
'compiler/test-changes-lowering.cc',
'compiler/test-codegen-deopt.cc',
+ 'compiler/test-control-reducer.cc',
'compiler/test-gap-resolver.cc',
'compiler/test-graph-reducer.cc',
+ 'compiler/test-graph-visualizer.cc',
'compiler/test-instruction.cc',
'compiler/test-js-context-specialization.cc',
'compiler/test-js-constant-cache.cc',
'compiler/test-js-typed-lowering.cc',
'compiler/test-linkage.cc',
+ 'compiler/test-loop-assignment-analysis.cc',
'compiler/test-machine-operator-reducer.cc',
'compiler/test-node-algorithm.cc',
'compiler/test-node-cache.cc',
'compiler/test-run-jsops.cc',
'compiler/test-run-machops.cc',
'compiler/test-run-properties.cc',
+ 'compiler/test-run-stackcheck.cc',
'compiler/test-run-variables.cc',
'compiler/test-schedule.cc',
'compiler/test-scheduler.cc',
'compiler/test-simplified-lowering.cc',
+ 'compiler/test-typer.cc',
'cctest.cc',
'gay-fixed.cc',
'gay-precision.cc',
'test-atomicops.cc',
'test-bignum.cc',
'test-bignum-dtoa.cc',
+ 'test-bit-vector.cc',
'test-checks.cc',
'test-circular-queue.cc',
'test-compiler.cc',
'test-constantpool.cc',
'test-conversions.cc',
'test-cpu-profiler.cc',
- 'test-dataflow.cc',
'test-date.cc',
'test-debug.cc',
'test-declarative-accessors.cc',
'test-double.cc',
'test-dtoa.cc',
'test-fast-dtoa.cc',
+ 'test-feedback-vector.cc',
'test-fixed-dtoa.cc',
'test-flags.cc',
'test-func-name-inference.cc',
'test-mementos.cc',
'test-object-observe.cc',
'test-ordered-hash-table.cc',
- 'test-ostreams.cc',
'test-parsing.cc',
'test-platform.cc',
'test-profile-generator.cc',
'test-regexp.cc',
'test-reloc-info.cc',
'test-representation.cc',
+ 'test-sampler-api.cc',
'test-serialize.cc',
'test-spaces.cc',
'test-strings.cc',
'test-strtod.cc',
'test-thread-termination.cc',
'test-threads.cc',
+ 'test-transitions.cc',
'test-types.cc',
'test-unbound-queue.cc',
'test-unique.cc',
static v8::Isolate* isolate() {
CHECK(isolate_ != NULL);
- isolate_used_ = true;
+ v8::base::NoBarrier_Store(&isolate_used_, 1);
return isolate_;
}
// TODO(dcarney): Remove.
// This must be called first in a test.
static void InitializeVM() {
- CHECK(!isolate_used_);
+ CHECK(!v8::base::NoBarrier_Load(&isolate_used_));
CHECK(!initialize_called_);
initialize_called_ = true;
v8::HandleScope handle_scope(CcTest::isolate());
static CcTest* last_;
static v8::Isolate* isolate_;
static bool initialize_called_;
- static bool isolate_used_;
+ static v8::base::Atomic32 isolate_used_;
};
// Switches between all the Api tests using the threading support.
// Helper function that simulates a full new-space in the heap.
-static inline void SimulateFullSpace(v8::internal::NewSpace* space) {
- int new_linear_size = static_cast<int>(
- *space->allocation_limit_address() - *space->allocation_top_address());
- if (new_linear_size == 0) return;
+static inline bool FillUpOnePage(v8::internal::NewSpace* space) {
v8::internal::AllocationResult allocation =
- space->AllocateRaw(new_linear_size);
+ space->AllocateRaw(v8::internal::Page::kMaxRegularHeapObjectSize);
+ if (allocation.IsRetry()) return false;
v8::internal::FreeListNode* node =
v8::internal::FreeListNode::cast(allocation.ToObjectChecked());
- node->set_size(space->heap(), new_linear_size);
+ node->set_size(space->heap(), v8::internal::Page::kMaxRegularHeapObjectSize);
+ return true;
+}
+
+
+static inline void SimulateFullSpace(v8::internal::NewSpace* space) {
+ int new_linear_size = static_cast<int>(*space->allocation_limit_address() -
+ *space->allocation_top_address());
+ if (new_linear_size > 0) {
+ // Fill up the current page.
+ v8::internal::AllocationResult allocation =
+ space->AllocateRaw(new_linear_size);
+ v8::internal::FreeListNode* node =
+ v8::internal::FreeListNode::cast(allocation.ToObjectChecked());
+ node->set_size(space->heap(), new_linear_size);
+ }
+ // Fill up all remaining pages.
+ while (FillUpOnePage(space))
+ ;
}
[ALWAYS, {
# All tests prefixed with 'Bug' are expected to fail.
'test-api/Bug*': [FAIL],
+ 'test-serialize/Bug*': [FAIL],
##############################################################################
}], # 'arch == mipsel or arch == mips'
##############################################################################
+['arch == mips', {
+ # Too slow with TF.
+ 'test-api/ExternalArrays': [PASS, NO_VARIANTS],
+
+ # TODO(mips-team): Currently fails on mips board.
+ 'test-simplified-lowering/RunNumberMultiply_TruncatingToUint32': [SKIP],
+ 'test-parsing/TooManyArguments': [SKIP],
+}], # 'arch == mips'
+
+##############################################################################
['arch == mips64el', {
# BUG(2657): Test sometimes times out on MIPS simulator.
Simulator::CallArgument::End()};
return ReturnValueTraits<R>::Cast(CallSimulator(FUNCTION_ADDR(f), args));
}
-#elif USE_SIMULATOR && V8_TARGET_ARCH_ARM
+#elif USE_SIMULATOR && (V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_MIPS)
uintptr_t CallSimulator(byte* f, int32_t p1 = 0, int32_t p2 = 0,
int32_t p3 = 0, int32_t p4 = 0) {
Simulator* simulator = Simulator::current(isolate_);
TEST(CompareWrapper) {
// Who tests the testers?
// If CompareWrapper is broken, then test expectations will be broken.
- RawMachineAssemblerTester<int32_t> m;
CompareWrapper wWord32Equal(IrOpcode::kWord32Equal);
CompareWrapper wInt32LessThan(IrOpcode::kInt32LessThan);
CompareWrapper wInt32LessThanOrEqual(IrOpcode::kInt32LessThanOrEqual);
TEST(RunHeapNumberConstant) {
- RawMachineAssemblerTester<Object*> m;
- Handle<Object> number = m.isolate()->factory()->NewHeapNumber(100.5);
+ RawMachineAssemblerTester<HeapObject*> m;
+ Handle<HeapObject> number = m.isolate()->factory()->NewHeapNumber(100.5);
m.Return(m.HeapConstant(number));
- Object* result = m.Call();
+ HeapObject* result = m.Call();
CHECK_EQ(result, *number);
}
#include "src/v8.h"
+#include "src/compiler/instruction-selector.h"
#include "src/compiler/pipeline.h"
#include "src/compiler/raw-machine-assembler.h"
#include "src/simulator.h"
public:
MachineAssemblerTester(MachineType return_type, MachineType p0,
MachineType p1, MachineType p2, MachineType p3,
- MachineType p4)
+ MachineType p4,
+ MachineOperatorBuilder::Flags flags =
+ MachineOperatorBuilder::Flag::kNoFlags)
: HandleAndZoneScope(),
CallHelper(
main_isolate(),
MachineAssembler(
new (main_zone()) Graph(main_zone()),
MakeMachineSignature(main_zone(), return_type, p0, p1, p2, p3, p4),
- kMachPtr) {}
+ kMachPtr, flags) {}
Node* LoadFromPointer(void* address, MachineType rep, int32_t offset = 0) {
return this->Load(rep, this->PointerConstant(address),
CallDescriptor* call_descriptor = this->call_descriptor();
Graph* graph = this->graph();
CompilationInfo info(graph->zone()->isolate(), graph->zone());
- Linkage linkage(&info, call_descriptor);
+ Linkage linkage(graph->zone(), call_descriptor);
Pipeline pipeline(&info);
code_ = pipeline.GenerateCodeForMachineGraph(&linkage, graph, schedule);
}
MachineType p3 = kMachNone,
MachineType p4 = kMachNone)
: MachineAssemblerTester<RawMachineAssembler>(
- ReturnValueTraits<ReturnType>::Representation(), p0, p1, p2, p3,
- p4) {}
+ ReturnValueTraits<ReturnType>::Representation(), p0, p1, p2, p3, p4,
+ InstructionSelector::SupportedMachineOperatorFlags()) {}
template <typename Ci, typename Fn>
void Run(const Ci& ci, const Fn& fn) {
#include "src/v8.h"
#include "test/cctest/cctest.h"
+#include "src/ast-numbering.h"
#include "src/compiler.h"
+#include "src/compiler/linkage.h"
#include "src/compiler/pipeline.h"
#include "src/execution.h"
#include "src/full-codegen.h"
CHECK_EQ(0, flags_ & ~supported_flags);
}
+ explicit FunctionTester(Graph* graph)
+ : isolate(main_isolate()),
+ function(NewFunction("(function(a,b){})")),
+ flags_(0) {
+ CompileGraph(graph);
+ }
+
Isolate* isolate;
Handle<JSFunction> function;
- Handle<JSFunction> Compile(Handle<JSFunction> function) {
-#if V8_TURBOFAN_TARGET
- CompilationInfoWithZone info(function);
-
- CHECK(Parser::Parse(&info));
- info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
- if (flags_ & CompilationInfo::kContextSpecializing) {
- info.MarkAsContextSpecializing();
- }
- if (flags_ & CompilationInfo::kInliningEnabled) {
- info.MarkAsInliningEnabled();
- }
- if (flags_ & CompilationInfo::kTypingEnabled) {
- info.MarkAsTypingEnabled();
- }
- CHECK(Rewriter::Rewrite(&info));
- CHECK(Scope::Analyze(&info));
- CHECK(Compiler::EnsureDeoptimizationSupport(&info));
-
- Pipeline pipeline(&info);
- Handle<Code> code = pipeline.GenerateCode();
- if (FLAG_turbo_deoptimization) {
- info.context()->native_context()->AddOptimizedCode(*code);
- }
-
- CHECK(!code.is_null());
- function->ReplaceCode(*code);
-#elif USE_CRANKSHAFT
- Handle<Code> unoptimized = Handle<Code>(function->code());
- Handle<Code> code = Compiler::GetOptimizedCode(function, unoptimized,
- Compiler::NOT_CONCURRENT);
- CHECK(!code.is_null());
-#if ENABLE_DISASSEMBLER
- if (FLAG_print_opt_code) {
- CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
- code->Disassemble("test code", tracing_scope.file());
- }
-#endif
- function->ReplaceCode(*code);
-#endif
- return function;
- }
-
MaybeHandle<Object> Call(Handle<Object> a, Handle<Object> b) {
Handle<Object> args[] = {a, b};
return Execution::Call(isolate, function, undefined(), 2, args, false);
Handle<Object> false_value() { return isolate->factory()->false_value(); }
+ Handle<JSFunction> Compile(Handle<JSFunction> function) {
+// TODO(titzer): make this method private.
+#if V8_TURBOFAN_TARGET
+ CompilationInfoWithZone info(function);
+
+ CHECK(Parser::Parse(&info));
+ info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
+ if (flags_ & CompilationInfo::kContextSpecializing) {
+ info.MarkAsContextSpecializing();
+ }
+ if (flags_ & CompilationInfo::kInliningEnabled) {
+ info.MarkAsInliningEnabled();
+ }
+ if (flags_ & CompilationInfo::kTypingEnabled) {
+ info.MarkAsTypingEnabled();
+ }
+ CHECK(Compiler::Analyze(&info));
+ CHECK(Compiler::EnsureDeoptimizationSupport(&info));
+
+ Pipeline pipeline(&info);
+ Handle<Code> code = pipeline.GenerateCode();
+ if (FLAG_turbo_deoptimization) {
+ info.context()->native_context()->AddOptimizedCode(*code);
+ }
+
+ CHECK(!code.is_null());
+ function->ReplaceCode(*code);
+#elif USE_CRANKSHAFT
+ Handle<Code> unoptimized = Handle<Code>(function->code());
+ Handle<Code> code = Compiler::GetOptimizedCode(function, unoptimized,
+ Compiler::NOT_CONCURRENT);
+ CHECK(!code.is_null());
+#if ENABLE_DISASSEMBLER
+ if (FLAG_print_opt_code) {
+ CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
+ code->Disassemble("test code", tracing_scope.file());
+ }
+#endif
+ function->ReplaceCode(*code);
+#endif
+ return function;
+ }
+
+ static Handle<JSFunction> ForMachineGraph(Graph* graph) {
+ JSFunction* p = NULL;
+ { // because of the implicit handle scope of FunctionTester.
+ FunctionTester f(graph);
+ p = *f.function;
+ }
+ return Handle<JSFunction>(p); // allocated in outer handle scope.
+ }
+
private:
uint32_t flags_;
+
+ // 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) {
+ CHECK(Pipeline::SupportedTarget());
+ CompilationInfoWithZone info(function);
+
+ CHECK(Parser::Parse(&info));
+ info.SetOptimizing(BailoutId::None(),
+ Handle<Code>(function->shared()->code()));
+ CHECK(Compiler::Analyze(&info));
+ CHECK(Compiler::EnsureDeoptimizationSupport(&info));
+
+ Pipeline pipeline(&info);
+ Linkage linkage(info.zone(), &info);
+ Handle<Code> code = pipeline.GenerateCodeForMachineGraph(&linkage, graph);
+ CHECK(!code.is_null());
+ function->ReplaceCode(*code);
+ return function;
+ }
};
}
}
if (code_.is_null()) {
Zone* zone = graph_->zone();
CompilationInfo info(zone->isolate(), zone);
- Linkage linkage(&info,
+ Linkage linkage(zone,
Linkage::GetSimplifiedCDescriptor(zone, machine_sig_));
Pipeline pipeline(&info);
code_ = pipeline.GenerateCodeForMachineGraph(&linkage, graph_);
protected:
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs) FINAL {
- return graph()->NewNode(op, value_input_count, value_inputs);
+ Node** value_inputs, bool incomplete) FINAL {
+ return graph()->NewNode(op, value_input_count, value_inputs, incomplete);
}
};
Node* SimplifiedGraphBuilder::MakeNode(const Operator* op,
int value_input_count,
- Node** value_inputs) {
+ Node** value_inputs, bool incomplete) {
DCHECK(op->InputCount() == value_input_count);
DCHECK(!OperatorProperties::HasContextInput(op));
DCHECK(!OperatorProperties::HasFrameStateInput(op));
- bool has_control = OperatorProperties::GetControlInputCount(op) == 1;
- bool has_effect = OperatorProperties::GetEffectInputCount(op) == 1;
+ bool has_control = op->ControlInputCount() == 1;
+ bool has_effect = op->EffectInputCount() == 1;
- DCHECK(OperatorProperties::GetControlInputCount(op) < 2);
- DCHECK(OperatorProperties::GetEffectInputCount(op) < 2);
+ DCHECK(op->ControlInputCount() < 2);
+ DCHECK(op->EffectInputCount() < 2);
Node* result = NULL;
if (!has_control && !has_effect) {
- result = graph()->NewNode(op, value_input_count, value_inputs);
+ result = graph()->NewNode(op, value_input_count, value_inputs, incomplete);
} else {
int input_count_with_deps = value_input_count;
if (has_control) ++input_count_with_deps;
if (has_control) {
*current_input++ = graph()->start();
}
- result = graph()->NewNode(op, input_count_with_deps, buffer);
+ result = graph()->NewNode(op, input_count_with_deps, buffer, incomplete);
if (has_effect) {
effect_ = result;
}
- if (OperatorProperties::HasControlOutput(result->op())) {
- // This graph builder does not support control flow.
- UNREACHABLE();
- }
+ // This graph builder does not support control flow.
+ CHECK_EQ(0, op->ControlOutputCount());
}
return result;
Node* Int32Constant(int32_t value) {
return NewNode(common()->Int32Constant(value));
}
- Node* HeapConstant(Handle<Object> object) {
- Unique<Object> val = Unique<Object>::CreateUninitialized(object);
+ Node* HeapConstant(Handle<HeapObject> object) {
+ Unique<HeapObject> val = Unique<HeapObject>::CreateUninitialized(object);
return NewNode(common()->HeapConstant(val));
}
protected:
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs) FINAL;
+ Node** value_inputs, bool incomplete) FINAL;
private:
Node* effect_;
#include "src/compiler/js-graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/pipeline.h"
-#include "src/compiler/typer.h"
+#include "src/compiler/select-lowering.h"
+#include "src/compiler/simplified-lowering.h"
#include "src/compiler/verifier.h"
#include "src/execution.h"
#include "src/globals.h"
#include "src/scopes.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/function-tester.h"
#include "test/cctest/compiler/graph-builder-tester.h"
#include "test/cctest/compiler/value-helper.h"
public:
explicit ChangesLoweringTester(MachineType p0 = kMachNone)
: GraphBuilderTester<ReturnType>(p0),
- typer(this->zone()),
javascript(this->zone()),
- jsgraph(this->graph(), this->common(), &javascript, &typer,
- this->machine()),
+ jsgraph(this->graph(), this->common(), &javascript, this->machine()),
function(Handle<JSFunction>::null()) {}
- Typer typer;
JSOperatorBuilder javascript;
JSGraph jsgraph;
Handle<JSFunction> function;
template <typename T>
T* CallWithPotentialGC() {
- // TODO(titzer): we need to wrap the code in a JSFunction and call it via
- // Execution::Call() so that the GC knows about the frame, can walk it,
- // relocate the code object if necessary, etc.
- // This is pretty ugly and at the least should be moved up to helpers.
+ // TODO(titzer): we wrap the code in a JSFunction here to reuse the
+ // JSEntryStub; that could be done with a special prologue or other stub.
if (function.is_null()) {
- function =
- v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(CompileRun(
- "(function() { 'use strict'; return 2.7123; })")));
- CompilationInfoWithZone info(function);
- CHECK(Parser::Parse(&info));
- info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
- CHECK(Rewriter::Rewrite(&info));
- CHECK(Scope::Analyze(&info));
- CHECK_NE(NULL, info.scope());
- Handle<ScopeInfo> scope_info =
- ScopeInfo::Create(info.scope(), info.zone());
- info.shared_info()->set_scope_info(*scope_info);
- Pipeline pipeline(&info);
- Linkage linkage(&info);
- Handle<Code> code =
- pipeline.GenerateCodeForMachineGraph(&linkage, this->graph());
- CHECK(!code.is_null());
- function->ReplaceCode(*code);
+ function = FunctionTester::ForMachineGraph(this->graph());
}
Handle<Object>* args = NULL;
MaybeHandle<Object> result =
void* location) {
// We build a graph by hand here, because the raw machine assembler
// does not add the correct control and effect nodes.
- Node* load =
- this->graph()->NewNode(load_op, this->PointerConstant(location),
- this->Int32Constant(0), this->start());
+ Node* load = this->graph()->NewNode(
+ load_op, this->PointerConstant(location), this->Int32Constant(0),
+ this->start(), this->start());
Node* change = this->graph()->NewNode(op, load);
Node* ret = this->graph()->NewNode(this->common()->Return(), change,
this->start(), this->start());
void LowerChange(Node* change) {
// Run the graph reducer with changes lowering on a single node.
CompilationInfo info(this->isolate(), this->zone());
- Linkage linkage(&info);
- ChangeLowering lowering(&jsgraph, &linkage);
+ Linkage linkage(this->zone(), &info);
+ ChangeLowering change_lowering(&jsgraph, &linkage);
+ SelectLowering select_lowering(this->graph(), this->common());
GraphReducer reducer(this->graph());
- reducer.AddReducer(&lowering);
+ reducer.AddReducer(&change_lowering);
+ reducer.AddReducer(&select_lowering);
reducer.ReduceNode(change);
- Verifier::Run(this->graph());
+ Verifier::Run(this->graph(), Verifier::UNTYPED);
}
Factory* factory() { return this->isolate()->factory(); }
#include "src/compiler/register-allocator.h"
#include "src/compiler/schedule.h"
+#include "src/ast-numbering.h"
#include "src/full-codegen.h"
#include "src/parser.h"
#include "src/rewriter.h"
#if V8_TURBOFAN_TARGET
typedef RawMachineAssembler::Label MLabel;
+typedef v8::internal::compiler::InstructionSequence TestInstrSeq;
static Handle<JSFunction> NewFunction(const char* source) {
return v8::Utils::OpenHandle(
bailout_id(-1) {
CHECK(Parser::Parse(&info));
info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
- CHECK(Rewriter::Rewrite(&info));
- CHECK(Scope::Analyze(&info));
+ CHECK(Compiler::Analyze(&info));
CHECK(Compiler::EnsureDeoptimizationSupport(&info));
DCHECK(info.shared_info()->has_deoptimization_support());
}
// Initialize the codegen and generate code.
- Linkage* linkage = new (scope_->main_zone()) Linkage(&info);
- code = new v8::internal::compiler::InstructionSequence(linkage, graph,
- schedule);
+ Linkage* linkage = new (scope_->main_zone()) Linkage(info.zone(), &info);
+ InstructionBlocks* instruction_blocks =
+ TestInstrSeq::InstructionBlocksFor(scope_->main_zone(), schedule);
+ code = new TestInstrSeq(scope_->main_zone(), instruction_blocks);
SourcePositionTable source_positions(graph);
- InstructionSelector selector(code, &source_positions);
+ InstructionSelector selector(scope_->main_zone(), graph, linkage, code,
+ schedule, &source_positions);
selector.SelectInstructions();
if (FLAG_trace_turbo) {
+ PrintableInstructionSequence printable = {
+ RegisterConfiguration::ArchDefault(), code};
os << "----- Instruction sequence before register allocation -----\n"
- << *code;
+ << printable;
}
- RegisterAllocator allocator(code);
+ Frame frame;
+ RegisterAllocator allocator(RegisterConfiguration::ArchDefault(),
+ scope_->main_zone(), &frame, code);
CHECK(allocator.Allocate());
if (FLAG_trace_turbo) {
+ PrintableInstructionSequence printable = {
+ RegisterConfiguration::ArchDefault(), code};
os << "----- Instruction sequence after register allocation -----\n"
- << *code;
+ << printable;
}
- compiler::CodeGenerator generator(code);
+ compiler::CodeGenerator generator(&frame, linkage, code, &info);
result_code = generator.GenerateCode();
#ifdef OBJECT_PRINT
CompilationInfo info;
BailoutId bailout_id;
Handle<Code> result_code;
- v8::internal::compiler::InstructionSequence* code;
+ TestInstrSeq* code;
Graph* graph;
};
Handle<JSFunction> deopt_function =
NewFunction("function deopt() { %DeoptimizeFunction(foo); }; deopt");
- Unique<Object> deopt_fun_constant =
- Unique<Object>::CreateUninitialized(deopt_function);
+ Unique<JSFunction> deopt_fun_constant =
+ Unique<JSFunction>::CreateUninitialized(deopt_function);
Node* deopt_fun_node = m.NewNode(common.HeapConstant(deopt_fun_constant));
Handle<Context> caller_context(function->context(), CcTest::i_isolate());
- Unique<Object> caller_context_constant =
- Unique<Object>::CreateUninitialized(caller_context);
+ Unique<Context> caller_context_constant =
+ Unique<Context>::CreateUninitialized(caller_context);
Node* caller_context_node =
m.NewNode(common.HeapConstant(caller_context_constant));
Node* stack = m.NewNode(common.StateValues(0));
Node* state_node = m.NewNode(
- common.FrameState(JS_FRAME, bailout_id, kIgnoreOutput), parameters,
- locals, stack, caller_context_node, m.UndefinedConstant());
+ common.FrameState(JS_FRAME, bailout_id,
+ OutputFrameStateCombine::Ignore()),
+ parameters, locals, stack, caller_context_node, m.UndefinedConstant());
Handle<Context> context(deopt_function->context(), CcTest::i_isolate());
- Unique<Object> context_constant =
- Unique<Object>::CreateUninitialized(context);
+ Unique<Context> context_constant =
+ Unique<Context>::CreateUninitialized(context);
Node* context_node = m.NewNode(common.HeapConstant(context_constant));
m.CallJS0(deopt_fun_node, m.UndefinedConstant(), context_node, state_node);
CSignature1<Object*, Object*> sig;
RawMachineAssembler m(graph, &sig);
- Unique<Object> this_fun_constant =
- Unique<Object>::CreateUninitialized(function);
+ Unique<HeapObject> this_fun_constant =
+ Unique<HeapObject>::CreateUninitialized(function);
Node* this_fun_node = m.NewNode(common.HeapConstant(this_fun_constant));
Handle<Context> context(function->context(), CcTest::i_isolate());
- Unique<Object> context_constant =
- Unique<Object>::CreateUninitialized(context);
+ Unique<HeapObject> context_constant =
+ Unique<HeapObject>::CreateUninitialized(context);
Node* context_node = m.NewNode(common.HeapConstant(context_constant));
bailout_id = GetCallBailoutId();
Node* stack = m.NewNode(common.StateValues(0));
Node* state_node = m.NewNode(
- common.FrameState(JS_FRAME, bailout_id, kIgnoreOutput), parameters,
- locals, stack, context_node, m.UndefinedConstant());
+ common.FrameState(JS_FRAME, bailout_id,
+ OutputFrameStateCombine::Ignore()),
+ parameters, locals, stack, context_node, m.UndefinedConstant());
m.CallRuntime1(Runtime::kDeoptimizeFunction, this_fun_node, context_node,
state_node);
--- /dev/null
+// 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/v8.h"
+#include "test/cctest/cctest.h"
+
+#include "src/base/bits.h"
+#include "src/compiler/common-operator.h"
+#include "src/compiler/control-reducer.h"
+#include "src/compiler/graph-inl.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/node-properties-inl.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+static const size_t kNumLeafs = 4;
+
+// TODO(titzer): convert this whole file into unit tests.
+
+static int CheckInputs(Node* node, Node* i0 = NULL, Node* i1 = NULL,
+ Node* i2 = NULL) {
+ int count = 3;
+ if (i2 == NULL) count = 2;
+ if (i1 == NULL) count = 1;
+ if (i0 == NULL) count = 0;
+ CHECK_EQ(count, node->InputCount());
+ if (i0 != NULL) CHECK_EQ(i0, node->InputAt(0));
+ if (i1 != NULL) CHECK_EQ(i1, node->InputAt(1));
+ if (i2 != NULL) CHECK_EQ(i2, node->InputAt(2));
+ return count;
+}
+
+
+static int CheckMerge(Node* node, Node* i0 = NULL, Node* i1 = NULL,
+ Node* i2 = NULL) {
+ CHECK_EQ(IrOpcode::kMerge, node->opcode());
+ int count = CheckInputs(node, i0, i1, i2);
+ CHECK_EQ(count, node->op()->ControlInputCount());
+ return count;
+}
+
+
+static int CheckLoop(Node* node, Node* i0 = NULL, Node* i1 = NULL,
+ Node* i2 = NULL) {
+ CHECK_EQ(IrOpcode::kLoop, node->opcode());
+ int count = CheckInputs(node, i0, i1, i2);
+ CHECK_EQ(count, node->op()->ControlInputCount());
+ return count;
+}
+
+
+bool IsUsedBy(Node* a, Node* b) {
+ for (UseIter i = a->uses().begin(); i != a->uses().end(); ++i) {
+ if (b == *i) return true;
+ }
+ return false;
+}
+
+
+// A helper for all tests dealing with ControlTester.
+class ControlReducerTester : HandleAndZoneScope {
+ public:
+ ControlReducerTester()
+ : isolate(main_isolate()),
+ common(main_zone()),
+ graph(main_zone()),
+ jsgraph(&graph, &common, NULL, NULL),
+ start(graph.NewNode(common.Start(1))),
+ end(graph.NewNode(common.End(), start)),
+ p0(graph.NewNode(common.Parameter(0), start)),
+ zero(jsgraph.Int32Constant(0)),
+ one(jsgraph.OneConstant()),
+ half(jsgraph.Constant(0.5)),
+ self(graph.NewNode(common.Int32Constant(0xaabbccdd))),
+ dead(graph.NewNode(common.Dead())) {
+ graph.SetEnd(end);
+ graph.SetStart(start);
+ leaf[0] = zero;
+ leaf[1] = one;
+ leaf[2] = half;
+ leaf[3] = p0;
+ }
+
+ Isolate* isolate;
+ CommonOperatorBuilder common;
+ Graph graph;
+ JSGraph jsgraph;
+ Node* start;
+ Node* end;
+ Node* p0;
+ Node* zero;
+ Node* one;
+ Node* half;
+ Node* self;
+ Node* dead;
+ Node* leaf[kNumLeafs];
+
+ Node* Phi(Node* a) {
+ return SetSelfReferences(graph.NewNode(op(1, false), a, start));
+ }
+
+ Node* Phi(Node* a, Node* b) {
+ return SetSelfReferences(graph.NewNode(op(2, false), a, b, start));
+ }
+
+ Node* Phi(Node* a, Node* b, Node* c) {
+ return SetSelfReferences(graph.NewNode(op(3, false), a, b, c, start));
+ }
+
+ Node* Phi(Node* a, Node* b, Node* c, Node* d) {
+ return SetSelfReferences(graph.NewNode(op(4, false), a, b, c, d, start));
+ }
+
+ Node* EffectPhi(Node* a) {
+ return SetSelfReferences(graph.NewNode(op(1, true), a, start));
+ }
+
+ Node* EffectPhi(Node* a, Node* b) {
+ return SetSelfReferences(graph.NewNode(op(2, true), a, b, start));
+ }
+
+ Node* EffectPhi(Node* a, Node* b, Node* c) {
+ return SetSelfReferences(graph.NewNode(op(3, true), a, b, c, start));
+ }
+
+ Node* EffectPhi(Node* a, Node* b, Node* c, Node* d) {
+ return SetSelfReferences(graph.NewNode(op(4, true), a, b, c, d, start));
+ }
+
+ Node* SetSelfReferences(Node* node) {
+ Node::Inputs inputs = node->inputs();
+ for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
+ ++iter) {
+ Node* input = *iter;
+ if (input == self) node->ReplaceInput(iter.index(), node);
+ }
+ return node;
+ }
+
+ const Operator* op(int count, bool effect) {
+ return effect ? common.EffectPhi(count) : common.Phi(kMachAnyTagged, count);
+ }
+
+ void Trim() { ControlReducer::TrimGraph(main_zone(), &jsgraph); }
+
+ void ReduceGraph() {
+ ControlReducer::ReduceGraph(main_zone(), &jsgraph, &common);
+ }
+
+ // Checks one-step reduction of a phi.
+ void ReducePhi(Node* expect, Node* phi) {
+ Node* result = ControlReducer::ReducePhiForTesting(&jsgraph, &common, phi);
+ CHECK_EQ(expect, result);
+ ReducePhiIterative(expect, phi); // iterative should give the same result.
+ }
+
+ void ReducePhiIterative(Node* expect, Node* phi) {
+ p0->ReplaceInput(0, start); // hack: parameters may be trimmed.
+ Node* ret = graph.NewNode(common.Return(), phi, start, start);
+ Node* end = graph.NewNode(common.End(), ret);
+ graph.SetEnd(end);
+ ControlReducer::ReduceGraph(main_zone(), &jsgraph, &common);
+ CheckInputs(end, ret);
+ CheckInputs(ret, expect, start, start);
+ }
+
+ void ReduceMerge(Node* expect, Node* merge) {
+ Node* result =
+ ControlReducer::ReduceMergeForTesting(&jsgraph, &common, merge);
+ CHECK_EQ(expect, result);
+ }
+
+ void ReduceMergeIterative(Node* expect, Node* merge) {
+ p0->ReplaceInput(0, start); // hack: parameters may be trimmed.
+ Node* end = graph.NewNode(common.End(), merge);
+ graph.SetEnd(end);
+ ReduceGraph();
+ CheckInputs(end, expect);
+ }
+
+ void ReduceBranch(Node* expect, Node* branch) {
+ Node* result =
+ ControlReducer::ReduceBranchForTesting(&jsgraph, &common, branch);
+ CHECK_EQ(expect, result);
+ }
+
+ Node* Return(Node* val, Node* effect, Node* control) {
+ Node* ret = graph.NewNode(common.Return(), val, effect, control);
+ end->ReplaceInput(0, ret);
+ return ret;
+ }
+};
+
+
+TEST(Trim1_live) {
+ ControlReducerTester T;
+ CHECK(IsUsedBy(T.start, T.p0));
+ T.graph.SetEnd(T.p0);
+ T.Trim();
+ CHECK(IsUsedBy(T.start, T.p0));
+ CheckInputs(T.p0, T.start);
+}
+
+
+TEST(Trim1_dead) {
+ ControlReducerTester T;
+ CHECK(IsUsedBy(T.start, T.p0));
+ T.Trim();
+ CHECK(!IsUsedBy(T.start, T.p0));
+ CHECK_EQ(NULL, T.p0->InputAt(0));
+}
+
+
+TEST(Trim2_live) {
+ ControlReducerTester T;
+ Node* phi =
+ T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), T.one, T.half, T.start);
+ CHECK(IsUsedBy(T.one, phi));
+ CHECK(IsUsedBy(T.half, phi));
+ CHECK(IsUsedBy(T.start, phi));
+ T.graph.SetEnd(phi);
+ T.Trim();
+ CHECK(IsUsedBy(T.one, phi));
+ CHECK(IsUsedBy(T.half, phi));
+ CHECK(IsUsedBy(T.start, phi));
+ CheckInputs(phi, T.one, T.half, T.start);
+}
+
+
+TEST(Trim2_dead) {
+ ControlReducerTester T;
+ Node* phi =
+ T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), T.one, T.half, T.start);
+ CHECK(IsUsedBy(T.one, phi));
+ CHECK(IsUsedBy(T.half, phi));
+ CHECK(IsUsedBy(T.start, phi));
+ T.Trim();
+ CHECK(!IsUsedBy(T.one, phi));
+ CHECK(!IsUsedBy(T.half, phi));
+ CHECK(!IsUsedBy(T.start, phi));
+ CHECK_EQ(NULL, phi->InputAt(0));
+ CHECK_EQ(NULL, phi->InputAt(1));
+ CHECK_EQ(NULL, phi->InputAt(2));
+}
+
+
+TEST(Trim_chain1) {
+ ControlReducerTester T;
+ const int kDepth = 15;
+ Node* live[kDepth];
+ Node* dead[kDepth];
+ Node* end = T.start;
+ for (int i = 0; i < kDepth; i++) {
+ live[i] = end = T.graph.NewNode(T.common.Merge(1), end);
+ dead[i] = T.graph.NewNode(T.common.Merge(1), end);
+ }
+ // end -> live[last] -> live[last-1] -> ... -> start
+ // dead[last] ^ dead[last-1] ^ ... ^
+ T.graph.SetEnd(end);
+ T.Trim();
+ for (int i = 0; i < kDepth; i++) {
+ CHECK(!IsUsedBy(live[i], dead[i]));
+ CHECK_EQ(NULL, dead[i]->InputAt(0));
+ CHECK_EQ(i == 0 ? T.start : live[i - 1], live[i]->InputAt(0));
+ }
+}
+
+
+TEST(Trim_chain2) {
+ ControlReducerTester T;
+ const int kDepth = 15;
+ Node* live[kDepth];
+ Node* dead[kDepth];
+ Node* l = T.start;
+ Node* d = T.start;
+ for (int i = 0; i < kDepth; i++) {
+ live[i] = l = T.graph.NewNode(T.common.Merge(1), l);
+ dead[i] = d = T.graph.NewNode(T.common.Merge(1), d);
+ }
+ // end -> live[last] -> live[last-1] -> ... -> start
+ // dead[last] -> dead[last-1] -> ... -> start
+ T.graph.SetEnd(l);
+ T.Trim();
+ CHECK(!IsUsedBy(T.start, dead[0]));
+ for (int i = 0; i < kDepth; i++) {
+ CHECK_EQ(i == 0 ? NULL : dead[i - 1], dead[i]->InputAt(0));
+ CHECK_EQ(i == 0 ? T.start : live[i - 1], live[i]->InputAt(0));
+ }
+}
+
+
+TEST(Trim_cycle1) {
+ ControlReducerTester T;
+ Node* loop = T.graph.NewNode(T.common.Loop(1), T.start, T.start);
+ loop->ReplaceInput(1, loop);
+ Node* end = T.graph.NewNode(T.common.End(), loop);
+ T.graph.SetEnd(end);
+
+ CHECK(IsUsedBy(T.start, loop));
+ CHECK(IsUsedBy(loop, end));
+ CHECK(IsUsedBy(loop, loop));
+
+ T.Trim();
+
+ // nothing should have happened to the loop itself.
+ CHECK(IsUsedBy(T.start, loop));
+ CHECK(IsUsedBy(loop, end));
+ CHECK(IsUsedBy(loop, loop));
+ CheckInputs(loop, T.start, loop);
+ CheckInputs(end, loop);
+}
+
+
+TEST(Trim_cycle2) {
+ ControlReducerTester T;
+ Node* loop = T.graph.NewNode(T.common.Loop(2), T.start, T.start);
+ loop->ReplaceInput(1, loop);
+ Node* end = T.graph.NewNode(T.common.End(), loop);
+ Node* phi =
+ T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), T.one, T.half, loop);
+ T.graph.SetEnd(end);
+
+ CHECK(IsUsedBy(T.start, loop));
+ CHECK(IsUsedBy(loop, end));
+ CHECK(IsUsedBy(loop, loop));
+ CHECK(IsUsedBy(loop, phi));
+ CHECK(IsUsedBy(T.one, phi));
+ CHECK(IsUsedBy(T.half, phi));
+
+ T.Trim();
+
+ // nothing should have happened to the loop itself.
+ CHECK(IsUsedBy(T.start, loop));
+ CHECK(IsUsedBy(loop, end));
+ CHECK(IsUsedBy(loop, loop));
+ CheckInputs(loop, T.start, loop);
+ CheckInputs(end, loop);
+
+ // phi should have been trimmed away.
+ CHECK(!IsUsedBy(loop, phi));
+ CHECK(!IsUsedBy(T.one, phi));
+ CHECK(!IsUsedBy(T.half, phi));
+ CHECK_EQ(NULL, phi->InputAt(0));
+ CHECK_EQ(NULL, phi->InputAt(1));
+ CHECK_EQ(NULL, phi->InputAt(2));
+}
+
+
+void CheckTrimConstant(ControlReducerTester* T, Node* k) {
+ Node* phi = T->graph.NewNode(T->common.Phi(kMachInt32, 1), k, T->start);
+ CHECK(IsUsedBy(k, phi));
+ T->Trim();
+ CHECK(!IsUsedBy(k, phi));
+ CHECK_EQ(NULL, phi->InputAt(0));
+ CHECK_EQ(NULL, phi->InputAt(1));
+}
+
+
+TEST(Trim_constants) {
+ ControlReducerTester T;
+ int32_t int32_constants[] = {
+ 0, -1, -2, 2, 2, 3, 3, 4, 4, 5, 5, 4, 5, 6, 6, 7, 8, 7, 8, 9,
+ 0, -11, -12, 12, 12, 13, 13, 14, 14, 15, 15, 14, 15, 6, 6, 7, 8, 7, 8, 9};
+
+ for (size_t i = 0; i < arraysize(int32_constants); i++) {
+ CheckTrimConstant(&T, T.jsgraph.Int32Constant(int32_constants[i]));
+ CheckTrimConstant(&T, T.jsgraph.Float64Constant(int32_constants[i]));
+ CheckTrimConstant(&T, T.jsgraph.Constant(int32_constants[i]));
+ }
+
+ Node* other_constants[] = {
+ T.jsgraph.UndefinedConstant(), T.jsgraph.TheHoleConstant(),
+ T.jsgraph.TrueConstant(), T.jsgraph.FalseConstant(),
+ T.jsgraph.NullConstant(), T.jsgraph.ZeroConstant(),
+ T.jsgraph.OneConstant(), T.jsgraph.NaNConstant(),
+ T.jsgraph.Constant(21), T.jsgraph.Constant(22.2)};
+
+ for (size_t i = 0; i < arraysize(other_constants); i++) {
+ CheckTrimConstant(&T, other_constants[i]);
+ }
+}
+
+
+TEST(CReducePhi1) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.Phi(R.leaf[0]));
+ R.ReducePhi(R.leaf[1], R.Phi(R.leaf[1]));
+ R.ReducePhi(R.leaf[2], R.Phi(R.leaf[2]));
+ R.ReducePhi(R.leaf[3], R.Phi(R.leaf[3]));
+}
+
+
+TEST(CReducePhi1_dead) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.Phi(R.leaf[0], R.dead));
+ R.ReducePhi(R.leaf[1], R.Phi(R.leaf[1], R.dead));
+ R.ReducePhi(R.leaf[2], R.Phi(R.leaf[2], R.dead));
+ R.ReducePhi(R.leaf[3], R.Phi(R.leaf[3], R.dead));
+
+ R.ReducePhi(R.leaf[0], R.Phi(R.dead, R.leaf[0]));
+ R.ReducePhi(R.leaf[1], R.Phi(R.dead, R.leaf[1]));
+ R.ReducePhi(R.leaf[2], R.Phi(R.dead, R.leaf[2]));
+ R.ReducePhi(R.leaf[3], R.Phi(R.dead, R.leaf[3]));
+}
+
+
+TEST(CReducePhi1_dead2) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.Phi(R.leaf[0], R.dead, R.dead));
+ R.ReducePhi(R.leaf[0], R.Phi(R.dead, R.leaf[0], R.dead));
+ R.ReducePhi(R.leaf[0], R.Phi(R.dead, R.dead, R.leaf[0]));
+}
+
+
+TEST(CReducePhi2a) {
+ ControlReducerTester R;
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(a, a));
+ }
+}
+
+
+TEST(CReducePhi2b) {
+ ControlReducerTester R;
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(R.self, a));
+ R.ReducePhi(a, R.Phi(a, R.self));
+ }
+}
+
+
+TEST(CReducePhi2c) {
+ ControlReducerTester R;
+
+ for (size_t i = 1; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i], *b = R.leaf[0];
+ Node* phi1 = R.Phi(b, a);
+ R.ReducePhi(phi1, phi1);
+
+ Node* phi2 = R.Phi(a, b);
+ R.ReducePhi(phi2, phi2);
+ }
+}
+
+
+TEST(CReducePhi2_dead) {
+ ControlReducerTester R;
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(a, a, R.dead));
+ R.ReducePhi(a, R.Phi(a, R.dead, a));
+ R.ReducePhi(a, R.Phi(R.dead, a, a));
+ }
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(R.self, a));
+ R.ReducePhi(a, R.Phi(a, R.self));
+ R.ReducePhi(a, R.Phi(R.self, a, R.dead));
+ R.ReducePhi(a, R.Phi(a, R.self, R.dead));
+ }
+
+ for (size_t i = 1; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i], *b = R.leaf[0];
+ Node* phi1 = R.Phi(b, a, R.dead);
+ R.ReducePhi(phi1, phi1);
+
+ Node* phi2 = R.Phi(a, b, R.dead);
+ R.ReducePhi(phi2, phi2);
+ }
+}
+
+
+TEST(CReducePhi3) {
+ ControlReducerTester R;
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(a, a, a));
+ }
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(R.self, a, a));
+ R.ReducePhi(a, R.Phi(a, R.self, a));
+ R.ReducePhi(a, R.Phi(a, a, R.self));
+ }
+
+ for (size_t i = 1; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i], *b = R.leaf[0];
+ Node* phi1 = R.Phi(b, a, a);
+ R.ReducePhi(phi1, phi1);
+
+ Node* phi2 = R.Phi(a, b, a);
+ R.ReducePhi(phi2, phi2);
+
+ Node* phi3 = R.Phi(a, a, b);
+ R.ReducePhi(phi3, phi3);
+ }
+}
+
+
+TEST(CReducePhi4) {
+ ControlReducerTester R;
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(a, a, a, a));
+ }
+
+ for (size_t i = 0; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i];
+ R.ReducePhi(a, R.Phi(R.self, a, a, a));
+ R.ReducePhi(a, R.Phi(a, R.self, a, a));
+ R.ReducePhi(a, R.Phi(a, a, R.self, a));
+ R.ReducePhi(a, R.Phi(a, a, a, R.self));
+
+ R.ReducePhi(a, R.Phi(R.self, R.self, a, a));
+ R.ReducePhi(a, R.Phi(a, R.self, R.self, a));
+ R.ReducePhi(a, R.Phi(a, a, R.self, R.self));
+ R.ReducePhi(a, R.Phi(R.self, a, a, R.self));
+ }
+
+ for (size_t i = 1; i < kNumLeafs; i++) {
+ Node* a = R.leaf[i], *b = R.leaf[0];
+ Node* phi1 = R.Phi(b, a, a, a);
+ R.ReducePhi(phi1, phi1);
+
+ Node* phi2 = R.Phi(a, b, a, a);
+ R.ReducePhi(phi2, phi2);
+
+ Node* phi3 = R.Phi(a, a, b, a);
+ R.ReducePhi(phi3, phi3);
+
+ Node* phi4 = R.Phi(a, a, a, b);
+ R.ReducePhi(phi4, phi4);
+ }
+}
+
+
+TEST(CReducePhi_iterative1) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.leaf[0], R.Phi(R.leaf[0])));
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.Phi(R.leaf[0]), R.leaf[0]));
+}
+
+
+TEST(CReducePhi_iterative2) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.Phi(R.leaf[0]), R.Phi(R.leaf[0])));
+}
+
+
+TEST(CReducePhi_iterative3) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(R.leaf[0],
+ R.Phi(R.leaf[0], R.Phi(R.leaf[0], R.leaf[0])));
+ R.ReducePhiIterative(R.leaf[0],
+ R.Phi(R.Phi(R.leaf[0], R.leaf[0]), R.leaf[0]));
+}
+
+
+TEST(CReducePhi_iterative4) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.Phi(R.leaf[0], R.leaf[0]),
+ R.Phi(R.leaf[0], R.leaf[0])));
+
+ Node* p1 = R.Phi(R.leaf[0], R.leaf[0]);
+ R.ReducePhiIterative(R.leaf[0], R.Phi(p1, p1));
+
+ Node* p2 = R.Phi(R.leaf[0], R.leaf[0], R.leaf[0]);
+ R.ReducePhiIterative(R.leaf[0], R.Phi(p2, p2, p2));
+
+ Node* p3 = R.Phi(R.leaf[0], R.leaf[0], R.leaf[0]);
+ R.ReducePhiIterative(R.leaf[0], R.Phi(p3, p3, R.leaf[0]));
+}
+
+
+TEST(CReducePhi_iterative_self1) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.leaf[0], R.Phi(R.leaf[0], R.self)));
+ R.ReducePhiIterative(R.leaf[0], R.Phi(R.Phi(R.leaf[0], R.self), R.leaf[0]));
+}
+
+
+TEST(CReducePhi_iterative_self2) {
+ ControlReducerTester R;
+
+ R.ReducePhiIterative(
+ R.leaf[0], R.Phi(R.Phi(R.leaf[0], R.self), R.Phi(R.leaf[0], R.self)));
+ R.ReducePhiIterative(
+ R.leaf[0], R.Phi(R.Phi(R.self, R.leaf[0]), R.Phi(R.self, R.leaf[0])));
+
+ Node* p1 = R.Phi(R.leaf[0], R.self);
+ R.ReducePhiIterative(R.leaf[0], R.Phi(p1, p1));
+
+ Node* p2 = R.Phi(R.self, R.leaf[0]);
+ R.ReducePhiIterative(R.leaf[0], R.Phi(p2, p2));
+}
+
+
+TEST(EReducePhi1) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.leaf[0]));
+ R.ReducePhi(R.leaf[1], R.EffectPhi(R.leaf[1]));
+ R.ReducePhi(R.leaf[2], R.EffectPhi(R.leaf[2]));
+ R.ReducePhi(R.leaf[3], R.EffectPhi(R.leaf[3]));
+}
+
+
+TEST(EReducePhi1_dead) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.leaf[0], R.dead));
+ R.ReducePhi(R.leaf[1], R.EffectPhi(R.leaf[1], R.dead));
+ R.ReducePhi(R.leaf[2], R.EffectPhi(R.leaf[2], R.dead));
+ R.ReducePhi(R.leaf[3], R.EffectPhi(R.leaf[3], R.dead));
+
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.dead, R.leaf[0]));
+ R.ReducePhi(R.leaf[1], R.EffectPhi(R.dead, R.leaf[1]));
+ R.ReducePhi(R.leaf[2], R.EffectPhi(R.dead, R.leaf[2]));
+ R.ReducePhi(R.leaf[3], R.EffectPhi(R.dead, R.leaf[3]));
+}
+
+
+TEST(EReducePhi1_dead2) {
+ ControlReducerTester R;
+
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.leaf[0], R.dead, R.dead));
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.dead, R.leaf[0], R.dead));
+ R.ReducePhi(R.leaf[0], R.EffectPhi(R.dead, R.dead, R.leaf[0]));
+}
+
+
+TEST(CMergeReduce_simple1) {
+ ControlReducerTester R;
+
+ Node* merge = R.graph.NewNode(R.common.Merge(1), R.start);
+ R.ReduceMerge(R.start, merge);
+}
+
+
+TEST(CMergeReduce_simple2) {
+ ControlReducerTester R;
+
+ Node* merge1 = R.graph.NewNode(R.common.Merge(1), R.start);
+ Node* merge2 = R.graph.NewNode(R.common.Merge(1), merge1);
+ R.ReduceMerge(merge1, merge2);
+ R.ReduceMergeIterative(R.start, merge2);
+}
+
+
+TEST(CMergeReduce_none1) {
+ ControlReducerTester R;
+
+ Node* merge = R.graph.NewNode(R.common.Merge(2), R.start, R.start);
+ R.ReduceMerge(merge, merge);
+}
+
+
+TEST(CMergeReduce_none2) {
+ ControlReducerTester R;
+
+ Node* t = R.graph.NewNode(R.common.IfTrue(), R.start);
+ Node* f = R.graph.NewNode(R.common.IfFalse(), R.start);
+ Node* merge = R.graph.NewNode(R.common.Merge(2), t, f);
+ R.ReduceMerge(merge, merge);
+}
+
+
+TEST(CMergeReduce_self3) {
+ ControlReducerTester R;
+
+ Node* merge =
+ R.SetSelfReferences(R.graph.NewNode(R.common.Merge(2), R.start, R.self));
+ R.ReduceMerge(merge, merge);
+}
+
+
+TEST(CMergeReduce_dead1) {
+ ControlReducerTester R;
+
+ Node* merge = R.graph.NewNode(R.common.Merge(2), R.start, R.dead);
+ R.ReduceMerge(R.start, merge);
+}
+
+
+TEST(CMergeReduce_dead2) {
+ ControlReducerTester R;
+
+ Node* merge1 = R.graph.NewNode(R.common.Merge(1), R.start);
+ Node* merge2 = R.graph.NewNode(R.common.Merge(2), merge1, R.dead);
+ R.ReduceMerge(merge1, merge2);
+ R.ReduceMergeIterative(R.start, merge2);
+}
+
+
+TEST(CMergeReduce_dead_rm1a) {
+ ControlReducerTester R;
+
+ for (int i = 0; i < 3; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.start, R.start, R.start);
+ merge->ReplaceInput(i, R.dead);
+ R.ReduceMerge(merge, merge);
+ CheckMerge(merge, R.start, R.start);
+ }
+}
+
+
+TEST(CMergeReduce_dead_rm1b) {
+ ControlReducerTester R;
+
+ Node* t = R.graph.NewNode(R.common.IfTrue(), R.start);
+ Node* f = R.graph.NewNode(R.common.IfFalse(), R.start);
+ for (int i = 0; i < 2; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.dead, R.dead, R.dead);
+ for (int j = i + 1; j < 3; j++) {
+ merge->ReplaceInput(i, t);
+ merge->ReplaceInput(j, f);
+ R.ReduceMerge(merge, merge);
+ CheckMerge(merge, t, f);
+ }
+ }
+}
+
+
+TEST(CMergeReduce_dead_rm2) {
+ ControlReducerTester R;
+
+ for (int i = 0; i < 3; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.dead, R.dead, R.dead);
+ merge->ReplaceInput(i, R.start);
+ R.ReduceMerge(R.start, merge);
+ }
+}
+
+
+TEST(CLoopReduce_dead_rm1) {
+ ControlReducerTester R;
+
+ for (int i = 0; i < 3; i++) {
+ Node* loop = R.graph.NewNode(R.common.Loop(3), R.dead, R.start, R.start);
+ R.ReduceMerge(loop, loop);
+ CheckLoop(loop, R.start, R.start);
+ }
+}
+
+
+TEST(CMergeReduce_edit_phi1) {
+ ControlReducerTester R;
+
+ for (int i = 0; i < 3; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.start, R.start, R.start);
+ merge->ReplaceInput(i, R.dead);
+ Node* phi = R.graph.NewNode(R.common.Phi(kMachAnyTagged, 3), R.leaf[0],
+ R.leaf[1], R.leaf[2], merge);
+ R.ReduceMerge(merge, merge);
+ CHECK_EQ(IrOpcode::kPhi, phi->opcode());
+ CHECK_EQ(2, phi->op()->InputCount());
+ CHECK_EQ(3, phi->InputCount());
+ CHECK_EQ(R.leaf[i < 1 ? 1 : 0], phi->InputAt(0));
+ CHECK_EQ(R.leaf[i < 2 ? 2 : 1], phi->InputAt(1));
+ CHECK_EQ(merge, phi->InputAt(2));
+ }
+}
+
+
+TEST(CMergeReduce_edit_effect_phi1) {
+ ControlReducerTester R;
+
+ for (int i = 0; i < 3; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.start, R.start, R.start);
+ merge->ReplaceInput(i, R.dead);
+ Node* phi = R.graph.NewNode(R.common.EffectPhi(3), R.leaf[0], R.leaf[1],
+ R.leaf[2], merge);
+ R.ReduceMerge(merge, merge);
+ CHECK_EQ(IrOpcode::kEffectPhi, phi->opcode());
+ CHECK_EQ(0, phi->op()->InputCount());
+ CHECK_EQ(2, phi->op()->EffectInputCount());
+ CHECK_EQ(3, phi->InputCount());
+ CHECK_EQ(R.leaf[i < 1 ? 1 : 0], phi->InputAt(0));
+ CHECK_EQ(R.leaf[i < 2 ? 2 : 1], phi->InputAt(1));
+ CHECK_EQ(merge, phi->InputAt(2));
+ }
+}
+
+
+static const int kSelectorSize = 4;
+
+// Helper to select K of N nodes according to a mask, useful for the test below.
+struct Selector {
+ int mask;
+ int count;
+ explicit Selector(int m) {
+ mask = m;
+ count = v8::base::bits::CountPopulation32(m);
+ }
+ bool is_selected(int i) { return (mask & (1 << i)) != 0; }
+ void CheckNode(Node* node, IrOpcode::Value opcode, Node** inputs,
+ Node* control) {
+ CHECK_EQ(opcode, node->opcode());
+ CHECK_EQ(count + (control != NULL ? 1 : 0), node->InputCount());
+ int index = 0;
+ for (int i = 0; i < kSelectorSize; i++) {
+ if (mask & (1 << i)) {
+ CHECK_EQ(inputs[i], node->InputAt(index++));
+ }
+ }
+ CHECK_EQ(count, index);
+ if (control != NULL) CHECK_EQ(control, node->InputAt(index++));
+ }
+ int single_index() {
+ CHECK_EQ(1, count);
+ return WhichPowerOf2(mask);
+ }
+};
+
+
+TEST(CMergeReduce_exhaustive_4) {
+ ControlReducerTester R;
+ Node* controls[] = {
+ R.graph.NewNode(R.common.Start(1)), R.graph.NewNode(R.common.Start(2)),
+ R.graph.NewNode(R.common.Start(3)), R.graph.NewNode(R.common.Start(4))};
+ Node* values[] = {R.jsgraph.Int32Constant(11), R.jsgraph.Int32Constant(22),
+ R.jsgraph.Int32Constant(33), R.jsgraph.Int32Constant(44)};
+ Node* effects[] = {
+ R.jsgraph.Float64Constant(123.4), R.jsgraph.Float64Constant(223.4),
+ R.jsgraph.Float64Constant(323.4), R.jsgraph.Float64Constant(423.4)};
+
+ for (int mask = 0; mask < (1 << (kSelectorSize - 1)); mask++) {
+ // Reduce a single merge with a given mask.
+ Node* merge = R.graph.NewNode(R.common.Merge(4), controls[0], controls[1],
+ controls[2], controls[3]);
+ Node* phi = R.graph.NewNode(R.common.Phi(kMachAnyTagged, 4), values[0],
+ values[1], values[2], values[3], merge);
+ Node* ephi = R.graph.NewNode(R.common.EffectPhi(4), effects[0], effects[1],
+ effects[2], effects[3], merge);
+
+ Node* phi_use =
+ R.graph.NewNode(R.common.Phi(kMachAnyTagged, 1), phi, R.start);
+ Node* ephi_use = R.graph.NewNode(R.common.EffectPhi(1), ephi, R.start);
+
+ Selector selector(mask);
+
+ for (int i = 0; i < kSelectorSize; i++) { // set up dead merge inputs.
+ if (!selector.is_selected(i)) merge->ReplaceInput(i, R.dead);
+ }
+
+ Node* result =
+ ControlReducer::ReduceMergeForTesting(&R.jsgraph, &R.common, merge);
+
+ int count = selector.count;
+ if (count == 0) {
+ // result should be dead.
+ CHECK_EQ(IrOpcode::kDead, result->opcode());
+ } else if (count == 1) {
+ // merge should be replaced with one of the controls.
+ CHECK_EQ(controls[selector.single_index()], result);
+ // Phis should have been directly replaced.
+ CHECK_EQ(values[selector.single_index()], phi_use->InputAt(0));
+ CHECK_EQ(effects[selector.single_index()], ephi_use->InputAt(0));
+ } else {
+ // Otherwise, nodes should be edited in place.
+ CHECK_EQ(merge, result);
+ selector.CheckNode(merge, IrOpcode::kMerge, controls, NULL);
+ selector.CheckNode(phi, IrOpcode::kPhi, values, merge);
+ selector.CheckNode(ephi, IrOpcode::kEffectPhi, effects, merge);
+ CHECK_EQ(phi, phi_use->InputAt(0));
+ CHECK_EQ(ephi, ephi_use->InputAt(0));
+ CHECK_EQ(count, phi->op()->InputCount());
+ CHECK_EQ(count + 1, phi->InputCount());
+ CHECK_EQ(count, ephi->op()->EffectInputCount());
+ CHECK_EQ(count + 1, ephi->InputCount());
+ }
+ }
+}
+
+
+TEST(CMergeReduce_edit_many_phis1) {
+ ControlReducerTester R;
+
+ const int kPhiCount = 10;
+ Node* phis[kPhiCount];
+
+ for (int i = 0; i < 3; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(3), R.start, R.start, R.start);
+ merge->ReplaceInput(i, R.dead);
+ for (int j = 0; j < kPhiCount; j++) {
+ phis[j] = R.graph.NewNode(R.common.Phi(kMachAnyTagged, 3), R.leaf[0],
+ R.leaf[1], R.leaf[2], merge);
+ }
+ R.ReduceMerge(merge, merge);
+ for (int j = 0; j < kPhiCount; j++) {
+ Node* phi = phis[j];
+ CHECK_EQ(IrOpcode::kPhi, phi->opcode());
+ CHECK_EQ(2, phi->op()->InputCount());
+ CHECK_EQ(3, phi->InputCount());
+ CHECK_EQ(R.leaf[i < 1 ? 1 : 0], phi->InputAt(0));
+ CHECK_EQ(R.leaf[i < 2 ? 2 : 1], phi->InputAt(1));
+ CHECK_EQ(merge, phi->InputAt(2));
+ }
+ }
+}
+
+
+TEST(CMergeReduce_simple_chain1) {
+ ControlReducerTester R;
+ for (int i = 0; i < 5; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(1), R.start);
+ for (int j = 0; j < i; j++) {
+ merge = R.graph.NewNode(R.common.Merge(1), merge);
+ }
+ R.ReduceMergeIterative(R.start, merge);
+ }
+}
+
+
+TEST(CMergeReduce_dead_chain1) {
+ ControlReducerTester R;
+ for (int i = 0; i < 5; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(1), R.dead);
+ for (int j = 0; j < i; j++) {
+ merge = R.graph.NewNode(R.common.Merge(1), merge);
+ }
+ Node* end = R.graph.NewNode(R.common.End(), merge);
+ R.graph.SetEnd(end);
+ R.ReduceGraph();
+ CHECK(merge->IsDead());
+ CHECK_EQ(NULL, end->InputAt(0)); // end dies.
+ }
+}
+
+
+TEST(CMergeReduce_dead_chain2) {
+ ControlReducerTester R;
+ for (int i = 0; i < 5; i++) {
+ Node* merge = R.graph.NewNode(R.common.Merge(1), R.start);
+ for (int j = 0; j < i; j++) {
+ merge = R.graph.NewNode(R.common.Merge(2), merge, R.dead);
+ }
+ R.ReduceMergeIterative(R.start, merge);
+ }
+}
+
+
+struct Branch {
+ Node* branch;
+ Node* if_true;
+ Node* if_false;
+
+ Branch(ControlReducerTester& R, Node* cond, Node* control = NULL) {
+ if (control == NULL) control = R.start;
+ branch = R.graph.NewNode(R.common.Branch(), cond, control);
+ if_true = R.graph.NewNode(R.common.IfTrue(), branch);
+ if_false = R.graph.NewNode(R.common.IfFalse(), branch);
+ }
+};
+
+
+// TODO(titzer): use the diamonds from src/compiler/diamond.h here.
+struct Diamond {
+ Node* branch;
+ Node* if_true;
+ Node* if_false;
+ Node* merge;
+ Node* phi;
+
+ Diamond(ControlReducerTester& R, Node* cond) {
+ branch = R.graph.NewNode(R.common.Branch(), cond, R.start);
+ if_true = R.graph.NewNode(R.common.IfTrue(), branch);
+ if_false = R.graph.NewNode(R.common.IfFalse(), branch);
+ merge = R.graph.NewNode(R.common.Merge(2), if_true, if_false);
+ phi = NULL;
+ }
+
+ Diamond(ControlReducerTester& R, Node* cond, Node* tv, Node* fv) {
+ branch = R.graph.NewNode(R.common.Branch(), cond, R.start);
+ if_true = R.graph.NewNode(R.common.IfTrue(), branch);
+ if_false = R.graph.NewNode(R.common.IfFalse(), branch);
+ merge = R.graph.NewNode(R.common.Merge(2), if_true, if_false);
+ phi = R.graph.NewNode(R.common.Phi(kMachAnyTagged, 2), tv, fv, merge);
+ }
+
+ void chain(Diamond& that) { branch->ReplaceInput(1, that.merge); }
+
+ // Nest {this} into either the if_true or if_false branch of {that}.
+ void nest(Diamond& that, bool if_true) {
+ if (if_true) {
+ branch->ReplaceInput(1, that.if_true);
+ that.merge->ReplaceInput(0, merge);
+ } else {
+ branch->ReplaceInput(1, that.if_false);
+ that.merge->ReplaceInput(1, merge);
+ }
+ }
+};
+
+
+struct While {
+ Node* branch;
+ Node* if_true;
+ Node* exit;
+ Node* loop;
+
+ While(ControlReducerTester& R, Node* cond) {
+ loop = R.graph.NewNode(R.common.Loop(2), R.start, R.start);
+ branch = R.graph.NewNode(R.common.Branch(), cond, loop);
+ if_true = R.graph.NewNode(R.common.IfTrue(), branch);
+ exit = R.graph.NewNode(R.common.IfFalse(), branch);
+ loop->ReplaceInput(1, if_true);
+ }
+
+ void chain(Node* control) { loop->ReplaceInput(0, control); }
+};
+
+
+TEST(CBranchReduce_none1) {
+ ControlReducerTester R;
+ Diamond d(R, R.p0);
+ R.ReduceBranch(d.branch, d.branch);
+}
+
+
+TEST(CBranchReduce_none2) {
+ ControlReducerTester R;
+ Diamond d1(R, R.p0);
+ Diamond d2(R, R.p0);
+ d2.chain(d1);
+ R.ReduceBranch(d2.branch, d2.branch);
+}
+
+
+TEST(CBranchReduce_true) {
+ ControlReducerTester R;
+ Node* true_values[] = {
+ R.one, R.jsgraph.Int32Constant(2),
+ R.jsgraph.Int32Constant(0x7fffffff), R.jsgraph.Constant(1.0),
+ R.jsgraph.Constant(22.1), R.jsgraph.TrueConstant()};
+
+ for (size_t i = 0; i < arraysize(true_values); i++) {
+ Diamond d(R, true_values[i]);
+ Node* true_use = R.graph.NewNode(R.common.Merge(1), d.if_true);
+ Node* false_use = R.graph.NewNode(R.common.Merge(1), d.if_false);
+ R.ReduceBranch(R.start, d.branch);
+ CHECK_EQ(R.start, true_use->InputAt(0));
+ CHECK_EQ(IrOpcode::kDead, false_use->InputAt(0)->opcode());
+ CHECK(d.if_true->IsDead()); // replaced
+ CHECK(d.if_false->IsDead()); // replaced
+ }
+}
+
+
+TEST(CBranchReduce_false) {
+ ControlReducerTester R;
+ Node* false_values[] = {R.zero, R.jsgraph.Constant(0.0),
+ R.jsgraph.Constant(-0.0), R.jsgraph.FalseConstant()};
+
+ for (size_t i = 0; i < arraysize(false_values); i++) {
+ Diamond d(R, false_values[i]);
+ Node* true_use = R.graph.NewNode(R.common.Merge(1), d.if_true);
+ Node* false_use = R.graph.NewNode(R.common.Merge(1), d.if_false);
+ R.ReduceBranch(R.start, d.branch);
+ CHECK_EQ(R.start, false_use->InputAt(0));
+ CHECK_EQ(IrOpcode::kDead, true_use->InputAt(0)->opcode());
+ CHECK(d.if_true->IsDead()); // replaced
+ CHECK(d.if_false->IsDead()); // replaced
+ }
+}
+
+
+TEST(CDiamondReduce_true) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one);
+ R.ReduceMergeIterative(R.start, d1.merge);
+}
+
+
+TEST(CDiamondReduce_false) {
+ ControlReducerTester R;
+ Diamond d2(R, R.zero);
+ R.ReduceMergeIterative(R.start, d2.merge);
+}
+
+
+TEST(CChainedDiamondsReduce_true_false) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one);
+ Diamond d2(R, R.zero);
+ d2.chain(d1);
+
+ R.ReduceMergeIterative(R.start, d2.merge);
+}
+
+
+TEST(CChainedDiamondsReduce_x_false) {
+ ControlReducerTester R;
+ Diamond d1(R, R.p0);
+ Diamond d2(R, R.zero);
+ d2.chain(d1);
+
+ R.ReduceMergeIterative(d1.merge, d2.merge);
+}
+
+
+TEST(CChainedDiamondsReduce_false_x) {
+ ControlReducerTester R;
+ Diamond d1(R, R.zero);
+ Diamond d2(R, R.p0);
+ d2.chain(d1);
+
+ R.ReduceMergeIterative(d2.merge, d2.merge);
+ CheckInputs(d2.branch, R.p0, R.start);
+}
+
+
+TEST(CChainedDiamondsReduce_phi1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.zero, R.one, R.zero); // foldable branch, phi.
+ Diamond d2(R, d1.phi);
+ d2.chain(d1);
+
+ R.ReduceMergeIterative(R.start, d2.merge);
+}
+
+
+TEST(CChainedDiamondsReduce_phi2) {
+ ControlReducerTester R;
+ Diamond d1(R, R.p0, R.one, R.one); // redundant phi.
+ Diamond d2(R, d1.phi);
+ d2.chain(d1);
+
+ R.ReduceMergeIterative(d1.merge, d2.merge);
+}
+
+
+TEST(CNestedDiamondsReduce_true_true_false) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one);
+ Diamond d2(R, R.zero);
+ d2.nest(d1, true);
+
+ R.ReduceMergeIterative(R.start, d1.merge);
+}
+
+
+TEST(CNestedDiamondsReduce_false_true_false) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one);
+ Diamond d2(R, R.zero);
+ d2.nest(d1, false);
+
+ R.ReduceMergeIterative(R.start, d1.merge);
+}
+
+
+TEST(CNestedDiamonds_xyz) {
+ ControlReducerTester R;
+
+ for (int a = 0; a < 2; a++) {
+ for (int b = 0; b < 2; b++) {
+ for (int c = 0; c < 2; c++) {
+ Diamond d1(R, R.jsgraph.Int32Constant(a));
+ Diamond d2(R, R.jsgraph.Int32Constant(b));
+ d2.nest(d1, c);
+
+ R.ReduceMergeIterative(R.start, d1.merge);
+ }
+ }
+ }
+}
+
+
+TEST(CDeadLoop1) {
+ ControlReducerTester R;
+
+ Node* loop = R.graph.NewNode(R.common.Loop(1), R.start);
+ Branch b(R, R.p0, loop);
+ loop->ReplaceInput(0, b.if_true); // loop is not connected to start.
+ Node* merge = R.graph.NewNode(R.common.Merge(2), R.start, b.if_false);
+ R.ReduceMergeIterative(R.start, merge);
+ CHECK(b.if_true->IsDead());
+ CHECK(b.if_false->IsDead());
+}
+
+
+TEST(CDeadLoop2) {
+ ControlReducerTester R;
+
+ While w(R, R.p0);
+ Diamond d(R, R.zero);
+ // if (0) { while (p0) ; } else { }
+ w.branch->ReplaceInput(1, d.if_true);
+ d.merge->ReplaceInput(0, w.exit);
+
+ R.ReduceMergeIterative(R.start, d.merge);
+ CHECK(d.if_true->IsDead());
+ CHECK(d.if_false->IsDead());
+}
+
+
+TEST(CNonTermLoop1) {
+ ControlReducerTester R;
+ Node* loop =
+ R.SetSelfReferences(R.graph.NewNode(R.common.Loop(2), R.start, R.self));
+ R.ReduceGraph();
+ Node* end = R.graph.end();
+ CheckLoop(loop, R.start, loop);
+ Node* merge = end->InputAt(0);
+ CheckMerge(merge, R.start, loop);
+}
+
+
+TEST(CNonTermLoop2) {
+ ControlReducerTester R;
+ Diamond d(R, R.p0);
+ Node* loop = R.SetSelfReferences(
+ R.graph.NewNode(R.common.Loop(2), d.if_false, R.self));
+ d.merge->ReplaceInput(1, R.dead);
+ Node* end = R.graph.end();
+ end->ReplaceInput(0, d.merge);
+ R.ReduceGraph();
+ CHECK_EQ(end, R.graph.end());
+ CheckLoop(loop, d.if_false, loop);
+ Node* merge = end->InputAt(0);
+ CheckMerge(merge, d.if_true, loop);
+}
+
+
+TEST(NonTermLoop3) {
+ ControlReducerTester R;
+ Node* loop = R.graph.NewNode(R.common.Loop(2), R.start, R.start);
+ Branch b(R, R.one, loop);
+ loop->ReplaceInput(1, b.if_true);
+ Node* end = R.graph.end();
+ end->ReplaceInput(0, b.if_false);
+
+ R.ReduceGraph();
+
+ CHECK_EQ(end, R.graph.end());
+ CheckInputs(end, loop);
+ CheckInputs(loop, R.start, loop);
+}
+
+
+TEST(CNonTermLoop_terminate1) {
+ ControlReducerTester R;
+ Node* loop = R.graph.NewNode(R.common.Loop(2), R.start, R.start);
+ Node* effect = R.SetSelfReferences(
+ R.graph.NewNode(R.common.EffectPhi(2), R.start, R.self, loop));
+ Branch b(R, R.one, loop);
+ loop->ReplaceInput(1, b.if_true);
+ Node* end = R.graph.end();
+ end->ReplaceInput(0, b.if_false);
+
+ R.ReduceGraph();
+
+ CHECK_EQ(end, R.graph.end());
+ CheckLoop(loop, R.start, loop);
+ Node* terminate = end->InputAt(0);
+ CHECK_EQ(IrOpcode::kTerminate, terminate->opcode());
+ CHECK_EQ(2, terminate->InputCount());
+ CHECK_EQ(1, terminate->op()->EffectInputCount());
+ CHECK_EQ(1, terminate->op()->ControlInputCount());
+ CheckInputs(terminate, effect, loop);
+}
+
+
+TEST(CNonTermLoop_terminate2) {
+ ControlReducerTester R;
+ Node* loop = R.graph.NewNode(R.common.Loop(2), R.start, R.start);
+ Node* effect1 = R.SetSelfReferences(
+ R.graph.NewNode(R.common.EffectPhi(2), R.start, R.self, loop));
+ Node* effect2 = R.SetSelfReferences(
+ R.graph.NewNode(R.common.EffectPhi(2), R.start, R.self, loop));
+ Branch b(R, R.one, loop);
+ loop->ReplaceInput(1, b.if_true);
+ Node* end = R.graph.end();
+ end->ReplaceInput(0, b.if_false);
+
+ R.ReduceGraph();
+
+ CheckLoop(loop, R.start, loop);
+ CHECK_EQ(end, R.graph.end());
+ Node* terminate = end->InputAt(0);
+ CHECK_EQ(IrOpcode::kTerminate, terminate->opcode());
+ CHECK_EQ(3, terminate->InputCount());
+ CHECK_EQ(2, terminate->op()->EffectInputCount());
+ CHECK_EQ(1, terminate->op()->ControlInputCount());
+ Node* e0 = terminate->InputAt(0);
+ Node* e1 = terminate->InputAt(1);
+ CHECK(e0 == effect1 || e1 == effect1);
+ CHECK(e0 == effect2 || e1 == effect2);
+ CHECK_EQ(loop, terminate->InputAt(2));
+}
+
+
+TEST(CNonTermLoop_terminate_m1) {
+ ControlReducerTester R;
+ Node* loop =
+ R.SetSelfReferences(R.graph.NewNode(R.common.Loop(2), R.start, R.self));
+ Node* effect = R.SetSelfReferences(
+ R.graph.NewNode(R.common.EffectPhi(2), R.start, R.self, loop));
+ R.ReduceGraph();
+ Node* end = R.graph.end();
+ CHECK_EQ(R.start, loop->InputAt(0));
+ CHECK_EQ(loop, loop->InputAt(1));
+ Node* merge = end->InputAt(0);
+ CHECK_EQ(IrOpcode::kMerge, merge->opcode());
+ CHECK_EQ(2, merge->InputCount());
+ CHECK_EQ(2, merge->op()->ControlInputCount());
+ CHECK_EQ(R.start, merge->InputAt(0));
+
+ Node* terminate = merge->InputAt(1);
+ CHECK_EQ(IrOpcode::kTerminate, terminate->opcode());
+ CHECK_EQ(2, terminate->InputCount());
+ CHECK_EQ(1, terminate->op()->EffectInputCount());
+ CHECK_EQ(1, terminate->op()->ControlInputCount());
+ CHECK_EQ(effect, terminate->InputAt(0));
+ CHECK_EQ(loop, terminate->InputAt(1));
+}
+
+
+TEST(CNonTermLoop_big1) {
+ ControlReducerTester R;
+ Branch b1(R, R.p0);
+ Node* rt = R.graph.NewNode(R.common.Return(), R.one, R.start, b1.if_true);
+
+ Branch b2(R, R.p0, b1.if_false);
+ Node* rf = R.graph.NewNode(R.common.Return(), R.zero, R.start, b2.if_true);
+ Node* loop = R.SetSelfReferences(
+ R.graph.NewNode(R.common.Loop(2), b2.if_false, R.self));
+ Node* merge = R.graph.NewNode(R.common.Merge(2), rt, rf);
+ R.end->ReplaceInput(0, merge);
+
+ R.ReduceGraph();
+
+ CheckInputs(R.end, merge);
+ CheckInputs(merge, rt, rf, loop);
+ CheckInputs(loop, b2.if_false, loop);
+}
+
+
+TEST(CNonTermLoop_big2) {
+ ControlReducerTester R;
+ Branch b1(R, R.p0);
+ Node* rt = R.graph.NewNode(R.common.Return(), R.one, R.start, b1.if_true);
+
+ Branch b2(R, R.zero, b1.if_false);
+ Node* rf = R.graph.NewNode(R.common.Return(), R.zero, R.start, b2.if_true);
+ Node* loop = R.SetSelfReferences(
+ R.graph.NewNode(R.common.Loop(2), b2.if_false, R.self));
+ Node* merge = R.graph.NewNode(R.common.Merge(2), rt, rf);
+ R.end->ReplaceInput(0, merge);
+
+ R.ReduceGraph();
+
+ Node* new_merge = R.end->InputAt(0); // old merge was reduced.
+ CHECK_NE(merge, new_merge);
+ CheckInputs(new_merge, rt, loop);
+ CheckInputs(loop, b1.if_false, loop);
+ CHECK(merge->IsDead());
+ CHECK(rf->IsDead());
+ CHECK(b2.if_true->IsDead());
+}
+
+
+TEST(Return1) {
+ ControlReducerTester R;
+ Node* ret = R.Return(R.one, R.start, R.start);
+ R.ReduceGraph();
+ CheckInputs(R.graph.end(), ret);
+ CheckInputs(ret, R.one, R.start, R.start);
+}
+
+
+TEST(Return2) {
+ ControlReducerTester R;
+ Diamond d(R, R.one);
+ Node* ret = R.Return(R.half, R.start, d.merge);
+ R.ReduceGraph();
+ CHECK(d.branch->IsDead());
+ CHECK(d.if_true->IsDead());
+ CHECK(d.if_false->IsDead());
+ CHECK(d.merge->IsDead());
+
+ CheckInputs(R.graph.end(), ret);
+ CheckInputs(ret, R.half, R.start, R.start);
+}
+
+
+TEST(Return_true1) {
+ ControlReducerTester R;
+ Diamond d(R, R.one, R.half, R.zero);
+ Node* ret = R.Return(d.phi, R.start, d.merge);
+ R.ReduceGraph();
+ CHECK(d.branch->IsDead());
+ CHECK(d.if_true->IsDead());
+ CHECK(d.if_false->IsDead());
+ CHECK(d.merge->IsDead());
+ CHECK(d.phi->IsDead());
+
+ CheckInputs(R.graph.end(), ret);
+ CheckInputs(ret, R.half, R.start, R.start);
+}
+
+
+TEST(Return_false1) {
+ ControlReducerTester R;
+ Diamond d(R, R.zero, R.one, R.half);
+ Node* ret = R.Return(d.phi, R.start, d.merge);
+ R.ReduceGraph();
+ CHECK(d.branch->IsDead());
+ CHECK(d.if_true->IsDead());
+ CHECK(d.if_false->IsDead());
+ CHECK(d.merge->IsDead());
+ CHECK(d.phi->IsDead());
+
+ CheckInputs(R.graph.end(), ret);
+ CheckInputs(ret, R.half, R.start, R.start);
+}
+
+
+void CheckDeadDiamond(Diamond& d) {
+ CHECK(d.branch->IsDead());
+ CHECK(d.if_true->IsDead());
+ CHECK(d.if_false->IsDead());
+ CHECK(d.merge->IsDead());
+ if (d.phi != NULL) CHECK(d.phi->IsDead());
+}
+
+
+void CheckLiveDiamond(Diamond& d, bool live_phi = true) {
+ CheckInputs(d.merge, d.if_true, d.if_false);
+ CheckInputs(d.if_true, d.branch);
+ CheckInputs(d.if_false, d.branch);
+ if (d.phi != NULL) {
+ if (live_phi) {
+ CHECK_EQ(3, d.phi->InputCount());
+ CHECK_EQ(d.merge, d.phi->InputAt(2));
+ } else {
+ CHECK(d.phi->IsDead());
+ }
+ }
+}
+
+
+TEST(Return_effect1) {
+ ControlReducerTester R;
+ Diamond d(R, R.one);
+ Node* e1 = R.jsgraph.Float64Constant(-100.1);
+ Node* e2 = R.jsgraph.Float64Constant(+100.1);
+ Node* effect = R.graph.NewNode(R.common.EffectPhi(2), e1, e2, d.merge);
+ Node* ret = R.Return(R.p0, effect, d.merge);
+ R.ReduceGraph();
+ CheckDeadDiamond(d);
+ CHECK(effect->IsDead());
+
+ CheckInputs(R.graph.end(), ret);
+ CheckInputs(ret, R.p0, e1, R.start);
+}
+
+
+TEST(Return_nested_diamonds1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.p0, R.one, R.zero);
+ Diamond d2(R, R.p0);
+ Diamond d3(R, R.p0);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // nothing should happen.
+
+ CheckInputs(ret, d1.phi, R.start, d1.merge);
+ CheckInputs(d1.phi, R.one, R.zero, d1.merge);
+ CheckInputs(d1.merge, d2.merge, d3.merge);
+ CheckLiveDiamond(d2);
+ CheckLiveDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one, R.one, R.zero);
+ Diamond d2(R, R.p0);
+ Diamond d3(R, R.p0);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded true.
+
+ CheckInputs(ret, R.one, R.start, d2.merge);
+ CheckInputs(d2.branch, R.p0, R.start);
+ CheckDeadDiamond(d1);
+ CheckLiveDiamond(d2);
+ CheckDeadDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_false1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.zero, R.one, R.zero);
+ Diamond d2(R, R.p0);
+ Diamond d3(R, R.p0);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded false.
+
+ CheckInputs(ret, R.zero, R.start, d3.merge);
+ CheckInputs(d3.branch, R.p0, R.start);
+ CheckDeadDiamond(d1);
+ CheckDeadDiamond(d2);
+ CheckLiveDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true_true1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one, R.one, R.zero);
+ Diamond d2(R, R.one);
+ Diamond d3(R, R.p0);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 and d2 both get folded true.
+
+ CheckInputs(ret, R.one, R.start, R.start);
+ CheckDeadDiamond(d1);
+ CheckDeadDiamond(d2);
+ CheckDeadDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true_false1) {
+ ControlReducerTester R;
+ Diamond d1(R, R.one, R.one, R.zero);
+ Diamond d2(R, R.zero);
+ Diamond d3(R, R.p0);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded true and d2 gets folded false.
+
+ CheckInputs(ret, R.one, R.start, R.start);
+ CheckDeadDiamond(d1);
+ CheckDeadDiamond(d2);
+ CheckDeadDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds2) {
+ ControlReducerTester R;
+ Node* x2 = R.jsgraph.Float64Constant(11.1);
+ Node* y2 = R.jsgraph.Float64Constant(22.2);
+ Node* x3 = R.jsgraph.Float64Constant(33.3);
+ Node* y3 = R.jsgraph.Float64Constant(44.4);
+
+ Diamond d2(R, R.p0, x2, y2);
+ Diamond d3(R, R.p0, x3, y3);
+ Diamond d1(R, R.p0, d2.phi, d3.phi);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // nothing should happen.
+
+ CheckInputs(ret, d1.phi, R.start, d1.merge);
+ CheckInputs(d1.phi, d2.phi, d3.phi, d1.merge);
+ CheckInputs(d1.merge, d2.merge, d3.merge);
+ CheckLiveDiamond(d2);
+ CheckLiveDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true2) {
+ ControlReducerTester R;
+ Node* x2 = R.jsgraph.Float64Constant(11.1);
+ Node* y2 = R.jsgraph.Float64Constant(22.2);
+ Node* x3 = R.jsgraph.Float64Constant(33.3);
+ Node* y3 = R.jsgraph.Float64Constant(44.4);
+
+ Diamond d2(R, R.p0, x2, y2);
+ Diamond d3(R, R.p0, x3, y3);
+ Diamond d1(R, R.one, d2.phi, d3.phi);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded true.
+
+ CheckInputs(ret, d2.phi, R.start, d2.merge);
+ CheckInputs(d2.branch, R.p0, R.start);
+ CheckDeadDiamond(d1);
+ CheckLiveDiamond(d2);
+ CheckDeadDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true_true2) {
+ ControlReducerTester R;
+ Node* x2 = R.jsgraph.Float64Constant(11.1);
+ Node* y2 = R.jsgraph.Float64Constant(22.2);
+ Node* x3 = R.jsgraph.Float64Constant(33.3);
+ Node* y3 = R.jsgraph.Float64Constant(44.4);
+
+ Diamond d2(R, R.one, x2, y2);
+ Diamond d3(R, R.p0, x3, y3);
+ Diamond d1(R, R.one, d2.phi, d3.phi);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded true.
+
+ CheckInputs(ret, x2, R.start, R.start);
+ CheckDeadDiamond(d1);
+ CheckDeadDiamond(d2);
+ CheckDeadDiamond(d3);
+}
+
+
+TEST(Return_nested_diamonds_true_false2) {
+ ControlReducerTester R;
+ Node* x2 = R.jsgraph.Float64Constant(11.1);
+ Node* y2 = R.jsgraph.Float64Constant(22.2);
+ Node* x3 = R.jsgraph.Float64Constant(33.3);
+ Node* y3 = R.jsgraph.Float64Constant(44.4);
+
+ Diamond d2(R, R.zero, x2, y2);
+ Diamond d3(R, R.p0, x3, y3);
+ Diamond d1(R, R.one, d2.phi, d3.phi);
+
+ d2.nest(d1, true);
+ d3.nest(d1, false);
+
+ Node* ret = R.Return(d1.phi, R.start, d1.merge);
+
+ R.ReduceGraph(); // d1 gets folded true.
+
+ CheckInputs(ret, y2, R.start, R.start);
+ CheckDeadDiamond(d1);
+ CheckDeadDiamond(d2);
+ CheckDeadDiamond(d3);
+}
return Value(op->kind(), op->index());
}
- friend OStream& operator<<(OStream& os, const InterpreterState& is) {
+ friend std::ostream& operator<<(std::ostream& os,
+ const InterpreterState& is) {
for (OperandMap::const_iterator it = is.values_.begin();
it != is.values_.end(); ++it) {
if (it != is.values_.begin()) os << " ";
InstructionOperand source(it->first.first, it->first.second);
InstructionOperand destination(it->second.first, it->second.second);
- os << MoveOperands(&source, &destination);
+ MoveOperands mo(&source, &destination);
+ PrintableMoveOperands pmo = {RegisterConfiguration::ArchDefault(), &mo};
+ os << pmo;
}
return os;
}
const uint8_t OPCODE_C1 = 31;
const uint8_t OPCODE_C2 = 32;
-static SimpleOperator OPA0(OPCODE_A0, Operator::kNoWrite, 0, 0, "opa0");
-static SimpleOperator OPA1(OPCODE_A1, Operator::kNoWrite, 1, 0, "opa1");
-static SimpleOperator OPA2(OPCODE_A2, Operator::kNoWrite, 2, 0, "opa2");
-static SimpleOperator OPB0(OPCODE_B0, Operator::kNoWrite, 0, 0, "opa0");
-static SimpleOperator OPB1(OPCODE_B1, Operator::kNoWrite, 1, 0, "opa1");
-static SimpleOperator OPB2(OPCODE_B2, Operator::kNoWrite, 2, 0, "opa2");
-static SimpleOperator OPC0(OPCODE_C0, Operator::kNoWrite, 0, 0, "opc0");
-static SimpleOperator OPC1(OPCODE_C1, Operator::kNoWrite, 1, 0, "opc1");
-static SimpleOperator OPC2(OPCODE_C2, Operator::kNoWrite, 2, 0, "opc2");
+static Operator OPA0(OPCODE_A0, Operator::kNoWrite, "opa0", 0, 0, 0, 0, 0, 0);
+static Operator OPA1(OPCODE_A1, Operator::kNoWrite, "opa1", 1, 0, 0, 0, 0, 0);
+static Operator OPA2(OPCODE_A2, Operator::kNoWrite, "opa2", 2, 0, 0, 0, 0, 0);
+static Operator OPB0(OPCODE_B0, Operator::kNoWrite, "opa0", 0, 0, 0, 0, 0, 0);
+static Operator OPB1(OPCODE_B1, Operator::kNoWrite, "opa1", 1, 0, 0, 0, 0, 0);
+static Operator OPB2(OPCODE_B2, Operator::kNoWrite, "opa2", 2, 0, 0, 0, 0, 0);
+static Operator OPC0(OPCODE_C0, Operator::kNoWrite, "opc0", 0, 0, 0, 0, 0, 0);
+static Operator OPC1(OPCODE_C1, Operator::kNoWrite, "opc1", 1, 0, 0, 0, 0, 0);
+static Operator OPC2(OPCODE_C2, Operator::kNoWrite, "opc2", 2, 0, 0, 0, 0, 0);
// Replaces all "A" operators with "B" operators without creating new nodes.
--- /dev/null
+// 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/v8.h"
+#include "test/cctest/cctest.h"
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/generic-node-inl.h"
+#include "src/compiler/generic-node.h"
+#include "src/compiler/graph.h"
+#include "src/compiler/graph-visualizer.h"
+#include "src/compiler/js-operator.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/node.h"
+#include "src/compiler/operator.h"
+#include "src/compiler/schedule.h"
+#include "src/compiler/scheduler.h"
+#include "src/compiler/verifier.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+TEST(NodeWithNullInputReachableFromEnd) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(0));
+ graph.SetStart(start);
+ Node* k = graph.NewNode(common.Int32Constant(0));
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 1), k, start);
+ phi->ReplaceInput(0, NULL);
+ graph.SetEnd(phi);
+
+ OFStream os(stdout);
+ os << AsDOT(graph);
+ os << AsJSON(graph);
+}
+
+
+TEST(NodeWithNullControlReachableFromEnd) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(0));
+ graph.SetStart(start);
+ Node* k = graph.NewNode(common.Int32Constant(0));
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 1), k, start);
+ phi->ReplaceInput(1, NULL);
+ graph.SetEnd(phi);
+
+ OFStream os(stdout);
+ os << AsDOT(graph);
+ os << AsJSON(graph);
+}
+
+
+TEST(NodeWithNullInputReachableFromStart) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(0));
+ graph.SetStart(start);
+ Node* k = graph.NewNode(common.Int32Constant(0));
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 1), k, start);
+ phi->ReplaceInput(0, NULL);
+ graph.SetEnd(start);
+
+ OFStream os(stdout);
+ os << AsDOT(graph);
+ os << AsJSON(graph);
+}
+
+
+TEST(NodeWithNullControlReachableFromStart) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(0));
+ graph.SetStart(start);
+ Node* merge = graph.NewNode(common.Merge(2), start, start);
+ merge->ReplaceInput(1, NULL);
+ graph.SetEnd(merge);
+
+ OFStream os(stdout);
+ os << AsDOT(graph);
+ os << AsJSON(graph);
+}
graph(zone()),
schedule(zone()),
info(static_cast<HydrogenCodeStub*>(NULL), main_isolate()),
- linkage(&info),
+ linkage(zone(), &info),
common(zone()),
code(NULL) {}
void allocCode() {
if (schedule.rpo_order()->size() == 0) {
// Compute the RPO order.
- Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(isolate);
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
DCHECK(schedule.rpo_order()->size() > 0);
}
- code = new TestInstrSeq(&linkage, &graph, &schedule);
+ InstructionBlocks* instruction_blocks =
+ TestInstrSeq::InstructionBlocksFor(main_zone(), &schedule);
+ code = new TestInstrSeq(main_zone(), instruction_blocks);
}
Node* Int32Constant(int32_t val) {
return node;
}
- int NewInstr(BasicBlock* block) {
+ int NewInstr() {
InstructionCode opcode = static_cast<InstructionCode>(110);
TestInstr* instr = TestInstr::New(zone(), opcode);
- return code->AddInstruction(instr, block);
+ return code->AddInstruction(instr);
}
UnallocatedOperand* NewUnallocated(int vreg) {
unallocated->set_virtual_register(vreg);
return unallocated;
}
+
+ InstructionBlock* BlockAt(BasicBlock* block) {
+ return code->InstructionBlockAt(block->GetRpoNumber());
+ }
+ BasicBlock* GetBasicBlock(int instruction_index) {
+ const InstructionBlock* block =
+ code->GetInstructionBlock(instruction_index);
+ return schedule.rpo_order()->at(block->rpo_number().ToSize());
+ }
+ int first_instruction_index(BasicBlock* block) {
+ return BlockAt(block)->first_instruction_index();
+ }
+ int last_instruction_index(BasicBlock* block) {
+ return BlockAt(block)->last_instruction_index();
+ }
};
R.allocCode();
- CHECK_EQ(R.graph.NodeCount(), R.code->ValueCount());
-
BasicBlockVector* blocks = R.schedule.rpo_order();
- CHECK_EQ(static_cast<int>(blocks->size()), R.code->BasicBlockCount());
+ CHECK_EQ(static_cast<int>(blocks->size()), R.code->InstructionBlockCount());
int index = 0;
for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end();
i++, index++) {
BasicBlock* block = *i;
- CHECK_EQ(block, R.code->BlockAt(index));
- CHECK_EQ(-1, R.code->GetLoopEnd(block));
+ CHECK_EQ(block->rpo_number(), R.BlockAt(block)->rpo_number().ToInt());
+ CHECK_EQ(block->id().ToInt(), R.BlockAt(block)->id().ToInt());
+ CHECK_EQ(NULL, block->loop_end());
}
}
R.allocCode();
- R.code->StartBlock(b0);
- int i0 = R.NewInstr(b0);
- int i1 = R.NewInstr(b0);
- R.code->EndBlock(b0);
- R.code->StartBlock(b1);
- int i2 = R.NewInstr(b1);
- int i3 = R.NewInstr(b1);
- int i4 = R.NewInstr(b1);
- int i5 = R.NewInstr(b1);
- R.code->EndBlock(b1);
- R.code->StartBlock(b2);
- int i6 = R.NewInstr(b2);
- int i7 = R.NewInstr(b2);
- int i8 = R.NewInstr(b2);
- R.code->EndBlock(b2);
- R.code->StartBlock(b3);
- R.code->EndBlock(b3);
-
- CHECK_EQ(b0, R.code->GetBasicBlock(i0));
- CHECK_EQ(b0, R.code->GetBasicBlock(i1));
-
- CHECK_EQ(b1, R.code->GetBasicBlock(i2));
- CHECK_EQ(b1, R.code->GetBasicBlock(i3));
- CHECK_EQ(b1, R.code->GetBasicBlock(i4));
- CHECK_EQ(b1, R.code->GetBasicBlock(i5));
-
- CHECK_EQ(b2, R.code->GetBasicBlock(i6));
- CHECK_EQ(b2, R.code->GetBasicBlock(i7));
- CHECK_EQ(b2, R.code->GetBasicBlock(i8));
-
- CHECK_EQ(b0, R.code->GetBasicBlock(b0->first_instruction_index()));
- CHECK_EQ(b0, R.code->GetBasicBlock(b0->last_instruction_index()));
-
- CHECK_EQ(b1, R.code->GetBasicBlock(b1->first_instruction_index()));
- CHECK_EQ(b1, R.code->GetBasicBlock(b1->last_instruction_index()));
-
- CHECK_EQ(b2, R.code->GetBasicBlock(b2->first_instruction_index()));
- CHECK_EQ(b2, R.code->GetBasicBlock(b2->last_instruction_index()));
-
- CHECK_EQ(b3, R.code->GetBasicBlock(b3->first_instruction_index()));
- CHECK_EQ(b3, R.code->GetBasicBlock(b3->last_instruction_index()));
+ R.code->StartBlock(b0->GetRpoNumber());
+ int i0 = R.NewInstr();
+ int i1 = R.NewInstr();
+ R.code->EndBlock(b0->GetRpoNumber());
+ R.code->StartBlock(b1->GetRpoNumber());
+ int i2 = R.NewInstr();
+ int i3 = R.NewInstr();
+ int i4 = R.NewInstr();
+ int i5 = R.NewInstr();
+ R.code->EndBlock(b1->GetRpoNumber());
+ R.code->StartBlock(b2->GetRpoNumber());
+ int i6 = R.NewInstr();
+ int i7 = R.NewInstr();
+ int i8 = R.NewInstr();
+ R.code->EndBlock(b2->GetRpoNumber());
+ R.code->StartBlock(b3->GetRpoNumber());
+ R.code->EndBlock(b3->GetRpoNumber());
+
+ CHECK_EQ(b0, R.GetBasicBlock(i0));
+ CHECK_EQ(b0, R.GetBasicBlock(i1));
+
+ CHECK_EQ(b1, R.GetBasicBlock(i2));
+ CHECK_EQ(b1, R.GetBasicBlock(i3));
+ CHECK_EQ(b1, R.GetBasicBlock(i4));
+ CHECK_EQ(b1, R.GetBasicBlock(i5));
+
+ CHECK_EQ(b2, R.GetBasicBlock(i6));
+ CHECK_EQ(b2, R.GetBasicBlock(i7));
+ CHECK_EQ(b2, R.GetBasicBlock(i8));
+
+ CHECK_EQ(b0, R.GetBasicBlock(R.first_instruction_index(b0)));
+ CHECK_EQ(b0, R.GetBasicBlock(R.last_instruction_index(b0)));
+
+ CHECK_EQ(b1, R.GetBasicBlock(R.first_instruction_index(b1)));
+ CHECK_EQ(b1, R.GetBasicBlock(R.last_instruction_index(b1)));
+
+ CHECK_EQ(b2, R.GetBasicBlock(R.first_instruction_index(b2)));
+ CHECK_EQ(b2, R.GetBasicBlock(R.last_instruction_index(b2)));
+
+ CHECK_EQ(b3, R.GetBasicBlock(R.first_instruction_index(b3)));
+ CHECK_EQ(b3, R.GetBasicBlock(R.last_instruction_index(b3)));
}
R.allocCode();
TestInstr* i0 = TestInstr::New(R.zone(), 100);
TestInstr* g = TestInstr::New(R.zone(), 103)->MarkAsControl();
- R.code->StartBlock(b0);
- R.code->AddInstruction(i0, b0);
- R.code->AddInstruction(g, b0);
- R.code->EndBlock(b0);
+ R.code->StartBlock(b0->GetRpoNumber());
+ R.code->AddInstruction(i0);
+ R.code->AddInstruction(g);
+ R.code->EndBlock(b0->GetRpoNumber());
CHECK_EQ(true, R.code->InstructionAt(0)->IsBlockStart());
R.allocCode();
TestInstr* i0 = TestInstr::New(R.zone(), 100);
TestInstr* g = TestInstr::New(R.zone(), 103)->MarkAsControl();
- R.code->StartBlock(b0);
- R.code->AddInstruction(i0, b0);
- R.code->AddInstruction(g, b0);
- R.code->EndBlock(b0);
+ R.code->StartBlock(b0->GetRpoNumber());
+ R.code->AddInstruction(i0);
+ R.code->AddInstruction(g);
+ R.code->EndBlock(b0->GetRpoNumber());
TestInstr* i1 = TestInstr::New(R.zone(), 102);
TestInstr* g1 = TestInstr::New(R.zone(), 104)->MarkAsControl();
- R.code->StartBlock(b1);
- R.code->AddInstruction(i1, b1);
- R.code->AddInstruction(g1, b1);
- R.code->EndBlock(b1);
+ R.code->StartBlock(b1->GetRpoNumber());
+ R.code->AddInstruction(i1);
+ R.code->AddInstruction(g1);
+ R.code->EndBlock(b1->GetRpoNumber());
CHECK_EQ(true, R.code->InstructionAt(0)->IsBlockStart());
R.allocCode();
TestInstr* i0 = TestInstr::New(R.zone(), 100);
TestInstr* g = TestInstr::New(R.zone(), 103)->MarkAsControl();
- R.code->StartBlock(b0);
- R.code->AddInstruction(i0, b0);
- R.code->AddInstruction(g, b0);
- R.code->EndBlock(b0);
+ R.code->StartBlock(b0->GetRpoNumber());
+ R.code->AddInstruction(i0);
+ R.code->AddInstruction(g);
+ R.code->EndBlock(b0->GetRpoNumber());
CHECK_EQ(true, R.code->InstructionAt(0)->IsBlockStart());
#include "src/v8.h"
+#include "src/assembler.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/typer.h"
: main_graph_(zone),
main_common_(zone),
main_javascript_(zone),
- main_typer_(zone),
+ main_typer_(&main_graph_, MaybeHandle<Context>()),
main_machine_() {}
Graph main_graph_;
CommonOperatorBuilder main_common_;
};
+// TODO(dcarney): JSConstantCacheTester inherits from JSGraph???
class JSConstantCacheTester : public HandleAndZoneScope,
public JSCacheTesterHelper,
public JSGraph {
public:
JSConstantCacheTester()
: JSCacheTesterHelper(main_zone()),
- JSGraph(&main_graph_, &main_common_, &main_javascript_, &main_typer_,
- &main_machine_) {}
+ JSGraph(&main_graph_, &main_common_, &main_javascript_,
+ &main_machine_) {
+ main_graph_.SetStart(main_graph_.NewNode(common()->Start(0)));
+ main_graph_.SetEnd(main_graph_.NewNode(common()->End()));
+ main_typer_.Run();
+ }
Type* upper(Node* node) { return NodeProperties::GetBounds(node).upper; }
FOR_FLOAT64_INPUTS(i) {
double value = *i;
Node* node = T.Constant(value);
- CHECK(T.upper(node)->Equals(Type::Of(value, T.main_zone())));
+ CHECK(T.upper(node)->Is(Type::Of(value, T.main_zone())));
}
}
TEST(ExternalReferences) {
// TODO(titzer): test canonicalization of external references.
}
+
+
+static bool Contains(NodeVector* nodes, Node* n) {
+ for (size_t i = 0; i < nodes->size(); i++) {
+ if (nodes->at(i) == n) return true;
+ }
+ return false;
+}
+
+
+static void CheckGetCachedNodesContains(JSConstantCacheTester* T, Node* n) {
+ NodeVector nodes(T->main_zone());
+ T->GetCachedNodes(&nodes);
+ CHECK(Contains(&nodes, n));
+}
+
+
+TEST(JSGraph_GetCachedNodes1) {
+ JSConstantCacheTester T;
+ CheckGetCachedNodesContains(&T, T.TrueConstant());
+ CheckGetCachedNodesContains(&T, T.UndefinedConstant());
+ CheckGetCachedNodesContains(&T, T.TheHoleConstant());
+ CheckGetCachedNodesContains(&T, T.TrueConstant());
+ CheckGetCachedNodesContains(&T, T.FalseConstant());
+ CheckGetCachedNodesContains(&T, T.NullConstant());
+ CheckGetCachedNodesContains(&T, T.ZeroConstant());
+ CheckGetCachedNodesContains(&T, T.OneConstant());
+ CheckGetCachedNodesContains(&T, T.NaNConstant());
+}
+
+
+TEST(JSGraph_GetCachedNodes_int32) {
+ JSConstantCacheTester T;
+
+ int32_t constants[] = {0, 1, 1, 1, 1, 2, 3, 4, 11, 12, 13,
+ 14, 55, -55, -44, -33, -22, -11, 16, 16, 17, 17,
+ 18, 18, 19, 19, 20, 20, 21, 21, 22, 23, 24,
+ 25, 15, 30, 31, 45, 46, 47, 48};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int count_before = T.graph()->NodeCount();
+ NodeVector nodes_before(T.main_zone());
+ T.GetCachedNodes(&nodes_before);
+ Node* n = T.Int32Constant(constants[i]);
+ if (n->id() < count_before) {
+ // An old ID indicates a cached node. It should have been in the set.
+ CHECK(Contains(&nodes_before, n));
+ }
+ // Old or new, it should be in the cached set afterwards.
+ CheckGetCachedNodesContains(&T, n);
+ }
+}
+
+
+TEST(JSGraph_GetCachedNodes_float64) {
+ JSConstantCacheTester T;
+
+ double constants[] = {0, 11.1, 12.2, 13, 14, 55.5, -55.5, -44.4,
+ -33, -22, -11, 0, 11.1, 11.1, 12.3, 12.3,
+ 11, 11, -33.3, -33.3, -22, -11};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int count_before = T.graph()->NodeCount();
+ NodeVector nodes_before(T.main_zone());
+ T.GetCachedNodes(&nodes_before);
+ Node* n = T.Float64Constant(constants[i]);
+ if (n->id() < count_before) {
+ // An old ID indicates a cached node. It should have been in the set.
+ CHECK(Contains(&nodes_before, n));
+ }
+ // Old or new, it should be in the cached set afterwards.
+ CheckGetCachedNodesContains(&T, n);
+ }
+}
+
+
+TEST(JSGraph_GetCachedNodes_int64) {
+ JSConstantCacheTester T;
+
+ int32_t constants[] = {0, 11, 12, 13, 14, 55, -55, -44, -33,
+ -22, -11, 16, 16, 17, 17, 18, 18, 19,
+ 19, 20, 20, 21, 21, 22, 23, 24, 25};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int count_before = T.graph()->NodeCount();
+ NodeVector nodes_before(T.main_zone());
+ T.GetCachedNodes(&nodes_before);
+ Node* n = T.Int64Constant(constants[i]);
+ if (n->id() < count_before) {
+ // An old ID indicates a cached node. It should have been in the set.
+ CHECK(Contains(&nodes_before, n));
+ }
+ // Old or new, it should be in the cached set afterwards.
+ CheckGetCachedNodesContains(&T, n);
+ }
+}
+
+
+TEST(JSGraph_GetCachedNodes_number) {
+ JSConstantCacheTester T;
+
+ double constants[] = {0, 11.1, 12.2, 13, 14, 55.5, -55.5, -44.4,
+ -33, -22, -11, 0, 11.1, 11.1, 12.3, 12.3,
+ 11, 11, -33.3, -33.3, -22, -11};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int count_before = T.graph()->NodeCount();
+ NodeVector nodes_before(T.main_zone());
+ T.GetCachedNodes(&nodes_before);
+ Node* n = T.Constant(constants[i]);
+ if (n->id() < count_before) {
+ // An old ID indicates a cached node. It should have been in the set.
+ CHECK(Contains(&nodes_before, n));
+ }
+ // Old or new, it should be in the cached set afterwards.
+ CheckGetCachedNodesContains(&T, n);
+ }
+}
+
+
+TEST(JSGraph_GetCachedNodes_external) {
+ JSConstantCacheTester T;
+
+ ExternalReference constants[] = {ExternalReference::address_of_min_int(),
+ ExternalReference::address_of_min_int(),
+ ExternalReference::address_of_min_int(),
+ ExternalReference::address_of_one_half(),
+ ExternalReference::address_of_one_half(),
+ ExternalReference::address_of_min_int(),
+ ExternalReference::address_of_the_hole_nan(),
+ ExternalReference::address_of_one_half()};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int count_before = T.graph()->NodeCount();
+ NodeVector nodes_before(T.main_zone());
+ T.GetCachedNodes(&nodes_before);
+ Node* n = T.ExternalConstant(constants[i]);
+ if (n->id() < count_before) {
+ // An old ID indicates a cached node. It should have been in the set.
+ CHECK(Contains(&nodes_before, n));
+ }
+ // Old or new, it should be in the cached set afterwards.
+ CheckGetCachedNodesContains(&T, n);
+ }
+}
+
+
+TEST(JSGraph_GetCachedNodes_together) {
+ JSConstantCacheTester T;
+
+ Node* constants[] = {
+ T.TrueConstant(),
+ T.UndefinedConstant(),
+ T.TheHoleConstant(),
+ T.TrueConstant(),
+ T.FalseConstant(),
+ T.NullConstant(),
+ T.ZeroConstant(),
+ T.OneConstant(),
+ T.NaNConstant(),
+ T.Int32Constant(0),
+ T.Int32Constant(1),
+ T.Int64Constant(-2),
+ T.Int64Constant(-4),
+ T.Float64Constant(0.9),
+ T.Float64Constant(V8_INFINITY),
+ T.Constant(0.99),
+ T.Constant(1.11),
+ T.ExternalConstant(ExternalReference::address_of_one_half())};
+
+ NodeVector nodes(T.main_zone());
+ T.GetCachedNodes(&nodes);
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ CHECK(Contains(&nodes, constants[i]));
+ }
+}
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/source-position.h"
-#include "src/compiler/typer.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/function-tester.h"
#include "test/cctest/compiler/graph-builder-tester.h"
javascript_(main_zone()),
machine_(),
simplified_(main_zone()),
- typer_(main_zone()),
- jsgraph_(graph(), common(), &javascript_, &typer_, &machine_),
+ jsgraph_(graph(), common(), &javascript_, &machine_),
info_(main_isolate(), main_zone()) {}
Factory* factory() { return main_isolate()->factory(); }
JSOperatorBuilder javascript_;
MachineOperatorBuilder machine_;
SimplifiedOperatorBuilder simplified_;
- Typer typer_;
JSGraph jsgraph_;
CompilationInfo info_;
};
HeapObjectMatcher<Context> match(new_context_input);
CHECK_EQ(*native, *match.Value().handle());
ContextAccess access = OpParameter<ContextAccess>(r.replacement());
- CHECK_EQ(Context::GLOBAL_EVAL_FUN_INDEX, access.index());
- CHECK_EQ(0, access.depth());
+ CHECK_EQ(Context::GLOBAL_EVAL_FUN_INDEX, static_cast<int>(access.index()));
+ CHECK_EQ(0, static_cast<int>(access.depth()));
CHECK_EQ(false, access.immutable());
}
HeapObjectMatcher<Context> match(new_context_input);
CHECK_EQ(*native, *match.Value().handle());
ContextAccess access = OpParameter<ContextAccess>(r.replacement());
- CHECK_EQ(Context::GLOBAL_EVAL_FUN_INDEX, access.index());
- CHECK_EQ(0, access.depth());
+ CHECK_EQ(Context::GLOBAL_EVAL_FUN_INDEX, static_cast<int>(access.index()));
+ CHECK_EQ(0, static_cast<int>(access.depth()));
CHECK_EQ(false, access.immutable());
}
}
simplified(main_zone()),
common(main_zone()),
graph(main_zone()),
- typer(main_zone()),
+ typer(&graph, MaybeHandle<Context>()),
context_node(NULL) {
- typer.DecorateGraph(&graph);
- Node* s = graph.NewNode(common.Start(num_parameters));
- graph.SetStart(s);
+ graph.SetStart(graph.NewNode(common.Start(num_parameters)));
+ graph.SetEnd(graph.NewNode(common.End()));
+ typer.Run();
}
Isolate* isolate;
}
Node* UndefinedConstant() {
- Unique<Object> unique =
- Unique<Object>::CreateImmovable(isolate->factory()->undefined_value());
+ Unique<HeapObject> unique = Unique<HeapObject>::CreateImmovable(
+ isolate->factory()->undefined_value());
return graph.NewNode(common.HeapConstant(unique));
}
- Node* HeapConstant(Handle<Object> constant) {
- Unique<Object> unique = Unique<Object>::CreateUninitialized(constant);
+ Node* HeapConstant(Handle<HeapObject> constant) {
+ Unique<HeapObject> unique =
+ Unique<HeapObject>::CreateUninitialized(constant);
return graph.NewNode(common.HeapConstant(unique));
}
Node* stack = graph.NewNode(common.StateValues(0));
Node* state_node =
- graph.NewNode(common.FrameState(JS_FRAME, BailoutId(0), kIgnoreOutput),
+ graph.NewNode(common.FrameState(JS_FRAME, BailoutId(0),
+ OutputFrameStateCombine::Ignore()),
parameters, locals, stack, context, UndefinedConstant());
return state_node;
}
Node* reduce(Node* node) {
- JSGraph jsgraph(&graph, &common, &javascript, &typer, &machine);
+ JSGraph jsgraph(&graph, &common, &javascript, &machine);
JSTypedLowering reducer(&jsgraph);
Reduction reduction = reducer.Reduce(node);
if (reduction.Changed()) return reduction.replacement();
static void CheckToI32(Node* old_input, Node* new_input, bool is_signed) {
Type* old_type = NodeProperties::GetBounds(old_input).upper;
+ Type* new_type = NodeProperties::GetBounds(new_input).upper;
Type* expected_type = I32Type(is_signed);
+ CHECK(new_type->Is(expected_type));
if (old_type->Is(expected_type)) {
CHECK_EQ(old_input, new_input);
} else if (new_input->opcode() == IrOpcode::kNumberConstant) {
- CHECK(NodeProperties::GetBounds(new_input).upper->Is(expected_type));
double v = OpParameter<double>(new_input);
double e = static_cast<double>(is_signed ? FastD2I(v) : FastD2UI(v));
CHECK_EQ(e, v);
- } else {
- CHECK_EQ(NumberToI32(is_signed), new_input->opcode());
}
}
Type::Unsigned32(), Type::Signed32(), Type::MinusZero(),
Type::NaN(), Type::OtherNumber(), Type::Undefined(),
Type::Null(), Type::Boolean(), Type::Number(),
- Type::String(), Type::Object()};
+ Type::String()};
for (size_t i = 0; i < arraysize(types); ++i) {
Node* p0 = R.Parameter(types[i], 0);
JSBitwiseTypedLoweringTester R;
Type* types[] = {
- Type::SignedSmall(), Type::UnsignedSmall(), Type::OtherSigned32(),
- Type::Unsigned32(), Type::Signed32(), Type::MinusZero(),
- Type::NaN(), Type::OtherNumber(), Type::Undefined(),
- Type::Null(), Type::Boolean(), Type::Number(),
- Type::String(), Type::Object()};
+ Type::SignedSmall(), Type::UnsignedSmall(), Type::Unsigned32(),
+ Type::Signed32(), Type::MinusZero(), Type::NaN(),
+ Type::OtherNumber(), Type::Undefined(), Type::Null(),
+ Type::Boolean(), Type::Number(), Type::String()};
for (size_t i = 0; i < arraysize(types); ++i) {
Node* p0 = R.Parameter(types[i], 0);
{ // ToBoolean(string)
Node* r = R.ReduceUnop(op, Type::String());
- // TODO(titzer): test will break with better js-typed-lowering
- CHECK_EQ(IrOpcode::kJSToBoolean, r->opcode());
+ CHECK_EQ(IrOpcode::kBooleanNot, r->opcode());
+ Node* i = r->InputAt(0);
+ CHECK_EQ(IrOpcode::kNumberEqual, i->opcode());
+ Node* j = i->InputAt(0);
+ CHECK_EQ(IrOpcode::kLoadField, j->opcode());
+ // ToBoolean(x:string) => BooleanNot(NumberEqual(x.length, #0))
}
{ // ToBoolean(object)
R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual()};
- for (size_t i = 0; i < arraysize(kJSTypes); i++) {
- Type* t0 = kJSTypes[i];
- // Skip Type::String and Type::Receiver which might coerce into a string.
- if (t0->Is(Type::String()) || t0->Is(Type::Receiver())) continue;
- Node* p0 = R.Parameter(t0, 0);
-
- for (size_t j = 0; j < arraysize(kJSTypes); j++) {
- Type* t1 = kJSTypes[j];
- // Skip Type::String and Type::Receiver which might coerce into a string.
- if (t1->Is(Type::String()) || t0->Is(Type::Receiver())) continue;
- Node* p1 = R.Parameter(t1, 1);
+ Node* const p0 = R.Parameter(Type::Number(), 0);
+ Node* const p1 = R.Parameter(Type::Number(), 1);
- for (size_t k = 0; k < arraysize(ops); k += 2) {
- Node* cmp = R.Binop(ops[k], p0, p1);
- Node* r = R.reduce(cmp);
+ for (size_t k = 0; k < arraysize(ops); k += 2) {
+ Node* cmp = R.Binop(ops[k], p0, p1);
+ Node* r = R.reduce(cmp);
- R.CheckPureBinop(ops[k + 1], r);
- if (k >= 4) {
- // GreaterThan and GreaterThanOrEqual commute the inputs
- // and use the LessThan and LessThanOrEqual operators.
- CheckIsConvertedToNumber(p1, r->InputAt(0));
- CheckIsConvertedToNumber(p0, r->InputAt(1));
- } else {
- CheckIsConvertedToNumber(p0, r->InputAt(0));
- CheckIsConvertedToNumber(p1, r->InputAt(1));
- }
- }
+ R.CheckPureBinop(ops[k + 1], r);
+ if (k >= 4) {
+ // GreaterThan and GreaterThanOrEqual commute the inputs
+ // and use the LessThan and LessThanOrEqual operators.
+ CheckIsConvertedToNumber(p1, r->InputAt(0));
+ CheckIsConvertedToNumber(p0, r->InputAt(1));
+ } else {
+ CheckIsConvertedToNumber(p0, r->InputAt(0));
+ CheckIsConvertedToNumber(p1, r->InputAt(1));
}
}
}
}
-TEST(ObjectComparison) {
- JSTypedLoweringTester R;
-
- Node* p0 = R.Parameter(Type::Number(), 0);
- Node* p1 = R.Parameter(Type::Object(), 1);
-
- Node* cmp = R.Binop(R.javascript.LessThan(), p0, p1);
- Node* effect_use = R.UseForEffect(cmp);
-
- R.CheckEffectInput(R.start(), cmp);
- R.CheckEffectInput(cmp, effect_use);
-
- Node* r = R.reduce(cmp);
-
- R.CheckPureBinop(R.simplified.NumberLessThan(), r);
-
- Node* i0 = r->InputAt(0);
- Node* i1 = r->InputAt(1);
-
- CHECK_EQ(p0, i0);
- CHECK_NE(p1, i1);
- CHECK_EQ(IrOpcode::kParameter, i0->opcode());
- CHECK_EQ(IrOpcode::kJSToNumber, i1->opcode());
-
- // Check effect chain is correct.
- R.CheckEffectInput(R.start(), i1);
- R.CheckEffectInput(i1, effect_use);
-}
-
-
TEST(UnaryNot) {
JSTypedLoweringTester R;
const Operator* opnot = R.javascript.UnaryNot();
Node* CheckConverted(IrOpcode::Value opcode, Node* node, bool effects) {
CHECK_EQ(opcode, node->opcode());
if (effects) {
- CHECK_LT(0, OperatorProperties::GetEffectInputCount(node->op()));
+ CHECK_LT(0, node->op()->EffectInputCount());
} else {
- CHECK_EQ(0, OperatorProperties::GetEffectInputCount(node->op()));
+ CHECK_EQ(0, node->op()->EffectInputCount());
}
return node;
}
};
for (size_t j = 0; j < arraysize(ops); j += 2) {
- BinopEffectsTester B(ops[j], Type::Object(), Type::String());
+ BinopEffectsTester B(ops[j], Type::String(), Type::String());
CHECK_EQ(ops[j + 1]->opcode(), B.result->op()->opcode());
Node* i0 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 0, true);
for (int j = 0; j < R.kNumberOps; j += 2) {
bool signed_left = R.signedness[j], signed_right = R.signedness[j + 1];
- BinopEffectsTester B(R.ops[j], Type::Number(), Type::Object());
+ BinopEffectsTester B(R.ops[j], Type::Number(), Type::Primitive());
B.R.CheckPureBinop(B.result->opcode(), B.result);
for (int j = 0; j < R.kNumberOps; j += 2) {
bool signed_left = R.signedness[j], signed_right = R.signedness[j + 1];
- BinopEffectsTester B(R.ops[j], Type::Object(), Type::Number());
+ BinopEffectsTester B(R.ops[j], Type::Primitive(), Type::Number());
B.R.CheckPureBinop(B.result->opcode(), B.result);
for (int j = 0; j < R.kNumberOps; j += 2) {
bool signed_left = R.signedness[j], signed_right = R.signedness[j + 1];
- BinopEffectsTester B(R.ops[j], Type::Object(), Type::Object());
+ BinopEffectsTester B(R.ops[j], Type::Primitive(), Type::Primitive());
B.R.CheckPureBinop(B.result->opcode(), B.result);
using namespace v8::internal;
using namespace v8::internal::compiler;
-static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
- 0, 0, "dummy");
+static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
+ "dummy", 0, 0, 0, 0, 0, 0);
// So we can get a real JS function.
static Handle<JSFunction> Compile(const char* source) {
InitializedHandleScope handles;
Handle<JSFunction> function = Compile("a + b");
CompilationInfoWithZone info(function);
- Linkage linkage(&info);
+ Linkage linkage(info.zone(), &info);
}
Handle<JSFunction> function = v8::Utils::OpenHandle(
*v8::Handle<v8::Function>::Cast(CompileRun(sources[i])));
CompilationInfoWithZone info(function);
- Linkage linkage(&info);
+ Linkage linkage(info.zone(), &info);
CallDescriptor* descriptor = linkage.GetIncomingDescriptor();
CHECK_NE(NULL, descriptor);
TEST(TestLinkageCodeStubIncoming) {
Isolate* isolate = CcTest::InitIsolateOnce();
CompilationInfoWithZone info(static_cast<HydrogenCodeStub*>(NULL), isolate);
- Linkage linkage(&info);
+ Linkage linkage(info.zone(), &info);
// TODO(titzer): test linkage creation with a bonafide code stub.
// this just checks current behavior.
CHECK_EQ(NULL, linkage.GetIncomingDescriptor());
HandleAndZoneScope handles;
Handle<JSFunction> function = Compile("a + c");
CompilationInfoWithZone info(function);
- Linkage linkage(&info);
+ Linkage linkage(info.zone(), &info);
for (int i = 0; i < 32; i++) {
- CallDescriptor* descriptor = linkage.GetJSCallDescriptor(i);
+ CallDescriptor* descriptor =
+ linkage.GetJSCallDescriptor(i, CallDescriptor::kNoFlags);
CHECK_NE(NULL, descriptor);
CHECK_EQ(i, descriptor->JSParameterCount());
CHECK_EQ(1, descriptor->ReturnCount());
--- /dev/null
+// 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/ast-loop-assignment-analyzer.h"
+#include "src/parser.h"
+#include "src/rewriter.h"
+#include "src/scopes.h"
+#include "test/cctest/cctest.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+namespace {
+const int kBufferSize = 1024;
+
+struct TestHelper : public HandleAndZoneScope {
+ Handle<JSFunction> function;
+ LoopAssignmentAnalysis* result;
+
+ explicit TestHelper(const char* body)
+ : function(Handle<JSFunction>::null()), result(NULL) {
+ ScopedVector<char> program(kBufferSize);
+ SNPrintF(program, "function f(a,b,c) { %s; } f;", body);
+ v8::Local<v8::Value> v = CompileRun(program.start());
+ Handle<Object> obj = v8::Utils::OpenHandle(*v);
+ function = Handle<JSFunction>::cast(obj);
+ }
+
+ void CheckLoopAssignedCount(int expected, const char* var_name) {
+ // TODO(titzer): don't scope analyze every single time.
+ CompilationInfo info(function, main_zone());
+
+ CHECK(Parser::Parse(&info));
+ CHECK(Rewriter::Rewrite(&info));
+ CHECK(Scope::Analyze(&info));
+
+ Scope* scope = info.function()->scope();
+ AstValueFactory* factory = info.ast_value_factory();
+ CHECK_NE(NULL, scope);
+
+ if (result == NULL) {
+ AstLoopAssignmentAnalyzer analyzer(main_zone(), &info);
+ result = analyzer.Analyze();
+ CHECK_NE(NULL, result);
+ }
+
+ const i::AstRawString* name = factory->GetOneByteString(var_name);
+
+ i::Variable* var = scope->Lookup(name);
+ CHECK_NE(NULL, var);
+
+ if (var->location() == Variable::UNALLOCATED) {
+ CHECK_EQ(0, expected);
+ } else {
+ CHECK(var->IsStackAllocated());
+ CHECK_EQ(expected, result->GetAssignmentCountForTesting(scope, var));
+ }
+ }
+};
+}
+
+
+TEST(SimpleLoop1) {
+ TestHelper f("var x = 0; while (x) ;");
+
+ f.CheckLoopAssignedCount(0, "x");
+}
+
+
+TEST(SimpleLoop2) {
+ const char* loops[] = {
+ "while (x) { var x = 0; }", "for(;;) { var x = 0; }",
+ "for(;x;) { var x = 0; }", "for(;x;x) { var x = 0; }",
+ "for(var i = x; x; x) { var x = 0; }", "for(y in 0) { var x = 0; }",
+ "for(y of 0) { var x = 0; }", "for(var x = 0; x; x++) { }",
+ "for(var x = 0; x++;) { }", "var x; for(;x;x++) { }",
+ "var x; do { x = 1; } while (0);", "do { var x = 1; } while (0);"};
+
+ for (size_t i = 0; i < arraysize(loops); i++) {
+ TestHelper f(loops[i]);
+ f.CheckLoopAssignedCount(1, "x");
+ }
+}
+
+
+TEST(ForInOf1) {
+ const char* loops[] = {
+ "for(x in 0) { }", "for(x of 0) { }",
+ };
+
+ for (size_t i = 0; i < arraysize(loops); i++) {
+ TestHelper f(loops[i]);
+ f.CheckLoopAssignedCount(0, "x");
+ }
+}
+
+
+TEST(Param1) {
+ TestHelper f("while (1) a = 0;");
+
+ f.CheckLoopAssignedCount(1, "a");
+ f.CheckLoopAssignedCount(0, "b");
+ f.CheckLoopAssignedCount(0, "c");
+}
+
+
+TEST(Param2) {
+ TestHelper f("for (;;) b = 0;");
+
+ f.CheckLoopAssignedCount(0, "a");
+ f.CheckLoopAssignedCount(1, "b");
+ f.CheckLoopAssignedCount(0, "c");
+}
+
+
+TEST(Param2b) {
+ TestHelper f("a; b; c; for (;;) b = 0;");
+
+ f.CheckLoopAssignedCount(0, "a");
+ f.CheckLoopAssignedCount(1, "b");
+ f.CheckLoopAssignedCount(0, "c");
+}
+
+
+TEST(Param3) {
+ TestHelper f("for(x in 0) c = 0;");
+
+ f.CheckLoopAssignedCount(0, "a");
+ f.CheckLoopAssignedCount(0, "b");
+ f.CheckLoopAssignedCount(1, "c");
+}
+
+
+TEST(Param3b) {
+ TestHelper f("a; b; c; for(x in 0) c = 0;");
+
+ f.CheckLoopAssignedCount(0, "a");
+ f.CheckLoopAssignedCount(0, "b");
+ f.CheckLoopAssignedCount(1, "c");
+}
+
+
+TEST(NestedLoop1) {
+ TestHelper f("while (x) { while (x) { var x = 0; } }");
+
+ f.CheckLoopAssignedCount(2, "x");
+}
+
+
+TEST(NestedLoop2) {
+ TestHelper f("while (0) { while (0) { var x = 0; } }");
+
+ f.CheckLoopAssignedCount(2, "x");
+}
+
+
+TEST(NestedLoop3) {
+ TestHelper f("while (0) { var y = 1; while (0) { var x = 0; } }");
+
+ f.CheckLoopAssignedCount(2, "x");
+ f.CheckLoopAssignedCount(1, "y");
+}
+
+
+TEST(NestedInc1) {
+ const char* loops[] = {
+ "while (1) a(b++);",
+ "while (1) a(0, b++);",
+ "while (1) a(0, 0, b++);",
+ "while (1) a(b++, 1, 1);",
+ "while (1) a(++b);",
+ "while (1) a + (b++);",
+ "while (1) (b++) + a;",
+ "while (1) a + c(b++);",
+ "while (1) throw b++;",
+ "while (1) switch (b++) {} ;",
+ "while (1) switch (a) {case (b++): 0; } ;",
+ "while (1) switch (a) {case b: b++; } ;",
+ "while (1) a == (b++);",
+ "while (1) a === (b++);",
+ "while (1) +(b++);",
+ "while (1) ~(b++);",
+ "while (1) new a(b++);",
+ "while (1) (b++).f;",
+ "while (1) a[b++];",
+ "while (1) (b++)();",
+ "while (1) [b++];",
+ "while (1) [0,b++];",
+ "while (1) var y = [11,b++,12];",
+ "while (1) var y = {f:11,g:(b++),h:12};",
+ "while (1) try {b++;} finally {};",
+ "while (1) try {} finally {b++};",
+ "while (1) try {b++;} catch (e) {};",
+ "while (1) try {} catch (e) {b++};",
+ "while (1) return b++;",
+ "while (1) (b++) ? b : b;",
+ "while (1) b ? (b++) : b;",
+ "while (1) b ? b : (b++);",
+ };
+
+ for (size_t i = 0; i < arraysize(loops); i++) {
+ TestHelper f(loops[i]);
+ f.CheckLoopAssignedCount(1, "b");
+ }
+}
+
+
+TEST(NestedAssign1) {
+ const char* loops[] = {
+ "while (1) a(b=1);",
+ "while (1) a(0, b=1);",
+ "while (1) a(0, 0, b=1);",
+ "while (1) a(b=1, 1, 1);",
+ "while (1) a + (b=1);",
+ "while (1) (b=1) + a;",
+ "while (1) a + c(b=1);",
+ "while (1) throw b=1;",
+ "while (1) switch (b=1) {} ;",
+ "while (1) switch (a) {case b=1: 0; } ;",
+ "while (1) switch (a) {case b: b=1; } ;",
+ "while (1) a == (b=1);",
+ "while (1) a === (b=1);",
+ "while (1) +(b=1);",
+ "while (1) ~(b=1);",
+ "while (1) new a(b=1);",
+ "while (1) (b=1).f;",
+ "while (1) a[b=1];",
+ "while (1) (b=1)();",
+ "while (1) [b=1];",
+ "while (1) [0,b=1];",
+ "while (1) var z = [11,b=1,12];",
+ "while (1) var y = {f:11,g:(b=1),h:12};",
+ "while (1) try {b=1;} finally {};",
+ "while (1) try {} finally {b=1};",
+ "while (1) try {b=1;} catch (e) {};",
+ "while (1) try {} catch (e) {b=1};",
+ "while (1) return b=1;",
+ "while (1) (b=1) ? b : b;",
+ "while (1) b ? (b=1) : b;",
+ "while (1) b ? b : (b=1);",
+ };
+
+ for (size_t i = 0; i < arraysize(loops); i++) {
+ TestHelper f(loops[i]);
+ f.CheckLoopAssignedCount(1, "b");
+ }
+}
+
+
+TEST(NestedLoops3) {
+ TestHelper f("var x, y, z, w; while (x++) while (y++) while (z++) ; w;");
+
+ f.CheckLoopAssignedCount(1, "x");
+ f.CheckLoopAssignedCount(2, "y");
+ f.CheckLoopAssignedCount(3, "z");
+ f.CheckLoopAssignedCount(0, "w");
+}
+
+
+TEST(NestedLoops3b) {
+ TestHelper f(
+ "var x, y, z, w;"
+ "while (1) { x=1; while (1) { y=1; while (1) z=1; } }"
+ "w;");
+
+ f.CheckLoopAssignedCount(1, "x");
+ f.CheckLoopAssignedCount(2, "y");
+ f.CheckLoopAssignedCount(3, "z");
+ f.CheckLoopAssignedCount(0, "w");
+}
+
+
+TEST(NestedLoops3c) {
+ TestHelper f(
+ "var x, y, z, w;"
+ "while (1) {"
+ " x++;"
+ " while (1) {"
+ " y++;"
+ " while (1) z++;"
+ " }"
+ " while (1) {"
+ " y++;"
+ " while (1) z++;"
+ " }"
+ "}"
+ "w;");
+
+ f.CheckLoopAssignedCount(1, "x");
+ f.CheckLoopAssignedCount(3, "y");
+ f.CheckLoopAssignedCount(5, "z");
+ f.CheckLoopAssignedCount(0, "w");
+}
#include "test/cctest/cctest.h"
#include "src/base/utils/random-number-generator.h"
+#include "src/codegen.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/machine-operator-reducer.h"
+#include "src/compiler/operator-properties.h"
+#include "src/compiler/operator-properties-inl.h"
#include "src/compiler/typer.h"
#include "test/cctest/compiler/value-helper.h"
common(main_zone()),
graph(main_zone()),
javascript(main_zone()),
- typer(main_zone()),
- jsgraph(&graph, &common, &javascript, &typer, &machine),
+ typer(&graph, MaybeHandle<Context>()),
+ jsgraph(&graph, &common, &javascript, &machine),
maxuint32(Constant<int32_t>(kMaxUInt32)) {
Node* s = graph.NewNode(common.Start(num_parameters));
graph.SetStart(s);
template <typename T>
void CheckFoldBinop(volatile T expect, Node* a, Node* b) {
CHECK_NE(NULL, binop);
- Node* n = graph.NewNode(binop, a, b);
+ Node* n = CreateBinopNode(a, b);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
// the {expect} node.
void CheckBinop(Node* expect, Node* a, Node* b) {
CHECK_NE(NULL, binop);
- Node* n = graph.NewNode(binop, a, b);
+ Node* n = CreateBinopNode(a, b);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
void CheckFoldBinop(Node* left_expect, Node* right_expect, Node* left,
Node* right) {
CHECK_NE(NULL, binop);
- Node* n = graph.NewNode(binop, left, right);
+ Node* n = CreateBinopNode(left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
void CheckFoldBinop(volatile T left_expect, const Operator* op_expect,
Node* right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
- Node* n = graph.NewNode(binop, left, right);
+ Node* n = CreateBinopNode(left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction r = reducer.Reduce(n);
CHECK(r.Changed());
void CheckFoldBinop(Node* left_expect, const Operator* op_expect,
volatile T right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
- Node* n = graph.NewNode(binop, left, right);
+ Node* n = CreateBinopNode(left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction r = reducer.Reduce(n);
CHECK(r.Changed());
CHECK_EQ(op_expect->opcode(), r.replacement()->op()->opcode());
+ CHECK_EQ(OperatorProperties::GetTotalInputCount(op_expect),
+ r.replacement()->InputCount());
CHECK_EQ(left_expect, r.replacement()->InputAt(0));
CHECK_EQ(right_expect, ValueOf<T>(r.replacement()->InputAt(1)->op()));
}
Node* p = Parameter();
Node* k = Constant<T>(constant);
{
- Node* n = graph.NewNode(binop, k, p);
+ Node* n = CreateBinopNode(k, p);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed() || reduction.replacement() == n);
CHECK_EQ(k, n->InputAt(1));
}
{
- Node* n = graph.NewNode(binop, p, k);
+ Node* n = CreateBinopNode(p, k);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed());
CHECK(!binop->HasProperty(Operator::kCommutative));
Node* p = Parameter();
Node* k = Constant<T>(constant);
- Node* n = graph.NewNode(binop, k, p);
+ Node* n = CreateBinopNode(k, p);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed());
Node* Parameter(int32_t index = 0) {
return graph.NewNode(common.Parameter(index), graph.start());
}
+
+ private:
+ Node* CreateBinopNode(Node* left, Node* right) {
+ if (binop->ControlInputCount() > 0) {
+ return graph.NewNode(binop, left, right, graph.start());
+ } else {
+ return graph.NewNode(binop, left, right);
+ }
+ }
};
}
-TEST(ReduceInt32UDiv) {
+TEST(ReduceUint32Div) {
ReducerTester R;
- R.binop = R.machine.Int32UDiv();
+ R.binop = R.machine.Uint32Div();
FOR_UINT32_INPUTS(pl) {
FOR_UINT32_INPUTS(pr) {
}
-TEST(ReduceInt32UMod) {
+TEST(ReduceUint32Mod) {
ReducerTester R;
- R.binop = R.machine.Int32UMod();
+ R.binop = R.machine.Uint32Mod();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
// TODO(titzer): test MachineOperatorReducer for Int64Mul
// TODO(titzer): test MachineOperatorReducer for Int64UMul
// TODO(titzer): test MachineOperatorReducer for Int64Div
-// TODO(titzer): test MachineOperatorReducer for Int64UDiv
+// TODO(titzer): test MachineOperatorReducer for Uint64Div
// TODO(titzer): test MachineOperatorReducer for Int64Mod
-// TODO(titzer): test MachineOperatorReducer for Int64UMod
+// TODO(titzer): test MachineOperatorReducer for Uint64Mod
// TODO(titzer): test MachineOperatorReducer for Int64Neg
// TODO(titzer): test MachineOperatorReducer for ChangeInt32ToFloat64
// TODO(titzer): test MachineOperatorReducer for ChangeFloat64ToInt32
using namespace v8::internal;
using namespace v8::internal::compiler;
-static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
- 0, 0, "dummy");
+static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
+ "dummy", 0, 0, 0, 1, 0, 0);
class PreNodeVisitor : public NullNodeVisitor {
public:
- GenericGraphVisit::Control Pre(Node* node) {
+ void Pre(Node* node) {
printf("NODE ID: %d\n", node->id());
nodes_.push_back(node);
- return GenericGraphVisit::CONTINUE;
}
std::vector<Node*> nodes_;
};
class PostNodeVisitor : public NullNodeVisitor {
public:
- GenericGraphVisit::Control Post(Node* node) {
+ void Post(Node* node) {
printf("NODE ID: %d\n", node->id());
nodes_.push_back(node);
- return GenericGraphVisit::CONTINUE;
}
std::vector<Node*> nodes_;
};
}
-struct ReenterNodeVisitor : NullNodeVisitor {
- GenericGraphVisit::Control Pre(Node* node) {
- printf("[%d] PRE NODE: %d\n", static_cast<int>(nodes_.size()), node->id());
- nodes_.push_back(node->id());
- int size = static_cast<int>(nodes_.size());
- switch (node->id()) {
- case 0:
- return size < 6 ? GenericGraphVisit::REENTER : GenericGraphVisit::SKIP;
- case 1:
- return size < 4 ? GenericGraphVisit::DEFER
- : GenericGraphVisit::CONTINUE;
- default:
- return GenericGraphVisit::REENTER;
- }
- }
-
- GenericGraphVisit::Control Post(Node* node) {
- printf("[%d] POST NODE: %d\n", static_cast<int>(nodes_.size()), node->id());
- nodes_.push_back(-node->id());
- return node->id() == 4 ? GenericGraphVisit::REENTER
- : GenericGraphVisit::CONTINUE;
- }
-
- void PreEdge(Node* from, int index, Node* to) {
- printf("[%d] PRE EDGE: %d-%d\n", static_cast<int>(edges_.size()),
- from->id(), to->id());
- edges_.push_back(std::make_pair(from->id(), to->id()));
- }
-
- void PostEdge(Node* from, int index, Node* to) {
- printf("[%d] POST EDGE: %d-%d\n", static_cast<int>(edges_.size()),
- from->id(), to->id());
- edges_.push_back(std::make_pair(-from->id(), -to->id()));
- }
-
- std::vector<int> nodes_;
- std::vector<std::pair<int, int> > edges_;
-};
-
-
-TEST(TestUseNodeReenterVisit) {
- GraphWithStartNodeTester graph;
- Node* n0 = graph.start_node();
- Node* n1 = graph.NewNode(&dummy_operator, n0);
- Node* n2 = graph.NewNode(&dummy_operator, n0);
- Node* n3 = graph.NewNode(&dummy_operator, n2);
- Node* n4 = graph.NewNode(&dummy_operator, n0);
- Node* n5 = graph.NewNode(&dummy_operator, n4);
- n0->AppendInput(graph.main_zone(), n3);
- graph.SetStart(n0);
- graph.SetEnd(n5);
-
- ReenterNodeVisitor visitor;
- graph.VisitNodeUsesFromStart(&visitor);
-
- CHECK_EQ(22, static_cast<int>(visitor.nodes_.size()));
- CHECK_EQ(24, static_cast<int>(visitor.edges_.size()));
-
- CHECK(n0->id() == visitor.nodes_[0]);
- CHECK(n0->id() == visitor.edges_[0].first);
- CHECK(n1->id() == visitor.edges_[0].second);
- CHECK(n1->id() == visitor.nodes_[1]);
- // N1 is deferred.
- CHECK(-n1->id() == visitor.edges_[1].second);
- CHECK(-n0->id() == visitor.edges_[1].first);
- CHECK(n0->id() == visitor.edges_[2].first);
- CHECK(n2->id() == visitor.edges_[2].second);
- CHECK(n2->id() == visitor.nodes_[2]);
- CHECK(n2->id() == visitor.edges_[3].first);
- CHECK(n3->id() == visitor.edges_[3].second);
- CHECK(n3->id() == visitor.nodes_[3]);
- // Circle back to N0, which we may reenter for now.
- CHECK(n3->id() == visitor.edges_[4].first);
- CHECK(n0->id() == visitor.edges_[4].second);
- CHECK(n0->id() == visitor.nodes_[4]);
- CHECK(n0->id() == visitor.edges_[5].first);
- CHECK(n1->id() == visitor.edges_[5].second);
- CHECK(n1->id() == visitor.nodes_[5]);
- // This time N1 is no longer deferred.
- CHECK(-n1->id() == visitor.nodes_[6]);
- CHECK(-n1->id() == visitor.edges_[6].second);
- CHECK(-n0->id() == visitor.edges_[6].first);
- CHECK(n0->id() == visitor.edges_[7].first);
- CHECK(n2->id() == visitor.edges_[7].second);
- CHECK(n2->id() == visitor.nodes_[7]);
- CHECK(n2->id() == visitor.edges_[8].first);
- CHECK(n3->id() == visitor.edges_[8].second);
- CHECK(n3->id() == visitor.nodes_[8]);
- CHECK(n3->id() == visitor.edges_[9].first);
- CHECK(n0->id() == visitor.edges_[9].second);
- CHECK(n0->id() == visitor.nodes_[9]);
- // This time we break at N0 and skip it.
- CHECK(-n0->id() == visitor.edges_[10].second);
- CHECK(-n3->id() == visitor.edges_[10].first);
- CHECK(-n3->id() == visitor.nodes_[10]);
- CHECK(-n3->id() == visitor.edges_[11].second);
- CHECK(-n2->id() == visitor.edges_[11].first);
- CHECK(-n2->id() == visitor.nodes_[11]);
- CHECK(-n2->id() == visitor.edges_[12].second);
- CHECK(-n0->id() == visitor.edges_[12].first);
- CHECK(n0->id() == visitor.edges_[13].first);
- CHECK(n4->id() == visitor.edges_[13].second);
- CHECK(n4->id() == visitor.nodes_[12]);
- CHECK(n4->id() == visitor.edges_[14].first);
- CHECK(n5->id() == visitor.edges_[14].second);
- CHECK(n5->id() == visitor.nodes_[13]);
- CHECK(-n5->id() == visitor.nodes_[14]);
- CHECK(-n5->id() == visitor.edges_[15].second);
- CHECK(-n4->id() == visitor.edges_[15].first);
- CHECK(-n4->id() == visitor.nodes_[15]);
- CHECK(-n4->id() == visitor.edges_[16].second);
- CHECK(-n0->id() == visitor.edges_[16].first);
- CHECK(-n0->id() == visitor.nodes_[16]);
- CHECK(-n0->id() == visitor.edges_[17].second);
- CHECK(-n3->id() == visitor.edges_[17].first);
- CHECK(-n3->id() == visitor.nodes_[17]);
- CHECK(-n3->id() == visitor.edges_[18].second);
- CHECK(-n2->id() == visitor.edges_[18].first);
- CHECK(-n2->id() == visitor.nodes_[18]);
- CHECK(-n2->id() == visitor.edges_[19].second);
- CHECK(-n0->id() == visitor.edges_[19].first);
- // N4 may be reentered.
- CHECK(n0->id() == visitor.edges_[20].first);
- CHECK(n4->id() == visitor.edges_[20].second);
- CHECK(n4->id() == visitor.nodes_[19]);
- CHECK(n4->id() == visitor.edges_[21].first);
- CHECK(n5->id() == visitor.edges_[21].second);
- CHECK(-n5->id() == visitor.edges_[22].second);
- CHECK(-n4->id() == visitor.edges_[22].first);
- CHECK(-n4->id() == visitor.nodes_[20]);
- CHECK(-n4->id() == visitor.edges_[23].second);
- CHECK(-n0->id() == visitor.edges_[23].first);
- CHECK(-n0->id() == visitor.nodes_[21]);
-}
-
-
TEST(TestPrintNodeGraphToNodeGraphviz) {
GraphWithStartNodeTester graph;
Node* n2 = graph.NewNode(&dummy_operator, graph.start());
}
CHECK_LT(4, hits);
}
+
+
+static bool Contains(NodeVector* nodes, Node* n) {
+ for (size_t i = 0; i < nodes->size(); i++) {
+ if (nodes->at(i) == n) return true;
+ }
+ return false;
+}
+
+
+TEST(NodeCache_GetCachedNodes_int32) {
+ GraphTester graph;
+ Int32NodeCache cache;
+ CommonOperatorBuilder common(graph.zone());
+
+ int32_t constants[] = {0, 311, 12, 13, 14, 555, -555, -44, -33, -22, -11,
+ 0, 311, 311, 412, 412, 11, 11, -33, -33, -22, -11};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int32_t k = constants[i];
+ Node** pos = cache.Find(graph.zone(), k);
+ if (*pos != NULL) {
+ NodeVector nodes(graph.zone());
+ cache.GetCachedNodes(&nodes);
+ CHECK(Contains(&nodes, *pos));
+ } else {
+ NodeVector nodes(graph.zone());
+ Node* n = graph.NewNode(common.Int32Constant(k));
+ *pos = n;
+ cache.GetCachedNodes(&nodes);
+ CHECK(Contains(&nodes, n));
+ }
+ }
+}
+
+
+TEST(NodeCache_GetCachedNodes_int64) {
+ GraphTester graph;
+ Int64NodeCache cache;
+ CommonOperatorBuilder common(graph.zone());
+
+ int64_t constants[] = {0, 311, 12, 13, 14, 555, -555, -44, -33, -22, -11,
+ 0, 311, 311, 412, 412, 11, 11, -33, -33, -22, -11};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int64_t k = constants[i];
+ Node** pos = cache.Find(graph.zone(), k);
+ if (*pos != NULL) {
+ NodeVector nodes(graph.zone());
+ cache.GetCachedNodes(&nodes);
+ CHECK(Contains(&nodes, *pos));
+ } else {
+ NodeVector nodes(graph.zone());
+ Node* n = graph.NewNode(common.Int64Constant(k));
+ *pos = n;
+ cache.GetCachedNodes(&nodes);
+ CHECK(Contains(&nodes, n));
+ }
+ }
+}
using namespace v8::internal;
using namespace v8::internal::compiler;
-static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
- 0, 0, "dummy");
+static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
+ "dummy", 0, 0, 0, 1, 0, 0);
TEST(NodeAllocation) {
GraphTester graph;
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <sstream>
+
#include "src/v8.h"
#include "src/compiler/operator.h"
using namespace v8::internal;
using namespace v8::internal::compiler;
-#define NaN (v8::base::OS::nan_value())
-#define Infinity (std::numeric_limits<double>::infinity())
+#define NONE Operator::kNoProperties
+#define FOLD Operator::kFoldable
+
-TEST(TestOperatorMnemonic) {
- SimpleOperator op1(10, Operator::kNoProperties, 0, 0, "ThisOne");
+TEST(TestOperator_Mnemonic) {
+ Operator op1(10, NONE, "ThisOne", 0, 0, 0, 0, 0, 0);
CHECK_EQ(0, strcmp(op1.mnemonic(), "ThisOne"));
- SimpleOperator op2(11, Operator::kNoProperties, 0, 0, "ThatOne");
+ Operator op2(11, NONE, "ThatOne", 0, 0, 0, 0, 0, 0);
CHECK_EQ(0, strcmp(op2.mnemonic(), "ThatOne"));
- Operator1<int> op3(12, Operator::kNoProperties, 0, 1, "Mnemonic1", 12333);
+ Operator1<int> op3(12, NONE, "Mnemonic1", 0, 0, 0, 1, 0, 0, 12333);
CHECK_EQ(0, strcmp(op3.mnemonic(), "Mnemonic1"));
- Operator1<double> op4(13, Operator::kNoProperties, 0, 1, "TheOther", 99.9);
+ Operator1<double> op4(13, NONE, "TheOther", 0, 0, 0, 1, 0, 0, 99.9);
CHECK_EQ(0, strcmp(op4.mnemonic(), "TheOther"));
}
-TEST(TestSimpleOperatorHash) {
- SimpleOperator op1(17, Operator::kNoProperties, 0, 0, "Another");
- CHECK_EQ(17, op1.HashCode());
+TEST(TestOperator_Hash) {
+ Operator op1(17, NONE, "Another", 0, 0, 0, 0, 0, 0);
+ CHECK_EQ(17, static_cast<int>(op1.HashCode()));
- SimpleOperator op2(18, Operator::kNoProperties, 0, 0, "Falsch");
- CHECK_EQ(18, op2.HashCode());
+ Operator op2(18, NONE, "Falsch", 0, 0, 0, 0, 0, 0);
+ CHECK_EQ(18, static_cast<int>(op2.HashCode()));
}
-TEST(TestSimpleOperatorEquals) {
- SimpleOperator op1a(19, Operator::kNoProperties, 0, 0, "Another1");
- SimpleOperator op1b(19, Operator::kFoldable, 2, 2, "Another2");
+TEST(TestOperator_Equals) {
+ Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
+ Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
CHECK(op1a.Equals(&op1a));
CHECK(op1a.Equals(&op1b));
CHECK(op1b.Equals(&op1a));
CHECK(op1b.Equals(&op1b));
- SimpleOperator op2a(20, Operator::kNoProperties, 0, 0, "Falsch1");
- SimpleOperator op2b(20, Operator::kFoldable, 1, 1, "Falsch2");
+ Operator op2a(20, NONE, "Falsch1", 0, 0, 0, 0, 0, 0);
+ Operator op2b(20, FOLD, "Falsch2", 1, 0, 0, 1, 0, 0);
CHECK(op2a.Equals(&op2a));
CHECK(op2a.Equals(&op2b));
static SmartArrayPointer<const char> OperatorToString(Operator* op) {
- OStringStream os;
+ std::ostringstream os;
os << *op;
- return SmartArrayPointer<const char>(StrDup(os.c_str()));
+ return SmartArrayPointer<const char>(StrDup(os.str().c_str()));
}
-TEST(TestSimpleOperatorPrint) {
- SimpleOperator op1a(19, Operator::kNoProperties, 0, 0, "Another1");
- SimpleOperator op1b(19, Operator::kFoldable, 2, 2, "Another2");
+TEST(TestOperator_Print) {
+ Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
+ Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
CHECK_EQ("Another1", OperatorToString(&op1a).get());
CHECK_EQ("Another2", OperatorToString(&op1b).get());
- SimpleOperator op2a(20, Operator::kNoProperties, 0, 0, "Flog1");
- SimpleOperator op2b(20, Operator::kFoldable, 1, 1, "Flog2");
+ Operator op2a(20, NONE, "Flog1", 0, 0, 0, 0, 0, 0);
+ Operator op2b(20, FOLD, "Flog2", 1, 0, 0, 1, 0, 0);
CHECK_EQ("Flog1", OperatorToString(&op2a).get());
CHECK_EQ("Flog2", OperatorToString(&op2b).get());
}
-TEST(TestOperator1intHash) {
- Operator1<int> op1a(23, Operator::kNoProperties, 0, 0, "Wolfie", 11);
- Operator1<int> op1b(23, Operator::kFoldable, 2, 2, "Doggie", 11);
+TEST(TestOperator1int_Hash) {
+ Operator1<int> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11);
+ Operator1<int> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11);
- CHECK_EQ(op1a.HashCode(), op1b.HashCode());
+ CHECK(op1a.HashCode() == op1b.HashCode());
- Operator1<int> op2a(24, Operator::kNoProperties, 0, 0, "Arfie", 3);
- Operator1<int> op2b(24, Operator::kNoProperties, 0, 0, "Arfie", 4);
+ Operator1<int> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 3);
+ Operator1<int> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 4);
- CHECK_NE(op1a.HashCode(), op2a.HashCode());
- CHECK_NE(op2a.HashCode(), op2b.HashCode());
+ CHECK(op1a.HashCode() != op2a.HashCode());
+ CHECK(op2a.HashCode() != op2b.HashCode());
}
-TEST(TestOperator1intEquals) {
- Operator1<int> op1a(23, Operator::kNoProperties, 0, 0, "Scratchy", 11);
- Operator1<int> op1b(23, Operator::kFoldable, 2, 2, "Scratchy", 11);
+TEST(TestOperator1int_Equals) {
+ Operator1<int> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11);
+ Operator1<int> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11);
CHECK(op1a.Equals(&op1a));
CHECK(op1a.Equals(&op1b));
CHECK(op1b.Equals(&op1a));
CHECK(op1b.Equals(&op1b));
- Operator1<int> op2a(24, Operator::kNoProperties, 0, 0, "Im", 3);
- Operator1<int> op2b(24, Operator::kNoProperties, 0, 0, "Im", 4);
+ Operator1<int> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3);
+ Operator1<int> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 4);
CHECK(op2a.Equals(&op2a));
CHECK(!op2a.Equals(&op2b));
CHECK(!op2b.Equals(&op1a));
CHECK(!op2b.Equals(&op1b));
- SimpleOperator op3(25, Operator::kNoProperties, 0, 0, "Weepy");
+ Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
CHECK(!op1a.Equals(&op3));
CHECK(!op1b.Equals(&op3));
}
-TEST(TestOperator1intPrint) {
- Operator1<int> op1(12, Operator::kNoProperties, 0, 1, "Op1Test", 0);
+TEST(TestOperator1int_Print) {
+ Operator1<int> op1(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 0);
CHECK_EQ("Op1Test[0]", OperatorToString(&op1).get());
- Operator1<int> op2(12, Operator::kNoProperties, 0, 1, "Op1Test", 66666666);
+ Operator1<int> op2(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 66666666);
CHECK_EQ("Op1Test[66666666]", OperatorToString(&op2).get());
- Operator1<int> op3(12, Operator::kNoProperties, 0, 1, "FooBar", 2347);
+ Operator1<int> op3(12, NONE, "FooBar", 0, 0, 0, 1, 0, 0, 2347);
CHECK_EQ("FooBar[2347]", OperatorToString(&op3).get());
- Operator1<int> op4(12, Operator::kNoProperties, 0, 1, "BarFoo", -879);
+ Operator1<int> op4(12, NONE, "BarFoo", 0, 0, 0, 1, 0, 0, -879);
CHECK_EQ("BarFoo[-879]", OperatorToString(&op4).get());
}
-TEST(TestOperator1doubleHash) {
- Operator1<double> op1a(23, Operator::kNoProperties, 0, 0, "Wolfie", 11.77);
- Operator1<double> op1b(23, Operator::kFoldable, 2, 2, "Doggie", 11.77);
+TEST(TestOperator1double_Hash) {
+ Operator1<double> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11.77);
+ Operator1<double> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11.77);
- CHECK_EQ(op1a.HashCode(), op1b.HashCode());
+ CHECK(op1a.HashCode() == op1b.HashCode());
- Operator1<double> op2a(24, Operator::kNoProperties, 0, 0, "Arfie", -6.7);
- Operator1<double> op2b(24, Operator::kNoProperties, 0, 0, "Arfie", -6.8);
+ Operator1<double> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.7);
+ Operator1<double> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.8);
- CHECK_NE(op1a.HashCode(), op2a.HashCode());
- CHECK_NE(op2a.HashCode(), op2b.HashCode());
+ CHECK(op1a.HashCode() != op2a.HashCode());
+ CHECK(op2a.HashCode() != op2b.HashCode());
}
-TEST(TestOperator1doubleEquals) {
- Operator1<double> op1a(23, Operator::kNoProperties, 0, 0, "Scratchy", 11.77);
- Operator1<double> op1b(23, Operator::kFoldable, 2, 2, "Scratchy", 11.77);
+TEST(TestOperator1doublePrint) {
+ Operator1<double> op1a(23, NONE, "Canary", 0, 0, 0, 0, 0, 0, 0.5);
+ Operator1<double> op1b(23, FOLD, "Finch", 2, 0, 0, 2, 0, 0, -1.5);
+
+ CHECK_EQ("Canary[0.5]", OperatorToString(&op1a).get());
+ CHECK_EQ("Finch[-1.5]", OperatorToString(&op1b).get());
+}
+
+
+TEST(TestOperator1double_Equals) {
+ Operator1<double> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11.77);
+ Operator1<double> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11.77);
CHECK(op1a.Equals(&op1a));
CHECK(op1a.Equals(&op1b));
CHECK(op1b.Equals(&op1a));
CHECK(op1b.Equals(&op1b));
- Operator1<double> op2a(24, Operator::kNoProperties, 0, 0, "Im", 3.1);
- Operator1<double> op2b(24, Operator::kNoProperties, 0, 0, "Im", 3.2);
+ Operator1<double> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.1);
+ Operator1<double> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.2);
CHECK(op2a.Equals(&op2a));
CHECK(!op2a.Equals(&op2b));
CHECK(!op2b.Equals(&op1a));
CHECK(!op2b.Equals(&op1b));
- SimpleOperator op3(25, Operator::kNoProperties, 0, 0, "Weepy");
+ Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
CHECK(!op1a.Equals(&op3));
CHECK(!op1b.Equals(&op3));
CHECK(!op3.Equals(&op2a));
CHECK(!op3.Equals(&op2b));
- Operator1<double> op4a(24, Operator::kNoProperties, 0, 0, "Bashful", NaN);
- Operator1<double> op4b(24, Operator::kNoProperties, 0, 0, "Bashful", NaN);
+ Operator1<double> op4a(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
+ Operator1<double> op4b(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
CHECK(op4a.Equals(&op4a));
CHECK(op4a.Equals(&op4b));
}
-TEST(TestOperator1doublePrint) {
- Operator1<double> op1(12, Operator::kNoProperties, 0, 1, "Op1Test", 0);
- CHECK_EQ("Op1Test[0]", OperatorToString(&op1).get());
+TEST(TestOpParameter_Operator1double) {
+ double values[] = {7777.5, -66, 0, 11, 0.1};
- Operator1<double> op2(12, Operator::kNoProperties, 0, 1, "Op1Test", 7.3);
- CHECK_EQ("Op1Test[7.3]", OperatorToString(&op2).get());
+ for (size_t i = 0; i < arraysize(values); i++) {
+ Operator1<double> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
+ CHECK_EQ(values[i], OpParameter<double>(&op));
+ }
+}
+
+
+TEST(TestOpParameter_Operator1float) {
+ float values[] = {// thanks C++.
+ static_cast<float>(7777.5), static_cast<float>(-66),
+ static_cast<float>(0), static_cast<float>(11),
+ static_cast<float>(0.1)};
+
+ for (size_t i = 0; i < arraysize(values); i++) {
+ Operator1<float> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
+ CHECK_EQ(values[i], OpParameter<float>(&op));
+ }
+}
+
+
+TEST(TestOpParameter_Operator1int) {
+ int values[] = {7777, -66, 0, 11, 1, 0x666aff};
+
+ for (size_t i = 0; i < arraysize(values); i++) {
+ Operator1<int> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
+ CHECK_EQ(values[i], OpParameter<int>(&op));
+ }
+}
- Operator1<double> op3(12, Operator::kNoProperties, 0, 1, "FooBar", 2e+123);
- CHECK_EQ("FooBar[2e+123]", OperatorToString(&op3).get());
- Operator1<double> op4(12, Operator::kNoProperties, 0, 1, "BarFoo", Infinity);
- CHECK_EQ("BarFoo[inf]", OperatorToString(&op4).get());
+TEST(Operator_CountsOrder) {
+ Operator op(29, NONE, "Flashy", 11, 22, 33, 44, 55, 66);
+ CHECK_EQ(11, op.ValueInputCount());
+ CHECK_EQ(22, op.EffectInputCount());
+ CHECK_EQ(33, op.ControlInputCount());
- Operator1<double> op5(12, Operator::kNoProperties, 0, 1, "BarFoo", NaN);
- CHECK_EQ("BarFoo[nan]", OperatorToString(&op5).get());
+ CHECK_EQ(44, op.ValueOutputCount());
+ CHECK_EQ(55, op.EffectOutputCount());
+ CHECK_EQ(66, op.ControlOutputCount());
}
#include "src/v8.h"
#include "test/cctest/cctest.h"
+#include "src/ast-numbering.h"
#include "src/compiler.h"
#include "src/compiler/pipeline.h"
#include "src/handles.h"
*v8::Handle<v8::Function>::Cast(CompileRun(source)));
CompilationInfoWithZone info(function);
- CHECK(Parser::Parse(&info));
- CHECK(Rewriter::Rewrite(&info));
- CHECK(Scope::Analyze(&info));
- CHECK_NE(NULL, info.scope());
+ CHECK(Compiler::ParseAndAnalyze(&info));
Pipeline pipeline(&info);
#if V8_TURBOFAN_TARGET
#include "src/compiler/node-matchers.h"
#include "src/compiler/representation-change.h"
-#include "src/compiler/typer.h"
using namespace v8::internal;
using namespace v8::internal::compiler;
public:
explicit RepresentationChangerTester(int num_parameters = 0)
: GraphAndBuilders(main_zone()),
- typer_(main_zone()),
javascript_(main_zone()),
- jsgraph_(main_graph_, &main_common_, &javascript_, &typer_,
- &main_machine_),
+ jsgraph_(main_graph_, &main_common_, &javascript_, &main_machine_),
changer_(&jsgraph_, &main_simplified_, main_isolate()) {
Node* s = graph()->NewNode(common()->Start(num_parameters));
graph()->SetStart(s);
}
- Typer typer_;
JSOperatorBuilder javascript_;
JSGraph jsgraph_;
RepresentationChanger changer_;
CheckChange(IrOpcode::kChangeFloat64ToUint32, kRepFloat64 | kTypeUint32,
kRepWord32);
+ CheckChange(IrOpcode::kTruncateFloat64ToFloat32, kRepFloat64, kRepFloat32);
+
// Int32,Uint32 <-> Float32 require two changes.
CheckTwoChanges(IrOpcode::kChangeInt32ToFloat64,
IrOpcode::kTruncateFloat64ToFloat32, kRepWord32 | kTypeInt32,
}
+TEST(InlineIntrinsicIsSmi) {
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T(
+ "(function () {"
+ "var x = 42;"
+ "function bar(s,t) { return %_IsSmi(x); };"
+ "return bar;"
+ "})();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ InstallAssertInlineCountHelper(CcTest::isolate());
+ T.CheckCall(T.true_value(), T.Val(12), T.Val(4));
+}
+
+
+TEST(InlineIntrinsicIsNonNegativeSmi) {
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T(
+ "(function () {"
+ "var x = 42;"
+ "function bar(s,t) { return %_IsNonNegativeSmi(x); };"
+ "return bar;"
+ "})();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ InstallAssertInlineCountHelper(CcTest::isolate());
+ T.CheckCall(T.true_value(), T.Val(12), T.Val(4));
+}
+
+
+TEST(InlineIntrinsicIsArray) {
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T(
+ "(function () {"
+ "var x = [1,2,3];"
+ "function bar(s,t) { return %_IsArray(x); };"
+ "return bar;"
+ "})();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ InstallAssertInlineCountHelper(CcTest::isolate());
+ T.CheckCall(T.true_value(), T.Val(12), T.Val(4));
+
+ FunctionTester T2(
+ "(function () {"
+ "var x = 32;"
+ "function bar(s,t) { return %_IsArray(x); };"
+ "return bar;"
+ "})();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ T2.CheckCall(T.false_value(), T.Val(12), T.Val(4));
+
+ FunctionTester T3(
+ "(function () {"
+ "var x = bar;"
+ "function bar(s,t) { return %_IsArray(x); };"
+ "return bar;"
+ "})();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ T3.CheckCall(T.false_value(), T.Val(12), T.Val(4));
+}
+
+
+TEST(InlineWithArguments) {
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T(
+ "(function () {"
+ " function foo(s,t,u) { AssertInlineCount(2); "
+ " return foo.arguments.length == 3 && "
+ " foo.arguments[0] == 13 && "
+ " foo.arguments[1] == 14 && "
+ " foo.arguments[2] == 15; "
+ " }"
+ " function bar() { return foo(13, 14, 15); };"
+ " return bar;"
+ "}"
+ ")();",
+ CompilationInfo::kInliningEnabled |
+ CompilationInfo::kContextSpecializing |
+ CompilationInfo::kTypingEnabled);
+
+ InstallAssertInlineCountHelper(CcTest::isolate());
+ T.CheckCall(T.true_value(), T.Val(12), T.Val(14));
+}
+
#endif // V8_TURBOFAN_TARGET
using namespace v8::internal;
using namespace v8::internal::compiler;
-
+uint32_t flags = CompilationInfo::kInliningEnabled;
TEST(IsSmi) {
- FunctionTester T("(function(a) { return %_IsSmi(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsSmi(a); })", flags);
T.CheckTrue(T.Val(1));
T.CheckFalse(T.Val(1.1));
TEST(IsNonNegativeSmi) {
- FunctionTester T("(function(a) { return %_IsNonNegativeSmi(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsNonNegativeSmi(a); })", flags);
T.CheckTrue(T.Val(1));
T.CheckFalse(T.Val(1.1));
TEST(IsMinusZero) {
- FunctionTester T("(function(a) { return %_IsMinusZero(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsMinusZero(a); })", flags);
T.CheckFalse(T.Val(1));
T.CheckFalse(T.Val(1.1));
TEST(IsArray) {
- FunctionTester T("(function(a) { return %_IsArray(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsArray(a); })", flags);
T.CheckFalse(T.NewObject("(function() {})"));
T.CheckTrue(T.NewObject("([1])"));
TEST(IsObject) {
- FunctionTester T("(function(a) { return %_IsObject(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsObject(a); })", flags);
T.CheckFalse(T.NewObject("(function() {})"));
T.CheckTrue(T.NewObject("([1])"));
TEST(IsFunction) {
- FunctionTester T("(function(a) { return %_IsFunction(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsFunction(a); })", flags);
T.CheckTrue(T.NewObject("(function() {})"));
T.CheckFalse(T.NewObject("([1])"));
TEST(IsRegExp) {
- FunctionTester T("(function(a) { return %_IsRegExp(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_IsRegExp(a); })", flags);
T.CheckFalse(T.NewObject("(function() {})"));
T.CheckFalse(T.NewObject("([1])"));
TEST(ClassOf) {
- FunctionTester T("(function(a) { return %_ClassOf(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_ClassOf(a); })", flags);
T.CheckCall(T.Val("Function"), T.NewObject("(function() {})"));
T.CheckCall(T.Val("Array"), T.NewObject("([1])"));
TEST(ObjectEquals) {
- FunctionTester T("(function(a,b) { return %_ObjectEquals(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_ObjectEquals(a,b); })", flags);
CompileRun("var o = {}");
T.CheckTrue(T.NewObject("(o)"), T.NewObject("(o)"));
TEST(ValueOf) {
- FunctionTester T("(function(a) { return %_ValueOf(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_ValueOf(a); })", flags);
T.CheckCall(T.Val("a"), T.Val("a"));
T.CheckCall(T.Val("b"), T.NewObject("(new String('b'))"));
TEST(SetValueOf) {
- FunctionTester T("(function(a,b) { return %_SetValueOf(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_SetValueOf(a,b); })", flags);
T.CheckCall(T.Val("a"), T.NewObject("(new String)"), T.Val("a"));
T.CheckCall(T.Val(123), T.NewObject("(new Number)"), T.Val(123));
TEST(StringCharFromCode) {
- FunctionTester T("(function(a) { return %_StringCharFromCode(a); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a) { return %_StringCharFromCode(a); })", flags);
T.CheckCall(T.Val("a"), T.Val(97));
T.CheckCall(T.Val("\xE2\x9D\x8A"), T.Val(0x274A));
TEST(StringCharAt) {
- FunctionTester T("(function(a,b) { return %_StringCharAt(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ 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));
TEST(StringCharCodeAt) {
- FunctionTester T("(function(a,b) { return %_StringCharCodeAt(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_StringCharCodeAt(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));
TEST(StringAdd) {
- FunctionTester T("(function(a,b) { return %_StringAdd(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_StringAdd(a,b); })", flags);
T.CheckCall(T.Val("aaabbb"), T.Val("aaa"), T.Val("bbb"));
T.CheckCall(T.Val("aaa"), T.Val("aaa"), T.Val(""));
TEST(StringSubString) {
- FunctionTester T("(function(a,b) { return %_SubString(a,b,b+3); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_SubString(a,b,b+3); })", flags);
T.CheckCall(T.Val("aaa"), T.Val("aaabbb"), T.Val(0.0));
T.CheckCall(T.Val("abb"), T.Val("aaabbb"), T.Val(2));
TEST(StringCompare) {
- FunctionTester T("(function(a,b) { return %_StringCompare(a,b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_StringCompare(a,b); })", flags);
T.CheckCall(T.Val(-1), T.Val("aaa"), T.Val("bbb"));
T.CheckCall(T.Val(0.0), T.Val("bbb"), T.Val("bbb"));
TEST(CallFunction) {
- FunctionTester T("(function(a,b) { return %_CallFunction(a, 1, 2, 3, b); })");
+ FLAG_turbo_inlining_intrinsics = true;
+ FLAG_turbo_deoptimization = true;
+ FunctionTester T("(function(a,b) { return %_CallFunction(a, 1, 2, 3, b); })",
+ flags);
CompileRun("function f(a,b,c) { return a + b + c + this.d; }");
T.CheckCall(T.Val(129), T.NewObject("({d:123})"), T.NewObject("f"));
T.CheckCall(T.Val(2), T.Val(2), T.false_value());
T.CheckCall(T.undefined(), T.Val(1), T.null());
}
+
+
+TEST(IfTrue) {
+ FunctionTester T("(function(a,b) { if (true) return a; return b; })");
+
+ T.CheckCall(T.Val(55), T.Val(55), T.Val(11));
+ T.CheckCall(T.Val(666), T.Val(666), T.Val(-444));
+}
+
+
+TEST(TernaryTrue) {
+ FunctionTester T("(function(a,b) { return true ? a : b; })");
+
+ T.CheckCall(T.Val(77), T.Val(77), T.Val(11));
+ T.CheckCall(T.Val(111), T.Val(111), T.Val(-444));
+}
+
+
+TEST(IfFalse) {
+ FunctionTester T("(function(a,b) { if (false) return a; return b; })");
+
+ T.CheckCall(T.Val(11), T.Val(22), T.Val(11));
+ T.CheckCall(T.Val(-555), T.Val(333), T.Val(-555));
+}
+
+
+TEST(TernaryFalse) {
+ FunctionTester T("(function(a,b) { return false ? a : b; })");
+
+ T.CheckCall(T.Val(99), T.Val(33), T.Val(99));
+ T.CheckCall(T.Val(-99), T.Val(-33), T.Val(-99));
+}
+
+
+TEST(WhileTrue) {
+ FunctionTester T("(function(a,b) { while (true) return a; return b; })");
+
+ T.CheckCall(T.Val(551), T.Val(551), T.Val(111));
+ T.CheckCall(T.Val(661), T.Val(661), T.Val(-444));
+}
+
+
+TEST(WhileFalse) {
+ FunctionTester T("(function(a,b) { while (false) return a; return b; })");
+
+ T.CheckCall(T.Val(115), T.Val(551), T.Val(115));
+ T.CheckCall(T.Val(-445), T.Val(661), T.Val(-445));
+}
+
+
+TEST(DoWhileTrue) {
+ FunctionTester T(
+ "(function(a,b) { do { return a; } while (true); return b; })");
+
+ T.CheckCall(T.Val(7551), T.Val(7551), T.Val(7111));
+ T.CheckCall(T.Val(7661), T.Val(7661), T.Val(-7444));
+}
+
+
+TEST(DoWhileFalse) {
+ FunctionTester T(
+ "(function(a,b) { do { "
+ "; } while (false); return b; })");
+
+ T.CheckCall(T.Val(8115), T.Val(8551), T.Val(8115));
+ T.CheckCall(T.Val(-8445), T.Val(8661), T.Val(-8445));
+}
+
+
+TEST(EmptyFor) {
+ FunctionTester T("(function(a,b) { if (a) for(;;) ; return b; })");
+
+ T.CheckCall(T.Val(8126.1), T.Val(0.0), T.Val(8126.1));
+ T.CheckCall(T.Val(1123.1), T.Val(0.0), T.Val(1123.1));
+}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <cmath>
#include <functional>
#include <limits>
#include "src/base/bits.h"
+#include "src/codegen.h"
#include "src/compiler/generic-node-inl.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/codegen-tester.h"
TEST(CodeGenInt32Binop) {
RawMachineAssemblerTester<void> m;
- const Operator* ops[] = {
+ const Operator* kOps[] = {
m.machine()->Word32And(), m.machine()->Word32Or(),
m.machine()->Word32Xor(), m.machine()->Word32Shl(),
m.machine()->Word32Shr(), m.machine()->Word32Sar(),
m.machine()->Word32Equal(), m.machine()->Int32Add(),
m.machine()->Int32Sub(), m.machine()->Int32Mul(),
- m.machine()->Int32Div(), m.machine()->Int32UDiv(),
- m.machine()->Int32Mod(), m.machine()->Int32UMod(),
+ m.machine()->Int32MulHigh(), m.machine()->Int32Div(),
+ m.machine()->Uint32Div(), m.machine()->Int32Mod(),
+ m.machine()->Uint32Mod(), m.machine()->Uint32MulHigh(),
m.machine()->Int32LessThan(), m.machine()->Int32LessThanOrEqual(),
- m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual(),
- NULL};
+ m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual()};
- for (int i = 0; ops[i] != NULL; i++) {
+ for (size_t i = 0; i < arraysize(kOps); ++i) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 8; k++) {
RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
Node* a = Int32Input(&m, j);
Node* b = Int32Input(&m, k);
- m.Return(m.NewNode(ops[i], a, b));
+ m.Return(m.NewNode(kOps[i], a, b));
m.GenerateCode();
}
}
TEST(RunRedundantBranch2) {
RawMachineAssemblerTester<int32_t> m;
- int constant = 955777;
-
- MLabel blocka, blockb;
- m.Branch(m.Int32Constant(0), &blocka, &blocka);
- m.Bind(&blockb);
- m.Goto(&blocka);
- m.Bind(&blocka);
- m.Return(m.Int32Constant(constant));
-
- CHECK_EQ(constant, m.Call());
-}
-
-
-TEST(RunRedundantBranch3) {
- RawMachineAssemblerTester<int32_t> m;
int constant = 966777;
MLabel blocka, blockb, blockc;
}
+TEST(RunInt32AddAndWord32EqualP) {
+ {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Parameter(0),
+ m.Word32Equal(m.Parameter(1), m.Parameter(2))));
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k));
+ CHECK_EQ(expected, m.Call(*i, *j, *k));
+ }
+ }
+ }
+ }
+ {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Word32Equal(m.Parameter(0), m.Parameter(1)),
+ m.Parameter(2)));
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k));
+ CHECK_EQ(expected, m.Call(*i, *j, *k));
+ }
+ }
+ }
+ }
+}
+
+
+TEST(RunInt32AddAndWord32EqualImm) {
+ {
+ FOR_INT32_INPUTS(i) {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Int32Constant(*i),
+ m.Word32Equal(m.Parameter(0), m.Parameter(1))));
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k));
+ CHECK_EQ(expected, m.Call(*j, *k));
+ }
+ }
+ }
+ }
+ {
+ FOR_INT32_INPUTS(i) {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Word32Equal(m.Int32Constant(*i), m.Parameter(0)),
+ m.Parameter(1)));
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k));
+ CHECK_EQ(expected, m.Call(*j, *k));
+ }
+ }
+ }
+ }
+}
+
+
+TEST(RunInt32AddAndWord32NotEqualP) {
+ {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Parameter(0),
+ m.Word32NotEqual(m.Parameter(1), m.Parameter(2))));
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k));
+ CHECK_EQ(expected, m.Call(*i, *j, *k));
+ }
+ }
+ }
+ }
+ {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Word32NotEqual(m.Parameter(0), m.Parameter(1)),
+ m.Parameter(2)));
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k));
+ CHECK_EQ(expected, m.Call(*i, *j, *k));
+ }
+ }
+ }
+ }
+}
+
+
+TEST(RunInt32AddAndWord32NotEqualImm) {
+ {
+ FOR_INT32_INPUTS(i) {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Int32Constant(*i),
+ m.Word32NotEqual(m.Parameter(0), m.Parameter(1))));
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k));
+ CHECK_EQ(expected, m.Call(*j, *k));
+ }
+ }
+ }
+ }
+ {
+ FOR_INT32_INPUTS(i) {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Word32NotEqual(m.Int32Constant(*i), m.Parameter(0)),
+ m.Parameter(1)));
+ FOR_INT32_INPUTS(j) {
+ FOR_INT32_INPUTS(k) {
+ // Use uint32_t because signed overflow is UB in C.
+ int32_t const expected =
+ bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k));
+ CHECK_EQ(expected, m.Call(*j, *k));
+ }
+ }
+ }
+ }
+}
+
+
TEST(RunInt32AddAndWord32SarP) {
{
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
}
+TEST(RunInt32MulHighP) {
+ RawMachineAssemblerTester<int32_t> m;
+ Int32BinopTester bt(&m);
+ bt.AddReturn(m.Int32MulHigh(bt.param0, bt.param1));
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ int32_t expected = static_cast<int32_t>(
+ (static_cast<int64_t>(*i) * static_cast<int64_t>(*j)) >> 32);
+ CHECK_EQ(expected, bt.call(*i, *j));
+ }
+ }
+}
+
+
TEST(RunInt32MulImm) {
{
FOR_UINT32_INPUTS(i) {
TEST(RunInt32MulAndInt32AddP) {
{
+ FOR_INT32_INPUTS(i) {
+ FOR_INT32_INPUTS(j) {
+ RawMachineAssemblerTester<int32_t> m(kMachInt32);
+ int32_t p0 = *i;
+ int32_t p1 = *j;
+ m.Return(m.Int32Add(m.Int32Constant(p0),
+ m.Int32Mul(m.Parameter(0), m.Int32Constant(p1))));
+ FOR_INT32_INPUTS(k) {
+ int32_t p2 = *k;
+ int expected = p0 + static_cast<int32_t>(p1 * p2);
+ CHECK_EQ(expected, m.Call(p2));
+ }
+ }
+ }
+ }
+ {
RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
m.Return(
m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
}
+TEST(RunUint32MulHighP) {
+ RawMachineAssemblerTester<int32_t> m;
+ Int32BinopTester bt(&m);
+ bt.AddReturn(m.Uint32MulHigh(bt.param0, bt.param1));
+ FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(j) {
+ int32_t expected = bit_cast<int32_t>(static_cast<uint32_t>(
+ (static_cast<uint64_t>(*i) * static_cast<uint64_t>(*j)) >> 32));
+ CHECK_EQ(expected, bt.call(bit_cast<int32_t>(*i), bit_cast<int32_t>(*j)));
+ }
+ }
+}
+
+
TEST(RunInt32DivP) {
{
RawMachineAssemblerTester<int32_t> m;
}
-TEST(RunInt32UDivP) {
+TEST(RunUint32DivP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
- bt.AddReturn(m.Int32UDiv(bt.param0, bt.param1));
+ bt.AddReturn(m.Uint32Div(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
uint32_t p0 = *i;
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
- bt.AddReturn(m.Int32Add(bt.param0, m.Int32UDiv(bt.param0, bt.param1)));
+ bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
uint32_t p0 = *i;
}
-TEST(RunInt32UModP) {
+TEST(RunUint32ModP) {
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
- bt.AddReturn(m.Int32UMod(bt.param0, bt.param1));
+ bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
uint32_t p0 = *i;
{
RawMachineAssemblerTester<int32_t> m;
Int32BinopTester bt(&m);
- bt.AddReturn(m.Int32Add(bt.param0, m.Int32UMod(bt.param0, bt.param1)));
+ bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1)));
FOR_UINT32_INPUTS(i) {
FOR_UINT32_INPUTS(j) {
uint32_t p0 = *i;
TEST(RunDeadInt32Binops) {
RawMachineAssemblerTester<int32_t> m;
- const Operator* ops[] = {
- m.machine()->Word32And(), m.machine()->Word32Or(),
- m.machine()->Word32Xor(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr(), m.machine()->Word32Sar(),
- m.machine()->Word32Ror(), m.machine()->Word32Equal(),
- m.machine()->Int32Add(), m.machine()->Int32Sub(),
- m.machine()->Int32Mul(), m.machine()->Int32Div(),
- m.machine()->Int32UDiv(), m.machine()->Int32Mod(),
- m.machine()->Int32UMod(), m.machine()->Int32LessThan(),
- m.machine()->Int32LessThanOrEqual(), m.machine()->Uint32LessThan(),
- m.machine()->Uint32LessThanOrEqual(), NULL};
-
- for (int i = 0; ops[i] != NULL; i++) {
+ const Operator* kOps[] = {
+ m.machine()->Word32And(), m.machine()->Word32Or(),
+ m.machine()->Word32Xor(), m.machine()->Word32Shl(),
+ m.machine()->Word32Shr(), m.machine()->Word32Sar(),
+ m.machine()->Word32Ror(), m.machine()->Word32Equal(),
+ m.machine()->Int32Add(), m.machine()->Int32Sub(),
+ m.machine()->Int32Mul(), m.machine()->Int32MulHigh(),
+ m.machine()->Int32Div(), m.machine()->Uint32Div(),
+ m.machine()->Int32Mod(), m.machine()->Uint32Mod(),
+ m.machine()->Uint32MulHigh(), m.machine()->Int32LessThan(),
+ m.machine()->Int32LessThanOrEqual(), m.machine()->Uint32LessThan(),
+ m.machine()->Uint32LessThanOrEqual()};
+
+ for (size_t i = 0; i < arraysize(kOps); ++i) {
RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
- int constant = 0x55555 + i;
- m.NewNode(ops[i], m.Parameter(0), m.Parameter(1));
+ int32_t constant = static_cast<int32_t>(0x55555 + i);
+ m.NewNode(kOps[i], m.Parameter(0), m.Parameter(1));
m.Return(m.Int32Constant(constant));
CHECK_EQ(constant, m.Call(1, 1));
}
+TEST(RunChangeUint32ToFloat64_spilled) {
+ RawMachineAssemblerTester<int32_t> m;
+ const int kNumInputs = 32;
+ int32_t magic = 0x786234;
+ uint32_t input[kNumInputs];
+ double result[kNumInputs];
+ Node* input_node[kNumInputs];
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input_node[i] =
+ m.Load(kMachUint32, m.PointerConstant(&input), m.Int32Constant(i * 4));
+ }
+
+ for (int i = 0; i < kNumInputs; i++) {
+ m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(i * 8),
+ m.ChangeUint32ToFloat64(input_node[i]));
+ }
+
+ m.Return(m.Int32Constant(magic));
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input[i] = 100 + i;
+ }
+
+ CHECK_EQ(magic, m.Call());
+
+ for (int i = 0; i < kNumInputs; i++) {
+ CHECK_EQ(result[i], static_cast<double>(100 + i));
+ }
+}
+
+
TEST(RunChangeFloat64ToInt32_A) {
RawMachineAssemblerTester<int32_t> m;
int32_t magic = 0x786234;
}
+TEST(RunTruncateFloat64ToFloat32_spilled) {
+ RawMachineAssemblerTester<uint32_t> m;
+ const int kNumInputs = 32;
+ int32_t magic = 0x786234;
+ double input[kNumInputs];
+ float result[kNumInputs];
+ Node* input_node[kNumInputs];
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input_node[i] =
+ m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
+ }
+
+ for (int i = 0; i < kNumInputs; i++) {
+ m.Store(kMachFloat32, m.PointerConstant(&result), m.Int32Constant(i * 4),
+ m.TruncateFloat64ToFloat32(input_node[i]));
+ }
+
+ m.Return(m.Int32Constant(magic));
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input[i] = 0.1 + i;
+ }
+
+ CHECK_EQ(magic, m.Call());
+
+ for (int i = 0; i < kNumInputs; i++) {
+ CHECK_EQ(result[i], DoubleToFloat32(input[i]));
+ }
+}
+
+
TEST(RunDeadChangeFloat64ToInt32) {
RawMachineAssemblerTester<int32_t> m;
const int magic = 0x88abcda4;
}
+TEST(RunChangeFloat32ToFloat64_spilled) {
+ RawMachineAssemblerTester<int32_t> m;
+ const int kNumInputs = 32;
+ int32_t magic = 0x786234;
+ float input[kNumInputs];
+ double result[kNumInputs];
+ Node* input_node[kNumInputs];
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input_node[i] =
+ m.Load(kMachFloat32, m.PointerConstant(&input), m.Int32Constant(i * 4));
+ }
+
+ for (int i = 0; i < kNumInputs; i++) {
+ m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(i * 8),
+ m.ChangeFloat32ToFloat64(input_node[i]));
+ }
+
+ m.Return(m.Int32Constant(magic));
+
+ for (int i = 0; i < kNumInputs; i++) {
+ input[i] = 100.9f + i;
+ }
+
+ CHECK_EQ(magic, m.Call());
+
+ for (int i = 0; i < kNumInputs; i++) {
+ CHECK_EQ(result[i], static_cast<double>(input[i]));
+ }
+}
+
+
TEST(RunTruncateFloat64ToFloat32) {
float actual = 0.0f;
double input = 0.0;
}
}
+
+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.
+static double kValues[] = {0.1,
+ 0.2,
+ 0.49999999999999994,
+ 0.5,
+ 0.7,
+ 1.0 - std::numeric_limits<double>::epsilon(),
+ -0.1,
+ -0.49999999999999994,
+ -0.5,
+ -0.7,
+ 1.1,
+ 1.0 + std::numeric_limits<double>::epsilon(),
+ 1.5,
+ 1.7,
+ -1,
+ -1 + std::numeric_limits<double>::epsilon(),
+ -1 - std::numeric_limits<double>::epsilon(),
+ -1.1,
+ -1.5,
+ -1.7,
+ std::numeric_limits<double>::min(),
+ -std::numeric_limits<double>::min(),
+ std::numeric_limits<double>::max(),
+ -std::numeric_limits<double>::max(),
+ std::numeric_limits<double>::infinity(),
+ -std::numeric_limits<double>::infinity(),
+ two_30,
+ two_30 + 0.1,
+ two_30 + 0.5,
+ two_30 + 0.7,
+ two_30 - 1,
+ two_30 - 1 + 0.1,
+ two_30 - 1 + 0.5,
+ two_30 - 1 + 0.7,
+ -two_30,
+ -two_30 + 0.1,
+ -two_30 + 0.5,
+ -two_30 + 0.7,
+ -two_30 + 1,
+ -two_30 + 1 + 0.1,
+ -two_30 + 1 + 0.5,
+ -two_30 + 1 + 0.7,
+ two_52,
+ two_52 + 0.1,
+ two_52 + 0.5,
+ two_52 + 0.5,
+ two_52 + 0.7,
+ two_52 + 0.7,
+ two_52 - 1,
+ two_52 - 1 + 0.1,
+ two_52 - 1 + 0.5,
+ two_52 - 1 + 0.7,
+ -two_52,
+ -two_52 + 0.1,
+ -two_52 + 0.5,
+ -two_52 + 0.7,
+ -two_52 + 1,
+ -two_52 + 1 + 0.1,
+ -two_52 + 1 + 0.5,
+ -two_52 + 1 + 0.7,
+ two_30,
+ two_30 - 0.1,
+ two_30 - 0.5,
+ two_30 - 0.7,
+ two_30 - 1,
+ two_30 - 1 - 0.1,
+ two_30 - 1 - 0.5,
+ two_30 - 1 - 0.7,
+ -two_30,
+ -two_30 - 0.1,
+ -two_30 - 0.5,
+ -two_30 - 0.7,
+ -two_30 + 1,
+ -two_30 + 1 - 0.1,
+ -two_30 + 1 - 0.5,
+ -two_30 + 1 - 0.7,
+ two_52,
+ two_52 - 0.1,
+ two_52 - 0.5,
+ two_52 - 0.5,
+ two_52 - 0.7,
+ two_52 - 0.7,
+ two_52 - 1,
+ two_52 - 1 - 0.1,
+ two_52 - 1 - 0.5,
+ two_52 - 1 - 0.7,
+ -two_52,
+ -two_52 - 0.1,
+ -two_52 - 0.5,
+ -two_52 - 0.7,
+ -two_52 + 1,
+ -two_52 + 1 - 0.1,
+ -two_52 + 1 - 0.5,
+ -two_52 + 1 - 0.7};
+
+
+TEST(RunFloat64Floor) {
+ double input = -1.0;
+ double result = 0.0;
+ RawMachineAssemblerTester<int32_t> m;
+ if (!m.machine()->HasFloat64Floor()) return;
+ m.StoreToPointer(&result, kMachFloat64,
+ m.Float64Floor(m.LoadFromPointer(&input, kMachFloat64)));
+ m.Return(m.Int32Constant(0));
+ for (size_t i = 0; i < arraysize(kValues); ++i) {
+ input = kValues[i];
+ CHECK_EQ(0, m.Call());
+ double expected = std::floor(kValues[i]);
+ CHECK_EQ(expected, result);
+ }
+}
+
+
+TEST(RunFloat64Ceil) {
+ double input = -1.0;
+ double result = 0.0;
+ RawMachineAssemblerTester<int32_t> m;
+ if (!m.machine()->HasFloat64Ceil()) return;
+ m.StoreToPointer(&result, kMachFloat64,
+ m.Float64Ceil(m.LoadFromPointer(&input, kMachFloat64)));
+ m.Return(m.Int32Constant(0));
+ for (size_t i = 0; i < arraysize(kValues); ++i) {
+ input = kValues[i];
+ CHECK_EQ(0, m.Call());
+ double expected = std::ceil(kValues[i]);
+ CHECK_EQ(expected, result);
+ }
+}
+
+
+TEST(RunFloat64RoundTruncate) {
+ double input = -1.0;
+ double result = 0.0;
+ RawMachineAssemblerTester<int32_t> m;
+ if (!m.machine()->HasFloat64Ceil()) return;
+ m.StoreToPointer(
+ &result, kMachFloat64,
+ m.Float64RoundTruncate(m.LoadFromPointer(&input, kMachFloat64)));
+ m.Return(m.Int32Constant(0));
+ for (size_t i = 0; i < arraysize(kValues); ++i) {
+ input = kValues[i];
+ CHECK_EQ(0, m.Call());
+ double expected = trunc(kValues[i]);
+ CHECK_EQ(expected, result);
+ }
+}
+
+
+TEST(RunFloat64RoundTiesAway) {
+ double input = -1.0;
+ double result = 0.0;
+ RawMachineAssemblerTester<int32_t> m;
+ if (!m.machine()->HasFloat64RoundTiesAway()) return;
+ m.StoreToPointer(
+ &result, kMachFloat64,
+ m.Float64RoundTiesAway(m.LoadFromPointer(&input, kMachFloat64)));
+ m.Return(m.Int32Constant(0));
+ for (size_t i = 0; i < arraysize(kValues); ++i) {
+ input = kValues[i];
+ CHECK_EQ(0, m.Call());
+ double expected = round(kValues[i]);
+ CHECK_EQ(expected, result);
+ }
+}
#endif // V8_TURBOFAN_TARGET
--- /dev/null
+// 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/v8.h"
+
+#include "test/cctest/compiler/function-tester.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+TEST(TerminateAtMethodEntry) {
+ FunctionTester T("(function(a,b) { return 23; })");
+
+ T.CheckCall(T.Val(23));
+ T.isolate->stack_guard()->RequestTerminateExecution();
+ T.CheckThrows(T.undefined(), T.undefined());
+}
using namespace v8::internal;
using namespace v8::internal::compiler;
-static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
- 0, 0, "dummy");
+static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
+ "dummy", 0, 0, 0, 0, 0, 0);
TEST(TestScheduleAllocation) {
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
CHECK_NE(NULL, schedule.start());
- CHECK_EQ(schedule.start(), *(schedule.all_blocks().begin()));
+ CHECK_EQ(schedule.start(), schedule.GetBlockById(BasicBlock::Id::FromInt(0)));
}
TEST(TestScheduleAddNode) {
HandleAndZoneScope scope;
+ Schedule schedule(scope.main_zone());
Graph graph(scope.main_zone());
Node* n0 = graph.NewNode(&dummy_operator);
Node* n1 = graph.NewNode(&dummy_operator);
- Schedule schedule(scope.main_zone());
-
BasicBlock* entry = schedule.start();
schedule.AddNode(entry, n0);
schedule.AddNode(entry, n1);
TEST(TestScheduleAddGoto) {
HandleAndZoneScope scope;
-
Schedule schedule(scope.main_zone());
+
BasicBlock* entry = schedule.start();
BasicBlock* next = schedule.NewBasicBlock();
schedule.AddGoto(entry, next);
- CHECK_EQ(0, entry->PredecessorCount());
- CHECK_EQ(1, entry->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(entry->PredecessorCount()));
+ CHECK_EQ(1, static_cast<int>(entry->SuccessorCount()));
CHECK_EQ(next, entry->SuccessorAt(0));
- CHECK_EQ(1, next->PredecessorCount());
+ CHECK_EQ(1, static_cast<int>(next->PredecessorCount()));
CHECK_EQ(entry, next->PredecessorAt(0));
- CHECK_EQ(0, next->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(next->SuccessorCount()));
}
TEST(TestScheduleAddBranch) {
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
-
- BasicBlock* entry = schedule.start();
- BasicBlock* tblock = schedule.NewBasicBlock();
- BasicBlock* fblock = schedule.NewBasicBlock();
-
Graph graph(scope.main_zone());
CommonOperatorBuilder common(scope.main_zone());
Node* n0 = graph.NewNode(&dummy_operator);
Node* b = graph.NewNode(common.Branch(), n0);
+ BasicBlock* entry = schedule.start();
+ BasicBlock* tblock = schedule.NewBasicBlock();
+ BasicBlock* fblock = schedule.NewBasicBlock();
+
schedule.AddBranch(entry, b, tblock, fblock);
- CHECK_EQ(0, entry->PredecessorCount());
- CHECK_EQ(2, entry->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(entry->PredecessorCount()));
+ CHECK_EQ(2, static_cast<int>(entry->SuccessorCount()));
CHECK_EQ(tblock, entry->SuccessorAt(0));
CHECK_EQ(fblock, entry->SuccessorAt(1));
- CHECK_EQ(1, tblock->PredecessorCount());
+ CHECK_EQ(1, static_cast<int>(tblock->PredecessorCount()));
CHECK_EQ(entry, tblock->PredecessorAt(0));
- CHECK_EQ(0, tblock->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(tblock->SuccessorCount()));
- CHECK_EQ(1, fblock->PredecessorCount());
+ CHECK_EQ(1, static_cast<int>(fblock->PredecessorCount()));
CHECK_EQ(entry, fblock->PredecessorAt(0));
- CHECK_EQ(0, fblock->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(fblock->SuccessorCount()));
}
BasicBlock* entry = schedule.start();
schedule.AddReturn(entry, n0);
- CHECK_EQ(0, entry->PredecessorCount());
- CHECK_EQ(1, entry->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(entry->PredecessorCount()));
+ CHECK_EQ(1, static_cast<int>(entry->SuccessorCount()));
CHECK_EQ(schedule.end(), entry->SuccessorAt(0));
}
BasicBlock* entry = schedule.start();
schedule.AddThrow(entry, n0);
- CHECK_EQ(0, entry->PredecessorCount());
- CHECK_EQ(1, entry->SuccessorCount());
+ CHECK_EQ(0, static_cast<int>(entry->PredecessorCount()));
+ CHECK_EQ(1, static_cast<int>(entry->SuccessorCount()));
CHECK_EQ(schedule.end(), entry->SuccessorAt(0));
}
+TEST(TestScheduleInsertBranch) {
+ HandleAndZoneScope scope;
+ Schedule schedule(scope.main_zone());
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+ Node* n0 = graph.NewNode(&dummy_operator);
+ Node* n1 = graph.NewNode(&dummy_operator);
+ Node* b = graph.NewNode(common.Branch(), n1);
+
+ BasicBlock* entry = schedule.start();
+ BasicBlock* tblock = schedule.NewBasicBlock();
+ BasicBlock* fblock = schedule.NewBasicBlock();
+ BasicBlock* merge = schedule.NewBasicBlock();
+ schedule.AddReturn(entry, n0);
+ schedule.AddGoto(tblock, merge);
+ schedule.AddGoto(fblock, merge);
+
+ schedule.InsertBranch(entry, merge, b, tblock, fblock);
+
+ CHECK_EQ(0, static_cast<int>(entry->PredecessorCount()));
+ CHECK_EQ(2, static_cast<int>(entry->SuccessorCount()));
+ CHECK_EQ(tblock, entry->SuccessorAt(0));
+ CHECK_EQ(fblock, entry->SuccessorAt(1));
+
+ CHECK_EQ(2, static_cast<int>(merge->PredecessorCount()));
+ CHECK_EQ(1, static_cast<int>(merge->SuccessorCount()));
+ CHECK_EQ(schedule.end(), merge->SuccessorAt(0));
+
+ CHECK_EQ(1, static_cast<int>(schedule.end()->PredecessorCount()));
+ CHECK_EQ(0, static_cast<int>(schedule.end()->SuccessorCount()));
+ CHECK_EQ(merge, schedule.end()->PredecessorAt(0));
+}
+
+
TEST(BuildMulNodeGraph) {
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
#include "src/v8.h"
#include "test/cctest/cctest.h"
+#include "src/compiler/access-builder.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/generic-node-inl.h"
#include "src/compiler/generic-node.h"
#include "src/compiler/operator.h"
#include "src/compiler/schedule.h"
#include "src/compiler/scheduler.h"
+#include "src/compiler/simplified-operator.h"
#include "src/compiler/verifier.h"
using namespace v8::internal;
using namespace v8::internal::compiler;
// TODO(titzer): pull RPO tests out to their own file.
+static void CheckRPONumbers(BasicBlockVector* order, size_t expected,
+ bool loops_allowed) {
+ CHECK(expected == order->size());
+ for (int i = 0; i < static_cast<int>(order->size()); i++) {
+ CHECK(order->at(i)->rpo_number() == i);
+ if (!loops_allowed) {
+ CHECK_EQ(NULL, order->at(i)->loop_end());
+ CHECK_EQ(NULL, order->at(i)->loop_header());
+ }
+ }
+ int number = 0;
+ for (auto const block : *order) {
+ if (block->deferred()) continue;
+ CHECK_EQ(number, block->ao_number());
+ ++number;
+ }
+ for (auto const block : *order) {
+ if (!block->deferred()) continue;
+ CHECK_EQ(number, block->ao_number());
+ ++number;
+ }
+}
+
+
+static void CheckLoop(BasicBlockVector* order, BasicBlock** blocks,
+ int body_size) {
+ BasicBlock* header = blocks[0];
+ BasicBlock* end = header->loop_end();
+ CHECK_NE(NULL, end);
+ CHECK_GT(end->rpo_number(), 0);
+ CHECK_EQ(body_size, end->rpo_number() - header->rpo_number());
+ for (int i = 0; i < body_size; i++) {
+ CHECK_GE(blocks[i]->rpo_number(), header->rpo_number());
+ CHECK_LT(blocks[i]->rpo_number(), end->rpo_number());
+ CHECK(header->LoopContains(blocks[i]));
+ CHECK(header->IsLoopHeader() || blocks[i]->loop_header() == header);
+ }
+ if (header->rpo_number() > 0) {
+ CHECK_NE(order->at(header->rpo_number() - 1)->loop_header(), header);
+ }
+ if (end->rpo_number() < static_cast<int>(order->size())) {
+ CHECK_NE(order->at(end->rpo_number())->loop_header(), header);
+ }
+}
+
+
struct TestLoop {
int count;
BasicBlock** nodes;
BasicBlock* header() { return nodes[0]; }
BasicBlock* last() { return nodes[count - 1]; }
~TestLoop() { delete[] nodes; }
+
+ void Check(BasicBlockVector* order) { CheckLoop(order, nodes, count); }
};
loop->nodes = new BasicBlock* [count];
for (int i = 0; i < count; i++) {
loop->nodes[i] = schedule->NewBasicBlock();
- if (i > 0) schedule->AddSuccessor(loop->nodes[i - 1], loop->nodes[i]);
+ if (i > 0) {
+ schedule->AddSuccessorForTesting(loop->nodes[i - 1], loop->nodes[i]);
+ }
}
- schedule->AddSuccessor(loop->nodes[count - 1], loop->nodes[0]);
+ schedule->AddSuccessorForTesting(loop->nodes[count - 1], loop->nodes[0]);
return loop;
}
-static void CheckRPONumbers(BasicBlockVector* order, int expected,
- bool loops_allowed) {
- CHECK_EQ(expected, static_cast<int>(order->size()));
- for (int i = 0; i < static_cast<int>(order->size()); i++) {
- CHECK(order->at(i)->rpo_number_ == i);
- if (!loops_allowed) CHECK_LT(order->at(i)->loop_end_, 0);
- }
-}
-
-
-static void CheckLoopContains(BasicBlock** blocks, int body_size) {
- BasicBlock* header = blocks[0];
- CHECK_GT(header->loop_end_, 0);
- CHECK_EQ(body_size, (header->loop_end_ - header->rpo_number_));
- for (int i = 0; i < body_size; i++) {
- int num = blocks[i]->rpo_number_;
- CHECK(num >= header->rpo_number_ && num < header->loop_end_);
- CHECK(header->LoopContains(blocks[i]));
- CHECK(header->IsLoopHeader() || blocks[i]->loop_header_ == header);
- }
-}
-
-
static int GetScheduledNodeCount(Schedule* schedule) {
int node_count = 0;
for (BasicBlockVectorIter i = schedule->rpo_order()->begin();
++j) {
++node_count;
}
- BasicBlock::Control control = block->control_;
+ BasicBlock::Control control = block->control();
if (control != BasicBlock::kNone) {
++node_count;
}
os << AsDOT(*graph);
}
- Schedule* schedule = Scheduler::ComputeSchedule(graph);
+ ZonePool zone_pool(graph->zone()->isolate());
+ Schedule* schedule = Scheduler::ComputeSchedule(&zone_pool, graph);
if (FLAG_trace_turbo_scheduler) {
OFStream os(stdout);
- os << *schedule << endl;
+ os << *schedule << std::endl;
}
ScheduleVerifier::Run(schedule);
CHECK_EQ(expected, GetScheduledNodeCount(schedule));
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 1, false);
CHECK_EQ(schedule.start(), order->at(0));
}
Schedule schedule(scope.main_zone());
schedule.AddGoto(schedule.start(), schedule.end());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 2, false);
CHECK_EQ(schedule.start(), order->at(0));
CHECK_EQ(schedule.end(), order->at(1));
BasicBlock* last = schedule.start();
for (int j = 0; j < i; j++) {
BasicBlock* block = schedule.NewBasicBlock();
+ block->set_deferred(i & 1);
schedule.AddGoto(last, block);
last = block;
}
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 1 + i, false);
- Schedule::BasicBlocks blocks(schedule.all_blocks());
- for (Schedule::BasicBlocks::iterator iter = blocks.begin();
- iter != blocks.end(); ++iter) {
- BasicBlock* block = *iter;
- if (block->rpo_number_ >= 0 && block->SuccessorCount() == 1) {
- CHECK(block->rpo_number_ + 1 == block->SuccessorAt(0)->rpo_number_);
+ for (size_t i = 0; i < schedule.BasicBlockCount(); i++) {
+ BasicBlock* block = schedule.GetBlockById(BasicBlock::Id::FromSize(i));
+ if (block->rpo_number() >= 0 && block->SuccessorCount() == 1) {
+ CHECK(block->rpo_number() + 1 == block->SuccessorAt(0)->rpo_number());
}
}
}
TEST(RPOSelfLoop) {
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
- schedule.AddSuccessor(schedule.start(), schedule.start());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(schedule.start(), schedule.start());
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 1, true);
BasicBlock* loop[] = {schedule.start()};
- CheckLoopContains(loop, 1);
+ CheckLoop(order, loop, 1);
}
TEST(RPOEntryLoop) {
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
- schedule.AddSuccessor(schedule.start(), schedule.end());
- schedule.AddSuccessor(schedule.end(), schedule.start());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(schedule.start(), schedule.end());
+ schedule.AddSuccessorForTesting(schedule.end(), schedule.start());
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 2, true);
BasicBlock* loop[] = {schedule.start(), schedule.end()};
- CheckLoopContains(loop, 2);
+ CheckLoop(order, loop, 2);
}
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
- schedule.AddSuccessor(schedule.start(), loop1->header());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(schedule.start(), loop1->header());
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 3, true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
}
HandleAndZoneScope scope;
Schedule schedule(scope.main_zone());
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2));
- schedule.AddSuccessor(schedule.start(), loop1->header());
- schedule.AddSuccessor(loop1->last(), schedule.start());
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(schedule.start(), loop1->header());
+ schedule.AddSuccessorForTesting(loop1->last(), schedule.start());
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 3, true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
}
BasicBlock* C = schedule.NewBasicBlock();
BasicBlock* D = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(A, C);
- schedule.AddSuccessor(B, D);
- schedule.AddSuccessor(C, D);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(A, C);
+ schedule.AddSuccessorForTesting(B, D);
+ schedule.AddSuccessorForTesting(C, D);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 4, false);
- CHECK_EQ(0, A->rpo_number_);
- CHECK((B->rpo_number_ == 1 && C->rpo_number_ == 2) ||
- (B->rpo_number_ == 2 && C->rpo_number_ == 1));
- CHECK_EQ(3, D->rpo_number_);
+ CHECK_EQ(0, A->rpo_number());
+ CHECK((B->rpo_number() == 1 && C->rpo_number() == 2) ||
+ (B->rpo_number() == 2 && C->rpo_number() == 1));
+ CHECK_EQ(3, D->rpo_number());
}
BasicBlock* C = schedule.NewBasicBlock();
BasicBlock* D = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(C, B);
- schedule.AddSuccessor(C, D);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(C, B);
+ schedule.AddSuccessorForTesting(C, D);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 4, true);
BasicBlock* loop[] = {B, C};
- CheckLoopContains(loop, 2);
+ CheckLoop(order, loop, 2);
}
BasicBlock* C = schedule.NewBasicBlock();
BasicBlock* D = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(C, B);
- schedule.AddSuccessor(B, D);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(C, B);
+ schedule.AddSuccessorForTesting(B, D);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 4, true);
BasicBlock* loop[] = {B, C};
- CheckLoopContains(loop, 2);
+ CheckLoop(order, loop, 2);
}
BasicBlock* F = schedule.NewBasicBlock();
BasicBlock* G = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(C, D);
- schedule.AddSuccessor(D, E);
- schedule.AddSuccessor(E, F);
- schedule.AddSuccessor(F, B);
- schedule.AddSuccessor(B, G);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(C, D);
+ schedule.AddSuccessorForTesting(D, E);
+ schedule.AddSuccessorForTesting(E, F);
+ schedule.AddSuccessorForTesting(F, B);
+ schedule.AddSuccessorForTesting(B, G);
// Throw in extra backedges from time to time.
- if (i == 1) schedule.AddSuccessor(B, B);
- if (i == 2) schedule.AddSuccessor(C, B);
- if (i == 3) schedule.AddSuccessor(D, B);
- if (i == 4) schedule.AddSuccessor(E, B);
- if (i == 5) schedule.AddSuccessor(F, B);
+ if (i == 1) schedule.AddSuccessorForTesting(B, B);
+ if (i == 2) schedule.AddSuccessorForTesting(C, B);
+ if (i == 3) schedule.AddSuccessorForTesting(D, B);
+ if (i == 4) schedule.AddSuccessorForTesting(E, B);
+ if (i == 5) schedule.AddSuccessorForTesting(F, B);
// Throw in extra loop exits from time to time.
- if (i == 6) schedule.AddSuccessor(B, G);
- if (i == 7) schedule.AddSuccessor(C, G);
- if (i == 8) schedule.AddSuccessor(D, G);
- if (i == 9) schedule.AddSuccessor(E, G);
- if (i == 10) schedule.AddSuccessor(F, G);
-
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ if (i == 6) schedule.AddSuccessorForTesting(B, G);
+ if (i == 7) schedule.AddSuccessorForTesting(C, G);
+ if (i == 8) schedule.AddSuccessorForTesting(D, G);
+ if (i == 9) schedule.AddSuccessorForTesting(E, G);
+ if (i == 10) schedule.AddSuccessorForTesting(F, G);
+
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 7, true);
BasicBlock* loop[] = {B, C, D, E, F};
- CheckLoopContains(loop, 5);
+ CheckLoop(order, loop, 5);
}
}
BasicBlock* E = schedule.NewBasicBlock();
BasicBlock* F = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(C, D);
- schedule.AddSuccessor(D, C);
- schedule.AddSuccessor(D, E);
- schedule.AddSuccessor(E, B);
- schedule.AddSuccessor(E, F);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(C, D);
+ schedule.AddSuccessorForTesting(D, C);
+ schedule.AddSuccessorForTesting(D, E);
+ schedule.AddSuccessorForTesting(E, B);
+ schedule.AddSuccessorForTesting(E, F);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 6, true);
BasicBlock* loop1[] = {B, C, D, E};
- CheckLoopContains(loop1, 4);
+ CheckLoop(order, loop1, 4);
BasicBlock* loop2[] = {C, D};
- CheckLoopContains(loop2, 2);
+ CheckLoop(order, loop2, 2);
}
BasicBlock* G = schedule.NewBasicBlock();
BasicBlock* H = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(C, D);
- schedule.AddSuccessor(D, E);
- schedule.AddSuccessor(E, F);
- schedule.AddSuccessor(F, G);
- schedule.AddSuccessor(G, H);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(C, D);
+ schedule.AddSuccessorForTesting(D, E);
+ schedule.AddSuccessorForTesting(E, F);
+ schedule.AddSuccessorForTesting(F, G);
+ schedule.AddSuccessorForTesting(G, H);
- schedule.AddSuccessor(E, D);
- schedule.AddSuccessor(F, C);
- schedule.AddSuccessor(G, B);
+ schedule.AddSuccessorForTesting(E, D);
+ schedule.AddSuccessorForTesting(F, C);
+ schedule.AddSuccessorForTesting(G, B);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 8, true);
BasicBlock* loop1[] = {B, C, D, E, F, G};
- CheckLoopContains(loop1, 6);
+ CheckLoop(order, loop1, 6);
BasicBlock* loop2[] = {C, D, E, F};
- CheckLoopContains(loop2, 4);
+ CheckLoop(order, loop2, 4);
BasicBlock* loop3[] = {D, E};
- CheckLoopContains(loop3, 2);
+ CheckLoop(order, loop3, 2);
}
BasicBlock* A = schedule.start();
BasicBlock* E = schedule.end();
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->header(), loop2->header());
- schedule.AddSuccessor(loop2->last(), E);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->header(), loop2->header());
+ schedule.AddSuccessorForTesting(loop2->last(), E);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
- CheckLoopContains(loop1->nodes, loop1->count);
+ CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+ static_cast<int>(order->size()));
- CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
- CheckLoopContains(loop1->nodes, loop1->count);
- CheckLoopContains(loop2->nodes, loop2->count);
+ loop1->Check(order);
+ loop2->Check(order);
}
BasicBlock* S = schedule.NewBasicBlock();
BasicBlock* E = schedule.end();
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->header(), S);
- schedule.AddSuccessor(S, loop2->header());
- schedule.AddSuccessor(loop2->last(), E);
-
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->header(), S);
+ schedule.AddSuccessorForTesting(S, loop2->header());
+ schedule.AddSuccessorForTesting(loop2->last(), E);
- CheckLoopContains(loop1->nodes, loop1->count);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
- CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
- CheckLoopContains(loop1->nodes, loop1->count);
- CheckLoopContains(loop2->nodes, loop2->count);
+ CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+ static_cast<int>(order->size()));
+ loop1->Check(order);
+ loop2->Check(order);
}
BasicBlock* A = schedule.start();
BasicBlock* E = schedule.end();
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->nodes[exit], loop2->header());
- schedule.AddSuccessor(loop2->nodes[exit], E);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
- CheckLoopContains(loop1->nodes, loop1->count);
-
- CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
- CheckLoopContains(loop1->nodes, loop1->count);
- CheckLoopContains(loop2->nodes, loop2->count);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->nodes[exit], loop2->header());
+ schedule.AddSuccessorForTesting(loop2->nodes[exit], E);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
+
+ CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+ static_cast<int>(order->size()));
+ loop1->Check(order);
+ loop2->Check(order);
}
}
}
BasicBlock* C = schedule.NewBasicBlock();
BasicBlock* E = schedule.end();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, loop1->header());
- schedule.AddSuccessor(loop1->header(), loop2->header());
- schedule.AddSuccessor(loop2->last(), C);
- schedule.AddSuccessor(C, E);
- schedule.AddSuccessor(C, B);
-
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->header(), loop2->header());
+ schedule.AddSuccessorForTesting(loop2->last(), C);
+ schedule.AddSuccessorForTesting(C, E);
+ schedule.AddSuccessorForTesting(C, B);
- CheckLoopContains(loop1->nodes, loop1->count);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
- CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
- CheckLoopContains(loop1->nodes, loop1->count);
- CheckLoopContains(loop2->nodes, loop2->count);
+ CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+ static_cast<int>(order->size()));
+ loop1->Check(order);
+ loop2->Check(order);
BasicBlock* loop3[] = {B, loop1->nodes[0], loop2->nodes[0], C};
- CheckLoopContains(loop3, 4);
+ CheckLoop(order, loop3, 4);
}
BasicBlock* E = schedule.end();
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->last(), E);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->last(), E);
- schedule.AddSuccessor(loop1->nodes[i], loop1->header());
- schedule.AddSuccessor(loop1->nodes[j], E);
+ schedule.AddSuccessorForTesting(loop1->nodes[i], loop1->header());
+ schedule.AddSuccessorForTesting(loop1->nodes[j], E);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, schedule.BasicBlockCount(), true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
}
}
}
BasicBlock* E = schedule.end();
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->last(), E);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->last(), E);
- schedule.AddSuccessor(loop1->nodes[i], loop1->header());
- schedule.AddSuccessor(loop1->nodes[j], D);
- schedule.AddSuccessor(D, E);
+ schedule.AddSuccessorForTesting(loop1->nodes[i], loop1->header());
+ schedule.AddSuccessorForTesting(loop1->nodes[j], D);
+ schedule.AddSuccessorForTesting(D, E);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, schedule.BasicBlockCount(), true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
}
}
}
BasicBlock* E = schedule.end();
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->last(), E);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->last(), E);
for (int j = 0; j < size; j++) {
BasicBlock* O = schedule.NewBasicBlock();
- schedule.AddSuccessor(loop1->nodes[j], O);
- schedule.AddSuccessor(O, E);
+ schedule.AddSuccessorForTesting(loop1->nodes[j], O);
+ schedule.AddSuccessorForTesting(O, E);
}
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, schedule.BasicBlockCount(), true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
}
}
BasicBlock* A = schedule.start();
BasicBlock* E = schedule.end();
SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
- schedule.AddSuccessor(A, loop1->header());
- schedule.AddSuccessor(loop1->last(), E);
+ schedule.AddSuccessorForTesting(A, loop1->header());
+ schedule.AddSuccessorForTesting(loop1->last(), E);
TestLoop** loopN = new TestLoop* [size];
for (int j = 0; j < size; j++) {
loopN[j] = CreateLoop(&schedule, 2);
- schedule.AddSuccessor(loop1->nodes[j], loopN[j]->header());
- schedule.AddSuccessor(loopN[j]->last(), E);
+ schedule.AddSuccessorForTesting(loop1->nodes[j], loopN[j]->header());
+ schedule.AddSuccessorForTesting(loopN[j]->last(), E);
}
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order =
+ Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, schedule.BasicBlockCount(), true);
- CheckLoopContains(loop1->nodes, loop1->count);
+ loop1->Check(order);
for (int j = 0; j < size; j++) {
- CheckLoopContains(loopN[j]->nodes, loopN[j]->count);
+ loopN[j]->Check(order);
delete loopN[j];
}
delete[] loopN;
BasicBlock* D = schedule.end();
BasicBlock* E = schedule.NewBasicBlock();
- schedule.AddSuccessor(A, B);
- schedule.AddSuccessor(B, C);
- schedule.AddSuccessor(B, D);
- schedule.AddSuccessor(B, E);
- schedule.AddSuccessor(C, B);
- schedule.AddSuccessor(D, B);
- schedule.AddSuccessor(E, B);
+ schedule.AddSuccessorForTesting(A, B);
+ schedule.AddSuccessorForTesting(B, C);
+ schedule.AddSuccessorForTesting(B, D);
+ schedule.AddSuccessorForTesting(B, E);
+ schedule.AddSuccessorForTesting(C, B);
+ schedule.AddSuccessorForTesting(D, B);
+ schedule.AddSuccessorForTesting(E, B);
- BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
+ ZonePool zone_pool(scope.main_isolate());
+ BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&zone_pool, &schedule);
CheckRPONumbers(order, 5, true);
BasicBlock* loop1[] = {B, C, D, E};
- CheckLoopContains(loop1, 4);
+ CheckLoop(order, loop1, 4);
}
graph.SetStart(graph.NewNode(builder.Start(0)));
graph.SetEnd(graph.NewNode(builder.End(), graph.start()));
- USE(Scheduler::ComputeSchedule(&graph));
+ ZonePool zone_pool(scope.main_isolate());
+ USE(Scheduler::ComputeSchedule(&zone_pool, &graph));
}
graph.SetEnd(graph.NewNode(builder.End(), ret));
- USE(Scheduler::ComputeSchedule(&graph));
+ ZonePool zone_pool(scope.main_isolate());
+ USE(Scheduler::ComputeSchedule(&zone_pool, &graph));
}
JSOperatorBuilder js_builder(scope.main_zone());
const Operator* op;
- Handle<Object> object =
- Handle<Object>(isolate->heap()->undefined_value(), isolate);
- Unique<Object> unique_constant = Unique<Object>::CreateUninitialized(object);
+ Handle<HeapObject> object =
+ Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+ Unique<HeapObject> unique_constant =
+ Unique<HeapObject>::CreateUninitialized(object);
// Manually transcripted code for:
// function turbo_fan_test(a, b, c, y) {
JSOperatorBuilder js_builder(scope.main_zone());
const Operator* op;
- Handle<Object> object =
- Handle<Object>(isolate->heap()->undefined_value(), isolate);
- Unique<Object> unique_constant = Unique<Object>::CreateUninitialized(object);
+ Handle<HeapObject> object =
+ Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+ Unique<HeapObject> unique_constant =
+ Unique<HeapObject>::CreateUninitialized(object);
// Manually transcripted code for:
// function turbo_fan_test(a, b) {
JSOperatorBuilder js_builder(scope.main_zone());
const Operator* op;
- Handle<Object> object =
- Handle<Object>(isolate->heap()->undefined_value(), isolate);
- Unique<Object> unique_constant = Unique<Object>::CreateUninitialized(object);
+ Handle<HeapObject> object =
+ Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+ Unique<HeapObject> unique_constant =
+ Unique<HeapObject>::CreateUninitialized(object);
// Manually transcripted code for:
// function turbo_fan_test(a, b, c) {
JSOperatorBuilder js_builder(scope.main_zone());
const Operator* op;
- Handle<Object> object =
- Handle<Object>(isolate->heap()->undefined_value(), isolate);
- Unique<Object> unique_constant = Unique<Object>::CreateUninitialized(object);
+ Handle<HeapObject> object =
+ Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+ Unique<HeapObject> unique_constant =
+ Unique<HeapObject>::CreateUninitialized(object);
// Manually transcripted code for:
// function turbo_fan_test(a, b, c) {
MachineOperatorBuilder machine_builder;
const Operator* op;
- Handle<Object> object =
- Handle<Object>(isolate->heap()->undefined_value(), isolate);
- Unique<Object> unique_constant = Unique<Object>::CreateUninitialized(object);
+ Handle<HeapObject> object =
+ Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
+ Unique<HeapObject> unique_constant =
+ Unique<HeapObject>::CreateUninitialized(object);
// Manually transcripted code for:
// function turbo_fan_test(a, b, c) {
ComputeAndVerifySchedule(33, &graph);
}
+
+TEST(NestedFloatingDiamonds) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+ SimplifiedOperatorBuilder simplified(scope.main_zone());
+ MachineOperatorBuilder machine;
+
+ Node* start = graph.NewNode(common.Start(2));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+
+ Node* fv = graph.NewNode(common.Int32Constant(7));
+ Node* br = graph.NewNode(common.Branch(), p0, graph.start());
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+
+ Node* map = graph.NewNode(
+ simplified.LoadElement(AccessBuilder::ForFixedArrayElement()), p0, p0, p0,
+ start, f);
+ Node* br1 = graph.NewNode(common.Branch(), map, graph.start());
+ Node* t1 = graph.NewNode(common.IfTrue(), br1);
+ Node* f1 = graph.NewNode(common.IfFalse(), br1);
+ Node* m1 = graph.NewNode(common.Merge(2), t1, f1);
+ Node* ttrue = graph.NewNode(common.Int32Constant(1));
+ Node* ffalse = graph.NewNode(common.Int32Constant(0));
+ Node* phi1 = graph.NewNode(common.Phi(kMachAnyTagged, 2), ttrue, ffalse, m1);
+
+
+ Node* m = graph.NewNode(common.Merge(2), t, f);
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 2), fv, phi1, m);
+ Node* ephi1 = graph.NewNode(common.EffectPhi(2), start, map, m);
+
+ Node* ret = graph.NewNode(common.Return(), phi, ephi1, start);
+ Node* end = graph.NewNode(common.End(), ret, start);
+
+ graph.SetEnd(end);
+
+ ComputeAndVerifySchedule(23, &graph);
+}
+
+
+TEST(LoopedFloatingDiamond1) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+ SimplifiedOperatorBuilder simplified(scope.main_zone());
+ MachineOperatorBuilder machine;
+
+ Node* start = graph.NewNode(common.Start(2));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+
+ Node* c = graph.NewNode(common.Int32Constant(7));
+ Node* loop = graph.NewNode(common.Loop(2), start, start);
+ Node* ind = graph.NewNode(common.Phi(kMachAnyTagged, 2), p0, p0, loop);
+ Node* add = graph.NewNode(machine.IntAdd(), ind, c);
+
+ Node* br = graph.NewNode(common.Branch(), add, loop);
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+
+ Node* br1 = graph.NewNode(common.Branch(), p0, graph.start());
+ Node* t1 = graph.NewNode(common.IfTrue(), br1);
+ Node* f1 = graph.NewNode(common.IfFalse(), br1);
+ Node* m1 = graph.NewNode(common.Merge(2), t1, f1);
+ Node* phi1 = graph.NewNode(common.Phi(kMachAnyTagged, 2), add, p0, m1);
+
+ loop->ReplaceInput(1, t); // close loop.
+ ind->ReplaceInput(1, phi1); // close induction variable.
+
+ Node* ret = graph.NewNode(common.Return(), ind, start, f);
+ Node* end = graph.NewNode(common.End(), ret, f);
+
+ graph.SetEnd(end);
+
+ ComputeAndVerifySchedule(20, &graph);
+}
+
+
+TEST(LoopedFloatingDiamond2) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+ SimplifiedOperatorBuilder simplified(scope.main_zone());
+ MachineOperatorBuilder machine;
+
+ Node* start = graph.NewNode(common.Start(2));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+
+ Node* c = graph.NewNode(common.Int32Constant(7));
+ Node* loop = graph.NewNode(common.Loop(2), start, start);
+ Node* ind = graph.NewNode(common.Phi(kMachAnyTagged, 2), p0, p0, loop);
+
+ Node* br1 = graph.NewNode(common.Branch(), p0, graph.start());
+ Node* t1 = graph.NewNode(common.IfTrue(), br1);
+ Node* f1 = graph.NewNode(common.IfFalse(), br1);
+ Node* m1 = graph.NewNode(common.Merge(2), t1, f1);
+ Node* phi1 = graph.NewNode(common.Phi(kMachAnyTagged, 2), c, ind, m1);
+
+ Node* add = graph.NewNode(machine.IntAdd(), ind, phi1);
+
+ Node* br = graph.NewNode(common.Branch(), add, loop);
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+
+ loop->ReplaceInput(1, t); // close loop.
+ ind->ReplaceInput(1, add); // close induction variable.
+
+ Node* ret = graph.NewNode(common.Return(), ind, start, f);
+ Node* end = graph.NewNode(common.End(), ret, f);
+
+ graph.SetEnd(end);
+
+ ComputeAndVerifySchedule(20, &graph);
+}
+
+
+TEST(PhisPushedDownToDifferentBranches) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+ SimplifiedOperatorBuilder simplified(scope.main_zone());
+ MachineOperatorBuilder machine;
+
+ Node* start = graph.NewNode(common.Start(2));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+ Node* p1 = graph.NewNode(common.Parameter(1), start);
+
+ Node* v1 = graph.NewNode(common.Int32Constant(1));
+ Node* v2 = graph.NewNode(common.Int32Constant(2));
+ Node* v3 = graph.NewNode(common.Int32Constant(3));
+ Node* v4 = graph.NewNode(common.Int32Constant(4));
+ Node* br = graph.NewNode(common.Branch(), p0, graph.start());
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+ Node* m = graph.NewNode(common.Merge(2), t, f);
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 2), v1, v2, m);
+ Node* phi2 = graph.NewNode(common.Phi(kMachAnyTagged, 2), v3, v4, m);
+
+ Node* br2 = graph.NewNode(common.Branch(), p1, graph.start());
+ Node* t2 = graph.NewNode(common.IfTrue(), br2);
+ Node* f2 = graph.NewNode(common.IfFalse(), br2);
+ Node* m2 = graph.NewNode(common.Merge(2), t2, f2);
+ Node* phi3 = graph.NewNode(common.Phi(kMachAnyTagged, 2), phi, phi2, m2);
+
+ Node* ret = graph.NewNode(common.Return(), phi3, start, start);
+ Node* end = graph.NewNode(common.End(), ret, start);
+
+ graph.SetEnd(end);
+
+ ComputeAndVerifySchedule(24, &graph);
+}
+
+
+TEST(BranchHintTrue) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(1));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+ Node* tv = graph.NewNode(common.Int32Constant(6));
+ Node* fv = graph.NewNode(common.Int32Constant(7));
+ Node* br = graph.NewNode(common.Branch(BranchHint::kTrue), p0, start);
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+ Node* m = graph.NewNode(common.Merge(2), t, f);
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 2), tv, fv, m);
+ Node* ret = graph.NewNode(common.Return(), phi, start, start);
+ Node* end = graph.NewNode(common.End(), ret, start);
+
+ graph.SetEnd(end);
+
+ Schedule* schedule = ComputeAndVerifySchedule(13, &graph);
+ // Make sure the false block is marked as deferred.
+ CHECK(!schedule->block(t)->deferred());
+ CHECK(schedule->block(f)->deferred());
+}
+
+
+TEST(BranchHintFalse) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(1));
+ graph.SetStart(start);
+
+ Node* p0 = graph.NewNode(common.Parameter(0), start);
+ Node* tv = graph.NewNode(common.Int32Constant(6));
+ Node* fv = graph.NewNode(common.Int32Constant(7));
+ Node* br = graph.NewNode(common.Branch(BranchHint::kFalse), p0, start);
+ Node* t = graph.NewNode(common.IfTrue(), br);
+ Node* f = graph.NewNode(common.IfFalse(), br);
+ Node* m = graph.NewNode(common.Merge(2), t, f);
+ Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 2), tv, fv, m);
+ Node* ret = graph.NewNode(common.Return(), phi, start, start);
+ Node* end = graph.NewNode(common.End(), ret, start);
+
+ graph.SetEnd(end);
+
+ Schedule* schedule = ComputeAndVerifySchedule(13, &graph);
+ // Make sure the true block is marked as deferred.
+ CHECK(schedule->block(t)->deferred());
+ CHECK(!schedule->block(f)->deferred());
+}
+
+
+TEST(ScheduleTerminate) {
+ HandleAndZoneScope scope;
+ Graph graph(scope.main_zone());
+ CommonOperatorBuilder common(scope.main_zone());
+
+ Node* start = graph.NewNode(common.Start(1));
+ graph.SetStart(start);
+
+ Node* loop = graph.NewNode(common.Loop(2), start, start);
+ loop->ReplaceInput(1, loop); // self loop, NTL.
+
+ Node* effect = graph.NewNode(common.EffectPhi(1), start, loop);
+ effect->ReplaceInput(0, effect);
+
+ Node* terminate = graph.NewNode(common.Terminate(1), effect, loop);
+ Node* end = graph.NewNode(common.End(), terminate);
+
+ graph.SetEnd(end);
+
+ Schedule* schedule = ComputeAndVerifySchedule(6, &graph);
+ BasicBlock* block = schedule->block(loop);
+ CHECK_NE(NULL, loop);
+ CHECK_EQ(block, schedule->block(effect));
+ CHECK_GE(block->rpo_number(), 0);
+}
+
#endif
#include <limits>
#include "src/compiler/access-builder.h"
+#include "src/compiler/change-lowering.h"
#include "src/compiler/control-builders.h"
#include "src/compiler/generic-node-inl.h"
+#include "src/compiler/graph-reducer.h"
#include "src/compiler/graph-visualizer.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/pipeline.h"
MachineType p3 = kMachNone,
MachineType p4 = kMachNone)
: GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
- typer(this->zone()),
+ typer(this->graph(), MaybeHandle<Context>()),
javascript(this->zone()),
- jsgraph(this->graph(), this->common(), &javascript, &typer,
- this->machine()),
+ jsgraph(this->graph(), this->common(), &javascript, this->machine()),
lowering(&jsgraph) {}
Typer typer;
void LowerAllNodes() {
this->End();
+ typer.Run();
lowering.LowerAllNodes();
}
+ void LowerAllNodesAndLowerChanges() {
+ this->End();
+ typer.Run();
+ lowering.LowerAllNodes();
+
+ Zone* zone = this->zone();
+ CompilationInfo info(zone->isolate(), zone);
+ Linkage linkage(
+ zone, Linkage::GetSimplifiedCDescriptor(zone, this->machine_sig_));
+ ChangeLowering lowering(&jsgraph, &linkage);
+ GraphReducer reducer(this->graph());
+ reducer.AddReducer(&lowering);
+ reducer.ReduceGraph();
+ Verifier::Run(this->graph());
+ }
+
+ void CheckNumberCall(double expected, double input) {
+ // TODO(titzer): make calls to NewNumber work in cctests.
+ if (expected <= Smi::kMinValue) return;
+ if (expected >= Smi::kMaxValue) return;
+ Handle<Object> num = factory()->NewNumber(input);
+ Object* result = this->Call(*num);
+ CHECK(factory()->NewNumber(expected)->SameValue(result));
+ }
+
Factory* factory() { return this->isolate()->factory(); }
Heap* heap() { return this->isolate()->heap(); }
};
-#ifndef V8_TARGET_ARCH_ARM64
-// TODO(titzer): these result in a stub call that doesn't work on ARM64.
// TODO(titzer): factor these tests out to test-run-simplifiedops.cc.
// TODO(titzer): test tagged representation for input to NumberToInt32.
TEST(RunNumberToInt32_float64) {
FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
kMachFloat64};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
+ NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
Node* convert = t.NumberToInt32(loaded);
FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Signed32(),
kMachInt32};
FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
kMachFloat64};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
+ NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
Node* convert = t.NumberToUint32(loaded);
FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Unsigned32(),
kMachUint32};
}
}
}
-#endif
// Create a simple JSObject with a unique map.
for (size_t i = 0; i < arraysize(smis); i++) { // for header sizes
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
- ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- kMachAnyTagged};
+ ElementAccess access = {kNoBoundsCheck, kUntaggedBase, offset,
+ Type::Integral32(), kMachAnyTagged};
SimplifiedLoweringTester<Object*> t;
Node* load = t.LoadElement(
for (size_t i = 0; i < arraysize(smis); i++) { // for header sizes
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
- ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- kMachAnyTagged};
+ ElementAccess access = {kNoBoundsCheck, kUntaggedBase, offset,
+ Type::Integral32(), kMachAnyTagged};
SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
Node* p0 = t.Parameter(0);
private:
ElementAccess GetElementAccess() {
- ElementAccess access = {tagged ? kTaggedBase : kUntaggedBase,
- tagged ? FixedArrayBase::kHeaderSize : 0,
- Type::Any(), rep};
+ ElementAccess access = {
+ kNoBoundsCheck, tagged ? kTaggedBase : kUntaggedBase,
+ tagged ? FixedArrayBase::kHeaderSize : 0, Type::Any(), rep};
return access;
}
explicit TestingGraph(Type* p0_type, Type* p1_type = Type::None(),
Type* p2_type = Type::None())
: GraphAndBuilders(main_zone()),
- typer(main_zone()),
+ typer(graph(), MaybeHandle<Context>()),
javascript(main_zone()),
- jsgraph(graph(), common(), &javascript, &typer, machine()) {
+ jsgraph(graph(), common(), &javascript, machine()) {
start = graph()->NewNode(common()->Start(2));
graph()->SetStart(start);
ret =
p0 = graph()->NewNode(common()->Parameter(0), start);
p1 = graph()->NewNode(common()->Parameter(1), start);
p2 = graph()->NewNode(common()->Parameter(2), start);
+ typer.Run();
NodeProperties::SetBounds(p0, Bounds(p0_type));
NodeProperties::SetBounds(p1, Bounds(p1_type));
NodeProperties::SetBounds(p2, Bounds(p2_type));
}
void Lower() {
- SimplifiedLowering lowering(&jsgraph);
- lowering.LowerAllNodes();
+ SimplifiedLowering(&jsgraph).LowerAllNodes();
}
// Inserts the node as the return value of the graph.
Node* use = t.Branch(inv);
t.Lower();
Node* cmp = use->InputAt(0);
- CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
+ CHECK_EQ(t.machine()->Word32Equal()->opcode(), cmp->opcode());
CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
Node* f = t.jsgraph.Int32Constant(0);
CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
t.Lower();
CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
Node* cmp = use->InputAt(0)->InputAt(0);
- CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
+ CHECK_EQ(t.machine()->Word32Equal()->opcode(), cmp->opcode());
CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
Node* f = t.jsgraph.Int32Constant(0);
CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
TEST(LowerNumberAddSub_to_int32) {
- TestingGraph t(Type::Signed32(), Type::Signed32());
- t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
- t.simplified()->NumberAdd(),
- t.simplified()->NumberToInt32());
- t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
- t.simplified()->NumberSubtract(),
- t.simplified()->NumberToInt32());
+ HandleAndZoneScope scope;
+ Factory* f = scope.main_zone()->isolate()->factory();
+ Type* small_range =
+ Type::Range(f->NewNumber(1), f->NewNumber(10), scope.main_zone());
+ Type* large_range =
+ Type::Range(f->NewNumber(-1e+13), f->NewNumber(1e+14), scope.main_zone());
+ static Type* types[] = {Type::Signed32(), Type::Integral32(), small_range,
+ large_range};
+
+ for (size_t i = 0; i < arraysize(types); i++) {
+ for (size_t j = 0; j < arraysize(types); j++) {
+ TestingGraph t(types[i], types[j]);
+ t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
+ t.simplified()->NumberAdd(),
+ t.simplified()->NumberToInt32());
+ t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
+ t.simplified()->NumberSubtract(),
+ t.simplified()->NumberToInt32());
+ }
+ }
}
TEST(LowerNumberAddSub_to_uint32) {
- TestingGraph t(Type::Unsigned32(), Type::Unsigned32());
- t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
- t.simplified()->NumberAdd(),
- t.simplified()->NumberToUint32());
- t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
- t.simplified()->NumberSubtract(),
- t.simplified()->NumberToUint32());
+ HandleAndZoneScope scope;
+ Factory* f = scope.main_zone()->isolate()->factory();
+ Type* small_range =
+ Type::Range(f->NewNumber(1), f->NewNumber(10), scope.main_zone());
+ Type* large_range =
+ Type::Range(f->NewNumber(-1e+13), f->NewNumber(1e+14), scope.main_zone());
+ static Type* types[] = {Type::Signed32(), Type::Integral32(), small_range,
+ large_range};
+
+ for (size_t i = 0; i < arraysize(types); i++) {
+ for (size_t j = 0; j < arraysize(types); j++) {
+ TestingGraph t(types[i], types[j]);
+ t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
+ t.simplified()->NumberAdd(),
+ t.simplified()->NumberToUint32());
+ t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
+ t.simplified()->NumberSubtract(),
+ t.simplified()->NumberToUint32());
+ }
+ }
}
TestingGraph t(test_types[i], test_types[i]);
t.CheckLoweringBinop(IrOpcode::kFloat64Div, t.simplified()->NumberDivide());
- t.CheckLoweringBinop(IrOpcode::kFloat64Mod,
- t.simplified()->NumberModulus());
+ if (!test_types[i]->Is(Type::Unsigned32())) {
+ t.CheckLoweringBinop(IrOpcode::kFloat64Mod,
+ t.simplified()->NumberModulus());
+ }
}
}
// NumberToInt32(x: kRepFloat64) used as kMachInt32
TestingGraph t(Type::Number());
Node* p0 = t.ExampleWithOutput(kMachFloat64);
+ // TODO(titzer): run the typer here, or attach machine type to param.
+ NodeProperties::SetBounds(p0, Bounds(Type::Number()));
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), p0);
Node* use = t.Use(trunc, kMachInt32);
t.Return(use);
// NumberToUint32(x: kRepFloat64) used as kMachUint32
TestingGraph t(Type::Number());
Node* p0 = t.ExampleWithOutput(kMachFloat64);
+ // TODO(titzer): run the typer here, or attach machine type to param.
+ NodeProperties::SetBounds(p0, Bounds(Type::Number()));
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), p0);
Node* use = t.Use(trunc, kMachUint32);
t.Return(use);
}
+namespace {
+
void CheckFieldAccessArithmetic(FieldAccess access, Node* load_or_store) {
- Int32Matcher index = Int32Matcher(load_or_store->InputAt(1));
- CHECK(index.Is(access.offset - access.tag()));
+ IntPtrMatcher mindex(load_or_store->InputAt(1));
+ CHECK(mindex.Is(access.offset - access.tag()));
}
Node* CheckElementAccessArithmetic(ElementAccess access, Node* load_or_store) {
- Int32BinopMatcher index(load_or_store->InputAt(1));
- CHECK_EQ(IrOpcode::kInt32Add, index.node()->opcode());
- CHECK(index.right().Is(access.header_size - access.tag()));
+ Node* index = load_or_store->InputAt(1);
+ if (kPointerSize == 8) {
+ CHECK_EQ(IrOpcode::kChangeUint32ToUint64, index->opcode());
+ index = index->InputAt(0);
+ }
- int element_size = ElementSizeOf(access.machine_type);
+ Int32BinopMatcher mindex(index);
+ CHECK_EQ(IrOpcode::kInt32Add, mindex.node()->opcode());
+ CHECK(mindex.right().Is(access.header_size - access.tag()));
- if (element_size != 1) {
- Int32BinopMatcher mul(index.left().node());
- CHECK_EQ(IrOpcode::kInt32Mul, mul.node()->opcode());
- CHECK(mul.right().Is(element_size));
- return mul.left().node();
+ const int element_size_shift = ElementSizeLog2Of(access.machine_type);
+ if (element_size_shift) {
+ Int32BinopMatcher shl(mindex.left().node());
+ CHECK_EQ(IrOpcode::kWord32Shl, shl.node()->opcode());
+ CHECK(shl.right().Is(element_size_shift));
+ return shl.left().node();
} else {
- return index.left().node();
+ return mindex.left().node();
}
}
-static const MachineType machine_reps[] = {
- kRepBit, kMachInt8, kMachInt16, kMachInt32,
- kMachInt64, kMachFloat64, kMachAnyTagged};
+const MachineType kMachineReps[] = {kRepBit, kMachInt8, kMachInt16,
+ kMachInt32, kMachInt64, kMachFloat64,
+ kMachAnyTagged};
+
+} // namespace
TEST(LowerLoadField_to_load) {
TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(machine_reps); i++) {
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), machine_reps[i]};
+ Handle<Name>::null(), Type::Any(), kMachineReps[i]};
Node* load =
t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
- Node* use = t.Use(load, machine_reps[i]);
+ Node* use = t.Use(load, kMachineReps[i]);
t.Return(use);
t.Lower();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
CheckFieldAccessArithmetic(access, load);
MachineType rep = OpParameter<MachineType>(load);
- CHECK_EQ(machine_reps[i], rep);
+ CHECK_EQ(kMachineReps[i], rep);
}
}
TEST(LowerStoreField_to_store) {
TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(machine_reps); i++) {
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), machine_reps[i]};
+ Handle<Name>::null(), Type::Any(), kMachineReps[i]};
- Node* val = t.ExampleWithOutput(machine_reps[i]);
+ Node* val = t.ExampleWithOutput(kMachineReps[i]);
Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
val, t.start, t.start);
t.Effect(store);
CheckFieldAccessArithmetic(access, store);
StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
- if (machine_reps[i] & kRepTagged) {
+ if (kMachineReps[i] & kRepTagged) {
CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
}
- CHECK_EQ(machine_reps[i], rep.machine_type());
+ CHECK_EQ(kMachineReps[i], rep.machine_type());
}
}
TEST(LowerLoadElement_to_load) {
TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(machine_reps); i++) {
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), machine_reps[i]};
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
+ kMachineReps[i]};
Node* load =
t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0, t.p1,
- t.jsgraph.Int32Constant(1024), t.start);
- Node* use = t.Use(load, machine_reps[i]);
+ t.jsgraph.Int32Constant(1024), t.start, t.start);
+ Node* use = t.Use(load, kMachineReps[i]);
t.Return(use);
t.Lower();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
CheckElementAccessArithmetic(access, load);
MachineType rep = OpParameter<MachineType>(load);
- CHECK_EQ(machine_reps[i], rep);
+ CHECK_EQ(kMachineReps[i], rep);
}
}
TEST(LowerStoreElement_to_store) {
TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(machine_reps); i++) {
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), machine_reps[i]};
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
+ kMachineReps[i]};
- Node* val = t.ExampleWithOutput(machine_reps[i]);
+ Node* val = t.ExampleWithOutput(kMachineReps[i]);
Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
t.p1, t.jsgraph.Int32Constant(1024), val,
t.start, t.start);
CheckElementAccessArithmetic(access, store);
StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
- if (machine_reps[i] & kRepTagged) {
+ if (kMachineReps[i] & kRepTagged) {
CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
}
- CHECK_EQ(machine_reps[i], rep.machine_type());
+ CHECK_EQ(kMachineReps[i], rep.machine_type());
}
}
// LoadElement(obj: Tagged, index: kTypeInt32 | kRepTagged, length) =>
// Load(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k))
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
kMachAnyTagged};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
- t.p1, t.p2, t.start);
+ t.p1, t.p2, t.start, t.start);
t.Return(load);
t.Lower();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
// StoreElement(obj: Tagged, index: kTypeInt32 | kRepTagged, length, val) =>
// Store(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k), val)
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
kMachAnyTagged};
Node* store =
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(),
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
kMachFloat64};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
- t.p1, t.p1, t.start);
+ t.p1, t.p1, t.start, t.start);
t.Return(load);
t.Lower();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
TEST(InsertChangeForStoreElement) {
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
+ ElementAccess access = {kNoBoundsCheck, kTaggedBase,
+ FixedArrayBase::kHeaderSize, Type::Any(),
kMachFloat64};
Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
TestingGraph t(Type::Any(), Type::Signed32());
static const MachineType kMachineTypes[] = {kMachInt32, kMachUint32,
kMachFloat64};
+ Type* kTypes[] = {Type::Signed32(), Type::Unsigned32(), Type::Number()};
for (size_t i = 0; i < arraysize(kMachineTypes); i++) {
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachineTypes[i]};
+ Handle<Name>::null(), kTypes[i], kMachineTypes[i]};
Node* load0 =
t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
RepresentationOf(OpParameter<MachineType>(phi)));
}
}
+
+
+TEST(RunNumberDivide_minus_1_TruncatingToInt32) {
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToInt32(t.Parameter(0));
+ Node* div = t.NumberDivide(num, t.jsgraph.Constant(-1));
+ Node* trunc = t.NumberToInt32(div);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_INT32_INPUTS(i) {
+ int32_t x = 0 - *i;
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+}
+
+
+TEST(NumberMultiply_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, -1, 0, 1, 100, 1000};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
+ Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), mul);
+ t.Return(trunc);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Mul, mul->opcode());
+ }
+}
+
+
+TEST(RunNumberMultiply_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, -1, 0, 1, 100, 1000, 3000999};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ double k = static_cast<double>(constants[i]);
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToInt32(t.Parameter(0));
+ Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
+ Node* trunc = t.NumberToInt32(mul);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_INT32_INPUTS(i) {
+ int32_t x = DoubleToInt32(static_cast<double>(*i) * k);
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(RunNumberMultiply_TruncatingToUint32) {
+ uint32_t constants[] = {0, 1, 2, 3, 4, 100, 1000, 1024, 2048, 3000999};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ double k = static_cast<double>(constants[i]);
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToUint32(t.Parameter(0));
+ Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
+ Node* trunc = t.NumberToUint32(mul);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_UINT32_INPUTS(i) {
+ uint32_t x = DoubleToUint32(static_cast<double>(*i) * k);
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(RunNumberDivide_2_TruncatingToUint32) {
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToUint32(t.Parameter(0));
+ Node* div = t.NumberDivide(num, t.jsgraph.Constant(2));
+ Node* trunc = t.NumberToUint32(div);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_UINT32_INPUTS(i) {
+ uint32_t x = DoubleToUint32(static_cast<double>(*i / 2.0));
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+}
+
+
+TEST(NumberMultiply_ConstantOutOfRange) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(1000000023);
+ Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
+ Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), mul);
+ t.Return(trunc);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kFloat64Mul, mul->opcode());
+}
+
+
+TEST(NumberMultiply_NonTruncating) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(111);
+ Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
+ t.Return(mul);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kFloat64Mul, mul->opcode());
+}
+
+
+TEST(NumberDivide_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, 1, 4, 100, 1000};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
+ Node* use = t.Use(div, kMachInt32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Div, use->InputAt(0)->opcode());
+ }
+}
+
+
+TEST(RunNumberDivide_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, -1, 1, 2, 100, 1000, 1024, 2048};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int32_t k = constants[i];
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToInt32(t.Parameter(0));
+ Node* div = t.NumberDivide(num, t.jsgraph.Constant(k));
+ Node* trunc = t.NumberToInt32(div);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_INT32_INPUTS(i) {
+ if (*i == INT_MAX) continue; // exclude max int.
+ int32_t x = DoubleToInt32(static_cast<double>(*i) / k);
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(NumberDivide_TruncatingToUint32) {
+ double constants[] = {1, 3, 100, 1000, 100998348};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Unsigned32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
+ Node* use = t.Use(div, kMachUint32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kUint32Div, use->InputAt(0)->opcode());
+ }
+}
+
+
+TEST(RunNumberDivide_TruncatingToUint32) {
+ uint32_t constants[] = {100, 10, 1, 1, 2, 4, 1000, 1024, 2048};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ uint32_t k = constants[i];
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToUint32(t.Parameter(0));
+ Node* div = t.NumberDivide(num, t.jsgraph.Constant(static_cast<double>(k)));
+ Node* trunc = t.NumberToUint32(div);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_UINT32_INPUTS(i) {
+ uint32_t x = *i / k;
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(NumberDivide_BadConstants) {
+ {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(-1);
+ Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
+ Node* use = t.Use(div, kMachInt32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Sub, use->InputAt(0)->opcode());
+ }
+
+ {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(0);
+ Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
+ Node* use = t.Use(div, kMachInt32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Constant, use->InputAt(0)->opcode());
+ CHECK_EQ(0, OpParameter<int32_t>(use->InputAt(0)));
+ }
+
+ {
+ TestingGraph t(Type::Unsigned32());
+ Node* k = t.jsgraph.Constant(0);
+ Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
+ Node* use = t.Use(div, kMachUint32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Constant, use->InputAt(0)->opcode());
+ CHECK_EQ(0, OpParameter<int32_t>(use->InputAt(0)));
+ }
+}
+
+
+TEST(NumberModulus_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, 1, 4, 100, 1000};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
+ Node* use = t.Use(mod, kMachInt32);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kInt32Mod, use->InputAt(0)->opcode());
+ }
+}
+
+
+TEST(RunNumberModulus_TruncatingToInt32) {
+ int32_t constants[] = {-100, -10, -1, 1, 2, 100, 1000, 1024, 2048};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ int32_t k = constants[i];
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToInt32(t.Parameter(0));
+ Node* mod = t.NumberModulus(num, t.jsgraph.Constant(k));
+ Node* trunc = t.NumberToInt32(mod);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_INT32_INPUTS(i) {
+ if (*i == INT_MAX) continue; // exclude max int.
+ int32_t x = DoubleToInt32(std::fmod(static_cast<double>(*i), k));
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(NumberModulus_TruncatingToUint32) {
+ double constants[] = {1, 3, 100, 1000, 100998348};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Unsigned32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
+ Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), mod);
+ Node* ret = t.Return(trunc);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kUint32Mod, ret->InputAt(0)->opcode());
+ }
+}
+
+
+TEST(RunNumberModulus_TruncatingToUint32) {
+ uint32_t constants[] = {1, 2, 100, 1000, 1024, 2048};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ uint32_t k = constants[i];
+ SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ Node* num = t.NumberToUint32(t.Parameter(0));
+ Node* mod =
+ t.NumberModulus(num, t.jsgraph.Constant(static_cast<double>(k)));
+ Node* trunc = t.NumberToUint32(mod);
+ t.Return(trunc);
+
+ if (Pipeline::SupportedTarget()) {
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ FOR_UINT32_INPUTS(i) {
+ uint32_t x = *i % k;
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
+ }
+ }
+ }
+}
+
+
+TEST(NumberModulus_Int32) {
+ int32_t constants[] = {-100, -10, 1, 4, 100, 1000};
+
+ for (size_t i = 0; i < arraysize(constants); i++) {
+ TestingGraph t(Type::Signed32());
+ Node* k = t.jsgraph.Constant(constants[i]);
+ Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
+ t.Return(mod);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kFloat64Mod, mod->opcode()); // Pesky -0 behavior.
+ }
+}
+
+
+TEST(NumberModulus_Uint32) {
+ const double kConstants[] = {2, 100, 1000, 1024, 2048};
+ const MachineType kTypes[] = {kMachInt32, kMachUint32};
+
+ for (auto const type : kTypes) {
+ for (auto const c : kConstants) {
+ TestingGraph t(Type::Unsigned32());
+ Node* k = t.jsgraph.Constant(c);
+ Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
+ Node* use = t.Use(mod, type);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(IrOpcode::kUint32Mod, use->InputAt(0)->opcode());
+ }
+ }
+}
+
+
+TEST(PhiRepresentation) {
+ HandleAndZoneScope scope;
+ Zone* z = scope.main_zone();
+
+ Factory* f = z->isolate()->factory();
+ Handle<Object> range_min = f->NewNumber(-1e13);
+ Handle<Object> range_max = f->NewNumber(1e+15);
+ Type* range = Type::Range(range_min, range_max, z);
+
+ struct TestData {
+ Type* arg1;
+ Type* arg2;
+ MachineType use;
+ MachineTypeUnion expected;
+ };
+
+ TestData test_data[] = {
+ {Type::Signed32(), Type::Unsigned32(), kMachInt32,
+ kRepWord32 | kTypeNumber},
+ {range, range, kMachUint32, kRepWord32 | kTypeNumber},
+ {Type::Signed32(), Type::Signed32(), kMachInt32, kMachInt32},
+ {Type::Unsigned32(), Type::Unsigned32(), kMachInt32, kMachUint32},
+ {Type::Number(), Type::Signed32(), kMachInt32, kMachFloat64},
+ {Type::Signed32(), Type::String(), kMachInt32, kMachAnyTagged}};
+
+ for (auto const d : test_data) {
+ TestingGraph t(d.arg1, d.arg2, Type::Boolean());
+
+ Node* br = t.graph()->NewNode(t.common()->Branch(), t.p2, t.start);
+ Node* tb = t.graph()->NewNode(t.common()->IfTrue(), br);
+ Node* fb = t.graph()->NewNode(t.common()->IfFalse(), br);
+ Node* m = t.graph()->NewNode(t.common()->Merge(2), tb, fb);
+
+ Node* phi =
+ t.graph()->NewNode(t.common()->Phi(kMachAnyTagged, 2), t.p0, t.p1, m);
+
+ Bounds phi_bounds = Bounds::Either(Bounds(d.arg1), Bounds(d.arg2), z);
+ NodeProperties::SetBounds(phi, phi_bounds);
+
+ Node* use = t.Use(phi, d.use);
+ t.Return(use);
+ t.Lower();
+
+ CHECK_EQ(d.expected, OpParameter<MachineType>(phi));
+ }
+}
--- /dev/null
+// 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 <functional>
+
+#include "src/codegen.h"
+#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/typer.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/types-fuzz.h"
+
+using namespace v8::internal;
+using namespace v8::internal::compiler;
+
+
+// TODO(titzer): generate a large set of deterministic inputs for these tests.
+class TyperTester : public HandleAndZoneScope, public GraphAndBuilders {
+ public:
+ TyperTester()
+ : GraphAndBuilders(main_zone()),
+ types_(main_zone(), isolate()),
+ typer_(graph(), MaybeHandle<Context>()),
+ javascript_(main_zone()) {
+ Node* s = graph()->NewNode(common()->Start(3));
+ graph()->SetStart(s);
+ context_node_ = graph()->NewNode(common()->Parameter(2), graph()->start());
+ rng_ = isolate()->random_number_generator();
+
+ integers.push_back(0);
+ integers.push_back(0);
+ integers.push_back(-1);
+ integers.push_back(+1);
+ integers.push_back(-V8_INFINITY);
+ integers.push_back(+V8_INFINITY);
+ for (int i = 0; i < 5; ++i) {
+ double x = rng_->NextInt();
+ integers.push_back(x);
+ x *= rng_->NextInt();
+ if (!IsMinusZero(x)) integers.push_back(x);
+ }
+
+ int32s.push_back(0);
+ int32s.push_back(0);
+ int32s.push_back(-1);
+ int32s.push_back(+1);
+ int32s.push_back(kMinInt);
+ int32s.push_back(kMaxInt);
+ for (int i = 0; i < 10; ++i) {
+ int32s.push_back(rng_->NextInt());
+ }
+ }
+
+ Types<Type, Type*, Zone> types_;
+ Typer typer_;
+ JSOperatorBuilder javascript_;
+ Node* context_node_;
+ v8::base::RandomNumberGenerator* rng_;
+ std::vector<double> integers;
+ std::vector<double> int32s;
+
+ Isolate* isolate() { return main_isolate(); }
+ Graph* graph() { return main_graph_; }
+ CommonOperatorBuilder* common() { return &main_common_; }
+
+ Node* Parameter(int index = 0) {
+ return graph()->NewNode(common()->Parameter(index), graph()->start());
+ }
+
+ Type* TypeBinaryOp(const Operator* op, Type* lhs, Type* rhs) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ NodeProperties::SetBounds(p0, Bounds(lhs));
+ NodeProperties::SetBounds(p1, Bounds(rhs));
+ Node* n = graph()->NewNode(
+ op, p0, p1, context_node_, graph()->start(), graph()->start());
+ return NodeProperties::GetBounds(n).upper;
+ }
+
+ Type* RandomRange(bool int32 = false) {
+ std::vector<double>& numbers = int32 ? int32s : integers;
+ double i = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
+ double j = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
+ return NewRange(i, j);
+ }
+
+ Type* NewRange(double i, double j) {
+ Factory* f = isolate()->factory();
+ i::Handle<i::Object> min = f->NewNumber(i);
+ i::Handle<i::Object> max = f->NewNumber(j);
+ if (min->Number() > max->Number()) std::swap(min, max);
+ return Type::Range(min, max, main_zone());
+ }
+
+ double RandomInt(double min, double max) {
+ switch (rng_->NextInt(4)) {
+ case 0: return min;
+ case 1: return max;
+ default: break;
+ }
+ if (min == +V8_INFINITY) return +V8_INFINITY;
+ if (max == -V8_INFINITY) return -V8_INFINITY;
+ if (min == -V8_INFINITY && max == +V8_INFINITY) {
+ return rng_->NextInt() * static_cast<double>(rng_->NextInt());
+ }
+ double result = nearbyint(min + (max - min) * rng_->NextDouble());
+ if (IsMinusZero(result)) return 0;
+ if (std::isnan(result)) return rng_->NextInt(2) ? min : max;
+ DCHECK(min <= result && result <= max);
+ return result;
+ }
+
+ double RandomInt(Type::RangeType* range) {
+ return RandomInt(range->Min()->Number(), range->Max()->Number());
+ }
+
+ // Careful, this function runs O(max_width^5) trials.
+ template <class BinaryFunction>
+ void TestBinaryArithOpCloseToZero(const Operator* op, BinaryFunction opfun,
+ int max_width) {
+ const int min_min = -2 - max_width / 2;
+ const int max_min = 2 + max_width / 2;
+ for (int width = 0; width < max_width; width++) {
+ for (int lmin = min_min; lmin <= max_min; lmin++) {
+ for (int rmin = min_min; rmin <= max_min; rmin++) {
+ Type* r1 = NewRange(lmin, lmin + width);
+ Type* r2 = NewRange(rmin, rmin + width);
+ Type* expected_type = TypeBinaryOp(op, r1, r2);
+
+ for (int x1 = lmin; x1 < lmin + width; x1++) {
+ for (int x2 = rmin; x2 < rmin + width; x2++) {
+ double result_value = opfun(x1, x2);
+ Type* result_type = Type::Constant(
+ isolate()->factory()->NewNumber(result_value), main_zone());
+ CHECK(result_type->Is(expected_type));
+ }
+ }
+ }
+ }
+ }
+ }
+
+ template <class BinaryFunction>
+ void TestBinaryArithOp(const Operator* op, BinaryFunction opfun) {
+ TestBinaryArithOpCloseToZero(op, opfun, 8);
+ for (int i = 0; i < 100; ++i) {
+ Type::RangeType* r1 = RandomRange()->AsRange();
+ Type::RangeType* r2 = RandomRange()->AsRange();
+ Type* expected_type = TypeBinaryOp(op, r1, r2);
+ for (int i = 0; i < 10; i++) {
+ double x1 = RandomInt(r1);
+ double x2 = RandomInt(r2);
+ double result_value = opfun(x1, x2);
+ Type* result_type = Type::Constant(
+ isolate()->factory()->NewNumber(result_value), main_zone());
+ CHECK(result_type->Is(expected_type));
+ }
+ }
+ }
+
+ template <class BinaryFunction>
+ void TestBinaryCompareOp(const Operator* op, BinaryFunction opfun) {
+ for (int i = 0; i < 100; ++i) {
+ Type::RangeType* r1 = RandomRange()->AsRange();
+ Type::RangeType* r2 = RandomRange()->AsRange();
+ Type* expected_type = TypeBinaryOp(op, r1, r2);
+ for (int i = 0; i < 10; i++) {
+ double x1 = RandomInt(r1);
+ double x2 = RandomInt(r2);
+ bool result_value = opfun(x1, x2);
+ Type* result_type =
+ Type::Constant(result_value ? isolate()->factory()->true_value()
+ : isolate()->factory()->false_value(),
+ main_zone());
+ CHECK(result_type->Is(expected_type));
+ }
+ }
+ }
+
+ template <class BinaryFunction>
+ void TestBinaryBitOp(const Operator* op, BinaryFunction opfun) {
+ for (int i = 0; i < 100; ++i) {
+ Type::RangeType* r1 = RandomRange(true)->AsRange();
+ Type::RangeType* r2 = RandomRange(true)->AsRange();
+ Type* expected_type = TypeBinaryOp(op, r1, r2);
+ for (int i = 0; i < 10; i++) {
+ int32_t x1 = static_cast<int32_t>(RandomInt(r1));
+ int32_t x2 = static_cast<int32_t>(RandomInt(r2));
+ double result_value = opfun(x1, x2);
+ Type* result_type = Type::Constant(
+ isolate()->factory()->NewNumber(result_value), main_zone());
+ CHECK(result_type->Is(expected_type));
+ }
+ }
+ }
+
+ Type* RandomSubtype(Type* type) {
+ Type* subtype;
+ do {
+ subtype = types_.Fuzz();
+ } while (!subtype->Is(type));
+ return subtype;
+ }
+
+ void TestBinaryMonotonicity(const Operator* op) {
+ for (int i = 0; i < 50; ++i) {
+ Type* type1 = types_.Fuzz();
+ Type* type2 = types_.Fuzz();
+ Type* type = TypeBinaryOp(op, type1, type2);
+ Type* subtype1 = RandomSubtype(type1);;
+ Type* subtype2 = RandomSubtype(type2);;
+ Type* subtype = TypeBinaryOp(op, subtype1, subtype2);
+ CHECK(subtype->Is(type));
+ }
+ }
+};
+
+
+static int32_t shift_left(int32_t x, int32_t y) { return x << y; }
+static int32_t shift_right(int32_t x, int32_t y) { return x >> y; }
+static int32_t bit_or(int32_t x, int32_t y) { return x | y; }
+static int32_t bit_and(int32_t x, int32_t y) { return x & y; }
+static int32_t bit_xor(int32_t x, int32_t y) { return x ^ y; }
+
+
+//------------------------------------------------------------------------------
+// Soundness
+// For simplicity, we currently only test soundness on expression operators
+// that have a direct equivalent in C++. Also, testing is currently limited
+// to ranges as input types.
+
+
+TEST(TypeJSAdd) {
+ TyperTester t;
+ t.TestBinaryArithOp(t.javascript_.Add(), std::plus<double>());
+}
+
+
+TEST(TypeJSSubtract) {
+ TyperTester t;
+ t.TestBinaryArithOp(t.javascript_.Subtract(), std::minus<double>());
+}
+
+
+TEST(TypeJSMultiply) {
+ TyperTester t;
+ t.TestBinaryArithOp(t.javascript_.Multiply(), std::multiplies<double>());
+}
+
+
+TEST(TypeJSDivide) {
+ TyperTester t;
+ t.TestBinaryArithOp(t.javascript_.Divide(), std::divides<double>());
+}
+
+
+TEST(TypeJSModulus) {
+ TyperTester t;
+ t.TestBinaryArithOp(t.javascript_.Modulus(), modulo);
+}
+
+
+TEST(TypeJSBitwiseOr) {
+ TyperTester t;
+ t.TestBinaryBitOp(t.javascript_.BitwiseOr(), bit_or);
+}
+
+
+TEST(TypeJSBitwiseAnd) {
+ TyperTester t;
+ t.TestBinaryBitOp(t.javascript_.BitwiseAnd(), bit_and);
+}
+
+
+TEST(TypeJSBitwiseXor) {
+ TyperTester t;
+ t.TestBinaryBitOp(t.javascript_.BitwiseXor(), bit_xor);
+}
+
+
+TEST(TypeJSShiftLeft) {
+ TyperTester t;
+ t.TestBinaryBitOp(t.javascript_.ShiftLeft(), shift_left);
+}
+
+
+TEST(TypeJSShiftRight) {
+ TyperTester t;
+ t.TestBinaryBitOp(t.javascript_.ShiftRight(), shift_right);
+}
+
+
+TEST(TypeJSLessThan) {
+ TyperTester t;
+ t.TestBinaryCompareOp(t.javascript_.LessThan(), std::less<double>());
+}
+
+
+TEST(TypeJSLessThanOrEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(
+ t.javascript_.LessThanOrEqual(), std::less_equal<double>());
+}
+
+
+TEST(TypeJSGreaterThan) {
+ TyperTester t;
+ t.TestBinaryCompareOp(t.javascript_.GreaterThan(), std::greater<double>());
+}
+
+
+TEST(TypeJSGreaterThanOrEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(
+ t.javascript_.GreaterThanOrEqual(), std::greater_equal<double>());
+}
+
+
+TEST(TypeJSEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(t.javascript_.Equal(), std::equal_to<double>());
+}
+
+
+TEST(TypeJSNotEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(t.javascript_.NotEqual(), std::not_equal_to<double>());
+}
+
+
+// For numbers there's no difference between strict and non-strict equality.
+TEST(TypeJSStrictEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(t.javascript_.StrictEqual(), std::equal_to<double>());
+}
+
+
+TEST(TypeJSStrictNotEqual) {
+ TyperTester t;
+ t.TestBinaryCompareOp(
+ t.javascript_.StrictNotEqual(), std::not_equal_to<double>());
+}
+
+
+//------------------------------------------------------------------------------
+// Monotonicity
+
+
+// List should be in sync with JS_SIMPLE_BINOP_LIST.
+#define JSBINOP_LIST(V) \
+ V(Equal) \
+ V(NotEqual) \
+ V(StrictEqual) \
+ V(StrictNotEqual) \
+ V(LessThan) \
+ V(GreaterThan) \
+ V(LessThanOrEqual) \
+ V(GreaterThanOrEqual) \
+ V(BitwiseOr) \
+ V(BitwiseXor) \
+ V(BitwiseAnd) \
+ V(ShiftLeft) \
+ V(ShiftRight) \
+ V(ShiftRightLogical) \
+ V(Add) \
+ V(Subtract) \
+ V(Multiply) \
+ V(Divide) \
+ V(Modulus)
+
+
+#define TEST_FUNC(name) \
+ TEST(Monotonicity_##name) { \
+ TyperTester t; \
+ t.TestBinaryMonotonicity(t.javascript_.name()); \
+ }
+JSBINOP_LIST(TEST_FUNC)
+#undef TEST_FUNC
static const std::vector<uint32_t> uint32_vector() {
static const uint32_t kValues[] = {
0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
+ // This row is useful for testing lea optimizations on intel.
+ 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000008, 0x00000009,
0x273a798e, 0x187937a3, 0xece3af83, 0x5495a16b, 0x0b668ecc, 0x11223344,
0x0000009e, 0x00000043, 0x0000af73, 0x0000116b, 0x00658ecc, 0x002b3b4c,
0x88776655, 0x70000000, 0x07200000, 0x7fffffff, 0x56123761, 0x7fffff00,
Builtins::kIllegal)).ToObjectChecked();
// Return success.
- return Smi::FromInt(42);
+ return heap->true_value();
}
v8::Handle<v8::Context> env = v8::Context::New(CcTest::isolate());
env->Enter();
Handle<Object> o = Test();
- CHECK(o->IsSmi() && Smi::cast(*o)->value() == 42);
+ CHECK(o->IsTrue());
env->Exit();
}
// Call the accessor through JavaScript.
v8::Handle<v8::Value> result = v8::Script::Compile(
v8::String::NewFromUtf8(CcTest::isolate(), "(new Foo).get"))->Run();
- CHECK_EQ(42, result->Int32Value());
+ CHECK_EQ(true, result->BooleanValue());
env->Exit();
}
// If CPU profiler is active check that when API callback is invoked
// VMState is set to EXTERNAL.
if (isolate->cpu_profiler()->is_profiling()) {
- CHECK_EQ(i::EXTERNAL, isolate->current_vm_state());
+ CHECK_EQ(v8::EXTERNAL, isolate->current_vm_state());
CHECK(isolate->external_callback_scope());
CHECK_EQ(callback, isolate->external_callback_scope()->callback());
}
SimpleAccessorSetter(Local<String>::Cast(sym->Name()), value, info);
}
+void SymbolAccessorGetterReturnsDefault(
+ Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
+ CHECK(name->IsSymbol());
+ Local<Symbol> sym = Local<Symbol>::Cast(name);
+ if (sym->Name()->IsUndefined()) return;
+ info.GetReturnValue().Set(info.Data());
+}
+
+static void ThrowingSymbolAccessorGetter(
+ Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
+ info.GetReturnValue().Set(info.GetIsolate()->ThrowException(name));
+}
+
void EmptyInterceptorGetter(Local<String> name,
const v8::PropertyCallbackInfo<v8::Value>& info) {
}
}
+THREADED_TEST(GetIsolate) {
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ Local<v8::Object> obj = v8::Object::New(isolate);
+ CHECK_EQ(isolate, obj->GetIsolate());
+ CHECK_EQ(isolate, CcTest::global()->GetIsolate());
+}
+
+
THREADED_TEST(IdentityHash) {
LocalContext env;
v8::Isolate* isolate = env->GetIsolate();
}
+THREADED_TEST(ArrayBuffer_DisableNeuter) {
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope handle_scope(isolate);
+
+ i::ScopedVector<uint8_t> my_data(100);
+ memset(my_data.start(), 0, 100);
+ Local<v8::ArrayBuffer> ab =
+ v8::ArrayBuffer::New(isolate, my_data.start(), 100);
+ CHECK(ab->IsNeuterable());
+
+ i::Handle<i::JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
+ buf->set_is_neuterable(false);
+
+ CHECK(!ab->IsNeuterable());
+}
+
+
static void CheckDataViewIsNeutered(v8::Handle<v8::DataView> dv) {
CHECK_EQ(0, static_cast<int>(dv->ByteLength()));
CHECK_EQ(0, static_cast<int>(dv->ByteOffset()));
};
-static void DisposeAndSetFlag(
+static void SetFlag(
const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
- data.GetParameter()->handle.Reset();
data.GetParameter()->flag = true;
}
-THREADED_TEST(IndependentWeakHandle) {
+static void IndependentWeakHandle(bool global_gc, bool interlinked) {
v8::Isolate* iso = CcTest::isolate();
v8::HandleScope scope(iso);
v8::Handle<Context> context = Context::New(iso);
FlagAndPersistent object_a, object_b;
+ intptr_t big_heap_size;
+
{
v8::HandleScope handle_scope(iso);
- object_a.handle.Reset(iso, v8::Object::New(iso));
- object_b.handle.Reset(iso, v8::Object::New(iso));
+ Local<Object> a(v8::Object::New(iso));
+ Local<Object> b(v8::Object::New(iso));
+ object_a.handle.Reset(iso, a);
+ object_b.handle.Reset(iso, b);
+ if (interlinked) {
+ a->Set(v8_str("x"), b);
+ b->Set(v8_str("x"), a);
+ }
+ if (global_gc) {
+ CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
+ } else {
+ CcTest::heap()->CollectGarbage(i::NEW_SPACE);
+ }
+ // We are relying on this creating a big flag array and reserving the space
+ // up front.
+ v8::Handle<Value> big_array = CompileRun("new Array(50000)");
+ a->Set(v8_str("y"), big_array);
+ big_heap_size = CcTest::heap()->SizeOfObjects();
}
object_a.flag = false;
object_b.flag = false;
- object_a.handle.SetWeak(&object_a, &DisposeAndSetFlag);
- object_b.handle.SetWeak(&object_b, &DisposeAndSetFlag);
+ object_a.handle.SetPhantom(&object_a, &SetFlag);
+ object_b.handle.SetPhantom(&object_b, &SetFlag);
CHECK(!object_b.handle.IsIndependent());
object_a.handle.MarkIndependent();
object_b.handle.MarkIndependent();
CHECK(object_b.handle.IsIndependent());
- CcTest::heap()->CollectGarbage(i::NEW_SPACE);
+ if (global_gc) {
+ CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
+ } else {
+ CcTest::heap()->CollectGarbage(i::NEW_SPACE);
+ }
+ // A single GC should be enough to reclaim the memory, since we are using
+ // phantom handles.
+ CHECK_LT(CcTest::heap()->SizeOfObjects(), big_heap_size - 200000);
+ CHECK(object_a.flag);
+ CHECK(object_b.flag);
+}
+
+
+THREADED_TEST(IndependentWeakHandle) {
+ IndependentWeakHandle(false, false);
+ IndependentWeakHandle(false, true);
+ IndependentWeakHandle(true, false);
+ IndependentWeakHandle(true, true);
+}
+
+
+static void ResetUseValueAndSetFlag(
+ const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
+ // Blink will reset the handle, and then use the other handle, so they
+ // can't use the same backing slot.
+ data.GetParameter()->handle.Reset();
+ data.GetValue()->IsBoolean(); // Make sure the handle still works.
+ data.GetParameter()->flag = true;
+}
+
+
+static void ResetWeakHandle(bool global_gc) {
+ v8::Isolate* iso = CcTest::isolate();
+ v8::HandleScope scope(iso);
+ v8::Handle<Context> context = Context::New(iso);
+ Context::Scope context_scope(context);
+
+ FlagAndPersistent object_a, object_b;
+
+ {
+ v8::HandleScope handle_scope(iso);
+ Local<Object> a(v8::Object::New(iso));
+ Local<Object> b(v8::Object::New(iso));
+ object_a.handle.Reset(iso, a);
+ object_b.handle.Reset(iso, b);
+ if (global_gc) {
+ CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
+ } else {
+ CcTest::heap()->CollectGarbage(i::NEW_SPACE);
+ }
+ }
+
+ object_a.flag = false;
+ object_b.flag = false;
+ object_a.handle.SetWeak(&object_a, &ResetUseValueAndSetFlag);
+ object_b.handle.SetWeak(&object_b, &ResetUseValueAndSetFlag);
+ if (!global_gc) {
+ object_a.handle.MarkIndependent();
+ object_b.handle.MarkIndependent();
+ CHECK(object_b.handle.IsIndependent());
+ }
+ if (global_gc) {
+ CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
+ } else {
+ CcTest::heap()->CollectGarbage(i::NEW_SPACE);
+ }
CHECK(object_a.flag);
CHECK(object_b.flag);
}
+THREADED_TEST(ResetWeakHandle) {
+ ResetWeakHandle(false);
+ ResetWeakHandle(true);
+}
+
+
static void InvokeScavenge() {
CcTest::heap()->CollectGarbage(i::NEW_SPACE);
}
}
+static void ThrowV8Exception(const v8::FunctionCallbackInfo<v8::Value>& info) {
+ ApiTestFuzzer::Fuzz();
+ v8::Handle<String> foo = v8_str("foo");
+ v8::Handle<String> message = v8_str("message");
+ v8::Handle<Value> error = v8::Exception::Error(foo);
+ CHECK(error->IsObject());
+ CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
+ info.GetIsolate()->ThrowException(error);
+ info.GetReturnValue().SetUndefined();
+}
+
+
+THREADED_TEST(ExceptionGetMessage) {
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ v8::Handle<String> foo_str = v8_str("foo");
+ v8::Handle<String> message_str = v8_str("message");
+
+ v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
+
+ Local<v8::FunctionTemplate> fun =
+ v8::FunctionTemplate::New(context->GetIsolate(), ThrowV8Exception);
+ v8::Local<v8::Object> global = context->Global();
+ global->Set(v8_str("throwV8Exception"), fun->GetFunction());
+
+ TryCatch try_catch;
+ CompileRun(
+ "function f1() {\n"
+ " throwV8Exception();\n"
+ "};\n"
+ "f1();");
+ CHECK(try_catch.HasCaught());
+
+ v8::Handle<v8::Value> error = try_catch.Exception();
+ CHECK(error->IsObject());
+ CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
+
+ v8::Handle<v8::Message> message = v8::Exception::GetMessage(error);
+ CHECK(!message.IsEmpty());
+ CHECK_EQ(2, message->GetLineNumber());
+ CHECK_EQ(2, message->GetStartColumn());
+
+ v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
+ CHECK(!stackTrace.IsEmpty());
+ CHECK_EQ(2, stackTrace->GetFrameCount());
+
+ v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
+
+ // Now check message location when SetCaptureStackTraceForUncaughtExceptions
+ // is false.
+ try_catch.Reset();
+
+ CompileRun(
+ "function f2() {\n"
+ " return throwV8Exception();\n"
+ "};\n"
+ "f2();");
+ CHECK(try_catch.HasCaught());
+
+ error = try_catch.Exception();
+ CHECK(error->IsObject());
+ CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
+
+ message = v8::Exception::GetMessage(error);
+ CHECK(!message.IsEmpty());
+ CHECK_EQ(2, message->GetLineNumber());
+ CHECK_EQ(9, message->GetStartColumn());
+
+ // Should be empty stack trace.
+ stackTrace = message->GetStackTrace();
+ CHECK(stackTrace.IsEmpty());
+}
+
+
static void YGetter(Local<String> name,
const v8::PropertyCallbackInfo<v8::Value>& info) {
ApiTestFuzzer::Fuzz();
v8::V8::RemoveMessageListeners(ApiUncaughtExceptionTestListener);
}
+
+TEST(ApiUncaughtExceptionInObjectObserve) {
+ v8::internal::FLAG_stack_size = 150;
+ report_count = 0;
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::V8::AddMessageListener(ApiUncaughtExceptionTestListener);
+ CompileRun(
+ "var obj = {};"
+ "var observe_count = 0;"
+ "function observer1() { ++observe_count; };"
+ "function observer2() { ++observe_count; };"
+ "function observer_throws() { throw new Error(); };"
+ "function stack_overflow() { return (function f(x) { f(x+1); })(0); };"
+ "Object.observe(obj, observer_throws.bind());"
+ "Object.observe(obj, observer1);"
+ "Object.observe(obj, stack_overflow);"
+ "Object.observe(obj, observer2);"
+ "Object.observe(obj, observer_throws.bind());"
+ "obj.foo = 'bar';");
+ CHECK_EQ(3, report_count);
+ ExpectInt32("observe_count", 2);
+ v8::V8::RemoveMessageListeners(ApiUncaughtExceptionTestListener);
+}
+
+
static const char* script_resource_name = "ExceptionInNativeScript.js";
static void ExceptionInNativeScriptTestListener(v8::Handle<v8::Message> message,
v8::Handle<Value>) {
{
v8::TryCatch try_catch;
CompileRun(
+ "function f() { return super[42]; };"
+ "var m = f.toMethod(prohibited);"
+ "m();");
+ CHECK(try_catch.HasCaught());
+ }
+
+ {
+ v8::TryCatch try_catch;
+ CompileRun(
"function f() { super.hasOwnProperty = function () {}; };"
"var m = f.toMethod(prohibited);"
"m();");
}
+TEST(ObjectProtoToStringES6) {
+ // TODO(dslomov, caitp): merge into ObjectProtoToString test once shipped.
+ i::FLAG_harmony_tostring = true;
+ LocalContext context;
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope scope(isolate);
+ Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
+ templ->SetClassName(v8_str("MyClass"));
+
+ Local<String> customized_tostring = v8_str("customized toString");
+
+ // Replace Object.prototype.toString
+ CompileRun(
+ "Object.prototype.toString = function() {"
+ " return 'customized toString';"
+ "}");
+
+ // Normal ToString call should call replaced Object.prototype.toString
+ Local<v8::Object> instance = templ->GetFunction()->NewInstance();
+ Local<String> value = instance->ToString();
+ CHECK(value->IsString() && value->Equals(customized_tostring));
+
+ // ObjectProtoToString should not call replace toString function.
+ value = instance->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object MyClass]")));
+
+ // Check global
+ value = context->Global()->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object global]")));
+
+ // Check ordinary object
+ Local<Value> object = CompileRun("new Object()");
+ value = object.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object Object]")));
+
+ // Check that ES6 semantics using @@toStringTag work
+ Local<v8::Symbol> toStringTag = v8::Symbol::GetToStringTag(isolate);
+
+#define TEST_TOSTRINGTAG(type, tag, expected) \
+ do { \
+ object = CompileRun("new " #type "()"); \
+ object.As<v8::Object>()->Set(toStringTag, v8_str(#tag)); \
+ value = object.As<v8::Object>()->ObjectProtoToString(); \
+ CHECK(value->IsString() && \
+ value->Equals(v8_str("[object " #expected "]"))); \
+ } while (0)
+
+ TEST_TOSTRINGTAG(Array, Object, Object);
+ TEST_TOSTRINGTAG(Object, Arguments, ~Arguments);
+ TEST_TOSTRINGTAG(Object, Array, ~Array);
+ TEST_TOSTRINGTAG(Object, Boolean, ~Boolean);
+ TEST_TOSTRINGTAG(Object, Date, ~Date);
+ TEST_TOSTRINGTAG(Object, Error, ~Error);
+ TEST_TOSTRINGTAG(Object, Function, ~Function);
+ TEST_TOSTRINGTAG(Object, Number, ~Number);
+ TEST_TOSTRINGTAG(Object, RegExp, ~RegExp);
+ TEST_TOSTRINGTAG(Object, String, ~String);
+ TEST_TOSTRINGTAG(Object, Foo, Foo);
+
+#undef TEST_TOSTRINGTAG
+
+ // @@toStringTag getter throws
+ Local<Value> obj = v8::Object::New(isolate);
+ obj.As<v8::Object>()->SetAccessor(toStringTag, ThrowingSymbolAccessorGetter);
+ {
+ TryCatch try_catch;
+ value = obj.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value.IsEmpty());
+ CHECK(try_catch.HasCaught());
+ }
+
+ // @@toStringTag getter does not throw
+ obj = v8::Object::New(isolate);
+ obj.As<v8::Object>()->SetAccessor(
+ toStringTag, SymbolAccessorGetterReturnsDefault, 0, v8_str("Test"));
+ {
+ TryCatch try_catch;
+ value = obj.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object Test]")));
+ CHECK(!try_catch.HasCaught());
+ }
+
+ // JS @@toStringTag value
+ obj = CompileRun("obj = {}; obj[Symbol.toStringTag] = 'Test'; obj");
+ {
+ TryCatch try_catch;
+ value = obj.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object Test]")));
+ CHECK(!try_catch.HasCaught());
+ }
+
+ // JS @@toStringTag getter throws
+ obj = CompileRun(
+ "obj = {}; Object.defineProperty(obj, Symbol.toStringTag, {"
+ " get: function() { throw 'Test'; }"
+ "}); obj");
+ {
+ TryCatch try_catch;
+ value = obj.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value.IsEmpty());
+ CHECK(try_catch.HasCaught());
+ }
+
+ // JS @@toStringTag getter does not throw
+ obj = CompileRun(
+ "obj = {}; Object.defineProperty(obj, Symbol.toStringTag, {"
+ " get: function() { return 'Test'; }"
+ "}); obj");
+ {
+ TryCatch try_catch;
+ value = obj.As<v8::Object>()->ObjectProtoToString();
+ CHECK(value->IsString() && value->Equals(v8_str("[object Test]")));
+ CHECK(!try_catch.HasCaught());
+ }
+}
+
+
THREADED_TEST(ObjectGetConstructorName) {
LocalContext context;
v8::HandleScope scope(context->GetIsolate());
v8::Handle<v8::Array> props = val.As<v8::Object>()->GetPropertyNames();
CHECK_EQ(0, props->Length());
for (uint32_t i = 0; i < props->Length(); i++) {
- printf("p[%d]\n", i);
+ printf("p[%u]\n", i);
}
}
#ifndef V8_INTERPRETED_REGEXP
struct RegExpInterruptionData {
- int loop_count;
+ v8::base::Atomic32 loop_count;
UC16VectorResource* string_resource;
v8::Persistent<v8::String> string;
} regexp_interruption_data;
: Thread(Options("TimeoutThread")), isolate_(isolate) {}
virtual void Run() {
- for (regexp_interruption_data.loop_count = 0;
- regexp_interruption_data.loop_count < 7;
- regexp_interruption_data.loop_count++) {
+ for (v8::base::NoBarrier_Store(®exp_interruption_data.loop_count, 0);
+ v8::base::NoBarrier_Load(®exp_interruption_data.loop_count) < 7;
+ v8::base::NoBarrier_AtomicIncrement(
+ ®exp_interruption_data.loop_count, 1)) {
v8::base::OS::Sleep(50); // Wait a bit before requesting GC.
reinterpret_cast<i::Isolate*>(isolate_)->stack_guard()->RequestGC();
}
void RunBeforeGC(v8::GCType type, v8::GCCallbackFlags flags) {
- if (regexp_interruption_data.loop_count != 2) return;
+ if (v8::base::NoBarrier_Load(®exp_interruption_data.loop_count) != 2) {
+ return;
+ }
v8::HandleScope scope(CcTest::isolate());
v8::Local<v8::String> string = v8::Local<v8::String>::New(
CcTest::isolate(), regexp_interruption_data.string);
static void StackTraceForUncaughtExceptionListener(
v8::Handle<v8::Message> message,
v8::Handle<Value>) {
+ report_count++;
v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
CHECK_EQ(2, stack_trace->GetFrameCount());
checkStackFrame("origin", "foo", 2, 3, false, false,
Function::Cast(*trouble)->Call(global, 0, NULL);
v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
v8::V8::RemoveMessageListeners(StackTraceForUncaughtExceptionListener);
+ CHECK_EQ(1, report_count);
+}
+
+
+TEST(GetStackTraceForUncaughtExceptionFromSimpleStackTrace) {
+ report_count = 0;
+ LocalContext env;
+ v8::HandleScope scope(env->GetIsolate());
+
+ // Create an Error object first.
+ CompileRunWithOrigin(
+ "function foo() {\n"
+ "e=new Error('err');\n"
+ "};\n"
+ "function bar() {\n"
+ " foo();\n"
+ "};\n"
+ "var e;",
+ "origin");
+ v8::Local<v8::Object> global = env->Global();
+ Local<Value> trouble = global->Get(v8_str("bar"));
+ CHECK(trouble->IsFunction());
+ Function::Cast(*trouble)->Call(global, 0, NULL);
+
+ // Enable capturing detailed stack trace late, and throw the exception.
+ // The detailed stack trace should be extracted from the simple stack.
+ v8::V8::AddMessageListener(StackTraceForUncaughtExceptionListener);
+ v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
+ CompileRunWithOrigin("throw e", "origin");
+ v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
+ v8::V8::RemoveMessageListeners(StackTraceForUncaughtExceptionListener);
+ CHECK_EQ(1, report_count);
}
}
+v8::PromiseRejectEvent reject_event = v8::kPromiseRejectWithNoHandler;
+int promise_reject_counter = 0;
+int promise_revoke_counter = 0;
+int promise_reject_line_number = -1;
+int promise_reject_frame_count = -1;
+
+void PromiseRejectCallback(v8::PromiseRejectMessage message) {
+ if (message.GetEvent() == v8::kPromiseRejectWithNoHandler) {
+ promise_reject_counter++;
+ CcTest::global()->Set(v8_str("rejected"), message.GetPromise());
+ CcTest::global()->Set(v8_str("value"), message.GetValue());
+ v8::Handle<v8::StackTrace> stack_trace =
+ v8::Exception::GetMessage(message.GetValue())->GetStackTrace();
+ if (!stack_trace.IsEmpty()) {
+ promise_reject_frame_count = stack_trace->GetFrameCount();
+ if (promise_reject_frame_count > 0) {
+ CHECK(stack_trace->GetFrame(0)->GetScriptName()->Equals(v8_str("pro")));
+ promise_reject_line_number = stack_trace->GetFrame(0)->GetLineNumber();
+ } else {
+ promise_reject_line_number = -1;
+ }
+ }
+ } else {
+ promise_revoke_counter++;
+ CcTest::global()->Set(v8_str("revoked"), message.GetPromise());
+ CHECK(message.GetValue().IsEmpty());
+ }
+}
+
+
+v8::Handle<v8::Promise> GetPromise(const char* name) {
+ return v8::Handle<v8::Promise>::Cast(CcTest::global()->Get(v8_str(name)));
+}
+
+
+v8::Handle<v8::Value> RejectValue() {
+ return CcTest::global()->Get(v8_str("value"));
+}
+
+
+void ResetPromiseStates() {
+ promise_reject_counter = 0;
+ promise_revoke_counter = 0;
+ promise_reject_line_number = -1;
+ promise_reject_frame_count = -1;
+ CcTest::global()->Set(v8_str("rejected"), v8_str(""));
+ CcTest::global()->Set(v8_str("value"), v8_str(""));
+ CcTest::global()->Set(v8_str("revoked"), v8_str(""));
+}
+
+
+TEST(PromiseRejectCallback) {
+ LocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+
+ isolate->SetPromiseRejectCallback(PromiseRejectCallback);
+
+ ResetPromiseStates();
+
+ // Create promise p0.
+ CompileRun(
+ "var reject; \n"
+ "var p0 = new Promise( \n"
+ " function(res, rej) { \n"
+ " reject = rej; \n"
+ " } \n"
+ "); \n");
+ CHECK(!GetPromise("p0")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Add resolve handler (and default reject handler) to p0.
+ CompileRun("var p1 = p0.then(function(){});");
+ CHECK(GetPromise("p0")->HasHandler());
+ CHECK(!GetPromise("p1")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Reject p0.
+ CompileRun("reject('ppp');");
+ CHECK(GetPromise("p0")->HasHandler());
+ CHECK(!GetPromise("p1")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+ CHECK_EQ(v8::kPromiseRejectWithNoHandler, reject_event);
+ CHECK(GetPromise("rejected")->Equals(GetPromise("p1")));
+ CHECK(RejectValue()->Equals(v8_str("ppp")));
+
+ // Reject p0 again. Callback is not triggered again.
+ CompileRun("reject();");
+ CHECK(GetPromise("p0")->HasHandler());
+ CHECK(!GetPromise("p1")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Add resolve handler to p1.
+ CompileRun("var p2 = p1.then(function(){});");
+ CHECK(GetPromise("p0")->HasHandler());
+ CHECK(GetPromise("p1")->HasHandler());
+ CHECK(!GetPromise("p2")->HasHandler());
+ CHECK_EQ(2, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+ CHECK(GetPromise("rejected")->Equals(GetPromise("p2")));
+ CHECK(RejectValue()->Equals(v8_str("ppp")));
+ CHECK(GetPromise("revoked")->Equals(GetPromise("p1")));
+
+ ResetPromiseStates();
+
+ // Create promise q0.
+ CompileRun(
+ "var q0 = new Promise( \n"
+ " function(res, rej) { \n"
+ " reject = rej; \n"
+ " } \n"
+ "); \n");
+ CHECK(!GetPromise("q0")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Add reject handler to q0.
+ CompileRun("var q1 = q0.catch(function() {});");
+ CHECK(GetPromise("q0")->HasHandler());
+ CHECK(!GetPromise("q1")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Reject q0.
+ CompileRun("reject('qq')");
+ CHECK(GetPromise("q0")->HasHandler());
+ CHECK(!GetPromise("q1")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Add a new reject handler, which rejects by returning Promise.reject().
+ // The returned promise q_ triggers a reject callback at first, only to
+ // revoke it when returning it causes q2 to be rejected.
+ CompileRun(
+ "var q_;"
+ "var q2 = q0.catch( \n"
+ " function() { \n"
+ " q_ = Promise.reject('qqq'); \n"
+ " return q_; \n"
+ " } \n"
+ "); \n");
+ CHECK(GetPromise("q0")->HasHandler());
+ CHECK(!GetPromise("q1")->HasHandler());
+ CHECK(!GetPromise("q2")->HasHandler());
+ CHECK(GetPromise("q_")->HasHandler());
+ CHECK_EQ(2, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+ CHECK(GetPromise("rejected")->Equals(GetPromise("q2")));
+ CHECK(GetPromise("revoked")->Equals(GetPromise("q_")));
+ CHECK(RejectValue()->Equals(v8_str("qqq")));
+
+ // Add a reject handler to the resolved q1, which rejects by throwing.
+ CompileRun(
+ "var q3 = q1.then( \n"
+ " function() { \n"
+ " throw 'qqqq'; \n"
+ " } \n"
+ "); \n");
+ CHECK(GetPromise("q0")->HasHandler());
+ CHECK(GetPromise("q1")->HasHandler());
+ CHECK(!GetPromise("q2")->HasHandler());
+ CHECK(!GetPromise("q3")->HasHandler());
+ CHECK_EQ(3, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+ CHECK(GetPromise("rejected")->Equals(GetPromise("q3")));
+ CHECK(RejectValue()->Equals(v8_str("qqqq")));
+
+ ResetPromiseStates();
+
+ // Create promise r0, which has three handlers, two of which handle rejects.
+ CompileRun(
+ "var r0 = new Promise( \n"
+ " function(res, rej) { \n"
+ " reject = rej; \n"
+ " } \n"
+ "); \n"
+ "var r1 = r0.catch(function() {}); \n"
+ "var r2 = r0.then(function() {}); \n"
+ "var r3 = r0.then(function() {}, \n"
+ " function() {}); \n");
+ CHECK(GetPromise("r0")->HasHandler());
+ CHECK(!GetPromise("r1")->HasHandler());
+ CHECK(!GetPromise("r2")->HasHandler());
+ CHECK(!GetPromise("r3")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Reject r0.
+ CompileRun("reject('rrr')");
+ CHECK(GetPromise("r0")->HasHandler());
+ CHECK(!GetPromise("r1")->HasHandler());
+ CHECK(!GetPromise("r2")->HasHandler());
+ CHECK(!GetPromise("r3")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+ CHECK(GetPromise("rejected")->Equals(GetPromise("r2")));
+ CHECK(RejectValue()->Equals(v8_str("rrr")));
+
+ // Add reject handler to r2.
+ CompileRun("var r4 = r2.catch(function() {});");
+ CHECK(GetPromise("r0")->HasHandler());
+ CHECK(!GetPromise("r1")->HasHandler());
+ CHECK(GetPromise("r2")->HasHandler());
+ CHECK(!GetPromise("r3")->HasHandler());
+ CHECK(!GetPromise("r4")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+ CHECK(GetPromise("revoked")->Equals(GetPromise("r2")));
+ CHECK(RejectValue()->Equals(v8_str("rrr")));
+
+ // Add reject handlers to r4.
+ CompileRun("var r5 = r4.then(function() {}, function() {});");
+ CHECK(GetPromise("r0")->HasHandler());
+ CHECK(!GetPromise("r1")->HasHandler());
+ CHECK(GetPromise("r2")->HasHandler());
+ CHECK(!GetPromise("r3")->HasHandler());
+ CHECK(GetPromise("r4")->HasHandler());
+ CHECK(!GetPromise("r5")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+
+ ResetPromiseStates();
+
+ // Create promise s0, which has three handlers, none of which handle rejects.
+ CompileRun(
+ "var s0 = new Promise( \n"
+ " function(res, rej) { \n"
+ " reject = rej; \n"
+ " } \n"
+ "); \n"
+ "var s1 = s0.then(function() {}); \n"
+ "var s2 = s0.then(function() {}); \n"
+ "var s3 = s0.then(function() {}); \n");
+ CHECK(GetPromise("s0")->HasHandler());
+ CHECK(!GetPromise("s1")->HasHandler());
+ CHECK(!GetPromise("s2")->HasHandler());
+ CHECK(!GetPromise("s3")->HasHandler());
+ CHECK_EQ(0, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+
+ // Reject s0.
+ CompileRun("reject('sss')");
+ CHECK(GetPromise("s0")->HasHandler());
+ CHECK(!GetPromise("s1")->HasHandler());
+ CHECK(!GetPromise("s2")->HasHandler());
+ CHECK(!GetPromise("s3")->HasHandler());
+ CHECK_EQ(3, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+ CHECK(RejectValue()->Equals(v8_str("sss")));
+
+ // Test stack frames.
+ V8::SetCaptureStackTraceForUncaughtExceptions(true);
+
+ ResetPromiseStates();
+
+ // Create promise t0, which is rejected in the constructor with an error.
+ CompileRunWithOrigin(
+ "var t0 = new Promise( \n"
+ " function(res, rej) { \n"
+ " reference_error; \n"
+ " } \n"
+ "); \n",
+ "pro", 0, 0);
+ CHECK(!GetPromise("t0")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+ CHECK_EQ(2, promise_reject_frame_count);
+ CHECK_EQ(3, promise_reject_line_number);
+
+ ResetPromiseStates();
+
+ // Create promise u0 and chain u1 to it, which is rejected via throw.
+ CompileRunWithOrigin(
+ "var u0 = Promise.resolve(); \n"
+ "var u1 = u0.then( \n"
+ " function() { \n"
+ " (function() { \n"
+ " throw new Error(); \n"
+ " })(); \n"
+ " } \n"
+ " ); \n",
+ "pro", 0, 0);
+ CHECK(GetPromise("u0")->HasHandler());
+ CHECK(!GetPromise("u1")->HasHandler());
+ CHECK_EQ(1, promise_reject_counter);
+ CHECK_EQ(0, promise_revoke_counter);
+ CHECK_EQ(2, promise_reject_frame_count);
+ CHECK_EQ(5, promise_reject_line_number);
+
+ // Throw in u3, which handles u1's rejection.
+ CompileRunWithOrigin(
+ "function f() { \n"
+ " return (function() { \n"
+ " return new Error(); \n"
+ " })(); \n"
+ "} \n"
+ "var u2 = Promise.reject(f()); \n"
+ "var u3 = u1.catch( \n"
+ " function() { \n"
+ " return u2; \n"
+ " } \n"
+ " ); \n",
+ "pro", 0, 0);
+ CHECK(GetPromise("u0")->HasHandler());
+ CHECK(GetPromise("u1")->HasHandler());
+ CHECK(GetPromise("u2")->HasHandler());
+ CHECK(!GetPromise("u3")->HasHandler());
+ CHECK_EQ(3, promise_reject_counter);
+ CHECK_EQ(2, promise_revoke_counter);
+ CHECK_EQ(3, promise_reject_frame_count);
+ CHECK_EQ(3, promise_reject_line_number);
+
+ ResetPromiseStates();
+
+ // Create promise rejected promise v0, which is incorrectly handled by v1
+ // via chaining cycle.
+ CompileRunWithOrigin(
+ "var v0 = Promise.reject(); \n"
+ "var v1 = v0.catch( \n"
+ " function() { \n"
+ " return v1; \n"
+ " } \n"
+ " ); \n",
+ "pro", 0, 0);
+ CHECK(GetPromise("v0")->HasHandler());
+ CHECK(!GetPromise("v1")->HasHandler());
+ CHECK_EQ(2, promise_reject_counter);
+ CHECK_EQ(1, promise_revoke_counter);
+ CHECK_EQ(0, promise_reject_frame_count);
+ CHECK_EQ(-1, promise_reject_line_number);
+}
+
+
void AnalyzeStackOfEvalWithSourceURL(
const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::HandleScope scope(args.GetIsolate());
}
-TEST(Regress2107) {
- const intptr_t MB = 1024 * 1024;
- const int kIdlePauseInMs = 1000;
- LocalContext env;
- v8::Isolate* isolate = env->GetIsolate();
- v8::HandleScope scope(env->GetIsolate());
- intptr_t initial_size = CcTest::heap()->SizeOfObjects();
- // Send idle notification to start a round of incremental GCs.
- env->GetIsolate()->IdleNotification(kIdlePauseInMs);
- // Emulate 7 page reloads.
- for (int i = 0; i < 7; i++) {
- {
- v8::HandleScope inner_scope(env->GetIsolate());
- v8::Local<v8::Context> ctx = v8::Context::New(isolate);
- ctx->Enter();
- CreateGarbageInOldSpace();
- ctx->Exit();
- }
- env->GetIsolate()->ContextDisposedNotification();
- env->GetIsolate()->IdleNotification(kIdlePauseInMs);
- }
- // Create garbage and check that idle notification still collects it.
- CreateGarbageInOldSpace();
- intptr_t size_with_garbage = CcTest::heap()->SizeOfObjects();
- CHECK_GT(size_with_garbage, initial_size + MB);
- bool finished = false;
- for (int i = 0; i < 200 && !finished; i++) {
- finished = env->GetIsolate()->IdleNotification(kIdlePauseInMs);
- }
- intptr_t final_size = CcTest::heap()->SizeOfObjects();
- CHECK_LT(final_size, initial_size + 1);
-}
-
-
TEST(Regress2333) {
LocalContext env;
for (int i = 0; i < 3; i++) {
CHECK_EQ(42, object.WrapperClassId());
Visitor42 visitor(&object);
- v8::V8::VisitHandlesWithClassIds(&visitor);
+ v8::V8::VisitHandlesWithClassIds(isolate, &visitor);
CHECK_EQ(1, visitor.counter_);
object.Reset();
Handle<v8::Promise::Resolver> rr = v8::Promise::Resolver::New(isolate);
Handle<v8::Promise> p = pr->GetPromise();
Handle<v8::Promise> r = rr->GetPromise();
+ CHECK_EQ(isolate, p->GetIsolate());
// IsPromise predicate.
CHECK(p->IsPromise());
TEST(StreamingUtf8Script) {
- // We'd want to write \uc481 instead of \xeb\x91\x80, but Windows compilers
+ // We'd want to write \uc481 instead of \xec\x92\x81, but Windows compilers
// don't like it.
const char* chunk1 =
"function foo() {\n"
" // This function will contain an UTF-8 character which is not in\n"
" // ASCII.\n"
- " var foob\xeb\x91\x80r = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " var foob\xec\x92\x81r = 13;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
const char* chunks[] = {chunk1, "foo(); ", NULL};
RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8);
// A sanity check to prove that the approach of splitting UTF-8
// characters is correct. Here is an UTF-8 character which will take three
// bytes.
- const char* reference = "\xeb\x91\x80";
+ const char* reference = "\xec\x92\x81";
CHECK(3u == strlen(reference)); // NOLINT - no CHECK_EQ for unsigned.
char chunk1[] =
" var foob";
char chunk2[] =
"XXXr = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
for (int i = 0; i < 3; ++i) {
chunk2[i] = reference[i];
TEST(StreamingUtf8ScriptWithSplitCharacters) {
// Stream data where a multi-byte UTF-8 character is split between two data
// chunks.
- const char* reference = "\xeb\x91\x80";
+ const char* reference = "\xec\x92\x81";
char chunk1[] =
"function foo() {\n"
" // This function will contain an UTF-8 character which is not in\n"
" var foobX";
char chunk2[] =
"XXr = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
chunk1[strlen(chunk1) - 1] = reference[0];
chunk2[0] = reference[1];
// Case 1: a chunk contains only bytes for a split character (and no other
// data). This kind of a chunk would be exceptionally small, but we should
// still decode it correctly.
- const char* reference = "\xeb\x91\x80";
+ const char* reference = "\xec\x92\x81";
// The small chunk is at the beginning of the split character
{
char chunk1[] =
char chunk2[] = "XX";
char chunk3[] =
"Xr = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
chunk2[0] = reference[0];
chunk2[1] = reference[1];
char chunk2[] = "XX";
char chunk3[] =
"r = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
chunk1[strlen(chunk1) - 1] = reference[0];
chunk2[0] = reference[1];
// decoded correctly and not just ignored.
{
char chunk1[] =
- "var foob\xeb\x91\x80 = 13;\n"
- "foob\xeb\x91\x80";
+ "var foob\xec\x92\x81 = 13;\n"
+ "foob\xec\x92\x81";
const char* chunks[] = {chunk1, NULL};
RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8);
}
// Test cases where a UTF-8 character is split over several chunks. Those
// cases are not supported (the embedder should give the data in big enough
// chunks), but we shouldn't crash, just produce a parse error.
- const char* reference = "\xeb\x91\x80";
+ const char* reference = "\xec\x92\x81";
char chunk1[] =
"function foo() {\n"
" // This function will contain an UTF-8 character which is not in\n"
char chunk2[] = "X";
char chunk3[] =
"Xr = 13;\n"
- " return foob\xeb\x91\x80r;\n"
+ " return foob\xec\x92\x81r;\n"
"}\n";
chunk1[strlen(chunk1) - 1] = reference[0];
chunk2[0] = reference[1];
TEST(StreamingScriptWithInvalidUtf8) {
// Regression test for a crash: test that invalid UTF-8 bytes in the end of a
// chunk don't produce a crash.
- const char* reference = "\xeb\x91\x80\x80\x80";
+ const char* reference = "\xec\x92\x81\x80\x80";
char chunk1[] =
"function foo() {\n"
" // This function will contain an UTF-8 character which is not in\n"
" var foobXXXXX"; // Too many bytes which look like incomplete chars!
char chunk2[] =
"r = 13;\n"
- " return foob\xeb\x91\x80\x80\x80r;\n"
+ " return foob\xec\x92\x81\x80\x80r;\n"
"}\n";
for (int i = 0; i < 5; ++i) chunk1[strlen(chunk1) - 5 + i] = reference[i];
const char* chunks[] = {chunk1, chunk2, "foo();", NULL};
RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8, false);
}
+
+
+TEST(StreamingUtf8ScriptWithMultipleMultibyteCharactersSomeSplit) {
+ // Regression test: Stream data where there are several multi-byte UTF-8
+ // characters in a sequence and one of them is split between two data chunks.
+ const char* reference = "\xec\x92\x81";
+ char chunk1[] =
+ "function foo() {\n"
+ " // This function will contain an UTF-8 character which is not in\n"
+ " // ASCII.\n"
+ " var foob\xec\x92\x81X";
+ char chunk2[] =
+ "XXr = 13;\n"
+ " return foob\xec\x92\x81\xec\x92\x81r;\n"
+ "}\n";
+ chunk1[strlen(chunk1) - 1] = reference[0];
+ chunk2[0] = reference[1];
+ chunk2[1] = reference[2];
+ const char* chunks[] = {chunk1, chunk2, "foo();", NULL};
+ RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8);
+}
+
+
+TEST(StreamingUtf8ScriptWithMultipleMultibyteCharactersSomeSplit2) {
+ // Another regression test, similar to the previous one. The difference is
+ // that the split character is not the last one in the sequence.
+ const char* reference = "\xec\x92\x81";
+ char chunk1[] =
+ "function foo() {\n"
+ " // This function will contain an UTF-8 character which is not in\n"
+ " // ASCII.\n"
+ " var foobX";
+ char chunk2[] =
+ "XX\xec\x92\x81r = 13;\n"
+ " return foob\xec\x92\x81\xec\x92\x81r;\n"
+ "}\n";
+ chunk1[strlen(chunk1) - 1] = reference[0];
+ chunk2[0] = reference[1];
+ chunk2[1] = reference[2];
+ const char* chunks[] = {chunk1, chunk2, "foo();", NULL};
+ RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8);
+}
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <iostream> // NOLINT(readability/streams)
+
#include "src/v8.h"
#include "test/cctest/cctest.h"
#include "src/factory.h"
#include "src/ostreams.h"
+using namespace v8::base;
using namespace v8::internal;
CHECK_EQ(expected_, t.result);
-TEST(18) {
+TEST(sdiv) {
// Test the sdiv.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
-
- typedef struct {
- uint32_t dividend;
- uint32_t divisor;
- uint32_t result;
- } T;
- T t;
-
Assembler assm(isolate, NULL, 0);
+ struct T {
+ int32_t dividend;
+ int32_t divisor;
+ int32_t result;
+ } t;
+
if (CpuFeatures::IsSupported(SUDIV)) {
CpuFeatureScope scope(&assm, SUDIV);
#endif
F3 f = FUNCTION_CAST<F3>(code->entry());
Object* dummy;
+ TEST_SDIV(0, kMinInt, 0);
+ TEST_SDIV(0, 1024, 0);
TEST_SDIV(1073741824, kMinInt, -2);
TEST_SDIV(kMinInt, kMinInt, -1);
TEST_SDIV(5, 10, 2);
#undef TEST_SDIV
+#define TEST_UDIV(expected_, dividend_, divisor_) \
+ t.dividend = dividend_; \
+ t.divisor = divisor_; \
+ t.result = 0; \
+ dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0); \
+ CHECK_EQ(expected_, t.result);
+
+
+TEST(udiv) {
+ // Test the udiv.
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ Assembler assm(isolate, NULL, 0);
+
+ struct T {
+ uint32_t dividend;
+ uint32_t divisor;
+ uint32_t result;
+ } t;
+
+ if (CpuFeatures::IsSupported(SUDIV)) {
+ CpuFeatureScope scope(&assm, SUDIV);
+
+ __ mov(r3, Operand(r0));
+
+ __ ldr(r0, MemOperand(r3, OFFSET_OF(T, dividend)));
+ __ ldr(r1, MemOperand(r3, OFFSET_OF(T, divisor)));
+
+ __ sdiv(r2, r0, r1);
+ __ str(r2, MemOperand(r3, OFFSET_OF(T, result)));
+
+ __ bx(lr);
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+ OFStream os(stdout);
+ code->Print(os);
+#endif
+ F3 f = FUNCTION_CAST<F3>(code->entry());
+ Object* dummy;
+ TEST_UDIV(0, 0, 0);
+ TEST_UDIV(0, 1024, 0);
+ TEST_UDIV(5, 10, 2);
+ TEST_UDIV(3, 10, 3);
+ USE(dummy);
+ }
+}
+
+
+#undef TEST_UDIV
+
+
+TEST(smmla) {
+ CcTest::InitializeVM();
+ Isolate* const isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ RandomNumberGenerator* const rng = isolate->random_number_generator();
+ Assembler assm(isolate, nullptr, 0);
+ __ smmla(r1, r1, r2, r3);
+ __ str(r1, MemOperand(r0));
+ __ bx(lr);
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef OBJECT_PRINT
+ code->Print(std::cout);
+#endif
+ F3 f = FUNCTION_CAST<F3>(code->entry());
+ for (size_t i = 0; i < 128; ++i) {
+ int32_t r, x = rng->NextInt(), y = rng->NextInt(), z = rng->NextInt();
+ Object* dummy = CALL_GENERATED_CODE(f, &r, x, y, z, 0);
+ CHECK_EQ(bits::SignedMulHighAndAdd32(x, y, z), r);
+ USE(dummy);
+ }
+}
+
+
+TEST(smmul) {
+ CcTest::InitializeVM();
+ Isolate* const isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+ RandomNumberGenerator* const rng = isolate->random_number_generator();
+ Assembler assm(isolate, nullptr, 0);
+ __ smmul(r1, r1, r2);
+ __ str(r1, MemOperand(r0));
+ __ bx(lr);
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef OBJECT_PRINT
+ code->Print(std::cout);
+#endif
+ F3 f = FUNCTION_CAST<F3>(code->entry());
+ for (size_t i = 0; i < 128; ++i) {
+ int32_t r, x = rng->NextInt(), y = rng->NextInt();
+ Object* dummy = CALL_GENERATED_CODE(f, &r, x, y, 0, 0);
+ CHECK_EQ(bits::SignedMulHigh32(x, y), r);
+ USE(dummy);
+ }
+}
+
+
TEST(code_relative_offset) {
// Test extracting the offset of a label from the beginning of the code
// in a register.
CHECK_EQ(42, res);
}
+
+TEST(ARMv8_vrintX) {
+ // Test the vrintX floating point instructions.
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ HandleScope scope(isolate);
+
+ typedef struct {
+ double input;
+ double ar;
+ double nr;
+ double mr;
+ double pr;
+ double zr;
+ } T;
+ T t;
+
+ // Create a function that accepts &t, and loads, manipulates, and stores
+ // the doubles and floats.
+ Assembler assm(isolate, NULL, 0);
+ Label L, C;
+
+
+ if (CpuFeatures::IsSupported(ARMv8)) {
+ CpuFeatureScope scope(&assm, ARMv8);
+
+ __ mov(ip, Operand(sp));
+ __ stm(db_w, sp, r4.bit() | fp.bit() | lr.bit());
+
+ __ mov(r4, Operand(r0));
+
+ // Test vrinta
+ __ vldr(d6, r4, OFFSET_OF(T, input));
+ __ vrinta(d5, d6);
+ __ vstr(d5, r4, OFFSET_OF(T, ar));
+
+ // Test vrintn
+ __ vldr(d6, r4, OFFSET_OF(T, input));
+ __ vrintn(d5, d6);
+ __ vstr(d5, r4, OFFSET_OF(T, nr));
+
+ // Test vrintp
+ __ vldr(d6, r4, OFFSET_OF(T, input));
+ __ vrintp(d5, d6);
+ __ vstr(d5, r4, OFFSET_OF(T, pr));
+
+ // Test vrintm
+ __ vldr(d6, r4, OFFSET_OF(T, input));
+ __ vrintm(d5, d6);
+ __ vstr(d5, r4, OFFSET_OF(T, mr));
+
+ // Test vrintz
+ __ vldr(d6, r4, OFFSET_OF(T, input));
+ __ vrintz(d5, d6);
+ __ vstr(d5, r4, OFFSET_OF(T, zr));
+
+ __ ldm(ia_w, sp, r4.bit() | fp.bit() | pc.bit());
+
+ CodeDesc desc;
+ assm.GetCode(&desc);
+ Handle<Code> code = isolate->factory()->NewCode(
+ desc, Code::ComputeFlags(Code::STUB), Handle<Code>());
+#ifdef DEBUG
+ OFStream os(stdout);
+ code->Print(os);
+#endif
+ F3 f = FUNCTION_CAST<F3>(code->entry());
+
+ Object* dummy = nullptr;
+ USE(dummy);
+
+#define CHECK_VRINT(input_val, ares, nres, mres, pres, zres) \
+ t.input = input_val; \
+ dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0); \
+ CHECK_EQ(ares, t.ar); \
+ CHECK_EQ(nres, t.nr); \
+ CHECK_EQ(mres, t.mr); \
+ CHECK_EQ(pres, t.pr); \
+ CHECK_EQ(zres, t.zr);
+
+ CHECK_VRINT(-0.5, -1.0, -0.0, -1.0, -0.0, -0.0)
+ CHECK_VRINT(-0.6, -1.0, -1.0, -1.0, -0.0, -0.0)
+ CHECK_VRINT(-1.1, -1.0, -1.0, -2.0, -1.0, -1.0)
+ CHECK_VRINT(0.5, 1.0, 0.0, 0.0, 1.0, 0.0)
+ CHECK_VRINT(0.6, 1.0, 1.0, 0.0, 1.0, 0.0)
+ CHECK_VRINT(1.1, 1.0, 1.0, 1.0, 2.0, 1.0)
+ double inf = std::numeric_limits<double>::infinity();
+ CHECK_VRINT(inf, inf, inf, inf, inf, inf)
+ CHECK_VRINT(-inf, -inf, -inf, -inf, -inf, -inf)
+ CHECK_VRINT(-0.0, -0.0, -0.0, -0.0, -0.0, -0.0)
+ double nan = std::numeric_limits<double>::quiet_NaN();
+ CHECK_VRINT(nan, nan, nan, nan, nan, nan)
+
+#undef CHECK_VRINT
+ }
+}
#undef __
}
+TEST(frintp) {
+ INIT_V8();
+ SETUP();
+
+ START();
+ __ Fmov(s16, 1.0);
+ __ Fmov(s17, 1.1);
+ __ Fmov(s18, 1.5);
+ __ Fmov(s19, 1.9);
+ __ Fmov(s20, 2.5);
+ __ Fmov(s21, -1.5);
+ __ Fmov(s22, -2.5);
+ __ Fmov(s23, kFP32PositiveInfinity);
+ __ Fmov(s24, kFP32NegativeInfinity);
+ __ Fmov(s25, 0.0);
+ __ Fmov(s26, -0.0);
+ __ Fmov(s27, -0.2);
+
+ __ Frintp(s0, s16);
+ __ Frintp(s1, s17);
+ __ Frintp(s2, s18);
+ __ Frintp(s3, s19);
+ __ Frintp(s4, s20);
+ __ Frintp(s5, s21);
+ __ Frintp(s6, s22);
+ __ Frintp(s7, s23);
+ __ Frintp(s8, s24);
+ __ Frintp(s9, s25);
+ __ Frintp(s10, s26);
+ __ Frintp(s11, s27);
+
+ __ Fmov(d16, -0.5);
+ __ Fmov(d17, -0.8);
+ __ Fmov(d18, 1.5);
+ __ Fmov(d19, 1.9);
+ __ Fmov(d20, 2.5);
+ __ Fmov(d21, -1.5);
+ __ Fmov(d22, -2.5);
+ __ Fmov(d23, kFP32PositiveInfinity);
+ __ Fmov(d24, kFP32NegativeInfinity);
+ __ Fmov(d25, 0.0);
+ __ Fmov(d26, -0.0);
+ __ Fmov(d27, -0.2);
+
+ __ Frintp(d12, d16);
+ __ Frintp(d13, d17);
+ __ Frintp(d14, d18);
+ __ Frintp(d15, d19);
+ __ Frintp(d16, d20);
+ __ Frintp(d17, d21);
+ __ Frintp(d18, d22);
+ __ Frintp(d19, d23);
+ __ Frintp(d20, d24);
+ __ Frintp(d21, d25);
+ __ Frintp(d22, d26);
+ __ Frintp(d23, d27);
+ END();
+
+ RUN();
+
+ CHECK_EQUAL_FP32(1.0, s0);
+ CHECK_EQUAL_FP32(2.0, s1);
+ CHECK_EQUAL_FP32(2.0, s2);
+ CHECK_EQUAL_FP32(2.0, s3);
+ CHECK_EQUAL_FP32(3.0, s4);
+ CHECK_EQUAL_FP32(-1.0, s5);
+ CHECK_EQUAL_FP32(-2.0, s6);
+ CHECK_EQUAL_FP32(kFP32PositiveInfinity, s7);
+ CHECK_EQUAL_FP32(kFP32NegativeInfinity, s8);
+ CHECK_EQUAL_FP32(0.0, s9);
+ CHECK_EQUAL_FP32(-0.0, s10);
+ CHECK_EQUAL_FP32(-0.0, s11);
+ CHECK_EQUAL_FP64(-0.0, d12);
+ CHECK_EQUAL_FP64(-0.0, d13);
+ CHECK_EQUAL_FP64(2.0, d14);
+ CHECK_EQUAL_FP64(2.0, d15);
+ CHECK_EQUAL_FP64(3.0, d16);
+ CHECK_EQUAL_FP64(-1.0, d17);
+ CHECK_EQUAL_FP64(-2.0, d18);
+ CHECK_EQUAL_FP64(kFP64PositiveInfinity, d19);
+ CHECK_EQUAL_FP64(kFP64NegativeInfinity, d20);
+ CHECK_EQUAL_FP64(0.0, d21);
+ CHECK_EQUAL_FP64(-0.0, d22);
+ CHECK_EQUAL_FP64(-0.0, d23);
+
+ TEARDOWN();
+}
+
+
TEST(frintz) {
INIT_V8();
SETUP();
Isolate* isolate = CcTest::i_isolate();
Zone zone(isolate);
- AstNode::IdGen id_gen;
- AstNodeFactory<AstNullVisitor> factory(&zone, NULL, &id_gen);
+ AstValueFactory value_factory(&zone, 0);
+ AstNodeFactory<AstNullVisitor> factory(&value_factory);
AstNode* node = factory.NewEmptyStatement(RelocInfo::kNoPosition);
list->Add(node);
CHECK_EQ(1, list->length());
#include "src/v8.h"
-#include "src/data-flow.h"
+#include "src/bit-vector.h"
#include "test/cctest/cctest.h"
using namespace v8::internal;
BitVector v(15, &zone);
v.Add(0);
BitVector w(15, &zone);
- w = v;
+ w.CopyFrom(v);
CHECK(w.Contains(0));
w.Add(1);
BitVector u(w, &zone);
for (--reg_num; reg_num >= 2; --reg_num) {
Register reg = Register::from_code(reg_num);
if (!reg.is(destination_reg)) {
- __ lw(at, MemOperand(sp, 0));
+ __ ld(at, MemOperand(sp, 0));
__ Assert(eq, kRegisterWasClobbered, reg, Operand(at));
__ Daddu(sp, sp, Operand(kPointerSize));
}
// 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<FixedArray> feedback_vector(f->shared()->feedback_vector());
+ Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
// Verify that we gathered feedback.
- int expected_count = FLAG_vector_ics ? 2 : 1;
- CHECK_EQ(expected_count, feedback_vector->length());
- CHECK(feedback_vector->get(expected_count - 1)->IsJSFunction());
+ int expected_slots = 0;
+ int expected_ic_slots = FLAG_vector_ics ? 2 : 1;
+ CHECK_EQ(expected_slots, feedback_vector->Slots());
+ CHECK_EQ(expected_ic_slots, feedback_vector->ICSlots());
+ FeedbackVectorICSlot slot_for_a(FLAG_vector_ics ? 1 : 0);
+ CHECK(feedback_vector->Get(slot_for_a)->IsJSFunction());
CompileRun("%OptimizeFunctionOnNextCall(f); f(fun1);");
// of the full code.
CHECK(f->IsOptimized());
CHECK(f->shared()->has_deoptimization_support());
- CHECK(f->shared()->feedback_vector()->
- get(expected_count - 1)->IsJSFunction());
+ CHECK(f->shared()->feedback_vector()->Get(slot_for_a)->IsJSFunction());
}
*v8::Handle<v8::Function>::Cast(
CcTest::global()->Get(v8_str("morphing_call"))));
- int expected_count = FLAG_vector_ics ? 2 : 1;
- CHECK_EQ(expected_count, f->shared()->feedback_vector()->length());
+ int expected_slots = 0;
+ int expected_ic_slots = FLAG_vector_ics ? 2 : 1;
+ CHECK_EQ(expected_slots, f->shared()->feedback_vector()->Slots());
+ CHECK_EQ(expected_ic_slots, f->shared()->feedback_vector()->ICSlots());
+
// And yet it's not compiled.
CHECK(!f->shared()->is_compiled());
CompileRun("morphing_call();");
// The vector should have the same size despite the new scoping.
- CHECK_EQ(expected_count, f->shared()->feedback_vector()->length());
+ CHECK_EQ(expected_slots, f->shared()->feedback_vector()->Slots());
+ CHECK_EQ(expected_ic_slots, f->shared()->feedback_vector()->ICSlots());
CHECK(f->shared()->is_compiled());
}
}
+// This tests checks distribution of the samples through the source lines.
+TEST(TickLines) {
+ CcTest::InitializeVM();
+ LocalContext env;
+ i::FLAG_turbo_source_positions = true;
+ i::Isolate* isolate = CcTest::i_isolate();
+ i::Factory* factory = isolate->factory();
+ i::HandleScope scope(isolate);
+
+ i::EmbeddedVector<char, 512> script;
+
+ const char* func_name = "func";
+ i::SNPrintF(script,
+ "function %s() {\n"
+ " var n = 0;\n"
+ " var m = 100*100;\n"
+ " while (m > 1) {\n"
+ " m--;\n"
+ " n += m * m * m;\n"
+ " }\n"
+ "}\n"
+ "%s();\n",
+ func_name, func_name);
+
+ CompileRun(script.start());
+
+ i::Handle<i::JSFunction> func = v8::Utils::OpenHandle(
+ *v8::Local<v8::Function>::Cast((*env)->Global()->Get(v8_str(func_name))));
+ CHECK_NE(NULL, func->shared());
+ CHECK_NE(NULL, func->shared()->code());
+ i::Code* code = NULL;
+ if (func->code()->is_optimized_code()) {
+ code = func->code();
+ } else {
+ CHECK(func->shared()->code() == func->code() || !i::FLAG_crankshaft);
+ code = func->shared()->code();
+ }
+ CHECK_NE(NULL, code);
+ i::Address code_address = code->instruction_start();
+ CHECK_NE(NULL, code_address);
+
+ CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate->heap());
+ profiles->StartProfiling("", false);
+ ProfileGenerator generator(profiles);
+ ProfilerEventsProcessor* processor = new ProfilerEventsProcessor(
+ &generator, NULL, v8::base::TimeDelta::FromMicroseconds(100));
+ processor->Start();
+ CpuProfiler profiler(isolate, profiles, &generator, processor);
+
+ // 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(), NULL,
+ *str, line, column);
+
+ // Enqueue a tick event to enable code events processing.
+ EnqueueTickSampleEvent(processor, code_address);
+
+ processor->StopSynchronously();
+
+ CpuProfile* profile = profiles->StopProfiling("");
+ CHECK_NE(NULL, profile);
+
+ // Check the state of profile generator.
+ CodeEntry* func_entry = generator.code_map()->FindEntry(code_address);
+ CHECK_NE(NULL, func_entry);
+ CHECK_EQ(func_name, func_entry->name());
+ const i::JITLineInfoTable* line_info = func_entry->line_info();
+ CHECK_NE(NULL, line_info);
+ CHECK(!line_info->empty());
+
+ // Check the hit source lines using V8 Public APIs.
+ const i::ProfileTree* tree = profile->top_down();
+ ProfileNode* root = tree->root();
+ CHECK_NE(NULL, root);
+ ProfileNode* func_node = root->FindChild(func_entry);
+ CHECK_NE(NULL, func_node);
+
+ // Add 10 faked ticks to source line #5.
+ int hit_line = 5;
+ int hit_count = 10;
+ for (int i = 0; i < hit_count; i++) func_node->IncrementLineTicks(hit_line);
+
+ unsigned int line_count = func_node->GetHitLineCount();
+ CHECK_EQ(2, line_count); // Expect two hit source lines - #1 and #5.
+ ScopedVector<v8::CpuProfileNode::LineTick> entries(line_count);
+ CHECK(func_node->GetLineTicks(&entries[0], line_count));
+ int value = 0;
+ for (int i = 0; i < entries.length(); i++)
+ if (entries[i].line == hit_line) {
+ value = entries[i].hit_count;
+ break;
+ }
+ CHECK_EQ(hit_count, value);
+}
+
+
static const char* call_function_test_source = "function bar(iterations) {\n"
"}\n"
"function start(duration) {\n"
CompileRun(source);
}
+ threaded_debugging_barriers.barrier_4.Wait();
isolate_->Dispose();
}
threaded_debugging_barriers.barrier_2.Wait();
v8::Debug::SendCommand(isolate_, buffer, AsciiToUtf16(command_1, buffer));
v8::Debug::SendCommand(isolate_, buffer, AsciiToUtf16(command_2, buffer));
+ threaded_debugging_barriers.barrier_4.Wait();
}
breakpoints_barriers->barrier_2.Wait();
CompileRun(source_2);
}
+ breakpoints_barriers->barrier_4.Wait();
isolate_->Dispose();
}
CHECK_EQ(116, evaluate_int_result);
// 9: Continue evaluation of source2, reach end.
v8::Debug::SendCommand(isolate_, buffer, AsciiToUtf16(command_8, buffer));
+ breakpoints_barriers->barrier_4.Wait();
}
CompileRun("while (true);");
CHECK(try_catch.HasTerminated());
}
+
+
+static void DebugEventExpectNoException(
+ const v8::Debug::EventDetails& event_details) {
+ v8::DebugEvent event = event_details.GetEvent();
+ CHECK_NE(v8::Exception, event);
+}
+
+
+static void TryCatchWrappedThrowCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& args) {
+ v8::TryCatch try_catch;
+ CompileRun("throw 'rejection';");
+ CHECK(try_catch.HasCaught());
+}
+
+
+TEST(DebugPromiseInterceptedByTryCatch) {
+ DebugLocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::Debug::SetDebugEventListener(&DebugEventExpectNoException);
+ ChangeBreakOnException(false, true);
+
+ v8::Handle<v8::FunctionTemplate> fun =
+ v8::FunctionTemplate::New(isolate, TryCatchWrappedThrowCallback);
+ env->Global()->Set(v8_str("fun"), fun->GetFunction());
+
+ CompileRun("var p = new Promise(function(res, rej) { fun(); res(); });");
+ CompileRun(
+ "var r;"
+ "p.chain(function() { r = 'resolved'; },"
+ " function() { r = 'rejected'; });");
+ CHECK(CompileRun("r")->Equals(v8_str("resolved")));
+}
+
+
+static int exception_event_counter = 0;
+
+
+static void DebugEventCountException(
+ const v8::Debug::EventDetails& event_details) {
+ v8::DebugEvent event = event_details.GetEvent();
+ if (event == v8::Exception) exception_event_counter++;
+}
+
+
+static void ThrowCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
+ CompileRun("throw 'rejection';");
+}
+
+
+TEST(DebugPromiseRejectedByCallback) {
+ DebugLocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::Debug::SetDebugEventListener(&DebugEventCountException);
+ ChangeBreakOnException(false, true);
+ exception_event_counter = 0;
+
+ v8::Handle<v8::FunctionTemplate> fun =
+ v8::FunctionTemplate::New(isolate, ThrowCallback);
+ env->Global()->Set(v8_str("fun"), fun->GetFunction());
+
+ CompileRun("var p = new Promise(function(res, rej) { fun(); res(); });");
+ CompileRun(
+ "var r;"
+ "p.chain(function() { r = 'resolved'; },"
+ " function(e) { r = 'rejected' + e; });");
+ CHECK(CompileRun("r")->Equals(v8_str("rejectedrejection")));
+ CHECK_EQ(1, exception_event_counter);
+}
+
+
+TEST(DebugBreakOnExceptionInObserveCallback) {
+ DebugLocalContext env;
+ v8::Isolate* isolate = env->GetIsolate();
+ v8::HandleScope scope(isolate);
+ v8::Debug::SetDebugEventListener(&DebugEventCountException);
+ // Break on uncaught exception
+ ChangeBreakOnException(false, true);
+ exception_event_counter = 0;
+
+ v8::Handle<v8::FunctionTemplate> fun =
+ v8::FunctionTemplate::New(isolate, ThrowCallback);
+ env->Global()->Set(v8_str("fun"), fun->GetFunction());
+
+ CompileRun(
+ "var obj = {};"
+ "var callbackRan = false;"
+ "Object.observe(obj, function() {"
+ " callbackRan = true;"
+ " throw Error('foo');"
+ "});"
+ "obj.prop = 1");
+ CHECK(CompileRun("callbackRan")->BooleanValue());
+ CHECK_EQ(1, exception_event_counter);
+}
}
}
}
+
+
+TEST(CrossScriptDynamicLookup) {
+ i::FLAG_harmony_scoping = true;
+
+ HandleScope handle_scope(CcTest::isolate());
+
+ {
+ SimpleContext context;
+ Local<String> undefined_string = String::NewFromUtf8(
+ CcTest::isolate(), "undefined", String::kInternalizedString);
+ Local<String> number_string = String::NewFromUtf8(
+ CcTest::isolate(), "number", String::kInternalizedString);
+
+ context.Check(
+ "function f(o) { with(o) { return x; } }"
+ "function g(o) { with(o) { x = 15; } }"
+ "function h(o) { with(o) { return typeof x; } }",
+ EXPECT_RESULT, Undefined(CcTest::isolate()));
+ context.Check("h({})", EXPECT_RESULT, undefined_string);
+ context.Check(
+ "'use strict';"
+ "let x = 1;"
+ "f({})",
+ EXPECT_RESULT, Number::New(CcTest::isolate(), 1));
+ context.Check(
+ "'use strict';"
+ "g({});"
+ "x",
+ EXPECT_RESULT, Number::New(CcTest::isolate(), 15));
+ context.Check("f({})", EXPECT_RESULT, Number::New(CcTest::isolate(), 15));
+ context.Check("h({})", EXPECT_RESULT, number_string);
+ }
+}
"e6cf3474 uxtb16 r3, r4, ror #8");
}
+ COMPARE(smmla(r0, r1, r2, r3), "e7503211 smmla r0, r1, r2, r3");
+ COMPARE(smmla(r10, r9, r8, r7), "e75a7819 smmla r10, r9, r8, r7");
+
+ COMPARE(smmul(r0, r1, r2), "e750f211 smmul r0, r1, r2");
+ COMPARE(smmul(r8, r9, r10), "e758fa19 smmul r8, r9, r10");
+
VERIFY_RUN();
}
}
+TEST(ARMv8_vrintX_disasm) {
+ SET_UP();
+
+ if (CpuFeatures::IsSupported(ARMv8)) {
+ COMPARE(vrinta(d0, d0), "feb80b40 vrinta.f64.f64 d0, d0");
+ COMPARE(vrinta(d2, d3), "feb82b43 vrinta.f64.f64 d2, d3");
+
+ COMPARE(vrintp(d0, d0), "feba0b40 vrintp.f64.f64 d0, d0");
+ COMPARE(vrintp(d2, d3), "feba2b43 vrintp.f64.f64 d2, d3");
+
+ COMPARE(vrintn(d0, d0), "feb90b40 vrintn.f64.f64 d0, d0");
+ COMPARE(vrintn(d2, d3), "feb92b43 vrintn.f64.f64 d2, d3");
+
+ COMPARE(vrintm(d0, d0), "febb0b40 vrintm.f64.f64 d0, d0");
+ COMPARE(vrintm(d2, d3), "febb2b43 vrintm.f64.f64 d2, d3");
+
+ COMPARE(vrintz(d0, d0), "eeb60bc0 vrintz.f64.f64 d0, d0");
+ COMPARE(vrintz(d2, d3, ne), "1eb62bc3 vrintzne.f64.f64 d2, d3");
+ }
+
+ VERIFY_RUN();
+}
+
+
TEST(Neon) {
SET_UP();
COMPARE(frintn(s31, s30), "frintn s31, s30");
COMPARE(frintn(d12, d13), "frintn d12, d13");
COMPARE(frintn(d31, d30), "frintn d31, d30");
+ COMPARE(frintp(s10, s11), "frintp s10, s11");
+ COMPARE(frintp(s31, s30), "frintp s31, s30");
+ COMPARE(frintp(d12, d13), "frintp d12, d13");
+ COMPARE(frintp(d31, d30), "frintp d31, d30");
COMPARE(frintz(s10, s11), "frintz s10, s11");
COMPARE(frintz(s31, s30), "frintz s31, s30");
COMPARE(frintz(d12, d13), "frintz d12, d13");
__ rcl(edx, 7);
__ rcr(edx, 1);
__ rcr(edx, 7);
+ __ ror(edx, 1);
+ __ ror(edx, 6);
+ __ ror_cl(edx);
+ __ ror(Operand(ebx, ecx, times_4, 10000), 1);
+ __ ror(Operand(ebx, ecx, times_4, 10000), 6);
+ __ ror_cl(Operand(ebx, ecx, times_4, 10000));
__ sar(edx, 1);
__ sar(edx, 6);
__ sar_cl(edx);
// Move operation
__ movaps(xmm0, xmm1);
__ shufps(xmm0, xmm0, 0x0);
+ __ cvtsd2ss(xmm0, xmm1);
+ __ cvtsd2ss(xmm0, Operand(ebx, ecx, times_4, 10000));
// logic operation
__ andps(xmm0, xmm1);
{
__ cvttss2si(edx, Operand(ebx, ecx, times_4, 10000));
__ cvtsi2sd(xmm1, Operand(ebx, ecx, times_4, 10000));
+ __ cvtss2sd(xmm1, Operand(ebx, ecx, times_4, 10000));
+ __ cvtss2sd(xmm1, xmm0);
__ movsd(xmm1, Operand(ebx, ecx, times_4, 10000));
__ movsd(Operand(ebx, ecx, times_4, 10000), xmm1);
// 128 bit move instructions.
__ movdqu(Operand(ebx, ecx, times_4, 10000), xmm0);
__ addsd(xmm1, xmm0);
+ __ addsd(xmm1, Operand(ebx, ecx, times_4, 10000));
__ mulsd(xmm1, xmm0);
+ __ mulsd(xmm1, Operand(ebx, ecx, times_4, 10000));
__ subsd(xmm1, xmm0);
__ subsd(xmm1, Operand(ebx, ecx, times_4, 10000));
__ divsd(xmm1, xmm0);
+ __ divsd(xmm1, Operand(ebx, ecx, times_4, 10000));
__ ucomisd(xmm0, xmm1);
__ cmpltsd(xmm0, xmm1);
__ imulq(rdx, rcx);
__ shld(rdx, rcx);
__ shrd(rdx, rcx);
+ __ shlq(Operand(rdi, rax, times_4, 100), Immediate(1));
+ __ shlq(Operand(rdi, rax, times_4, 100), Immediate(6));
+ __ shlq(Operand(r15, 0), Immediate(1));
+ __ shlq(Operand(r15, 0), Immediate(6));
+ __ shlq_cl(Operand(r15, 0));
+ __ shlq_cl(Operand(r15, 0));
+ __ shlq_cl(Operand(rdi, rax, times_4, 100));
+ __ shlq_cl(Operand(rdi, rax, times_4, 100));
+ __ shlq(rdx, Immediate(1));
+ __ shlq(rdx, Immediate(6));
+ __ shll(Operand(rdi, rax, times_4, 100), Immediate(1));
+ __ shll(Operand(rdi, rax, times_4, 100), Immediate(6));
+ __ shll(Operand(r15, 0), Immediate(1));
+ __ shll(Operand(r15, 0), Immediate(6));
+ __ shll_cl(Operand(r15, 0));
+ __ shll_cl(Operand(r15, 0));
+ __ shll_cl(Operand(rdi, rax, times_4, 100));
+ __ shll_cl(Operand(rdi, rax, times_4, 100));
+ __ shll(rdx, Immediate(1));
+ __ shll(rdx, Immediate(6));
__ bts(Operand(rdx, 0), rcx);
__ bts(Operand(rbx, rcx, times_4, 0), rcx);
__ nop();
__ nop();
__ idivq(rdx);
- __ mul(rdx);
+ __ mull(rdx);
+ __ mulq(rdx);
__ negq(rdx);
__ notq(rdx);
__ testq(Operand(rbx, rcx, times_4, 10000), rdx);
- __ imulq(rdx, Operand(rbx, rcx, times_4, 10000));
__ imulq(rdx, rcx, Immediate(12));
__ imulq(rdx, rcx, Immediate(1000));
+ __ imulq(rdx, Operand(rbx, rcx, times_4, 10000));
+ __ imulq(rdx, Operand(rbx, rcx, times_4, 10000), Immediate(12));
__ imulq(rdx, Operand(rbx, rcx, times_4, 10000), Immediate(1000));
+ __ imull(r15, rcx, Immediate(12));
+ __ imull(r15, rcx, Immediate(1000));
+ __ imull(r15, Operand(rbx, rcx, times_4, 10000));
+ __ imull(r15, Operand(rbx, rcx, times_4, 10000), Immediate(12));
+ __ imull(r15, Operand(rbx, rcx, times_4, 10000), Immediate(1000));
__ incq(rdx);
__ incq(Operand(rbx, rcx, times_4, 10000));
// Move operation
__ cvttss2si(rdx, Operand(rbx, rcx, times_4, 10000));
__ cvttss2si(rdx, xmm1);
+ __ cvtsd2ss(xmm0, xmm1);
+ __ cvtsd2ss(xmm0, Operand(rbx, rcx, times_4, 10000));
__ movaps(xmm0, xmm1);
// logic operation
__ cvttsd2si(rdx, xmm1);
__ cvttsd2siq(rdx, xmm1);
__ cvttsd2siq(rdx, Operand(rbx, rcx, times_4, 10000));
+ __ cvtqsi2sd(xmm1, Operand(rbx, rcx, times_4, 10000));
+ __ cvtqsi2sd(xmm1, rdx);
__ movsd(xmm1, Operand(rbx, rcx, times_4, 10000));
__ movsd(Operand(rbx, rcx, times_4, 10000), xmm1);
// 128 bit move instructions.
__ movdqa(Operand(rbx, rcx, times_4, 10000), xmm0);
__ addsd(xmm1, xmm0);
+ __ addsd(xmm1, Operand(rbx, rcx, times_4, 10000));
__ mulsd(xmm1, xmm0);
+ __ mulsd(xmm1, Operand(rbx, rcx, times_4, 10000));
__ subsd(xmm1, xmm0);
+ __ subsd(xmm1, Operand(rbx, rcx, times_4, 10000));
__ divsd(xmm1, xmm0);
+ __ divsd(xmm1, Operand(rbx, rcx, times_4, 10000));
__ ucomisd(xmm0, xmm1);
__ andpd(xmm0, xmm1);
+
+ __ pslld(xmm0, 6);
+ __ psrld(xmm0, 6);
+ __ psllq(xmm0, 6);
+ __ psrlq(xmm0, 6);
+
+ __ pcmpeqd(xmm1, xmm0);
}
// cmov.
__ rcl(edx, 7);
__ rcr(edx, 1);
__ rcr(edx, 7);
+ __ ror(edx, 1);
+ __ ror(edx, 6);
+ __ ror_cl(edx);
+ __ ror(Operand(ebx, ecx, times_4, 10000), 1);
+ __ ror(Operand(ebx, ecx, times_4, 10000), 6);
+ __ ror_cl(Operand(ebx, ecx, times_4, 10000));
__ sar(edx, 1);
__ sar(edx, 6);
__ sar_cl(edx);
--- /dev/null
+// 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/v8.h"
+#include "test/cctest/cctest.h"
+
+#include "src/api.h"
+#include "src/debug.h"
+#include "src/execution.h"
+#include "src/factory.h"
+#include "src/global-handles.h"
+#include "src/macro-assembler.h"
+#include "src/objects.h"
+
+using namespace v8::internal;
+
+namespace {
+
+TEST(VectorStructure) {
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ // Empty vectors are the empty fixed array.
+ Handle<TypeFeedbackVector> vector = factory->NewTypeFeedbackVector(0, 0);
+ CHECK(Handle<FixedArray>::cast(vector)
+ .is_identical_to(factory->empty_fixed_array()));
+ // Which can nonetheless be queried.
+ CHECK_EQ(0, vector->ic_with_type_info_count());
+ CHECK_EQ(0, vector->ic_generic_count());
+ CHECK_EQ(0, vector->Slots());
+ CHECK_EQ(0, vector->ICSlots());
+
+ vector = factory->NewTypeFeedbackVector(1, 0);
+ CHECK_EQ(1, vector->Slots());
+ CHECK_EQ(0, vector->ICSlots());
+
+ vector = factory->NewTypeFeedbackVector(0, 1);
+ CHECK_EQ(0, vector->Slots());
+ CHECK_EQ(1, vector->ICSlots());
+
+ vector = factory->NewTypeFeedbackVector(3, 5);
+ CHECK_EQ(3, vector->Slots());
+ CHECK_EQ(5, vector->ICSlots());
+
+ int metadata_length = vector->ic_metadata_length();
+ if (!FLAG_vector_ics) {
+ CHECK_EQ(0, metadata_length);
+ } else {
+ CHECK(metadata_length > 0);
+ }
+
+ int index = vector->GetIndex(FeedbackVectorSlot(0));
+ CHECK_EQ(TypeFeedbackVector::kReservedIndexCount + metadata_length, index);
+ CHECK(FeedbackVectorSlot(0) == vector->ToSlot(index));
+
+ index = vector->GetIndex(FeedbackVectorICSlot(0));
+ CHECK_EQ(index,
+ TypeFeedbackVector::kReservedIndexCount + metadata_length + 3);
+ CHECK(FeedbackVectorICSlot(0) == vector->ToICSlot(index));
+
+ CHECK_EQ(TypeFeedbackVector::kReservedIndexCount + metadata_length + 3 + 5,
+ vector->length());
+}
+
+
+// IC slots need an encoding to recognize what is in there.
+TEST(VectorICMetadata) {
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ if (!FLAG_vector_ics) {
+ // If FLAG_vector_ics is false, we only store CALL_ICs in the vector, so
+ // there is no need for metadata to describe the slots.
+ return;
+ }
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ Handle<TypeFeedbackVector> vector =
+ factory->NewTypeFeedbackVector(10, 3 * 10);
+ CHECK_EQ(10, vector->Slots());
+ CHECK_EQ(3 * 10, vector->ICSlots());
+
+ // Set metadata.
+ for (int i = 0; i < 30; i++) {
+ Code::Kind kind;
+ if (i % 3 == 0) {
+ kind = Code::CALL_IC;
+ } else if (i % 3 == 1) {
+ kind = Code::LOAD_IC;
+ } else {
+ kind = Code::KEYED_LOAD_IC;
+ }
+ vector->SetKind(FeedbackVectorICSlot(i), kind);
+ }
+
+ // Meanwhile set some feedback values and type feedback values to
+ // verify the data structure remains intact.
+ vector->change_ic_with_type_info_count(100);
+ vector->change_ic_generic_count(3333);
+ vector->Set(FeedbackVectorSlot(0), *vector);
+
+ // Verify the metadata remains the same.
+ for (int i = 0; i < 30; i++) {
+ Code::Kind kind = vector->GetKind(FeedbackVectorICSlot(i));
+ if (i % 3 == 0) {
+ CHECK_EQ(Code::CALL_IC, kind);
+ } else if (i % 3 == 1) {
+ CHECK_EQ(Code::LOAD_IC, kind);
+ } else {
+ CHECK_EQ(Code::KEYED_LOAD_IC, kind);
+ }
+ }
+}
+
+
+TEST(VectorSlotClearing) {
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ // We only test clearing FeedbackVectorSlots, not FeedbackVectorICSlots.
+ // The reason is that FeedbackVectorICSlots need a full code environment
+ // to fully test (See VectorICProfilerStatistics test below).
+ Handle<TypeFeedbackVector> vector = factory->NewTypeFeedbackVector(5, 0);
+
+ // Fill with information
+ vector->Set(FeedbackVectorSlot(0), Smi::FromInt(1));
+ vector->Set(FeedbackVectorSlot(1), *factory->fixed_array_map());
+ Handle<AllocationSite> site = factory->NewAllocationSite();
+ vector->Set(FeedbackVectorSlot(2), *site);
+
+ vector->ClearSlots(NULL);
+
+ // The feedback vector slots are cleared. AllocationSites are granted
+ // an exemption from clearing, as are smis.
+ CHECK_EQ(Smi::FromInt(1), vector->Get(FeedbackVectorSlot(0)));
+ CHECK_EQ(*TypeFeedbackVector::UninitializedSentinel(isolate),
+ vector->Get(FeedbackVectorSlot(1)));
+ CHECK(vector->Get(FeedbackVectorSlot(2))->IsAllocationSite());
+}
+
+
+TEST(VectorICProfilerStatistics) {
+ if (i::FLAG_always_opt) return;
+ CcTest::InitializeVM();
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Heap* heap = isolate->heap();
+
+ // Make sure function f has a call that uses a type feedback slot.
+ CompileRun(
+ "function fun() {};"
+ "function f(a) { a(); } f(fun);");
+ Handle<JSFunction> f = v8::Utils::OpenHandle(
+ *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+ // There should be one IC.
+ Code* code = f->shared()->code();
+ TypeFeedbackInfo* feedback_info =
+ TypeFeedbackInfo::cast(code->type_feedback_info());
+ CHECK_EQ(1, feedback_info->ic_total_count());
+ CHECK_EQ(0, feedback_info->ic_with_type_info_count());
+ CHECK_EQ(0, feedback_info->ic_generic_count());
+ TypeFeedbackVector* feedback_vector = f->shared()->feedback_vector();
+ CHECK_EQ(1, feedback_vector->ic_with_type_info_count());
+ CHECK_EQ(0, feedback_vector->ic_generic_count());
+
+ // Now send the information generic.
+ CompileRun("f(Object);");
+ feedback_vector = f->shared()->feedback_vector();
+ CHECK_EQ(0, feedback_vector->ic_with_type_info_count());
+ CHECK_EQ(1, feedback_vector->ic_generic_count());
+
+ // A collection will make the site uninitialized again.
+ heap->CollectAllGarbage(i::Heap::kNoGCFlags);
+ feedback_vector = f->shared()->feedback_vector();
+ CHECK_EQ(0, feedback_vector->ic_with_type_info_count());
+ CHECK_EQ(0, feedback_vector->ic_generic_count());
+
+ // The Array function is special. A call to array remains monomorphic
+ // and isn't cleared by gc because an AllocationSite is being held.
+ CompileRun("f(Array);");
+ feedback_vector = f->shared()->feedback_vector();
+ CHECK_EQ(1, feedback_vector->ic_with_type_info_count());
+ CHECK_EQ(0, feedback_vector->ic_generic_count());
+
+ int ic_slot = FLAG_vector_ics ? 1 : 0;
+ CHECK(
+ feedback_vector->Get(FeedbackVectorICSlot(ic_slot))->IsAllocationSite());
+ heap->CollectAllGarbage(i::Heap::kNoGCFlags);
+ feedback_vector = f->shared()->feedback_vector();
+ CHECK_EQ(1, feedback_vector->ic_with_type_info_count());
+ CHECK_EQ(0, feedback_vector->ic_generic_count());
+ CHECK(
+ feedback_vector->Get(FeedbackVectorICSlot(ic_slot))->IsAllocationSite());
+}
+
+
+TEST(VectorCallICStates) {
+ if (i::FLAG_always_opt) return;
+ CcTest::InitializeVM();
+ LocalContext context;
+ v8::HandleScope scope(context->GetIsolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Heap* heap = isolate->heap();
+
+ // 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 = v8::Utils::OpenHandle(
+ *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+ // There should be one IC.
+ Handle<TypeFeedbackVector> feedback_vector =
+ Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
+ FeedbackVectorICSlot slot(FLAG_vector_ics ? 1 : 0);
+ CallICNexus nexus(feedback_vector, slot);
+ CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
+ // CallIC doesn't return map feedback.
+ CHECK_EQ(NULL, nexus.FindFirstMap());
+
+ CompileRun("f(function() { return 16; })");
+ CHECK_EQ(GENERIC, nexus.StateFromFeedback());
+
+ // After a collection, state should be reset to UNINITIALIZED.
+ heap->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CHECK_EQ(UNINITIALIZED, nexus.StateFromFeedback());
+
+ // Array is special. It will remain monomorphic across gcs and it contains an
+ // AllocationSite.
+ CompileRun("f(Array)");
+ CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
+ CHECK(feedback_vector->Get(FeedbackVectorICSlot(slot))->IsAllocationSite());
+
+ heap->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
+}
+}
#include "src/api.h"
#include "src/debug.h"
-#include "src/runtime/runtime.h"
+#include "src/string-search.h"
#include "test/cctest/cctest.h"
using ::v8::internal::SmartArrayPointer;
using ::v8::internal::SharedFunctionInfo;
using ::v8::internal::String;
+using ::v8::internal::Vector;
static void CheckFunctionName(v8::Handle<v8::Script> script,
const char* func_pos_src,
const char* ref_inferred_name) {
Isolate* isolate = CcTest::i_isolate();
- Factory* factory = isolate->factory();
// Get script source.
Handle<Object> obj = v8::Utils::OpenHandle(*script);
Handle<String> script_src(String::cast(i_script->source()));
// Find the position of a given func source substring in the source.
- Handle<String> func_pos_str =
- factory->NewStringFromAsciiChecked(func_pos_src);
- int func_pos = Runtime::StringMatch(isolate,
- script_src,
- func_pos_str,
- 0);
+ int func_pos;
+ {
+ i::DisallowHeapAllocation no_gc;
+ Vector<const uint8_t> func_pos_str = i::OneByteVector(func_pos_src);
+ String::FlatContent script_content = script_src->GetFlatContent();
+ func_pos = SearchString(isolate, script_content.ToOneByteVector(),
+ func_pos_str, 0);
+ }
CHECK_NE(0, func_pos);
// Obtain SharedFunctionInfo for the function.
}
+TEST(CompilationCacheCachingBehavior) {
+ // If we do not flush code, or have the compilation cache turned off, this
+ // test is invalid.
+ if (!FLAG_flush_code || !FLAG_flush_code_incrementally ||
+ !FLAG_compilation_cache) {
+ return;
+ }
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+ Heap* heap = isolate->heap();
+ CompilationCache* compilation_cache = isolate->compilation_cache();
+
+ v8::HandleScope scope(CcTest::isolate());
+ const char* raw_source =
+ "function foo() {"
+ " var x = 42;"
+ " var y = 42;"
+ " var z = x + y;"
+ "};"
+ "foo()";
+ Handle<String> source = factory->InternalizeUtf8String(raw_source);
+ Handle<Context> native_context = isolate->native_context();
+
+ {
+ v8::HandleScope scope(CcTest::isolate());
+ CompileRun(raw_source);
+ }
+
+ // On first compilation, only a hash is inserted in the code cache. We can't
+ // find that value.
+ MaybeHandle<SharedFunctionInfo> info = compilation_cache->LookupScript(
+ source, Handle<Object>(), 0, 0, true, native_context);
+ CHECK(info.is_null());
+
+ {
+ v8::HandleScope scope(CcTest::isolate());
+ CompileRun(raw_source);
+ }
+
+ // On second compilation, the hash is replaced by a real cache entry mapping
+ // the source to the shared function info containing the code.
+ info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, true,
+ native_context);
+ CHECK(!info.is_null());
+
+ heap->CollectAllGarbage(Heap::kNoGCFlags);
+
+ // On second compilation, the hash is replaced by a real cache entry mapping
+ // the source to the shared function info containing the code.
+ info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, true,
+ native_context);
+ CHECK(!info.is_null());
+
+ while (!info.ToHandleChecked()->code()->IsOld()) {
+ info.ToHandleChecked()->code()->MakeOlder(NO_MARKING_PARITY);
+ }
+
+ heap->CollectAllGarbage(Heap::kNoGCFlags);
+ // Ensure code aging cleared the entry from the cache.
+ info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, true,
+ native_context);
+ CHECK(info.is_null());
+
+ {
+ v8::HandleScope scope(CcTest::isolate());
+ CompileRun(raw_source);
+ }
+
+ // On first compilation, only a hash is inserted in the code cache. We can't
+ // find that value.
+ info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, true,
+ native_context);
+ CHECK(info.is_null());
+
+ for (int i = 0; i < CompilationCacheTable::kHashGenerations; i++) {
+ compilation_cache->MarkCompactPrologue();
+ }
+
+ {
+ v8::HandleScope scope(CcTest::isolate());
+ CompileRun(raw_source);
+ }
+
+ // If we aged the cache before caching the script, ensure that we didn't cache
+ // on next compilation.
+ info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, true,
+ native_context);
+ CHECK(info.is_null());
+}
+
+
// Count the number of native contexts in the weak list of native contexts.
int CountNativeContexts() {
int count = 0;
}
+TEST(IdleNotificationFinishMarking) {
+ i::FLAG_allow_natives_syntax = true;
+ CcTest::InitializeVM();
+ SimulateFullSpace(CcTest::heap()->old_pointer_space());
+ IncrementalMarking* marking = CcTest::heap()->incremental_marking();
+ marking->Abort();
+ marking->Start();
+
+ CHECK_EQ(CcTest::heap()->gc_count(), 0);
+
+ // TODO(hpayer): We cannot write proper unit test right now for heap.
+ // The ideal test would call kMaxIdleMarkingDelayCounter to test the
+ // marking delay counter.
+
+ // Perform a huge incremental marking step but don't complete marking.
+ intptr_t bytes_processed = 0;
+ do {
+ bytes_processed =
+ marking->Step(1 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD,
+ IncrementalMarking::FORCE_MARKING,
+ IncrementalMarking::DO_NOT_FORCE_COMPLETION);
+ CHECK(!marking->IsIdleMarkingDelayCounterLimitReached());
+ } while (bytes_processed);
+
+ // The next invocations of incremental marking are not going to complete
+ // marking
+ // since the completion threshold is not reached
+ for (size_t i = 0; i < IncrementalMarking::kMaxIdleMarkingDelayCounter - 2;
+ i++) {
+ marking->Step(1 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD,
+ IncrementalMarking::FORCE_MARKING,
+ IncrementalMarking::DO_NOT_FORCE_COMPLETION);
+ CHECK(!marking->IsIdleMarkingDelayCounterLimitReached());
+ }
+
+ // The next idle notification has to finish incremental marking.
+ const int kLongIdleTime = 1000000;
+ CcTest::isolate()->IdleNotification(kLongIdleTime);
+ CHECK_EQ(CcTest::heap()->gc_count(), 1);
+}
+
+
// Test that HAllocateObject will always return an object in new-space.
TEST(OptimizedAllocationAlwaysInNewSpace) {
i::FLAG_allow_natives_syntax = true;
"root = new F");
root = GetByName("root");
AddPropertyTo(2, root, "funny");
+ CcTest::heap()->CollectGarbage(NEW_SPACE);
// Count number of live transitions after marking. Note that one transition
// is left, because 'o' still holds an instance of one transition target.
root = GetByName("root");
AddPropertyTo(2, root, "funny");
+ CcTest::heap()->CollectGarbage(NEW_SPACE);
// Count number of live transitions after marking. Note that one transition
// is left, because 'o' still holds an instance of one transition target.
OFStream os(stdout);
g->shared()->Print(os);
- os << endl;
+ os << std::endl;
}
#endif // OBJECT_PRINT
Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
- int expected_length = FLAG_vector_ics ? 4 : 2;
- CHECK_EQ(expected_length, feedback_vector->length());
- for (int i = 0; i < expected_length; i++) {
- if ((i % 2) == 1) {
- CHECK(feedback_vector->get(i)->IsJSFunction());
- }
+ int expected_slots = 2;
+ CHECK_EQ(expected_slots, feedback_vector->ICSlots());
+ for (int i = 0; i < expected_slots; i++) {
+ CHECK(feedback_vector->Get(FeedbackVectorICSlot(i))->IsJSFunction());
}
SimulateIncrementalMarking(CcTest::heap());
CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
- CHECK_EQ(expected_length, feedback_vector->length());
- for (int i = 0; i < expected_length; i++) {
- CHECK_EQ(feedback_vector->get(i),
+ CHECK_EQ(expected_slots, feedback_vector->ICSlots());
+ for (int i = 0; i < expected_slots; i++) {
+ CHECK_EQ(feedback_vector->Get(FeedbackVectorICSlot(i)),
*TypeFeedbackVector::UninitializedSentinel(CcTest::i_isolate()));
}
}
}
+TEST(WeakCell) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ v8::internal::Heap* heap = CcTest::heap();
+ v8::internal::Factory* factory = isolate->factory();
+
+ HandleScope outer_scope(isolate);
+ Handle<WeakCell> weak_cell1;
+ {
+ HandleScope inner_scope(isolate);
+ Handle<HeapObject> value = factory->NewFixedArray(1, NOT_TENURED);
+ weak_cell1 = inner_scope.CloseAndEscape(factory->NewWeakCell(value));
+ }
+
+ Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
+ Handle<WeakCell> weak_cell2;
+ {
+ HandleScope inner_scope(isolate);
+ weak_cell2 = inner_scope.CloseAndEscape(factory->NewWeakCell(survivor));
+ }
+ CHECK(weak_cell1->value()->IsFixedArray());
+ CHECK_EQ(*survivor, weak_cell2->value());
+ heap->CollectGarbage(NEW_SPACE);
+ CHECK(weak_cell1->value()->IsFixedArray());
+ CHECK_EQ(*survivor, weak_cell2->value());
+ heap->CollectGarbage(NEW_SPACE);
+ CHECK(weak_cell1->value()->IsFixedArray());
+ CHECK_EQ(*survivor, weak_cell2->value());
+ heap->CollectAllAvailableGarbage();
+ CHECK(weak_cell1->cleared());
+ CHECK_EQ(*survivor, weak_cell2->value());
+}
+
+
+TEST(WeakCellsWithIncrementalMarking) {
+ CcTest::InitializeVM();
+ Isolate* isolate = CcTest::i_isolate();
+ v8::internal::Heap* heap = CcTest::heap();
+ v8::internal::Factory* factory = isolate->factory();
+
+ const int N = 16;
+ HandleScope outer_scope(isolate);
+ Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
+ Handle<WeakCell> weak_cells[N];
+
+ for (int i = 0; i < N; i++) {
+ HandleScope inner_scope(isolate);
+ Handle<HeapObject> value =
+ i == 0 ? survivor : factory->NewFixedArray(1, NOT_TENURED);
+ Handle<WeakCell> weak_cell = factory->NewWeakCell(value);
+ CHECK(weak_cell->value()->IsFixedArray());
+ IncrementalMarking* marking = heap->incremental_marking();
+ if (marking->IsStopped()) marking->Start();
+ marking->Step(128, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ heap->CollectGarbage(NEW_SPACE);
+ CHECK(weak_cell->value()->IsFixedArray());
+ weak_cells[i] = inner_scope.CloseAndEscape(weak_cell);
+ }
+ heap->CollectAllGarbage(Heap::kNoGCFlags);
+ CHECK_EQ(*survivor, weak_cells[0]->value());
+ for (int i = 1; i < N; i++) {
+ CHECK(weak_cells[i]->cleared());
+ }
+}
+
+
#ifdef DEBUG
TEST(AddInstructionChangesNewSpacePromotion) {
i::FLAG_allow_natives_syntax = true;
}
+TEST(Regress3631) {
+ i::FLAG_expose_gc = true;
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Heap* heap = isolate->heap();
+ IncrementalMarking* marking = CcTest::heap()->incremental_marking();
+ v8::Local<v8::Value> result = CompileRun(
+ "var weak_map = new WeakMap();"
+ "var future_keys = [];"
+ "for (var i = 0; i < 50; i++) {"
+ " var key = {'k' : i + 0.1};"
+ " weak_map.set(key, 1);"
+ " future_keys.push({'x' : i + 0.2});"
+ "}"
+ "weak_map");
+ if (marking->IsStopped()) {
+ marking->Start();
+ }
+ // Incrementally mark the backing store.
+ Handle<JSObject> obj =
+ v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
+ Handle<JSWeakCollection> weak_map(reinterpret_cast<JSWeakCollection*>(*obj));
+ while (!Marking::IsBlack(
+ Marking::MarkBitFrom(HeapObject::cast(weak_map->table()))) &&
+ !marking->IsStopped()) {
+ marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
+ }
+ // Stash the backing store in a handle.
+ Handle<Object> save(weak_map->table(), isolate);
+ // The following line will update the backing store.
+ CompileRun(
+ "for (var i = 0; i < 50; i++) {"
+ " weak_map.set(future_keys[i], i);"
+ "}");
+ heap->incremental_marking()->set_should_hurry(true);
+ heap->CollectGarbage(OLD_POINTER_SPACE);
+}
+
+
#ifdef DEBUG
TEST(PathTracer) {
CcTest::InitializeVM();
void Join() {
semaphore_.Wait();
+ thread_.Join();
}
virtual void Run() = 0;
static void CFuncDoTrace(byte dummy_parameter) {
Address fp;
-#ifdef __GNUC__
+#if V8_HAS_BUILTIN_FRAME_ADDRESS
fp = reinterpret_cast<Address>(__builtin_frame_address(0));
-#elif defined _MSC_VER
+#elif V8_CC_MSVC
// Approximate a frame pointer address. We compile without base pointers,
// so we can't trust ebp/rbp.
fp = &dummy_parameter - 2 * sizeof(void*); // NOLINT
}
+TEST(DeliveryCallbackThrows) {
+ HandleScope scope(CcTest::isolate());
+ LocalContext context(CcTest::isolate());
+ CompileRun(
+ "var obj = {};"
+ "var ordering = [];"
+ "function observer1() { ordering.push(1); };"
+ "function observer2() { ordering.push(2); };"
+ "function observer_throws() {"
+ " ordering.push(0);"
+ " throw new Error();"
+ " ordering.push(-1);"
+ "};"
+ "Object.observe(obj, observer_throws.bind());"
+ "Object.observe(obj, observer1);"
+ "Object.observe(obj, observer_throws.bind());"
+ "Object.observe(obj, observer2);"
+ "Object.observe(obj, observer_throws.bind());"
+ "obj.foo = 'bar';");
+ CHECK_EQ(5, CompileRun("ordering.length")->Int32Value());
+ CHECK_EQ(0, CompileRun("ordering[0]")->Int32Value());
+ CHECK_EQ(1, CompileRun("ordering[1]")->Int32Value());
+ CHECK_EQ(0, CompileRun("ordering[2]")->Int32Value());
+ CHECK_EQ(2, CompileRun("ordering[3]")->Int32Value());
+ CHECK_EQ(0, CompileRun("ordering[4]")->Int32Value());
+}
+
+
+TEST(DeliveryChangesMutationInCallback) {
+ HandleScope scope(CcTest::isolate());
+ LocalContext context(CcTest::isolate());
+ CompileRun(
+ "var obj = {};"
+ "var ordering = [];"
+ "function observer1(records) {"
+ " ordering.push(100 + records.length);"
+ " records.push(11);"
+ " records.push(22);"
+ "};"
+ "function observer2(records) {"
+ " ordering.push(200 + records.length);"
+ " records.push(33);"
+ " records.push(44);"
+ "};"
+ "Object.observe(obj, observer1);"
+ "Object.observe(obj, observer2);"
+ "obj.foo = 'bar';");
+ CHECK_EQ(2, CompileRun("ordering.length")->Int32Value());
+ CHECK_EQ(101, CompileRun("ordering[0]")->Int32Value());
+ CHECK_EQ(201, CompileRun("ordering[1]")->Int32Value());
+}
+
+
TEST(DeliveryOrderingReentrant) {
HandleScope scope(CcTest::isolate());
LocalContext context(CcTest::isolate());
+++ /dev/null
-// 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 <string.h>
-#include <limits>
-
-#include "include/v8stdint.h"
-#include "src/ostreams.h"
-#include "test/cctest/cctest.h"
-
-using namespace v8::internal;
-
-
-TEST(OStringStreamConstructor) {
- OStringStream oss;
- const size_t expected_size = 0;
- CHECK(expected_size == oss.size());
- CHECK_GT(oss.capacity(), 0);
- CHECK_NE(NULL, oss.data());
- CHECK_EQ("", oss.c_str());
-}
-
-
-#define TEST_STRING \
- "Ash nazg durbatuluk, " \
- "ash nazg gimbatul, " \
- "ash nazg thrakatuluk, " \
- "agh burzum-ishi krimpatul."
-
-TEST(OStringStreamGrow) {
- OStringStream oss;
- const int repeat = 30;
- size_t len = strlen(TEST_STRING);
- for (int i = 0; i < repeat; ++i) {
- oss.write(TEST_STRING, len);
- }
- const char* expected =
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING
- TEST_STRING TEST_STRING TEST_STRING TEST_STRING TEST_STRING;
- const size_t expected_len = len * repeat;
- CHECK(expected_len == oss.size());
- CHECK_GT(oss.capacity(), 0);
- CHECK_EQ(0, strncmp(expected, oss.data(), expected_len));
- CHECK_EQ(expected, oss.c_str());
-}
-
-
-template <class T>
-static void check(const char* expected, T value) {
- OStringStream oss;
- oss << value << " " << hex << value;
- CHECK_EQ(expected, oss.c_str());
-}
-
-
-TEST(NumericFormatting) {
- check<bool>("0 0", false);
- check<bool>("1 1", true);
-
- check<int16_t>("-12345 cfc7", -12345);
- check<int16_t>("-32768 8000", std::numeric_limits<int16_t>::min());
- check<int16_t>("32767 7fff", std::numeric_limits<int16_t>::max());
-
- check<uint16_t>("34567 8707", 34567);
- check<uint16_t>("0 0", std::numeric_limits<uint16_t>::min());
- check<uint16_t>("65535 ffff", std::numeric_limits<uint16_t>::max());
-
- check<int32_t>("-1234567 ffed2979", -1234567);
- check<int32_t>("-2147483648 80000000", std::numeric_limits<int32_t>::min());
- check<int32_t>("2147483647 7fffffff", std::numeric_limits<int32_t>::max());
-
- check<uint32_t>("3456789 34bf15", 3456789);
- check<uint32_t>("0 0", std::numeric_limits<uint32_t>::min());
- check<uint32_t>("4294967295 ffffffff", std::numeric_limits<uint32_t>::max());
-
- check<int64_t>("-1234567 ffffffffffed2979", -1234567);
- check<int64_t>("-9223372036854775808 8000000000000000",
- std::numeric_limits<int64_t>::min());
- check<int64_t>("9223372036854775807 7fffffffffffffff",
- std::numeric_limits<int64_t>::max());
-
- check<uint64_t>("3456789 34bf15", 3456789);
- check<uint64_t>("0 0", std::numeric_limits<uint64_t>::min());
- check<uint64_t>("18446744073709551615 ffffffffffffffff",
- std::numeric_limits<uint64_t>::max());
-
- check<float>("0 0", 0.0f);
- check<float>("123 123", 123.0f);
- check<float>("-0.5 -0.5", -0.5f);
- check<float>("1.25 1.25", 1.25f);
- check<float>("0.0625 0.0625", 6.25e-2f);
-
- check<double>("0 0", 0.0);
- check<double>("123 123", 123.0);
- check<double>("-0.5 -0.5", -0.5);
- check<double>("1.25 1.25", 1.25);
- check<double>("0.0625 0.0625", 6.25e-2);
-}
-
-
-TEST(CharacterOutput) {
- check<char>("a a", 'a');
- check<signed char>("B B", 'B');
- check<unsigned char>("9 9", '9');
- check<const char*>("bye bye", "bye");
-
- OStringStream os;
- os.put('H').write("ello", 4);
- CHECK_EQ("Hello", os.c_str());
-}
-
-
-TEST(Manipulators) {
- OStringStream os;
- os << 123 << hex << 123 << endl << 123 << dec << 123 << 123;
- CHECK_EQ("1237b\n7b123123", os.c_str());
-}
-
-
-class MiscStuff {
- public:
- MiscStuff(int i, double d, const char* s) : i_(i), d_(d), s_(s) { }
-
- private:
- friend OStream& operator<<(OStream& os, const MiscStuff& m);
-
- int i_;
- double d_;
- const char* s_;
-};
-
-
-OStream& operator<<(OStream& os, const MiscStuff& m) {
- return os << "{i:" << m.i_ << ", d:" << m.d_ << ", s:'" << m.s_ << "'}";
-}
-
-
-TEST(CustomOutput) {
- OStringStream os;
- MiscStuff m(123, 4.5, "Hurz!");
- os << m;
- CHECK_EQ("{i:123, d:4.5, s:'Hurz!'}", os.c_str());
-}
#include "src/v8.h"
+#include "src/ast.h"
+#include "src/ast-numbering.h"
#include "src/ast-value-factory.h"
#include "src/compiler.h"
#include "src/execution.h"
}
+TEST(ScopeUsesThisAndArguments) {
+ static const struct {
+ const char* prefix;
+ const char* suffix;
+ } surroundings[] = {
+ { "function f() {", "}" },
+ { "var f = () => {", "}" },
+ };
+
+ static const struct {
+ const char* body;
+ bool uses_this;
+ bool uses_arguments;
+ bool inner_uses_this;
+ bool inner_uses_arguments;
+ } source_data[] = {
+ { "",
+ false, false, false, false },
+ { "return this",
+ true, false, false, false },
+ { "return arguments",
+ false, true, false, false },
+ { "return arguments[0]",
+ false, true, false, false },
+ { "return this + arguments[0]",
+ true, true, false, false },
+ { "return x => this + x",
+ false, false, true, false },
+ { "this.foo = 42;",
+ true, false, false, false },
+ { "this.foo();",
+ true, false, false, false },
+ { "if (foo()) { this.f() }",
+ true, false, false, false },
+ { "if (arguments.length) { this.f() }",
+ true, true, false, false },
+ { "while (true) { this.f() }",
+ true, false, false, false },
+ { "if (true) { while (true) this.foo(arguments) }",
+ true, true, false, false },
+ // Multiple nesting levels must work as well.
+ { "while (true) { while (true) { while (true) return this } }",
+ true, false, false, false },
+ { "if (1) { return () => { while (true) new this() } }",
+ false, false, true, false },
+ // Note that propagation of the inner_uses_this() value does not
+ // cross boundaries of normal functions onto parent scopes.
+ { "return function (x) { return this + x }",
+ false, false, false, false },
+ { "var x = function () { this.foo = 42 };",
+ false, false, false, false },
+ { "if (1) { return function () { while (true) new this() } }",
+ false, false, false, false },
+ { "return function (x) { return () => this }",
+ false, false, false, false },
+ // Flags must be correctly set when using block scoping.
+ { "\"use strict\"; while (true) { let x; this, arguments; }",
+ false, false, true, true },
+ { "\"use strict\"; if (foo()) { let x; this.f() }",
+ false, false, true, false },
+ { "\"use strict\"; if (1) {"
+ " let x; return function () { return this + arguments }"
+ "}",
+ false, false, false, false },
+ };
+
+ i::Isolate* isolate = CcTest::i_isolate();
+ i::Factory* factory = isolate->factory();
+
+ v8::HandleScope handles(CcTest::isolate());
+ v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
+ v8::Context::Scope context_scope(context);
+
+ isolate->stack_guard()->SetStackLimit(i::GetCurrentStackPosition() -
+ 128 * 1024);
+
+ for (unsigned j = 0; j < arraysize(surroundings); ++j) {
+ for (unsigned i = 0; i < arraysize(source_data); ++i) {
+ int kProgramByteSize = i::StrLength(surroundings[j].prefix) +
+ i::StrLength(surroundings[j].suffix) +
+ i::StrLength(source_data[i].body);
+ i::ScopedVector<char> program(kProgramByteSize + 1);
+ i::SNPrintF(program, "%s%s%s", surroundings[j].prefix,
+ source_data[i].body, surroundings[j].suffix);
+ i::Handle<i::String> source =
+ factory->NewStringFromUtf8(i::CStrVector(program.start()))
+ .ToHandleChecked();
+ i::Handle<i::Script> script = factory->NewScript(source);
+ i::CompilationInfoWithZone info(script);
+ i::Parser::ParseInfo parse_info = {isolate->stack_guard()->real_climit(),
+ isolate->heap()->HashSeed(),
+ isolate->unicode_cache()};
+ i::Parser parser(&info, &parse_info);
+ parser.set_allow_arrow_functions(true);
+ parser.set_allow_harmony_scoping(true);
+ info.MarkAsGlobal();
+ parser.Parse();
+ CHECK(i::Rewriter::Rewrite(&info));
+ CHECK(i::Scope::Analyze(&info));
+ CHECK(info.function() != NULL);
+
+ i::Scope* global_scope = info.function()->scope();
+ CHECK(global_scope->is_global_scope());
+ CHECK_EQ(1, global_scope->inner_scopes()->length());
+
+ i::Scope* scope = global_scope->inner_scopes()->at(0);
+ CHECK_EQ(source_data[i].uses_this, scope->uses_this());
+ CHECK_EQ(source_data[i].uses_arguments, scope->uses_arguments());
+ CHECK_EQ(source_data[i].inner_uses_this, scope->inner_uses_this());
+ CHECK_EQ(source_data[i].inner_uses_arguments,
+ scope->inner_uses_arguments());
+ }
+ }
+}
+
+
TEST(ScopePositions) {
v8::internal::FLAG_harmony_scoping = true;
" infunction;\n"
" }", "\n"
" more;", i::FUNCTION_SCOPE, i::SLOPPY },
- // TODO(aperez): Change to use i::ARROW_SCOPE when implemented
{ " start;\n", "(a,b) => a + b", "; more;",
- i::FUNCTION_SCOPE, i::SLOPPY },
+ i::ARROW_SCOPE, i::SLOPPY },
{ " start;\n", "(a,b) => { return a+b; }", "\nmore;",
- i::FUNCTION_SCOPE, i::SLOPPY },
+ i::ARROW_SCOPE, i::SLOPPY },
{ " start;\n"
" (function fun", "(a,b) { infunction; }", ")();",
i::FUNCTION_SCOPE, i::SLOPPY },
}
+#define FUTURE_STRICT_RESERVED_WORDS(V) \
+ V(implements) \
+ V(interface) \
+ V(let) \
+ V(package) \
+ V(private) \
+ V(protected) \
+ V(public) \
+ V(static) \
+ V(yield)
+
+
+#define FUTURE_STRICT_RESERVED_STATEMENTS(NAME) \
+ "var " #NAME ";", \
+ "var foo, " #NAME ";", \
+ "try { } catch (" #NAME ") { }", \
+ "function " #NAME "() { }", \
+ "(function " #NAME "() { })", \
+ "function foo(" #NAME ") { }", \
+ "function foo(bar, " #NAME ") { }", \
+ #NAME " = 1;", \
+ #NAME " += 1;", \
+ "var foo = " #NAME " = 1;", \
+ "++" #NAME ";", \
+ #NAME " ++;",
+
+
TEST(ErrorsFutureStrictReservedWords) {
// Tests that both preparsing and parsing produce the right kind of errors for
// using future strict reserved words as identifiers. Without the strict mode,
{ NULL, NULL }
};
- const char* statement_data[] = {
- "var interface;",
- "var foo, interface;",
- "try { } catch (interface) { }",
- "function interface() { }",
- "function foo(interface) { }",
- "function foo(bar, interface) { }",
- "interface = 1;",
- "var foo = interface = 1;",
- "++interface;",
- "interface++;",
- "var yield = 13;",
+ const char* statement_data[] {
+ FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
NULL
};
static const ParserFlag always_flags[] = {kAllowArrowFunctions};
RunParserSyncTest(context_data, statement_data, kError, NULL, 0, always_flags,
arraysize(always_flags));
+
+ static const ParserFlag classes_flags[] = {
+ kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, statement_data, kError, NULL, 0,
+ classes_flags, arraysize(classes_flags));
}
};
const char* statement_data[] = {
- "var interface;",
- "var foo, interface;",
- "try { } catch (interface) { }",
- "function interface() { }",
- "function foo(interface) { }",
- "function foo(bar, interface) { }",
- "interface = 1;",
- "var foo = interface = 1;",
- "++interface;",
- "interface++;",
- "var yield = 13;",
+ FUTURE_STRICT_RESERVED_WORDS(FUTURE_STRICT_RESERVED_STATEMENTS)
NULL
};
static const ParserFlag always_flags[] = {kAllowArrowFunctions};
RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
always_flags, arraysize(always_flags));
+
+ static const ParserFlag classes_flags[] = {
+ kAllowArrowFunctions, kAllowClasses, kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+ classes_flags, arraysize(classes_flags));
}
{ NULL, NULL }
};
+#define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
const char* statement_data[] = {
"super: while(true) { break super; }",
- "interface: while(true) { break interface; }",
- "yield: while(true) { break yield; }",
+ FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
NULL
};
+#undef LABELLED_WHILE
RunParserSyncTest(context_data, statement_data, kError);
}
}
+TEST(NoErrorsFutureStrictReservedAsLabelsSloppy) {
+ const char* context_data[][2] = {
+ { "", ""},
+ { "function test_func() {", "}" },
+ { "() => {", "}" },
+ { NULL, NULL }
+ };
+
+#define LABELLED_WHILE(NAME) #NAME ": while (true) { break " #NAME "; }",
+ const char* statement_data[] {
+ FUTURE_STRICT_RESERVED_WORDS(LABELLED_WHILE)
+ NULL
+ };
+#undef LABELLED_WHILE
+
+ static const ParserFlag always_flags[] = {kAllowArrowFunctions};
+ RunParserSyncTest(context_data, statement_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
TEST(ErrorsParenthesizedLabels) {
// Parenthesized identifiers shouldn't be recognized as labels.
const char* context_data[][2] = {
i::Parser parser(&info, &parse_info);
parser.set_allow_harmony_scoping(true);
CHECK(parser.Parse());
- CHECK(i::Rewriter::Rewrite(&info));
- CHECK(i::Scope::Analyze(&info));
+ CHECK(i::Compiler::Analyze(&info));
CHECK(info.function() != NULL);
i::Scope* scope = info.function()->scope();
"static get prototype() {}",
"static set prototype(_) {}",
"static *prototype() {}",
+ "static 'prototype'() {}",
+ "static *'prototype'() {}",
+ "static prot\\u006ftype() {}",
+ "static 'prot\\u006ftype'() {}",
+ "static get 'prot\\u006ftype'() {}",
+ "static set 'prot\\u006ftype'(_) {}",
+ "static *'prot\\u006ftype'() {}",
NULL};
static const ParserFlag always_flags[] = {
"get constructor() {}",
"get constructor(_) {}",
"*constructor() {}",
+ "get 'constructor'() {}",
+ "*'constructor'() {}",
+ "get c\\u006fnstructor() {}",
+ "*c\\u006fnstructor() {}",
+ "get 'c\\u006fnstructor'() {}",
+ "get 'c\\u006fnstructor'(_) {}",
+ "*'c\\u006fnstructor'() {}",
NULL};
static const ParserFlag always_flags[] = {
TEST(ClassMultipleConstructorErrors) {
- // We currently do not allow any duplicate properties in class bodies. This
- // test ensures that when we change that we still throw on duplicate
- // constructors.
const char* context_data[][2] = {{"class C {", "}"},
{"(class {", "});"},
{NULL, NULL}};
}
-// TODO(arv): We should allow duplicate property names.
-// https://code.google.com/p/v8/issues/detail?id=3570
-DISABLED_TEST(ClassMultiplePropertyNamesNoErrors) {
+TEST(ClassMultiplePropertyNamesNoErrors) {
const char* context_data[][2] = {{"class C {", "}"},
{"(class {", "});"},
{NULL, NULL}};
"constructor() {}; static constructor() {}",
"m() {}; static m() {}",
"m() {}; m() {}",
+ "static m() {}; static m() {}",
+ "get m() {}; set m(_) {}; get m() {}; set m(_) {};",
NULL};
static const ParserFlag always_flags[] = {
RunParserSyncTest(context_data, class_body_data, kError, NULL, 0,
always_flags, arraysize(always_flags));
}
+
+
+TEST(ObjectLiteralPropertyShorthandKeywordsError) {
+ const char* context_data[][2] = {{"({", "});"},
+ {"'use strict'; ({", "});"},
+ {NULL, NULL}};
+
+ const char* name_data[] = {
+ "break",
+ "case",
+ "catch",
+ "class",
+ "const",
+ "continue",
+ "debugger",
+ "default",
+ "delete",
+ "do",
+ "else",
+ "enum",
+ "export",
+ "extends",
+ "false",
+ "finally",
+ "for",
+ "function",
+ "if",
+ "import",
+ "in",
+ "instanceof",
+ "new",
+ "null",
+ "return",
+ "super",
+ "switch",
+ "this",
+ "throw",
+ "true",
+ "try",
+ "typeof",
+ "var",
+ "void",
+ "while",
+ "with",
+ NULL
+ };
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
+ RunParserSyncTest(context_data, name_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
+TEST(ObjectLiteralPropertyShorthandStrictKeywords) {
+ const char* context_data[][2] = {{"({", "});"},
+ {NULL, NULL}};
+
+ const char* name_data[] = {
+ "implements",
+ "interface",
+ "let",
+ "package",
+ "private",
+ "protected",
+ "public",
+ "static",
+ "yield",
+ NULL
+ };
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
+ RunParserSyncTest(context_data, name_data, kSuccess, NULL, 0,
+ always_flags, arraysize(always_flags));
+
+ const char* context_strict_data[][2] = {{"'use strict'; ({", "});"},
+ {NULL, NULL}};
+ RunParserSyncTest(context_strict_data, name_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
+TEST(ObjectLiteralPropertyShorthandError) {
+ const char* context_data[][2] = {{"({", "});"},
+ {"'use strict'; ({", "});"},
+ {NULL, NULL}};
+
+ const char* name_data[] = {
+ "1",
+ "1.2",
+ "0",
+ "0.1",
+ "1.0",
+ "1e1",
+ "0x1",
+ "\"s\"",
+ "'s'",
+ NULL
+ };
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
+ RunParserSyncTest(context_data, name_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
+TEST(ObjectLiteralPropertyShorthandYieldInGeneratorError) {
+ const char* context_data[][2] = {{"", ""},
+ {NULL, NULL}};
+
+ const char* name_data[] = {
+ "function* g() { ({yield}); }",
+ NULL
+ };
+
+ static const ParserFlag always_flags[] = {kAllowHarmonyObjectLiterals};
+ RunParserSyncTest(context_data, name_data, kError, NULL, 0,
+ always_flags, arraysize(always_flags));
+}
+
+
+TEST(ConstParsingInForIn) {
+ const char* context_data[][2] = {{"'use strict';", ""},
+ {"function foo(){ 'use strict';", "}"},
+ {NULL, NULL}};
+
+ const char* data[] = {
+ "for(const x = 1; ; ) {}",
+ "for(const x = 1, y = 2;;){}",
+ "for(const x in [1,2,3]) {}",
+ "for(const x of [1,2,3]) {}",
+ NULL};
+ static const ParserFlag always_flags[] = {kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, data, kSuccess, NULL, 0, always_flags,
+ arraysize(always_flags));
+}
+
+
+TEST(ConstParsingInForInError) {
+ const char* context_data[][2] = {{"'use strict';", ""},
+ {"function foo(){ 'use strict';", "}"},
+ {NULL, NULL}};
+
+ const char* data[] = {
+ "for(const x,y = 1; ; ) {}",
+ "for(const x = 4 in [1,2,3]) {}",
+ "for(const x = 4, y in [1,2,3]) {}",
+ "for(const x = 4 of [1,2,3]) {}",
+ "for(const x = 4, y of [1,2,3]) {}",
+ "for(const x = 1, y = 2 in []) {}",
+ "for(const x,y in []) {}",
+ "for(const x = 1, y = 2 of []) {}",
+ "for(const x,y of []) {}",
+ NULL};
+ static const ParserFlag always_flags[] = {kAllowHarmonyScoping};
+ RunParserSyncTest(context_data, data, kError, NULL, 0, always_flags,
+ arraysize(always_flags));
+}
+
+
+TEST(InvalidUnicodeEscapes) {
+ const char* context_data[][2] = {{"", ""},
+ {"'use strict';", ""},
+ {NULL, NULL}};
+ const char* data[] = {
+ "var foob\\u123r = 0;",
+ "var \\u123roo = 0;",
+ "\"foob\\u123rr\"",
+ "/regex/g\\u123r",
+ NULL};
+ RunParserSyncTest(context_data, data, kError);
+}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/build_config.h"
#include "src/base/platform/platform.h"
#include "test/cctest/cctest.h"
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <stdlib.h>
+#include <cstdlib>
+#include <sstream>
#include "src/v8.h"
&reader, false, &result, &zone));
CHECK(result.tree != NULL);
CHECK(result.error.is_null());
- OStringStream os;
+ std::ostringstream os;
result.tree->Print(os, &zone);
- CHECK_EQ(expected, os.c_str());
+ CHECK_EQ(expected, os.str().c_str());
}
// Check that we don't allow more than kMaxCapture captures
const int kMaxCaptures = 1 << 16; // Must match RegExpParser::kMaxCaptures.
const char* kTooManyCaptures = "Too many captures";
- OStringStream os;
+ std::ostringstream os;
for (int i = 0; i <= kMaxCaptures; i++) {
os << "()";
}
- ExpectError(os.c_str(), kTooManyCaptures);
+ ExpectError(os.str().c_str(), kTooManyCaptures);
}
--- /dev/null
+// 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.
+//
+// Tests the sampling API in include/v8.h
+
+#include <map>
+#include <string>
+#include "include/v8.h"
+#include "src/simulator.h"
+#include "test/cctest/cctest.h"
+
+namespace {
+
+class Sample {
+ public:
+ enum { kFramesLimit = 255 };
+
+ Sample() {}
+
+ typedef const void* const* const_iterator;
+ const_iterator begin() const { return data_.start(); }
+ const_iterator end() const { return &data_[data_.length()]; }
+
+ int size() const { return data_.length(); }
+ v8::internal::Vector<void*>& data() { return data_; }
+
+ private:
+ v8::internal::EmbeddedVector<void*, kFramesLimit> data_;
+};
+
+
+#if defined(USE_SIMULATOR)
+class SimulatorHelper {
+ public:
+ inline bool Init(v8::Isolate* isolate) {
+ simulator_ = reinterpret_cast<v8::internal::Isolate*>(isolate)
+ ->thread_local_top()
+ ->simulator_;
+ // Check if there is active simulator.
+ return simulator_ != NULL;
+ }
+
+ inline void FillRegisters(v8::RegisterState* state) {
+#if V8_TARGET_ARCH_ARM
+ state->pc = reinterpret_cast<void*>(simulator_->get_pc());
+ state->sp = reinterpret_cast<void*>(
+ simulator_->get_register(v8::internal::Simulator::sp));
+ state->fp = reinterpret_cast<void*>(
+ simulator_->get_register(v8::internal::Simulator::r11));
+#elif V8_TARGET_ARCH_ARM64
+ if (simulator_->sp() == 0 || simulator_->fp() == 0) {
+ // It's possible that the simulator is interrupted while it is updating
+ // the sp or fp register. ARM64 simulator does this in two steps:
+ // first setting it to zero and then setting it to a new value.
+ // Bailout if sp/fp doesn't contain the new value.
+ return;
+ }
+ state->pc = reinterpret_cast<void*>(simulator_->pc());
+ state->sp = reinterpret_cast<void*>(simulator_->sp());
+ state->fp = reinterpret_cast<void*>(simulator_->fp());
+#elif V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64
+ state->pc = reinterpret_cast<void*>(simulator_->get_pc());
+ state->sp = reinterpret_cast<void*>(
+ simulator_->get_register(v8::internal::Simulator::sp));
+ state->fp = reinterpret_cast<void*>(
+ simulator_->get_register(v8::internal::Simulator::fp));
+#endif
+ }
+
+ private:
+ v8::internal::Simulator* simulator_;
+};
+#endif // USE_SIMULATOR
+
+
+class SamplingTestHelper {
+ public:
+ struct CodeEventEntry {
+ std::string name;
+ const void* code_start;
+ size_t code_len;
+ };
+ typedef std::map<const void*, CodeEventEntry> CodeEntries;
+
+ explicit SamplingTestHelper(const std::string& test_function)
+ : sample_is_taken_(false), isolate_(CcTest::isolate()) {
+ DCHECK_EQ(NULL, instance_);
+ instance_ = this;
+ v8::HandleScope scope(isolate_);
+ v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
+ global->Set(v8::String::NewFromUtf8(isolate_, "CollectSample"),
+ v8::FunctionTemplate::New(isolate_, CollectSample));
+ LocalContext env(isolate_, NULL, global);
+ isolate_->SetJitCodeEventHandler(v8::kJitCodeEventDefault,
+ JitCodeEventHandler);
+ v8::Script::Compile(
+ v8::String::NewFromUtf8(isolate_, test_function.c_str()))->Run();
+ }
+
+ ~SamplingTestHelper() {
+ isolate_->SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL);
+ instance_ = NULL;
+ }
+
+ Sample& sample() { return sample_; }
+
+ const CodeEventEntry* FindEventEntry(const void* address) {
+ CodeEntries::const_iterator it = code_entries_.upper_bound(address);
+ if (it == code_entries_.begin()) return NULL;
+ const CodeEventEntry& entry = (--it)->second;
+ const void* code_end =
+ static_cast<const uint8_t*>(entry.code_start) + entry.code_len;
+ return address < code_end ? &entry : NULL;
+ }
+
+ private:
+ static void CollectSample(const v8::FunctionCallbackInfo<v8::Value>& args) {
+ instance_->DoCollectSample();
+ }
+
+ static void JitCodeEventHandler(const v8::JitCodeEvent* event) {
+ instance_->DoJitCodeEventHandler(event);
+ }
+
+ // The JavaScript calls this function when on full stack depth.
+ void DoCollectSample() {
+ v8::RegisterState state;
+#if defined(USE_SIMULATOR)
+ SimulatorHelper simulator_helper;
+ if (!simulator_helper.Init(isolate_)) return;
+ simulator_helper.FillRegisters(&state);
+#else
+ state.pc = NULL;
+ state.fp = &state;
+ state.sp = &state;
+#endif
+ v8::SampleInfo info;
+ isolate_->GetStackSample(state, sample_.data().start(),
+ static_cast<size_t>(sample_.size()), &info);
+ size_t frames_count = info.frames_count;
+ CHECK_LE(frames_count, static_cast<size_t>(sample_.size()));
+ sample_.data().Truncate(static_cast<int>(frames_count));
+ sample_is_taken_ = true;
+ }
+
+ void DoJitCodeEventHandler(const v8::JitCodeEvent* event) {
+ if (sample_is_taken_) return;
+ switch (event->type) {
+ case v8::JitCodeEvent::CODE_ADDED: {
+ CodeEventEntry entry;
+ entry.name = std::string(event->name.str, event->name.len);
+ entry.code_start = event->code_start;
+ entry.code_len = event->code_len;
+ code_entries_.insert(std::make_pair(entry.code_start, entry));
+ break;
+ }
+ case v8::JitCodeEvent::CODE_MOVED: {
+ CodeEntries::iterator it = code_entries_.find(event->code_start);
+ CHECK(it != code_entries_.end());
+ code_entries_.erase(it);
+ CodeEventEntry entry;
+ entry.name = std::string(event->name.str, event->name.len);
+ entry.code_start = event->new_code_start;
+ entry.code_len = event->code_len;
+ code_entries_.insert(std::make_pair(entry.code_start, entry));
+ break;
+ }
+ case v8::JitCodeEvent::CODE_REMOVED:
+ code_entries_.erase(event->code_start);
+ break;
+ default:
+ break;
+ }
+ }
+
+ Sample sample_;
+ bool sample_is_taken_;
+ v8::Isolate* isolate_;
+ CodeEntries code_entries_;
+
+ static SamplingTestHelper* instance_;
+};
+
+SamplingTestHelper* SamplingTestHelper::instance_;
+
+} // namespace
+
+
+// A JavaScript function which takes stack depth
+// (minimum value 2) as an argument.
+// When at the bottom of the recursion,
+// the JavaScript code calls into C++ test code,
+// waiting for the sampler to take a sample.
+static const char* test_function =
+ "function func(depth) {"
+ " if (depth == 2) CollectSample();"
+ " else return func(depth - 1);"
+ "}";
+
+
+TEST(StackDepthIsConsistent) {
+ SamplingTestHelper helper(std::string(test_function) + "func(8);");
+ CHECK_EQ(8, helper.sample().size());
+}
+
+
+TEST(StackDepthDoesNotExceedMaxValue) {
+ SamplingTestHelper helper(std::string(test_function) + "func(300);");
+ CHECK_EQ(Sample::kFramesLimit, helper.sample().size());
+}
+
+
+// The captured sample should have three pc values.
+// They should fall in the range where the compiled code resides.
+// The expected stack is:
+// bottom of stack [{anon script}, outer, inner] top of stack
+// ^ ^ ^
+// sample.stack indices 2 1 0
+TEST(StackFramesConsistent) {
+ // Note: The arguments.callee stuff is there so that the
+ // functions are not optimized away.
+ const char* test_script =
+ "function test_sampler_api_inner() {"
+ " CollectSample();"
+ " return arguments.callee.toString();"
+ "}"
+ "function test_sampler_api_outer() {"
+ " return test_sampler_api_inner() + arguments.callee.toString();"
+ "}"
+ "test_sampler_api_outer();";
+
+ SamplingTestHelper helper(test_script);
+ Sample& sample = helper.sample();
+ CHECK_EQ(3, sample.size());
+
+ const SamplingTestHelper::CodeEventEntry* entry;
+ entry = helper.FindEventEntry(sample.begin()[0]);
+ CHECK_NE(NULL, entry);
+ CHECK(std::string::npos != entry->name.find("test_sampler_api_inner"));
+
+ entry = helper.FindEventEntry(sample.begin()[1]);
+ CHECK_NE(NULL, entry);
+ CHECK(std::string::npos != entry->name.find("test_sampler_api_outer"));
+}
}
-class FileByteSink : public SnapshotByteSink {
- public:
- explicit FileByteSink(const char* snapshot_file) {
- fp_ = v8::base::OS::FOpen(snapshot_file, "wb");
- file_name_ = snapshot_file;
- if (fp_ == NULL) {
- PrintF("Unable to write to snapshot file \"%s\"\n", snapshot_file);
- exit(1);
- }
- }
- virtual ~FileByteSink() {
- if (fp_ != NULL) {
- fclose(fp_);
- }
+void WritePayload(const List<byte>& payload, const char* file_name) {
+ FILE* file = v8::base::OS::FOpen(file_name, "wb");
+ if (file == NULL) {
+ PrintF("Unable to write to snapshot file \"%s\"\n", file_name);
+ exit(1);
}
- virtual void Put(byte b, const char* description) {
- if (fp_ != NULL) {
- fputc(b, fp_);
- }
- }
- virtual int Position() {
- return ftell(fp_);
+ size_t written = fwrite(payload.begin(), 1, payload.length(), file);
+ if (written != static_cast<size_t>(payload.length())) {
+ i::PrintF("Writing snapshot file failed.. Aborting.\n");
+ exit(1);
}
- void WriteSpaceUsed(int new_space_used, int pointer_space_used,
- int data_space_used, int code_space_used,
- int map_space_used, int cell_space_used,
- int property_cell_space_used, int lo_space_used);
-
- private:
- FILE* fp_;
- const char* file_name_;
-};
+ fclose(file);
+}
-void FileByteSink::WriteSpaceUsed(int new_space_used, int pointer_space_used,
- int data_space_used, int code_space_used,
- int map_space_used, int cell_space_used,
- int property_cell_space_used,
- int lo_space_used) {
- int file_name_length = StrLength(file_name_) + 10;
+void WriteSpaceUsed(Serializer* ser, const char* file_name) {
+ int file_name_length = StrLength(file_name) + 10;
Vector<char> name = Vector<char>::New(file_name_length + 1);
- SNPrintF(name, "%s.size", file_name_);
+ SNPrintF(name, "%s.size", file_name);
FILE* fp = v8::base::OS::FOpen(name.start(), "w");
name.Dispose();
- fprintf(fp, "new %d\n", new_space_used);
- fprintf(fp, "pointer %d\n", pointer_space_used);
- fprintf(fp, "data %d\n", data_space_used);
- fprintf(fp, "code %d\n", code_space_used);
- fprintf(fp, "map %d\n", map_space_used);
- fprintf(fp, "cell %d\n", cell_space_used);
- fprintf(fp, "property cell %d\n", property_cell_space_used);
- fprintf(fp, "lo %d\n", lo_space_used);
+
+ Vector<const uint32_t> chunks = ser->FinalAllocationChunks(NEW_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "new %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(OLD_POINTER_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "pointer %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(OLD_DATA_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "data %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(CODE_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "code %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(MAP_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "map %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(CELL_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "cell %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(PROPERTY_CELL_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "property cell %d\n", chunks[0]);
+ chunks = ser->FinalAllocationChunks(LO_SPACE);
+ CHECK_EQ(1, chunks.length());
+ fprintf(fp, "lo %d\n", chunks[0]);
fclose(fp);
}
static bool WriteToFile(Isolate* isolate, const char* snapshot_file) {
- FileByteSink file(snapshot_file);
- StartupSerializer ser(isolate, &file);
+ SnapshotByteSink sink;
+ StartupSerializer ser(isolate, &sink);
ser.Serialize();
+ ser.FinalizeAllocation();
- file.WriteSpaceUsed(ser.CurrentAllocationAddress(NEW_SPACE),
- ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
- ser.CurrentAllocationAddress(OLD_DATA_SPACE),
- ser.CurrentAllocationAddress(CODE_SPACE),
- ser.CurrentAllocationAddress(MAP_SPACE),
- ser.CurrentAllocationAddress(CELL_SPACE),
- ser.CurrentAllocationAddress(PROPERTY_CELL_SPACE),
- ser.CurrentAllocationAddress(LO_SPACE));
+ WritePayload(sink.data(), snapshot_file);
+ WriteSpaceUsed(&ser, snapshot_file);
return true;
}
}
Isolate* internal_isolate = reinterpret_cast<Isolate*>(isolate);
- internal_isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags, "serialize");
+ internal_isolate->heap()->CollectAllAvailableGarbage("serialize");
WriteToFile(internal_isolate, FLAG_testing_serialization_file);
}
name.Dispose();
int new_size, pointer_size, data_size, code_size, map_size, cell_size,
property_cell_size, lo_size;
-#ifdef _MSC_VER
+#if V8_CC_MSVC
// Avoid warning about unsafe fscanf from MSVC.
// Please note that this is only fine if %c and %s are not being used.
#define fscanf fscanf_s
CHECK_EQ(1, fscanf(fp, "cell %d\n", &cell_size));
CHECK_EQ(1, fscanf(fp, "property cell %d\n", &property_cell_size));
CHECK_EQ(1, fscanf(fp, "lo %d\n", &lo_size));
-#ifdef _MSC_VER
+#if V8_CC_MSVC
#undef fscanf
#endif
fclose(fp);
- deserializer->set_reservation(NEW_SPACE, new_size);
- deserializer->set_reservation(OLD_POINTER_SPACE, pointer_size);
- deserializer->set_reservation(OLD_DATA_SPACE, data_size);
- deserializer->set_reservation(CODE_SPACE, code_size);
- deserializer->set_reservation(MAP_SPACE, map_size);
- deserializer->set_reservation(CELL_SPACE, cell_size);
- deserializer->set_reservation(PROPERTY_CELL_SPACE, property_cell_size);
- deserializer->set_reservation(LO_SPACE, lo_size);
+ deserializer->AddReservation(NEW_SPACE, new_size);
+ deserializer->AddReservation(OLD_POINTER_SPACE, pointer_size);
+ deserializer->AddReservation(OLD_DATA_SPACE, data_size);
+ deserializer->AddReservation(CODE_SPACE, code_size);
+ deserializer->AddReservation(MAP_SPACE, map_size);
+ deserializer->AddReservation(CELL_SPACE, cell_size);
+ deserializer->AddReservation(PROPERTY_CELL_SPACE, property_cell_size);
+ deserializer->AddReservation(LO_SPACE, lo_size);
}
}
env.Reset();
- FileByteSink startup_sink(startup_name.start());
+ SnapshotByteSink startup_sink;
StartupSerializer startup_serializer(isolate, &startup_sink);
startup_serializer.SerializeStrongReferences();
- FileByteSink partial_sink(FLAG_testing_serialization_file);
- PartialSerializer p_ser(isolate, &startup_serializer, &partial_sink);
- p_ser.Serialize(&raw_foo);
+ SnapshotByteSink partial_sink;
+ PartialSerializer partial_serializer(isolate, &startup_serializer,
+ &partial_sink);
+ partial_serializer.Serialize(&raw_foo);
+
startup_serializer.SerializeWeakReferences();
- partial_sink.WriteSpaceUsed(
- p_ser.CurrentAllocationAddress(NEW_SPACE),
- p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
- p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
- p_ser.CurrentAllocationAddress(CODE_SPACE),
- p_ser.CurrentAllocationAddress(MAP_SPACE),
- p_ser.CurrentAllocationAddress(CELL_SPACE),
- p_ser.CurrentAllocationAddress(PROPERTY_CELL_SPACE),
- p_ser.CurrentAllocationAddress(LO_SPACE));
-
- startup_sink.WriteSpaceUsed(
- startup_serializer.CurrentAllocationAddress(NEW_SPACE),
- startup_serializer.CurrentAllocationAddress(OLD_POINTER_SPACE),
- startup_serializer.CurrentAllocationAddress(OLD_DATA_SPACE),
- startup_serializer.CurrentAllocationAddress(CODE_SPACE),
- startup_serializer.CurrentAllocationAddress(MAP_SPACE),
- startup_serializer.CurrentAllocationAddress(CELL_SPACE),
- startup_serializer.CurrentAllocationAddress(PROPERTY_CELL_SPACE),
- startup_serializer.CurrentAllocationAddress(LO_SPACE));
+ partial_serializer.FinalizeAllocation();
+ startup_serializer.FinalizeAllocation();
+
+ WritePayload(partial_sink.data(), FLAG_testing_serialization_file);
+ WritePayload(startup_sink.data(), startup_name.start());
+
+ WriteSpaceUsed(&partial_serializer, FLAG_testing_serialization_file);
+ WriteSpaceUsed(&startup_serializer, startup_name.start());
+
startup_name.Dispose();
}
v8_isolate->Exit();
env.Reset();
- FileByteSink startup_sink(startup_name.start());
+ SnapshotByteSink startup_sink;
StartupSerializer startup_serializer(isolate, &startup_sink);
startup_serializer.SerializeStrongReferences();
- FileByteSink partial_sink(FLAG_testing_serialization_file);
- PartialSerializer p_ser(isolate, &startup_serializer, &partial_sink);
- p_ser.Serialize(&raw_context);
+ SnapshotByteSink partial_sink;
+ PartialSerializer partial_serializer(isolate, &startup_serializer,
+ &partial_sink);
+ partial_serializer.Serialize(&raw_context);
startup_serializer.SerializeWeakReferences();
- partial_sink.WriteSpaceUsed(
- p_ser.CurrentAllocationAddress(NEW_SPACE),
- p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
- p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
- p_ser.CurrentAllocationAddress(CODE_SPACE),
- p_ser.CurrentAllocationAddress(MAP_SPACE),
- p_ser.CurrentAllocationAddress(CELL_SPACE),
- p_ser.CurrentAllocationAddress(PROPERTY_CELL_SPACE),
- p_ser.CurrentAllocationAddress(LO_SPACE));
-
- startup_sink.WriteSpaceUsed(
- startup_serializer.CurrentAllocationAddress(NEW_SPACE),
- startup_serializer.CurrentAllocationAddress(OLD_POINTER_SPACE),
- startup_serializer.CurrentAllocationAddress(OLD_DATA_SPACE),
- startup_serializer.CurrentAllocationAddress(CODE_SPACE),
- startup_serializer.CurrentAllocationAddress(MAP_SPACE),
- startup_serializer.CurrentAllocationAddress(CELL_SPACE),
- startup_serializer.CurrentAllocationAddress(PROPERTY_CELL_SPACE),
- startup_serializer.CurrentAllocationAddress(LO_SPACE));
+ partial_serializer.FinalizeAllocation();
+ startup_serializer.FinalizeAllocation();
+
+ WritePayload(partial_sink.data(), FLAG_testing_serialization_file);
+ WritePayload(startup_sink.data(), startup_name.start());
+
+ WriteSpaceUsed(&partial_serializer, FLAG_testing_serialization_file);
+ WriteSpaceUsed(&startup_serializer, startup_name.start());
+
startup_name.Dispose();
}
v8_isolate->Dispose();
}
-TEST(SerializeToplevelLargeString) {
+TEST(SerializeToplevelLargeStrings) {
FLAG_serialize_toplevel = true;
LocalContext context;
Isolate* isolate = CcTest::i_isolate();
+ Factory* f = isolate->factory();
isolate->compilation_cache()->Disable(); // Disable same-isolate code cache.
v8::HandleScope scope(CcTest::isolate());
- Vector<const uint8_t> source = ConstructSource(
+ Vector<const uint8_t> source_s = ConstructSource(
STATIC_CHAR_VECTOR("var s = \""), STATIC_CHAR_VECTOR("abcdef"),
- STATIC_CHAR_VECTOR("\"; s"), 1000000);
+ STATIC_CHAR_VECTOR("\";"), 1000000);
+ Vector<const uint8_t> source_t = ConstructSource(
+ STATIC_CHAR_VECTOR("var t = \""), STATIC_CHAR_VECTOR("uvwxyz"),
+ STATIC_CHAR_VECTOR("\"; s + t"), 999999);
Handle<String> source_str =
- isolate->factory()->NewStringFromOneByte(source).ToHandleChecked();
+ f->NewConsString(f->NewStringFromOneByte(source_s).ToHandleChecked(),
+ f->NewStringFromOneByte(source_t).ToHandleChecked())
+ .ToHandleChecked();
Handle<JSObject> global(isolate->context()->global_object());
ScriptData* cache = NULL;
Handle<Object> copy_result =
Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
- CHECK_EQ(6 * 1000000, Handle<String>::cast(copy_result)->length());
- CHECK(isolate->heap()->InSpace(HeapObject::cast(*copy_result), LO_SPACE));
+ CHECK_EQ(6 * 1999999, Handle<String>::cast(copy_result)->length());
+ Handle<Object> property = JSObject::GetDataProperty(
+ isolate->global_object(), f->NewStringFromAsciiChecked("s"));
+ CHECK(isolate->heap()->InSpace(HeapObject::cast(*property), LO_SPACE));
+ property = JSObject::GetDataProperty(isolate->global_object(),
+ f->NewStringFromAsciiChecked("t"));
+ CHECK(isolate->heap()->InSpace(HeapObject::cast(*property), LO_SPACE));
+ // Make sure we do not serialize too much, e.g. include the source string.
+ CHECK_LT(cache->length(), 13000000);
delete cache;
- source.Dispose();
+ source_s.Dispose();
+ source_t.Dispose();
+}
+
+
+TEST(SerializeToplevelThreeBigStrings) {
+ FLAG_serialize_toplevel = true;
+ LocalContext context;
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* f = isolate->factory();
+ isolate->compilation_cache()->Disable(); // Disable same-isolate code cache.
+
+ v8::HandleScope scope(CcTest::isolate());
+
+ Vector<const uint8_t> source_a =
+ ConstructSource(STATIC_CHAR_VECTOR("var a = \""), STATIC_CHAR_VECTOR("a"),
+ STATIC_CHAR_VECTOR("\";"), 700000);
+ Handle<String> source_a_str =
+ f->NewStringFromOneByte(source_a).ToHandleChecked();
+
+ Vector<const uint8_t> source_b =
+ ConstructSource(STATIC_CHAR_VECTOR("var b = \""), STATIC_CHAR_VECTOR("b"),
+ STATIC_CHAR_VECTOR("\";"), 600000);
+ Handle<String> source_b_str =
+ f->NewStringFromOneByte(source_b).ToHandleChecked();
+
+ Vector<const uint8_t> source_c =
+ ConstructSource(STATIC_CHAR_VECTOR("var c = \""), STATIC_CHAR_VECTOR("c"),
+ STATIC_CHAR_VECTOR("\";"), 500000);
+ Handle<String> source_c_str =
+ f->NewStringFromOneByte(source_c).ToHandleChecked();
+
+ Handle<String> source_str =
+ f->NewConsString(
+ f->NewConsString(source_a_str, source_b_str).ToHandleChecked(),
+ source_c_str).ToHandleChecked();
+
+ Handle<JSObject> global(isolate->context()->global_object());
+ ScriptData* cache = NULL;
+
+ Handle<SharedFunctionInfo> orig = Compiler::CompileScript(
+ source_str, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kProduceCodeCache, NOT_NATIVES_CODE);
+
+ Handle<SharedFunctionInfo> copy;
+ {
+ DisallowCompilation no_compile_expected(isolate);
+ copy = Compiler::CompileScript(
+ source_str, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kConsumeCodeCache, NOT_NATIVES_CODE);
+ }
+ CHECK_NE(*orig, *copy);
+
+ Handle<JSFunction> copy_fun =
+ isolate->factory()->NewFunctionFromSharedFunctionInfo(
+ copy, isolate->native_context());
+
+ USE(Execution::Call(isolate, copy_fun, global, 0, NULL));
+
+ CHECK_EQ(600000 + 700000, CompileRun("(a + b).length")->Int32Value());
+ CHECK_EQ(500000 + 600000, CompileRun("(b + c).length")->Int32Value());
+ Heap* heap = isolate->heap();
+ CHECK(heap->InSpace(*v8::Utils::OpenHandle(*CompileRun("a")->ToString()),
+ OLD_DATA_SPACE));
+ CHECK(heap->InSpace(*v8::Utils::OpenHandle(*CompileRun("b")->ToString()),
+ OLD_DATA_SPACE));
+ CHECK(heap->InSpace(*v8::Utils::OpenHandle(*CompileRun("c")->ToString()),
+ OLD_DATA_SPACE));
+
+ delete cache;
+ source_a.Dispose();
+ source_b.Dispose();
+ source_c.Dispose();
+}
+
+
+class SerializerOneByteResource
+ : public v8::String::ExternalOneByteStringResource {
+ public:
+ SerializerOneByteResource(const char* data, size_t length)
+ : data_(data), length_(length) {}
+ virtual const char* data() const { return data_; }
+ virtual size_t length() const { return length_; }
+
+ private:
+ const char* data_;
+ size_t length_;
+};
+
+
+class SerializerTwoByteResource : public v8::String::ExternalStringResource {
+ public:
+ SerializerTwoByteResource(const char* data, size_t length)
+ : data_(AsciiToTwoByteString(data)), length_(length) {}
+ ~SerializerTwoByteResource() { DeleteArray<const uint16_t>(data_); }
+
+ virtual const uint16_t* data() const { return data_; }
+ virtual size_t length() const { return length_; }
+
+ private:
+ const uint16_t* data_;
+ size_t length_;
+};
+
+
+TEST(SerializeToplevelExternalString) {
+ 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());
+
+ // Obtain external internalized one-byte string.
+ SerializerOneByteResource one_byte_resource("one_byte", 8);
+ Handle<String> one_byte_string =
+ isolate->factory()->NewStringFromAsciiChecked("one_byte");
+ one_byte_string = isolate->factory()->InternalizeString(one_byte_string);
+ one_byte_string->MakeExternal(&one_byte_resource);
+ CHECK(one_byte_string->IsExternalOneByteString());
+ CHECK(one_byte_string->IsInternalizedString());
+
+ // Obtain external internalized two-byte string.
+ SerializerTwoByteResource two_byte_resource("two_byte", 8);
+ Handle<String> two_byte_string =
+ isolate->factory()->NewStringFromAsciiChecked("two_byte");
+ two_byte_string = isolate->factory()->InternalizeString(two_byte_string);
+ two_byte_string->MakeExternal(&two_byte_resource);
+ CHECK(two_byte_string->IsExternalTwoByteString());
+ CHECK(two_byte_string->IsInternalizedString());
+
+ const char* source =
+ "var o = {} \n"
+ "o.one_byte = 7; \n"
+ "o.two_byte = 8; \n"
+ "o.one_byte + o.two_byte; \n";
+ Handle<String> source_string = isolate->factory()
+ ->NewStringFromUtf8(CStrVector(source))
+ .ToHandleChecked();
+
+ Handle<JSObject> global(isolate->context()->global_object());
+ ScriptData* cache = NULL;
+
+ Handle<SharedFunctionInfo> orig = Compiler::CompileScript(
+ source_string, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kProduceCodeCache, NOT_NATIVES_CODE);
+
+ Handle<SharedFunctionInfo> copy;
+ {
+ DisallowCompilation no_compile_expected(isolate);
+ copy = Compiler::CompileScript(
+ source_string, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kConsumeCodeCache, NOT_NATIVES_CODE);
+ }
+ CHECK_NE(*orig, *copy);
+
+ Handle<JSFunction> copy_fun =
+ isolate->factory()->NewFunctionFromSharedFunctionInfo(
+ copy, isolate->native_context());
+
+ Handle<Object> copy_result =
+ Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
+
+ CHECK_EQ(15.0f, copy_result->Number());
+
+ delete cache;
+}
+
+
+TEST(SerializeToplevelLargeExternalString) {
+ FLAG_serialize_toplevel = true;
+ LocalContext context;
+ Isolate* isolate = CcTest::i_isolate();
+ isolate->compilation_cache()->Disable(); // Disable same-isolate code cache.
+
+ Factory* f = isolate->factory();
+
+ v8::HandleScope scope(CcTest::isolate());
+
+ // Create a huge external internalized string to use as variable name.
+ Vector<const uint8_t> string =
+ ConstructSource(STATIC_CHAR_VECTOR(""), STATIC_CHAR_VECTOR("abcdef"),
+ STATIC_CHAR_VECTOR(""), 999999);
+ Handle<String> name = f->NewStringFromOneByte(string).ToHandleChecked();
+ SerializerOneByteResource one_byte_resource(
+ reinterpret_cast<const char*>(string.start()), string.length());
+ name = f->InternalizeString(name);
+ name->MakeExternal(&one_byte_resource);
+ CHECK(name->IsExternalOneByteString());
+ CHECK(name->IsInternalizedString());
+ CHECK(isolate->heap()->InSpace(*name, LO_SPACE));
+
+ // Create the source, which is "var <literal> = 42; <literal>".
+ Handle<String> source_str =
+ f->NewConsString(
+ f->NewConsString(f->NewStringFromAsciiChecked("var "), name)
+ .ToHandleChecked(),
+ f->NewConsString(f->NewStringFromAsciiChecked(" = 42; "), name)
+ .ToHandleChecked()).ToHandleChecked();
+
+ Handle<JSObject> global(isolate->context()->global_object());
+ ScriptData* cache = NULL;
+
+ Handle<SharedFunctionInfo> orig = Compiler::CompileScript(
+ source_str, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kProduceCodeCache, NOT_NATIVES_CODE);
+
+ Handle<SharedFunctionInfo> copy;
+ {
+ DisallowCompilation no_compile_expected(isolate);
+ copy = Compiler::CompileScript(
+ source_str, Handle<String>(), 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kConsumeCodeCache, NOT_NATIVES_CODE);
+ }
+ CHECK_NE(*orig, *copy);
+
+ Handle<JSFunction> copy_fun =
+ f->NewFunctionFromSharedFunctionInfo(copy, isolate->native_context());
+
+ Handle<Object> copy_result =
+ Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
+
+ CHECK_EQ(42.0f, copy_result->Number());
+
+ delete cache;
+ string.Dispose();
+}
+
+
+TEST(SerializeToplevelExternalScriptName) {
+ FLAG_serialize_toplevel = true;
+ LocalContext context;
+ Isolate* isolate = CcTest::i_isolate();
+ isolate->compilation_cache()->Disable(); // Disable same-isolate code cache.
+
+ Factory* f = isolate->factory();
+
+ v8::HandleScope scope(CcTest::isolate());
+
+ const char* source =
+ "var a = [1, 2, 3, 4];"
+ "a.reduce(function(x, y) { return x + y }, 0)";
+
+ Handle<String> source_string =
+ f->NewStringFromUtf8(CStrVector(source)).ToHandleChecked();
+
+ const SerializerOneByteResource one_byte_resource("one_byte", 8);
+ Handle<String> name =
+ f->NewExternalStringFromOneByte(&one_byte_resource).ToHandleChecked();
+ CHECK(name->IsExternalOneByteString());
+ CHECK(!name->IsInternalizedString());
+
+ Handle<JSObject> global(isolate->context()->global_object());
+ ScriptData* cache = NULL;
+
+ Handle<SharedFunctionInfo> orig = Compiler::CompileScript(
+ source_string, name, 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kProduceCodeCache, NOT_NATIVES_CODE);
+
+ Handle<SharedFunctionInfo> copy;
+ {
+ DisallowCompilation no_compile_expected(isolate);
+ copy = Compiler::CompileScript(
+ source_string, name, 0, 0, false,
+ Handle<Context>(isolate->native_context()), NULL, &cache,
+ v8::ScriptCompiler::kConsumeCodeCache, NOT_NATIVES_CODE);
+ }
+ CHECK_NE(*orig, *copy);
+
+ Handle<JSFunction> copy_fun =
+ f->NewFunctionFromSharedFunctionInfo(copy, isolate->native_context());
+
+ Handle<Object> copy_result =
+ Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
+
+ CHECK_EQ(10.0f, copy_result->Number());
+
+ delete cache;
+}
+
+
+static bool toplevel_test_code_event_found = false;
+
+
+static void SerializerCodeEventListener(const v8::JitCodeEvent* event) {
+ if (event->type == v8::JitCodeEvent::CODE_ADDED &&
+ memcmp(event->name.str, "Script:~test", 12) == 0) {
+ toplevel_test_code_event_found = true;
+ }
}
v8::Local<v8::UnboundScript> script = v8::ScriptCompiler::CompileUnbound(
isolate1, &source, v8::ScriptCompiler::kProduceCodeCache);
const v8::ScriptCompiler::CachedData* data = source.GetCachedData();
+ CHECK(data);
// Persist cached data.
uint8_t* buffer = NewArray<uint8_t>(data->length);
MemCopy(buffer, data->data, data->length);
isolate1->Dispose();
v8::Isolate* isolate2 = v8::Isolate::New();
+ isolate2->SetJitCodeEventHandler(v8::kJitCodeEventDefault,
+ SerializerCodeEventListener);
+ toplevel_test_code_event_found = false;
{
v8::Isolate::Scope iscope(isolate2);
v8::HandleScope scope(isolate2);
v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
CHECK(result->ToString()->Equals(v8_str("abcdef")));
}
+ DCHECK(toplevel_test_code_event_found);
+ isolate2->Dispose();
+}
+
+
+TEST(Bug3628) {
+ FLAG_serialize_toplevel = true;
+ FLAG_harmony_scoping = true;
+
+ const char* source1 = "'use strict'; let x = 'X'";
+ const char* source2 = "'use strict'; let y = 'Y'";
+ const char* source3 = "'use strict'; x + y";
+
+ v8::ScriptCompiler::CachedData* cache;
+
+ v8::Isolate* isolate1 = v8::Isolate::New();
+ {
+ v8::Isolate::Scope iscope(isolate1);
+ v8::HandleScope scope(isolate1);
+ v8::Local<v8::Context> context = v8::Context::New(isolate1);
+ v8::Context::Scope context_scope(context);
+
+ CompileRun(source1);
+ CompileRun(source2);
+
+ v8::Local<v8::String> source_str = v8_str(source3);
+ v8::ScriptOrigin origin(v8_str("test"));
+ v8::ScriptCompiler::Source source(source_str, origin);
+ v8::Local<v8::UnboundScript> script = v8::ScriptCompiler::CompileUnbound(
+ isolate1, &source, v8::ScriptCompiler::kProduceCodeCache);
+ const v8::ScriptCompiler::CachedData* data = source.GetCachedData();
+ CHECK(data);
+ // Persist cached data.
+ uint8_t* buffer = NewArray<uint8_t>(data->length);
+ MemCopy(buffer, data->data, data->length);
+ cache = new v8::ScriptCompiler::CachedData(
+ buffer, data->length, v8::ScriptCompiler::CachedData::BufferOwned);
+
+ v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
+ CHECK(result->ToString()->Equals(v8_str("XY")));
+ }
+ isolate1->Dispose();
+
+ v8::Isolate* isolate2 = v8::Isolate::New();
+ {
+ v8::Isolate::Scope iscope(isolate2);
+ v8::HandleScope scope(isolate2);
+ v8::Local<v8::Context> context = v8::Context::New(isolate2);
+ v8::Context::Scope context_scope(context);
+
+ // Reverse order of prior running scripts.
+ CompileRun(source2);
+ CompileRun(source1);
+
+ v8::Local<v8::String> source_str = v8_str(source3);
+ v8::ScriptOrigin origin(v8_str("test"));
+ v8::ScriptCompiler::Source source(source_str, origin, cache);
+ v8::Local<v8::UnboundScript> script;
+ {
+ DisallowCompilation no_compile(reinterpret_cast<Isolate*>(isolate2));
+ script = v8::ScriptCompiler::CompileUnbound(
+ isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache);
+ }
+ v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
+ CHECK(result->ToString()->Equals(v8_str("XY")));
+ }
isolate2->Dispose();
}
#include <stdlib.h>
+#include "src/base/platform/platform.h"
#include "src/snapshot.h"
#include "src/v8.h"
#include "test/cctest/cctest.h"
TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
CodeRange* code_range = new CodeRange(isolate);
const size_t code_range_size = 4 * MB;
- if (!code_range->SetUp(code_range_size)) return;
+ if (!code_range->SetUp(
+ code_range_size +
+ RoundUp(v8::base::OS::CommitPageSize() * kReservedCodeRangePages,
+ MemoryChunk::kAlignment))) {
+ return;
+ }
Address address;
size_t size;
address = code_range->AllocateRawMemory(code_range_size - MB,
// No large objects required to perform the above steps.
CHECK(isolate->heap()->lo_space()->IsEmpty());
}
+
+
+static inline void FillCurrentPage(v8::internal::NewSpace* space) {
+ int new_linear_size = static_cast<int>(*space->allocation_limit_address() -
+ *space->allocation_top_address());
+ if (new_linear_size == 0) return;
+ v8::internal::AllocationResult allocation =
+ space->AllocateRaw(new_linear_size);
+ v8::internal::FreeListNode* node =
+ v8::internal::FreeListNode::cast(allocation.ToObjectChecked());
+ node->set_size(space->heap(), new_linear_size);
+}
+
+
+UNINITIALIZED_TEST(NewSpaceGrowsToTargetCapacity) {
+ FLAG_target_semi_space_size = 2;
+ if (FLAG_optimize_for_size) return;
+
+ v8::Isolate* isolate = v8::Isolate::New();
+ {
+ v8::Isolate::Scope isolate_scope(isolate);
+ v8::HandleScope handle_scope(isolate);
+ v8::Context::New(isolate)->Enter();
+
+ Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
+
+ NewSpace* new_space = i_isolate->heap()->new_space();
+
+ // This test doesn't work if we start with a non-default new space
+ // configuration.
+ if (new_space->InitialTotalCapacity() == Page::kPageSize) {
+ CHECK(new_space->CommittedMemory() == new_space->InitialTotalCapacity());
+
+ // Fill up the first (and only) page of the semi space.
+ FillCurrentPage(new_space);
+
+ // Try to allocate out of the new space. A new page should be added and
+ // the
+ // allocation should succeed.
+ v8::internal::AllocationResult allocation = new_space->AllocateRaw(80);
+ CHECK(!allocation.IsRetry());
+ CHECK(new_space->CommittedMemory() == 2 * Page::kPageSize);
+
+ // Turn the allocation into a proper object so isolate teardown won't
+ // crash.
+ v8::internal::FreeListNode* node =
+ v8::internal::FreeListNode::cast(allocation.ToObjectChecked());
+ node->set_size(new_space->heap(), 80);
+ }
+ }
+ isolate->Dispose();
+}
#include "src/api.h"
#include "src/factory.h"
#include "src/objects.h"
+#include "src/unicode-decoder.h"
#include "test/cctest/cctest.h"
// Adapted from http://en.wikipedia.org/wiki/Multiply-with-carry
void AccumulateStatsWithOperator(
ConsString* cons_string, ConsStringStats* stats) {
- ConsStringIteratorOp op(cons_string);
+ ConsStringIterator iter(cons_string);
String* string;
int offset;
- while (NULL != (string = op.Next(&offset))) {
+ while (NULL != (string = iter.Next(&offset))) {
// Accumulate stats.
CHECK_EQ(0, offset);
stats->leaves_++;
}
-static ConsStringIteratorOp cons_string_iterator_op_1;
-static ConsStringIteratorOp cons_string_iterator_op_2;
-
static void Traverse(Handle<String> s1, Handle<String> s2) {
int i = 0;
- StringCharacterStream character_stream_1(*s1, &cons_string_iterator_op_1);
- StringCharacterStream character_stream_2(*s2, &cons_string_iterator_op_2);
+ StringCharacterStream character_stream_1(*s1);
+ StringCharacterStream character_stream_2(*s2);
while (character_stream_1.HasMore()) {
CHECK(character_stream_2.HasMore());
uint16_t c = character_stream_1.GetNext();
static void TraverseFirst(Handle<String> s1, Handle<String> s2, int chars) {
int i = 0;
- StringCharacterStream character_stream_1(*s1, &cons_string_iterator_op_1);
- StringCharacterStream character_stream_2(*s2, &cons_string_iterator_op_2);
+ StringCharacterStream character_stream_1(*s1);
+ StringCharacterStream character_stream_2(*s2);
while (character_stream_1.HasMore() && i < chars) {
CHECK(character_stream_2.HasMore());
uint16_t c = character_stream_1.GetNext();
if (offset < 0) offset = 0;
// Want to test the offset == length case.
if (offset > length) offset = length;
- StringCharacterStream flat_stream(
- flat_string, &cons_string_iterator_op_1, offset);
- StringCharacterStream cons_stream(
- cons_string, &cons_string_iterator_op_2, offset);
+ StringCharacterStream flat_stream(flat_string, offset);
+ StringCharacterStream cons_stream(cons_string, offset);
for (int i = offset; i < length; i++) {
uint16_t c = flat_string->Get(i);
CHECK(flat_stream.HasMore());
static inline void PrintStats(const ConsStringGenerationData& data) {
#ifdef DEBUG
-printf(
- "%s: [%d], %s: [%d], %s: [%d], %s: [%d], %s: [%d], %s: [%d]\n",
- "leaves", data.stats_.leaves_,
- "empty", data.stats_.empty_leaves_,
- "chars", data.stats_.chars_,
- "lefts", data.stats_.left_traversals_,
- "rights", data.stats_.right_traversals_,
- "early_terminations", data.early_terminations_);
+ printf("%s: [%u], %s: [%u], %s: [%u], %s: [%u], %s: [%u], %s: [%u]\n",
+ "leaves", data.stats_.leaves_, "empty", data.stats_.empty_leaves_,
+ "chars", data.stats_.chars_, "lefts", data.stats_.left_traversals_,
+ "rights", data.stats_.right_traversals_, "early_terminations",
+ data.early_terminations_);
#endif
}
}
+namespace {
+
+int* global_use_counts = NULL;
+
+void MockUseCounterCallback(v8::Isolate* isolate,
+ v8::Isolate::UseCounterFeature feature) {
+ ++global_use_counts[feature];
+}
+}
+
+
+TEST(CountBreakIterator) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ LocalContext context;
+ int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
+ global_use_counts = use_counts;
+ CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
+ CHECK_EQ(0, use_counts[v8::Isolate::kBreakIterator]);
+ v8::Local<v8::Value> result = CompileRun(
+ "(function() {"
+ " if (!this.Intl) return 0;"
+ " var iterator = Intl.v8BreakIterator(['en']);"
+ " iterator.adoptText('Now is the time');"
+ " iterator.next();"
+ " return iterator.next();"
+ "})();");
+ CHECK(result->IsNumber());
+ int uses = result->ToInt32()->Value() == 0 ? 0 : 1;
+ CHECK_EQ(uses, use_counts[v8::Isolate::kBreakIterator]);
+ // Make sure GC cleans up the break iterator, so we don't get a memory leak
+ // reported by ASAN.
+ CcTest::isolate()->LowMemoryNotification();
+}
+
+
TEST(StringReplaceAtomTwoByteResult) {
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
--- /dev/null
+// 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 <stdlib.h>
+#include <utility>
+
+#include "src/v8.h"
+
+#include "src/compilation-cache.h"
+#include "src/execution.h"
+#include "src/factory.h"
+#include "src/global-handles.h"
+#include "test/cctest/cctest.h"
+
+using namespace v8::internal;
+
+
+//
+// Helper functions.
+//
+
+static void ConnectTransition(Handle<Map> parent,
+ Handle<TransitionArray> transitions,
+ Handle<Map> child) {
+ if (!parent->HasTransitionArray() || *transitions != parent->transitions()) {
+ parent->set_transitions(*transitions);
+ }
+ child->SetBackPointer(*parent);
+}
+
+
+TEST(TransitionArray_SimpleFieldTransitions) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ Handle<String> name1 = factory->InternalizeUtf8String("foo");
+ Handle<String> name2 = factory->InternalizeUtf8String("bar");
+ PropertyAttributes attributes = NONE;
+
+ Handle<Map> map0 = Map::Create(isolate, 0);
+ Handle<Map> map1 =
+ Map::CopyWithField(map0, name1, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ Handle<Map> map2 =
+ Map::CopyWithField(map0, name2, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+
+ CHECK(!map0->HasTransitionArray());
+ Handle<TransitionArray> transitions = TransitionArray::Allocate(isolate, 0);
+ CHECK(transitions->IsFullTransitionArray());
+
+ int transition;
+ transitions =
+ transitions->Insert(map0, name1, map1, SIMPLE_PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map1);
+ CHECK(transitions->IsSimpleTransition());
+ transition = transitions->Search(FIELD, *name1, attributes);
+ CHECK_EQ(TransitionArray::kSimpleTransitionIndex, transition);
+ CHECK_EQ(*name1, transitions->GetKey(transition));
+ CHECK_EQ(*map1, transitions->GetTarget(transition));
+
+ transitions =
+ transitions->Insert(map0, name2, map2, SIMPLE_PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map2);
+ CHECK(transitions->IsFullTransitionArray());
+
+ transition = transitions->Search(FIELD, *name1, attributes);
+ CHECK_EQ(*name1, transitions->GetKey(transition));
+ CHECK_EQ(*map1, transitions->GetTarget(transition));
+
+ transition = transitions->Search(FIELD, *name2, attributes);
+ CHECK_EQ(*name2, transitions->GetKey(transition));
+ CHECK_EQ(*map2, transitions->GetTarget(transition));
+
+ DCHECK(transitions->IsSortedNoDuplicates());
+}
+
+
+TEST(TransitionArray_FullFieldTransitions) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ Handle<String> name1 = factory->InternalizeUtf8String("foo");
+ Handle<String> name2 = factory->InternalizeUtf8String("bar");
+ PropertyAttributes attributes = NONE;
+
+ Handle<Map> map0 = Map::Create(isolate, 0);
+ Handle<Map> map1 =
+ Map::CopyWithField(map0, name1, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ Handle<Map> map2 =
+ Map::CopyWithField(map0, name2, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+
+ CHECK(!map0->HasTransitionArray());
+ Handle<TransitionArray> transitions = TransitionArray::Allocate(isolate, 0);
+ CHECK(transitions->IsFullTransitionArray());
+
+ int transition;
+ transitions = transitions->Insert(map0, name1, map1, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map1);
+ CHECK(transitions->IsFullTransitionArray());
+ transition = transitions->Search(FIELD, *name1, attributes);
+ CHECK_EQ(*name1, transitions->GetKey(transition));
+ CHECK_EQ(*map1, transitions->GetTarget(transition));
+
+ transitions = transitions->Insert(map0, name2, map2, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map2);
+ CHECK(transitions->IsFullTransitionArray());
+
+ transition = transitions->Search(FIELD, *name1, attributes);
+ CHECK_EQ(*name1, transitions->GetKey(transition));
+ CHECK_EQ(*map1, transitions->GetTarget(transition));
+
+ transition = transitions->Search(FIELD, *name2, attributes);
+ CHECK_EQ(*name2, transitions->GetKey(transition));
+ CHECK_EQ(*map2, transitions->GetTarget(transition));
+
+ DCHECK(transitions->IsSortedNoDuplicates());
+}
+
+
+TEST(TransitionArray_DifferentFieldNames) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ const int PROPS_COUNT = 10;
+ Handle<String> names[PROPS_COUNT];
+ Handle<Map> maps[PROPS_COUNT];
+ PropertyAttributes attributes = NONE;
+
+ Handle<Map> map0 = Map::Create(isolate, 0);
+ CHECK(!map0->HasTransitionArray());
+ Handle<TransitionArray> transitions = TransitionArray::Allocate(isolate, 0);
+ CHECK(transitions->IsFullTransitionArray());
+
+ for (int i = 0; i < PROPS_COUNT; i++) {
+ EmbeddedVector<char, 64> buffer;
+ SNPrintF(buffer, "prop%d", i);
+ Handle<String> name = factory->InternalizeUtf8String(buffer.start());
+ Handle<Map> map =
+ Map::CopyWithField(map0, name, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ names[i] = name;
+ maps[i] = map;
+
+ transitions = transitions->Insert(map0, name, map, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map);
+ }
+
+ for (int i = 0; i < PROPS_COUNT; i++) {
+ int transition = transitions->Search(FIELD, *names[i], attributes);
+ CHECK_EQ(*names[i], transitions->GetKey(transition));
+ CHECK_EQ(*maps[i], transitions->GetTarget(transition));
+ }
+
+ DCHECK(transitions->IsSortedNoDuplicates());
+}
+
+
+TEST(TransitionArray_SameFieldNamesDifferentAttributesSimple) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ Handle<Map> map0 = Map::Create(isolate, 0);
+ CHECK(!map0->HasTransitionArray());
+ Handle<TransitionArray> transitions = TransitionArray::Allocate(isolate, 0);
+ CHECK(transitions->IsFullTransitionArray());
+
+ const int ATTRS_COUNT = (READ_ONLY | DONT_ENUM | DONT_DELETE) + 1;
+ STATIC_ASSERT(ATTRS_COUNT == 8);
+ Handle<Map> attr_maps[ATTRS_COUNT];
+ Handle<String> name = factory->InternalizeUtf8String("foo");
+
+ // Add transitions for same field name but different attributes.
+ for (int i = 0; i < ATTRS_COUNT; i++) {
+ PropertyAttributes attributes = static_cast<PropertyAttributes>(i);
+
+ Handle<Map> map =
+ Map::CopyWithField(map0, name, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ attr_maps[i] = map;
+
+ transitions = transitions->Insert(map0, name, map, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map);
+ }
+
+ // Ensure that transitions for |name| field are valid.
+ for (int i = 0; i < ATTRS_COUNT; i++) {
+ PropertyAttributes attributes = static_cast<PropertyAttributes>(i);
+
+ int transition = transitions->Search(FIELD, *name, attributes);
+ CHECK_EQ(*name, transitions->GetKey(transition));
+ CHECK_EQ(*attr_maps[i], transitions->GetTarget(transition));
+ }
+
+ DCHECK(transitions->IsSortedNoDuplicates());
+}
+
+
+TEST(TransitionArray_SameFieldNamesDifferentAttributes) {
+ CcTest::InitializeVM();
+ v8::HandleScope scope(CcTest::isolate());
+ Isolate* isolate = CcTest::i_isolate();
+ Factory* factory = isolate->factory();
+
+ const int PROPS_COUNT = 10;
+ Handle<String> names[PROPS_COUNT];
+ Handle<Map> maps[PROPS_COUNT];
+
+ Handle<Map> map0 = Map::Create(isolate, 0);
+ CHECK(!map0->HasTransitionArray());
+ Handle<TransitionArray> transitions = TransitionArray::Allocate(isolate, 0);
+ CHECK(transitions->IsFullTransitionArray());
+
+ // Some number of fields.
+ for (int i = 0; i < PROPS_COUNT; i++) {
+ EmbeddedVector<char, 64> buffer;
+ SNPrintF(buffer, "prop%d", i);
+ Handle<String> name = factory->InternalizeUtf8String(buffer.start());
+ Handle<Map> map =
+ Map::CopyWithField(map0, name, handle(HeapType::Any(), isolate), NONE,
+ Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ names[i] = name;
+ maps[i] = map;
+
+ transitions = transitions->Insert(map0, name, map, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map);
+ }
+
+ const int ATTRS_COUNT = (READ_ONLY | DONT_ENUM | DONT_DELETE) + 1;
+ STATIC_ASSERT(ATTRS_COUNT == 8);
+ Handle<Map> attr_maps[ATTRS_COUNT];
+ Handle<String> name = factory->InternalizeUtf8String("foo");
+
+ // Add transitions for same field name but different attributes.
+ for (int i = 0; i < ATTRS_COUNT; i++) {
+ PropertyAttributes attributes = static_cast<PropertyAttributes>(i);
+
+ Handle<Map> map =
+ Map::CopyWithField(map0, name, handle(HeapType::Any(), isolate),
+ attributes, Representation::Tagged(),
+ OMIT_TRANSITION).ToHandleChecked();
+ attr_maps[i] = map;
+
+ transitions = transitions->Insert(map0, name, map, PROPERTY_TRANSITION);
+ ConnectTransition(map0, transitions, map);
+ }
+
+ // Ensure that transitions for |name| field are valid.
+ for (int i = 0; i < ATTRS_COUNT; i++) {
+ PropertyAttributes attributes = static_cast<PropertyAttributes>(i);
+
+ int transition = transitions->Search(FIELD, *name, attributes);
+ CHECK_EQ(*name, transitions->GetKey(transition));
+ CHECK_EQ(*attr_maps[i], transitions->GetTarget(transition));
+ }
+
+ // Ensure that info about the other fields still valid.
+ for (int i = 0; i < PROPS_COUNT; i++) {
+ int transition = transitions->Search(FIELD, *names[i], NONE);
+ CHECK_EQ(*names[i], transitions->GetKey(transition));
+ CHECK_EQ(*maps[i], transitions->GetTarget(transition));
+ }
+
+ DCHECK(transitions->IsSortedNoDuplicates());
+}
#include "src/isolate-inl.h"
#include "src/types.h"
#include "test/cctest/cctest.h"
+#include "test/cctest/types-fuzz.h"
using namespace v8::internal;
};
-template<class Type, class TypeHandle, class Region>
-class Types {
- public:
- Types(Region* region, Isolate* isolate)
- : region_(region), rng_(isolate->random_number_generator()) {
- #define DECLARE_TYPE(name, value) \
- name = Type::name(region); \
- types.push_back(name);
- PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
- #undef DECLARE_TYPE
-
- object_map = isolate->factory()->NewMap(
- JS_OBJECT_TYPE, JSObject::kHeaderSize);
- array_map = isolate->factory()->NewMap(
- JS_ARRAY_TYPE, JSArray::kSize);
- number_map = isolate->factory()->NewMap(
- HEAP_NUMBER_TYPE, HeapNumber::kSize);
- uninitialized_map = isolate->factory()->uninitialized_map();
- ObjectClass = Type::Class(object_map, region);
- ArrayClass = Type::Class(array_map, region);
- NumberClass = Type::Class(number_map, region);
- UninitializedClass = Type::Class(uninitialized_map, region);
-
- maps.push_back(object_map);
- maps.push_back(array_map);
- maps.push_back(uninitialized_map);
- for (MapVector::iterator it = maps.begin(); it != maps.end(); ++it) {
- types.push_back(Type::Class(*it, region));
- }
-
- smi = handle(Smi::FromInt(666), isolate);
- signed32 = isolate->factory()->NewHeapNumber(0x40000000);
- object1 = isolate->factory()->NewJSObjectFromMap(object_map);
- object2 = isolate->factory()->NewJSObjectFromMap(object_map);
- array = isolate->factory()->NewJSArray(20);
- uninitialized = isolate->factory()->uninitialized_value();
- SmiConstant = Type::Constant(smi, region);
- Signed32Constant = Type::Constant(signed32, region);
- ObjectConstant1 = Type::Constant(object1, region);
- ObjectConstant2 = Type::Constant(object2, region);
- ArrayConstant = Type::Constant(array, region);
- UninitializedConstant = Type::Constant(uninitialized, region);
-
- values.push_back(smi);
- values.push_back(signed32);
- values.push_back(object1);
- values.push_back(object2);
- values.push_back(array);
- values.push_back(uninitialized);
- for (ValueVector::iterator it = values.begin(); it != values.end(); ++it) {
- types.push_back(Type::Constant(*it, region));
- }
-
- integers.push_back(isolate->factory()->NewNumber(-V8_INFINITY));
- integers.push_back(isolate->factory()->NewNumber(+V8_INFINITY));
- integers.push_back(isolate->factory()->NewNumber(-rng_->NextInt(10)));
- integers.push_back(isolate->factory()->NewNumber(+rng_->NextInt(10)));
- for (int i = 0; i < 10; ++i) {
- double x = rng_->NextInt();
- integers.push_back(isolate->factory()->NewNumber(x));
- x *= rng_->NextInt();
- if (!IsMinusZero(x)) integers.push_back(isolate->factory()->NewNumber(x));
- }
-
- NumberArray = Type::Array(Number, region);
- StringArray = Type::Array(String, region);
- AnyArray = Type::Array(Any, region);
-
- SignedFunction1 = Type::Function(SignedSmall, SignedSmall, region);
- NumberFunction1 = Type::Function(Number, Number, region);
- NumberFunction2 = Type::Function(Number, Number, Number, region);
- MethodFunction = Type::Function(String, Object, 0, region);
-
- for (int i = 0; i < 30; ++i) {
- types.push_back(Fuzz());
- }
- }
-
- Handle<i::Map> object_map;
- Handle<i::Map> array_map;
- Handle<i::Map> number_map;
- Handle<i::Map> uninitialized_map;
-
- Handle<i::Smi> smi;
- Handle<i::HeapNumber> signed32;
- Handle<i::JSObject> object1;
- Handle<i::JSObject> object2;
- Handle<i::JSArray> array;
- Handle<i::Oddball> uninitialized;
-
- #define DECLARE_TYPE(name, value) TypeHandle name;
- BITSET_TYPE_LIST(DECLARE_TYPE)
- #undef DECLARE_TYPE
-
- TypeHandle ObjectClass;
- TypeHandle ArrayClass;
- TypeHandle NumberClass;
- TypeHandle UninitializedClass;
-
- TypeHandle SmiConstant;
- TypeHandle Signed32Constant;
- TypeHandle ObjectConstant1;
- TypeHandle ObjectConstant2;
- TypeHandle ArrayConstant;
- TypeHandle UninitializedConstant;
-
- TypeHandle NumberArray;
- TypeHandle StringArray;
- TypeHandle AnyArray;
-
- TypeHandle SignedFunction1;
- TypeHandle NumberFunction1;
- TypeHandle NumberFunction2;
- TypeHandle MethodFunction;
-
- typedef std::vector<TypeHandle> TypeVector;
- typedef std::vector<Handle<i::Map> > MapVector;
- typedef std::vector<Handle<i::Object> > ValueVector;
-
- TypeVector types;
- MapVector maps;
- ValueVector values;
- ValueVector integers; // "Integer" values used for range limits.
-
- TypeHandle Of(Handle<i::Object> value) {
- return Type::Of(value, region_);
- }
-
- TypeHandle NowOf(Handle<i::Object> value) {
- return Type::NowOf(value, region_);
- }
-
- TypeHandle Class(Handle<i::Map> map) {
- return Type::Class(map, region_);
- }
-
- TypeHandle Constant(Handle<i::Object> value) {
- return Type::Constant(value, region_);
- }
-
- TypeHandle Range(Handle<i::Object> min, Handle<i::Object> max) {
- return Type::Range(min, max, region_);
- }
-
- TypeHandle Context(TypeHandle outer) {
- return Type::Context(outer, region_);
- }
-
- TypeHandle Array1(TypeHandle element) {
- return Type::Array(element, region_);
- }
-
- TypeHandle Function0(TypeHandle result, TypeHandle receiver) {
- return Type::Function(result, receiver, 0, region_);
- }
-
- TypeHandle Function1(TypeHandle result, TypeHandle receiver, TypeHandle arg) {
- TypeHandle type = Type::Function(result, receiver, 1, region_);
- type->AsFunction()->InitParameter(0, arg);
- return type;
- }
-
- TypeHandle Function2(TypeHandle result, TypeHandle arg1, TypeHandle arg2) {
- return Type::Function(result, arg1, arg2, region_);
- }
-
- TypeHandle Union(TypeHandle t1, TypeHandle t2) {
- return Type::Union(t1, t2, region_);
- }
- TypeHandle Intersect(TypeHandle t1, TypeHandle t2) {
- return Type::Intersect(t1, t2, region_);
- }
-
- template<class Type2, class TypeHandle2>
- TypeHandle Convert(TypeHandle2 t) {
- return Type::template Convert<Type2>(t, region_);
- }
-
- TypeHandle Random() {
- return types[rng_->NextInt(static_cast<int>(types.size()))];
- }
-
- TypeHandle Fuzz(int depth = 4) {
- switch (rng_->NextInt(depth == 0 ? 3 : 20)) {
- case 0: { // bitset
- #define COUNT_BITSET_TYPES(type, value) + 1
- int n = 0 PROPER_BITSET_TYPE_LIST(COUNT_BITSET_TYPES);
- #undef COUNT_BITSET_TYPES
- // Pick a bunch of named bitsets and return their intersection.
- TypeHandle result = Type::Any(region_);
- for (int i = 0, m = 1 + rng_->NextInt(3); i < m; ++i) {
- int j = rng_->NextInt(n);
- #define PICK_BITSET_TYPE(type, value) \
- if (j-- == 0) { \
- TypeHandle tmp = Type::Intersect( \
- result, Type::type(region_), region_); \
- if (tmp->Is(Type::None()) && i != 0) { \
- break; \
- } { \
- result = tmp; \
- continue; \
- } \
- }
- PROPER_BITSET_TYPE_LIST(PICK_BITSET_TYPE)
- #undef PICK_BITSET_TYPE
- }
- return result;
- }
- case 1: { // class
- int i = rng_->NextInt(static_cast<int>(maps.size()));
- return Type::Class(maps[i], region_);
- }
- case 2: { // constant
- int i = rng_->NextInt(static_cast<int>(values.size()));
- return Type::Constant(values[i], region_);
- }
- case 3: { // range
- int i = rng_->NextInt(static_cast<int>(integers.size()));
- int j = rng_->NextInt(static_cast<int>(integers.size()));
- i::Handle<i::Object> min = integers[i];
- i::Handle<i::Object> max = integers[j];
- if (min->Number() > max->Number()) std::swap(min, max);
- return Type::Range(min, max, region_);
- }
- case 4: { // context
- int depth = rng_->NextInt(3);
- TypeHandle type = Type::Internal(region_);
- for (int i = 0; i < depth; ++i) type = Type::Context(type, region_);
- return type;
- }
- case 5: { // array
- TypeHandle element = Fuzz(depth / 2);
- return Type::Array(element, region_);
- }
- case 6:
- case 7: { // function
- TypeHandle result = Fuzz(depth / 2);
- TypeHandle receiver = Fuzz(depth / 2);
- int arity = rng_->NextInt(3);
- TypeHandle type = Type::Function(result, receiver, arity, region_);
- for (int i = 0; i < type->AsFunction()->Arity(); ++i) {
- TypeHandle parameter = Fuzz(depth / 2);
- type->AsFunction()->InitParameter(i, parameter);
- }
- return type;
- }
- default: { // union
- int n = rng_->NextInt(10);
- TypeHandle type = None;
- for (int i = 0; i < n; ++i) {
- TypeHandle operand = Fuzz(depth - 1);
- type = Type::Union(type, operand, region_);
- }
- return type;
- }
- }
- UNREACHABLE();
- }
-
- Region* region() { return region_; }
-
- private:
- Region* region_;
- v8::base::RandomNumberGenerator* rng_;
-};
-
-
template<class Type, class TypeHandle, class Region, class Rep>
struct Tests : Rep {
typedef Types<Type, TypeHandle, Region> TypesInstance;
}
void MinMax() {
+ Factory* fac = isolate->factory();
+
// If b is regular numeric bitset, then Range(b->Min(), b->Max())->Is(b).
// TODO(neis): Need to ignore representation for this to be true.
/*
// If b is regular numeric bitset, then b->Min() and b->Max() are integers.
for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
TypeHandle type = *it;
- if (this->IsBitset(type) && type->Is(T.Number) &&
- !type->Is(T.None) && !type->Is(T.NaN)) {
+ if (this->IsBitset(type) && type->Is(T.Number) && !type->Is(T.NaN)) {
CHECK(IsInteger(type->Min()) && IsInteger(type->Max()));
}
}
CHECK(lub->Min() <= type->Min() && type->Max() <= lub->Max());
}
}
+
+ // Rangification: If T->Is(Range(-inf,+inf)) and !T->Is(None), then
+ // T->Is(Range(T->Min(), T->Max())).
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ CHECK(!(type->Is(T.Integer) && !type->Is(T.None)) ||
+ type->Is(T.Range(fac->NewNumber(type->Min()),
+ fac->NewNumber(type->Max()))));
+ }
}
void BitsetGlb() {
}
+TEST(MinMax) {
+ CcTest::InitializeVM();
+ ZoneTests().MinMax();
+ HeapTests().MinMax();
+}
+
+
TEST(BitsetGlb) {
CcTest::InitializeVM();
ZoneTests().BitsetGlb();
}
+TEST(BitSetComputer) {
+ typedef BitSetComputer<bool, 1, kSmiValueSize, uint32_t> BoolComputer;
+ CHECK_EQ(0, BoolComputer::word_count(0));
+ CHECK_EQ(1, BoolComputer::word_count(8));
+ CHECK_EQ(2, BoolComputer::word_count(50));
+ CHECK_EQ(0, BoolComputer::index(0, 8));
+ CHECK_EQ(100, BoolComputer::index(100, 8));
+ CHECK_EQ(1, BoolComputer::index(0, 40));
+ uint32_t data = 0;
+ data = BoolComputer::encode(data, 1, true);
+ data = BoolComputer::encode(data, 4, true);
+ CHECK_EQ(true, BoolComputer::decode(data, 1));
+ CHECK_EQ(true, BoolComputer::decode(data, 4));
+ CHECK_EQ(false, BoolComputer::decode(data, 0));
+ CHECK_EQ(false, BoolComputer::decode(data, 2));
+ CHECK_EQ(false, BoolComputer::decode(data, 3));
+
+ // Lets store 2 bits per item with 3000 items and verify the values are
+ // correct.
+ typedef BitSetComputer<unsigned char, 2, 8, unsigned char> TwoBits;
+ const int words = 750;
+ CHECK_EQ(words, TwoBits::word_count(3000));
+ const int offset = 10;
+ Vector<unsigned char> buffer = Vector<unsigned char>::New(offset + words);
+ memset(buffer.start(), 0, sizeof(unsigned char) * buffer.length());
+ for (int i = 0; i < words; i++) {
+ const int index = TwoBits::index(offset, i);
+ unsigned char data = buffer[index];
+ data = TwoBits::encode(data, i, i % 4);
+ buffer[index] = data;
+ }
+
+ for (int i = 0; i < words; i++) {
+ const int index = TwoBits::index(offset, i);
+ unsigned char data = buffer[index];
+ CHECK_EQ(i % 4, TwoBits::decode(data, i));
+ }
+ buffer.Dispose();
+}
+
+
TEST(SNPrintF) {
// Make sure that strings that are truncated because of too small
// buffers are zero-terminated anyway.
}
-// TODO(svenpanne) Unconditionally test this when our infrastructure is fixed.
-#if !V8_OS_NACL
TEST(CPlusPlus11Features) {
struct S {
bool x;
j += 11;
}
}
-#endif
// sp is only used to define stack high bound
regs.sp =
reinterpret_cast<Address>(trace_env.sample) - 10240;
- trace_env.sample->Init(CcTest::i_isolate(), regs);
+ trace_env.sample->Init(CcTest::i_isolate(), regs,
+ TickSample::kSkipCEntryFrame);
}
--- /dev/null
+// 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.
+
+#ifndef V8_TEST_CCTEST_TYPES_H_
+#define V8_TEST_CCTEST_TYPES_H_
+
+#include "src/v8.h"
+
+namespace v8 {
+namespace internal {
+
+
+template<class Type, class TypeHandle, class Region>
+class Types {
+ public:
+ Types(Region* region, Isolate* isolate)
+ : region_(region), rng_(isolate->random_number_generator()) {
+ #define DECLARE_TYPE(name, value) \
+ name = Type::name(region); \
+ if (SmiValuesAre31Bits() || \
+ (!Type::name(region)->Equals(Type::OtherSigned32()) && \
+ !Type::name(region)->Equals(Type::OtherUnsigned31()))) { \
+ /* Hack: Avoid generating those empty bitset types. */ \
+ types.push_back(name); \
+ }
+ PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
+ #undef DECLARE_TYPE
+
+ object_map = isolate->factory()->NewMap(
+ JS_OBJECT_TYPE, JSObject::kHeaderSize);
+ array_map = isolate->factory()->NewMap(
+ JS_ARRAY_TYPE, JSArray::kSize);
+ number_map = isolate->factory()->NewMap(
+ HEAP_NUMBER_TYPE, HeapNumber::kSize);
+ uninitialized_map = isolate->factory()->uninitialized_map();
+ ObjectClass = Type::Class(object_map, region);
+ ArrayClass = Type::Class(array_map, region);
+ NumberClass = Type::Class(number_map, region);
+ UninitializedClass = Type::Class(uninitialized_map, region);
+
+ maps.push_back(object_map);
+ maps.push_back(array_map);
+ maps.push_back(uninitialized_map);
+ for (MapVector::iterator it = maps.begin(); it != maps.end(); ++it) {
+ types.push_back(Type::Class(*it, region));
+ }
+
+ smi = handle(Smi::FromInt(666), isolate);
+ signed32 = isolate->factory()->NewHeapNumber(0x40000000);
+ object1 = isolate->factory()->NewJSObjectFromMap(object_map);
+ object2 = isolate->factory()->NewJSObjectFromMap(object_map);
+ array = isolate->factory()->NewJSArray(20);
+ uninitialized = isolate->factory()->uninitialized_value();
+ SmiConstant = Type::Constant(smi, region);
+ Signed32Constant = Type::Constant(signed32, region);
+ ObjectConstant1 = Type::Constant(object1, region);
+ ObjectConstant2 = Type::Constant(object2, region);
+ ArrayConstant = Type::Constant(array, region);
+ UninitializedConstant = Type::Constant(uninitialized, region);
+
+ values.push_back(smi);
+ values.push_back(signed32);
+ values.push_back(object1);
+ values.push_back(object2);
+ values.push_back(array);
+ values.push_back(uninitialized);
+ for (ValueVector::iterator it = values.begin(); it != values.end(); ++it) {
+ types.push_back(Type::Constant(*it, region));
+ }
+
+ integers.push_back(isolate->factory()->NewNumber(-V8_INFINITY));
+ integers.push_back(isolate->factory()->NewNumber(+V8_INFINITY));
+ integers.push_back(isolate->factory()->NewNumber(-rng_->NextInt(10)));
+ integers.push_back(isolate->factory()->NewNumber(+rng_->NextInt(10)));
+ for (int i = 0; i < 10; ++i) {
+ double x = rng_->NextInt();
+ integers.push_back(isolate->factory()->NewNumber(x));
+ x *= rng_->NextInt();
+ if (!IsMinusZero(x)) integers.push_back(isolate->factory()->NewNumber(x));
+ }
+
+ Integer = Type::Range(isolate->factory()->NewNumber(-V8_INFINITY),
+ isolate->factory()->NewNumber(+V8_INFINITY), region);
+
+ NumberArray = Type::Array(Number, region);
+ StringArray = Type::Array(String, region);
+ AnyArray = Type::Array(Any, region);
+
+ SignedFunction1 = Type::Function(SignedSmall, SignedSmall, region);
+ NumberFunction1 = Type::Function(Number, Number, region);
+ NumberFunction2 = Type::Function(Number, Number, Number, region);
+ MethodFunction = Type::Function(String, Object, 0, region);
+
+ for (int i = 0; i < 30; ++i) {
+ types.push_back(Fuzz());
+ }
+ }
+
+ Handle<i::Map> object_map;
+ Handle<i::Map> array_map;
+ Handle<i::Map> number_map;
+ Handle<i::Map> uninitialized_map;
+
+ Handle<i::Smi> smi;
+ Handle<i::HeapNumber> signed32;
+ Handle<i::JSObject> object1;
+ Handle<i::JSObject> object2;
+ Handle<i::JSArray> array;
+ Handle<i::Oddball> uninitialized;
+
+ #define DECLARE_TYPE(name, value) TypeHandle name;
+ BITSET_TYPE_LIST(DECLARE_TYPE)
+ #undef DECLARE_TYPE
+
+ TypeHandle ObjectClass;
+ TypeHandle ArrayClass;
+ TypeHandle NumberClass;
+ TypeHandle UninitializedClass;
+
+ TypeHandle SmiConstant;
+ TypeHandle Signed32Constant;
+ TypeHandle ObjectConstant1;
+ TypeHandle ObjectConstant2;
+ TypeHandle ArrayConstant;
+ TypeHandle UninitializedConstant;
+
+ TypeHandle Integer;
+
+ TypeHandle NumberArray;
+ TypeHandle StringArray;
+ TypeHandle AnyArray;
+
+ TypeHandle SignedFunction1;
+ TypeHandle NumberFunction1;
+ TypeHandle NumberFunction2;
+ TypeHandle MethodFunction;
+
+ typedef std::vector<TypeHandle> TypeVector;
+ typedef std::vector<Handle<i::Map> > MapVector;
+ typedef std::vector<Handle<i::Object> > ValueVector;
+
+ TypeVector types;
+ MapVector maps;
+ ValueVector values;
+ ValueVector integers; // "Integer" values used for range limits.
+
+ TypeHandle Of(Handle<i::Object> value) {
+ return Type::Of(value, region_);
+ }
+
+ TypeHandle NowOf(Handle<i::Object> value) {
+ return Type::NowOf(value, region_);
+ }
+
+ TypeHandle Class(Handle<i::Map> map) {
+ return Type::Class(map, region_);
+ }
+
+ TypeHandle Constant(Handle<i::Object> value) {
+ return Type::Constant(value, region_);
+ }
+
+ TypeHandle Range(Handle<i::Object> min, Handle<i::Object> max) {
+ return Type::Range(min, max, region_);
+ }
+
+ TypeHandle Context(TypeHandle outer) {
+ return Type::Context(outer, region_);
+ }
+
+ TypeHandle Array1(TypeHandle element) {
+ return Type::Array(element, region_);
+ }
+
+ TypeHandle Function0(TypeHandle result, TypeHandle receiver) {
+ return Type::Function(result, receiver, 0, region_);
+ }
+
+ TypeHandle Function1(TypeHandle result, TypeHandle receiver, TypeHandle arg) {
+ TypeHandle type = Type::Function(result, receiver, 1, region_);
+ type->AsFunction()->InitParameter(0, arg);
+ return type;
+ }
+
+ TypeHandle Function2(TypeHandle result, TypeHandle arg1, TypeHandle arg2) {
+ return Type::Function(result, arg1, arg2, region_);
+ }
+
+ TypeHandle Union(TypeHandle t1, TypeHandle t2) {
+ return Type::Union(t1, t2, region_);
+ }
+ TypeHandle Intersect(TypeHandle t1, TypeHandle t2) {
+ return Type::Intersect(t1, t2, region_);
+ }
+
+ template<class Type2, class TypeHandle2>
+ TypeHandle Convert(TypeHandle2 t) {
+ return Type::template Convert<Type2>(t, region_);
+ }
+
+ TypeHandle Random() {
+ return types[rng_->NextInt(static_cast<int>(types.size()))];
+ }
+
+ TypeHandle Fuzz(int depth = 4) {
+ switch (rng_->NextInt(depth == 0 ? 3 : 20)) {
+ case 0: { // bitset
+ #define COUNT_BITSET_TYPES(type, value) + 1
+ int n = 0 PROPER_BITSET_TYPE_LIST(COUNT_BITSET_TYPES);
+ #undef COUNT_BITSET_TYPES
+ // Pick a bunch of named bitsets and return their intersection.
+ TypeHandle result = Type::Any(region_);
+ for (int i = 0, m = 1 + rng_->NextInt(3); i < m; ++i) {
+ int j = rng_->NextInt(n);
+ #define PICK_BITSET_TYPE(type, value) \
+ if (j-- == 0) { \
+ if (!SmiValuesAre31Bits() && \
+ (Type::type(region_)->Equals(Type::OtherSigned32()) || \
+ Type::type(region_)->Equals(Type::OtherUnsigned31()))) { \
+ /* Hack: Avoid generating those empty bitset types. */ \
+ continue; \
+ } \
+ TypeHandle tmp = Type::Intersect( \
+ result, Type::type(region_), region_); \
+ if (tmp->Is(Type::None()) && i != 0) { \
+ break; \
+ } else { \
+ result = tmp; \
+ continue; \
+ } \
+ }
+ PROPER_BITSET_TYPE_LIST(PICK_BITSET_TYPE)
+ #undef PICK_BITSET_TYPE
+ }
+ return result;
+ }
+ case 1: { // class
+ int i = rng_->NextInt(static_cast<int>(maps.size()));
+ return Type::Class(maps[i], region_);
+ }
+ case 2: { // constant
+ int i = rng_->NextInt(static_cast<int>(values.size()));
+ return Type::Constant(values[i], region_);
+ }
+ case 3: { // range
+ int i = rng_->NextInt(static_cast<int>(integers.size()));
+ int j = rng_->NextInt(static_cast<int>(integers.size()));
+ i::Handle<i::Object> min = integers[i];
+ i::Handle<i::Object> max = integers[j];
+ if (min->Number() > max->Number()) std::swap(min, max);
+ return Type::Range(min, max, region_);
+ }
+ case 4: { // context
+ int depth = rng_->NextInt(3);
+ TypeHandle type = Type::Internal(region_);
+ for (int i = 0; i < depth; ++i) type = Type::Context(type, region_);
+ return type;
+ }
+ case 5: { // array
+ TypeHandle element = Fuzz(depth / 2);
+ return Type::Array(element, region_);
+ }
+ case 6:
+ case 7: { // function
+ TypeHandle result = Fuzz(depth / 2);
+ TypeHandle receiver = Fuzz(depth / 2);
+ int arity = rng_->NextInt(3);
+ TypeHandle type = Type::Function(result, receiver, arity, region_);
+ for (int i = 0; i < type->AsFunction()->Arity(); ++i) {
+ TypeHandle parameter = Fuzz(depth / 2);
+ type->AsFunction()->InitParameter(i, parameter);
+ }
+ return type;
+ }
+ default: { // union
+ int n = rng_->NextInt(10);
+ TypeHandle type = None;
+ for (int i = 0; i < n; ++i) {
+ TypeHandle operand = Fuzz(depth - 1);
+ type = Type::Union(type, operand, region_);
+ }
+ return type;
+ }
+ }
+ UNREACHABLE();
+ }
+
+ Region* region() { return region_; }
+
+ private:
+ Region* region_;
+ v8::base::RandomNumberGenerator* rng_;
+};
+
+
+} } // namespace v8::internal
+
+#endif
+++ /dev/null
-# 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.
-
-[
-]
+++ /dev/null
-// 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
-
-// TODO(jkummerow): There are many ways to improve these tests, e.g.:
-// - more variance in randomized inputs
-// - better time complexity management
-// - better code readability and documentation of intentions.
-
-var RUN_WITH_ALL_ARGUMENT_ENTRIES = false;
-var kOnManyArgumentsRemove = 5;
-
-function makeArguments() {
- var result = [ ];
- result.push(17);
- result.push(-31);
- result.push(new Array(100));
- var a = %NormalizeElements([]);
- a.length = 100003;
- result.push(a);
- result.push(Number.MIN_VALUE);
- result.push("whoops");
- result.push("x");
- result.push({"x": 1, "y": 2});
- var slowCaseObj = {"a": 3, "b": 4, "c": 5};
- delete slowCaseObj.c;
- result.push(slowCaseObj);
- result.push(function () { return 8; });
- return result;
-}
-
-var kArgObjects = makeArguments().length;
-
-function makeFunction(name, argc) {
- var args = [];
- for (var i = 0; i < argc; i++)
- args.push("x" + i);
- var argsStr = args.join(", ");
- return new Function(argsStr,
- "return %" + name + "(" + argsStr + ");");
-}
-
-function testArgumentCount(name, argc) {
- for (var i = 0; i < 10; i++) {
- var func = null;
- try {
- func = makeFunction(name, i);
- } catch (e) {
- if (e != "SyntaxError: Illegal access") throw e;
- }
- if (func === null && i == argc) {
- throw "unexpected exception";
- }
- var args = [ ];
- for (var j = 0; j < i; j++)
- args.push(0);
- try {
- func.apply(void 0, args);
- } catch (e) {
- // we don't care what happens as long as we don't crash
- }
- }
-}
-
-function testArgumentTypes(name, argc) {
- var type = 0;
- var hasMore = true;
- var func = makeFunction(name, argc);
- while (hasMore) {
- var argPool = makeArguments();
- // When we have 5 or more arguments we lower the amount of tests cases
- // by randomly removing kOnManyArgumentsRemove entries
- var numArguments = RUN_WITH_ALL_ARGUMENT_ENTRIES ?
- kArgObjects : kArgObjects - kOnManyArgumentsRemove;
- if (kArgObjects >= 5 && !RUN_WITH_ALL_ARGUMENT_ENTRIES) {
- for (var i = 0; i < kOnManyArgumentsRemove; i++) {
- var rand = Math.floor(Math.random() * (kArgObjects - i));
- argPool.splice(rand, 1);
- }
- }
- var current = type;
- hasMore = false;
- var argList = [ ];
- for (var i = 0; i < argc; i++) {
- var index = current % numArguments;
- current = (current / numArguments) << 0;
- if (index != (numArguments - 1))
- hasMore = true;
- argList.push(argPool[index]);
- }
- try {
- func.apply(void 0, argList);
- } catch (e) {
- // we don't care what happens as long as we don't crash
- }
- type++;
- }
-}
-
-testArgumentCount(NAME, ARGC);
-testArgumentTypes(NAME, ARGC);
+++ /dev/null
-# 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.
-
-[
-[ALWAYS, {
- # These are designed to crash:
- "Abort": [SKIP],
- "AbortJS": [SKIP],
- "SystemBreak": [SKIP],
- "_DebugBreakInOptimizedCode": [SKIP],
-
- # varargs.
- "Call": [SKIP],
- "_CallFunction": [SKIP],
-
- # Implemented in the parser, not callable.
- "IS_VAR": [SKIP],
-
- # Compile-time ASSERTs.
- "_DateField": [SKIP],
- "_GetFromCache": [SKIP],
-
- # Riddled with ASSERTs.
- "CompileForOnStackReplacement": [SKIP],
-
- # Too slow for fuzzing.
- "SetAllocationTimeout": [SKIP],
-
- # TODO(jkummerow): Fix these and un-blacklist them!
- "CreateDateTimeFormat": [SKIP],
- "CreateNumberFormat": [SKIP],
-
- # TODO(danno): Fix these internal function that are only callable form stubs
- # and un-blacklist them!
- "CompileLazy": [SKIP],
- "NotifyDeoptimized": [SKIP],
- "NotifyStubFailure": [SKIP],
- "NewSloppyArguments": [SKIP],
- "NewStrictArguments": [SKIP],
- "ArrayConstructor": [SKIP],
- "InternalArrayConstructor": [SKIP],
- "FinalizeInstanceSize": [SKIP],
- "PromoteScheduledException": [SKIP],
- "NewFunctionContext": [SKIP],
- "PushWithContext": [SKIP],
- "PushCatchContext": [SKIP],
- "PushModuleContext": [SKIP],
- "LoadLookupSlot": [SKIP],
- "LoadLookupSlotNoReferenceError": [SKIP],
- "ResolvePossiblyDirectEval": [SKIP],
- "ForInInit": [SKIP],
- "ForInNext": [SKIP],
-
- # TODO(jkummerow): Figure out what to do about inlined functions.
- "_GeneratorNext": [SKIP],
- "_GeneratorThrow": [SKIP],
- "_GetCachedArrayIndex": [SKIP],
- "_HasCachedArrayIndex": [SKIP],
- "_IsStringWrapperSafeForDefaultValueOf": [SKIP],
- "_OneByteSeqStringSetChar": [SKIP],
- "_RegExpConstructResult": [SKIP],
- "_TwoByteSeqStringSetChar": [SKIP],
-
- # These are slow.
- "DebugEvaluate": [PASS, SLOW],
- "DebugReferencedBy": [PASS, SLOW],
- "SetAccessorProperty": [PASS, SLOW],
- "SetScopeVariableValue": [PASS, SLOW],
-}] # ALWAYS
-]
+++ /dev/null
-# 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.
-
-import os
-
-from testrunner.local import commands
-from testrunner.local import testsuite
-from testrunner.local import utils
-from testrunner.objects import testcase
-
-class FuzzNativesTestSuite(testsuite.TestSuite):
-
- def __init__(self, name, root):
- super(FuzzNativesTestSuite, self).__init__(name, root)
-
- def ListTests(self, context):
- shell = os.path.abspath(os.path.join(context.shell_dir, self.shell()))
- if utils.IsWindows():
- shell += ".exe"
- output = commands.Execute(
- context.command_prefix +
- [shell, "--allow-natives-syntax", "-e",
- "try { var natives = %ListNatives();"
- " for (var n in natives) { print(natives[n]); }"
- "} catch(e) {}"] +
- context.extra_flags)
- if output.exit_code != 0:
- print output.stdout
- print output.stderr
- assert False, "Failed to get natives list."
- tests = []
- for line in output.stdout.strip().split():
- try:
- (name, argc) = line.split(",")
- flags = ["--allow-natives-syntax",
- "-e", "var NAME = '%s', ARGC = %s;" % (name, argc)]
- test = testcase.TestCase(self, name, flags)
- tests.append(test)
- except:
- # Work-around: If parsing didn't work, it might have been due to output
- # caused by other d8 flags.
- pass
- return tests
-
- def GetFlagsForTestCase(self, testcase, context):
- name = testcase.path
- basefile = os.path.join(self.root, "base.js")
- return testcase.flags + [basefile] + context.mode_flags
-
-def GetSuite(name, root):
- return FuzzNativesTestSuite(name, root)
+++ /dev/null
-# 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.
-
-[
-]
--- /dev/null
+// 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.
+
+function toSurrogatePair(c) {
+ return String.fromCharCode(((c - 0x10000) >>> 10) & 0x3FF | 0xD800) +
+ String.fromCharCode(c & 0x3FF | 0xDC00);
+}
+
+function testIdStart(c, is_id_start) {
+ var source = "var " + toSurrogatePair(c);
+ print(source);
+ if (is_id_start) {
+ assertDoesNotThrow(source);
+ } else {
+ assertThrows(source);
+ }
+}
+
+function testIdPart(c, is_id_start) {
+ var source = "var v" + toSurrogatePair(c);
+ print(source);
+ if (is_id_start) {
+ assertDoesNotThrow(source);
+ } else {
+ assertThrows(source);
+ }
+}
+
+[0x10403, 0x1043C, 0x16F9C, 0x10048, 0x1014D].forEach(function(c) {
+ testIdStart(c, true);
+ testIdPart(c, true);
+});
+
+[0x101FD, 0x11002, 0x104A9].forEach(function(c) {
+ testIdStart(c, false);
+ testIdPart(c, true);
+});
+
+[0x10111, 0x1F4A9].forEach(function(c) {
+ testIdStart(c, false);
+ testIdPart(c, false);
+});
--- /dev/null
+{
+ "name": "JSTests/Classes",
+ "path": ["."],
+ "main": "run.js",
+ "flags": ["--harmony-classes"],
+ "run_count": 5,
+ "units": "score",
+ "results_regexp": "^%s\\-Classes\\(Score\\): (.+)$",
+ "total": true,
+ "tests": [
+ {"name": "Super"}
+ ]
+}
--- /dev/null
+// 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.
+
+
+load('../base.js');
+load('super.js');
+
+
+var success = true;
+
+function PrintResult(name, result) {
+ print(name + '-Classes(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 });
--- /dev/null
+// 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.
+'use strict';
+
+var SuperBenchmark = new BenchmarkSuite('Super', [100], [
+ new Benchmark('SuperMethodCall', false, false, 0, SuperMethodCall),
+ new Benchmark('SuperGetterCall', false, false, 0, SuperGetterCall),
+ new Benchmark('SuperSetterCall', false, false, 0, SuperSetterCall),
+]);
+
+
+function Base() { }
+Base.prototype = {
+ constructor: Base,
+ get x() {
+ return this._x++;
+ },
+ set x(v) {
+ this._x += v;
+ return this._x;
+ }
+}
+
+Base.prototype.f = function() {
+ return this._x++;
+}.toMethod(Base.prototype);
+
+function Derived() {
+ this._x = 1;
+}
+Derived.prototype = Object.create(Base.prototype);
+Object.setPrototypeOf(Derived, Base);
+
+Derived.prototype.SuperCall = function() {
+ return super.f();
+}.toMethod(Derived.prototype);
+
+Derived.prototype.GetterCall = function() {
+ return super.x;
+}.toMethod(Derived.prototype);
+
+Derived.prototype.SetterCall = function() {
+ return super.x = 5;
+}.toMethod(Derived.prototype);
+
+var derived = new Derived();
+
+function SuperMethodCall() {
+ return derived.SuperCall();
+}
+
+function SuperGetterCall() {
+ return derived.GetterCall();
+}
+
+function SuperSetterCall() {
+ return derived.SetterCall();
+}
--- /dev/null
+{
+ "name": "JSTests/Collections",
+ "path": ["."],
+ "main": "run.js",
+ "run_count": 5,
+ "units": "score",
+ "results_regexp": "^%s\\-Collections\\(Score\\): (.+)$",
+ "total": true,
+ "tests": [
+ {"name": "Map-Smi"},
+ {"name": "Map-String"},
+ {"name": "Map-Object"},
+ {"name": "Map-Iteration"},
+ {"name": "Set-Smi"},
+ {"name": "Set-String"},
+ {"name": "Set-Object"},
+ {"name": "Set-Iteration"},
+ {"name": "WeakMap"},
+ {"name": "WeakSet"}
+ ]
+}
--- /dev/null
+// 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.
+
+
+var N = 10;
+var keys;
+
+
+function SetupSmiKeys() {
+ keys = new Array(N * 2);
+ for (var i = 0; i < N * 2; i++) {
+ keys[i] = i;
+ }
+}
+
+
+function SetupStringKeys() {
+ keys = new Array(N * 2);
+ for (var i = 0; i < N * 2; i++) {
+ keys[i] = 's' + i;
+ }
+}
+
+
+function SetupObjectKeys() {
+ keys = new Array(N * 2);
+ for (var i = 0; i < N * 2; i++) {
+ keys[i] = {};
+ }
+}
--- /dev/null
+// 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.
+
+
+var MapSmiBenchmark = new BenchmarkSuite('Map-Smi', [1000], [
+ new Benchmark('Set', false, false, 0, MapSetSmi, MapSetupSmiBase, MapTearDown),
+ new Benchmark('Has', false, false, 0, MapHasSmi, MapSetupSmi, MapTearDown),
+ new Benchmark('Get', false, false, 0, MapGetSmi, MapSetupSmi, MapTearDown),
+ new Benchmark('Delete', false, false, 0, MapDeleteSmi, MapSetupSmi, MapTearDown),
+]);
+
+
+var MapStringBenchmark = new BenchmarkSuite('Map-String', [1000], [
+ new Benchmark('Set', false, false, 0, MapSetString, MapSetupStringBase, MapTearDown),
+ new Benchmark('Has', false, false, 0, MapHasString, MapSetupString, MapTearDown),
+ new Benchmark('Get', false, false, 0, MapGetString, MapSetupString, MapTearDown),
+ new Benchmark('Delete', false, false, 0, MapDeleteString, MapSetupString, MapTearDown),
+]);
+
+
+var MapObjectBenchmark = new BenchmarkSuite('Map-Object', [1000], [
+ new Benchmark('Set', false, false, 0, MapSetObject, MapSetupObjectBase, MapTearDown),
+ new Benchmark('Has', false, false, 0, MapHasObject, MapSetupObject, MapTearDown),
+ new Benchmark('Get', false, false, 0, MapGetObject, MapSetupObject, MapTearDown),
+ new Benchmark('Delete', false, false, 0, MapDeleteObject, MapSetupObject, MapTearDown),
+]);
+
+
+var MapIterationBenchmark = new BenchmarkSuite('Map-Iteration', [1000], [
+ new Benchmark('ForEach', false, false, 0, MapForEach, MapSetupSmi, MapTearDown),
+]);
+
+
+var map;
+
+
+function MapSetupSmiBase() {
+ SetupSmiKeys();
+ map = new Map;
+}
+
+
+function MapSetupSmi() {
+ MapSetupSmiBase();
+ MapSetSmi();
+}
+
+
+function MapSetupStringBase() {
+ SetupStringKeys();
+ map = new Map;
+}
+
+
+function MapSetupString() {
+ MapSetupStringBase();
+ MapSetString();
+}
+
+
+function MapSetupObjectBase() {
+ SetupObjectKeys();
+ map = new Map;
+}
+
+
+function MapSetupObject() {
+ MapSetupObjectBase();
+ MapSetObject();
+}
+
+
+function MapTearDown() {
+ map = null;
+}
+
+
+function MapSetSmi() {
+ for (var i = 0; i < N; i++) {
+ map.set(keys[i], i);
+ }
+}
+
+
+function MapHasSmi() {
+ for (var i = 0; i < N; i++) {
+ if (!map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapGetSmi() {
+ for (var i = 0; i < N; i++) {
+ if (map.get(keys[i]) !== i) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.get(keys[i]) !== undefined) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapDeleteSmi() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ map.delete(keys[i]);
+ }
+}
+
+
+function MapSetString() {
+ for (var i = 0; i < N; i++) {
+ map.set(keys[i], i);
+ }
+}
+
+
+function MapHasString() {
+ for (var i = 0; i < N; i++) {
+ if (!map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapGetString() {
+ for (var i = 0; i < N; i++) {
+ if (map.get(keys[i]) !== i) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.get(keys[i]) !== undefined) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapDeleteString() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ map.delete(keys[i]);
+ }
+}
+
+
+function MapSetObject() {
+ for (var i = 0; i < N; i++) {
+ map.set(keys[i], i);
+ }
+}
+
+
+function MapHasObject() {
+ for (var i = 0; i < N; i++) {
+ if (!map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapGetObject() {
+ for (var i = 0; i < N; i++) {
+ if (map.get(keys[i]) !== i) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (map.get(keys[i]) !== undefined) {
+ throw new Error();
+ }
+ }
+}
+
+
+function MapDeleteObject() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ map.delete(keys[i]);
+ }
+}
+
+
+function MapForEach() {
+ map.forEach(function(v, k) {
+ if (v !== k) {
+ throw new Error();
+ }
+ });
+}
// found in the LICENSE file.
-load('base.js');
+load('../base.js');
+load('common.js');
load('map.js');
load('set.js');
load('weakmap.js');
--- /dev/null
+// 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.
+
+
+var SetSmiBenchmark = new BenchmarkSuite('Set-Smi', [1000], [
+ new Benchmark('Set', false, false, 0, SetAddSmi, SetSetupSmiBase, SetTearDown),
+ new Benchmark('Has', false, false, 0, SetHasSmi, SetSetupSmi, SetTearDown),
+ new Benchmark('Delete', false, false, 0, SetDeleteSmi, SetSetupSmi, SetTearDown),
+]);
+
+
+var SetStringBenchmark = new BenchmarkSuite('Set-String', [1000], [
+ new Benchmark('Set', false, false, 0, SetAddString, SetSetupStringBase, SetTearDown),
+ new Benchmark('Has', false, false, 0, SetHasString, SetSetupString, SetTearDown),
+ new Benchmark('Delete', false, false, 0, SetDeleteString, SetSetupString, SetTearDown),
+]);
+
+
+var SetObjectBenchmark = new BenchmarkSuite('Set-Object', [1000], [
+ new Benchmark('Set', false, false, 0, SetAddObject, SetSetupObjectBase, SetTearDown),
+ new Benchmark('Has', false, false, 0, SetHasObject, SetSetupObject, SetTearDown),
+ new Benchmark('Delete', false, false, 0, SetDeleteObject, SetSetupObject, SetTearDown),
+]);
+
+
+var SetIterationBenchmark = new BenchmarkSuite('Set-Iteration', [1000], [
+ new Benchmark('ForEach', false, false, 0, SetForEach, SetSetupSmi, SetTearDown),
+]);
+
+
+var set;
+
+
+function SetSetupSmiBase() {
+ SetupSmiKeys();
+ set = new Set;
+}
+
+
+function SetSetupSmi() {
+ SetSetupSmiBase();
+ SetAddSmi();
+}
+
+
+function SetSetupStringBase() {
+ SetupStringKeys();
+ set = new Set;
+}
+
+
+function SetSetupString() {
+ SetSetupStringBase();
+ SetAddString();
+}
+
+
+function SetSetupObjectBase() {
+ SetupObjectKeys();
+ set = new Set;
+}
+
+
+function SetSetupObject() {
+ SetSetupObjectBase();
+ SetAddObject();
+}
+
+
+function SetTearDown() {
+ set = null;
+}
+
+
+function SetAddSmi() {
+ for (var i = 0; i < N; i++) {
+ set.add(keys[i], i);
+ }
+}
+
+
+function SetHasSmi() {
+ for (var i = 0; i < N; i++) {
+ if (!set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function SetDeleteSmi() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ set.delete(keys[i]);
+ }
+}
+
+
+function SetAddString() {
+ for (var i = 0; i < N; i++) {
+ set.add(keys[i], i);
+ }
+}
+
+
+function SetHasString() {
+ for (var i = 0; i < N; i++) {
+ if (!set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function SetDeleteString() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ set.delete(keys[i]);
+ }
+}
+
+
+function SetAddObject() {
+ for (var i = 0; i < N; i++) {
+ set.add(keys[i], i);
+ }
+}
+
+
+function SetHasObject() {
+ for (var i = 0; i < N; i++) {
+ if (!set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+ for (var i = N; i < 2 * N; i++) {
+ if (set.has(keys[i])) {
+ throw new Error();
+ }
+ }
+}
+
+
+function SetDeleteObject() {
+ // This is run more than once per setup so we will end up deleting items
+ // more than once. Therefore, we do not the return value of delete.
+ for (var i = 0; i < N; i++) {
+ set.delete(keys[i]);
+ }
+}
+
+
+function SetForEach() {
+ set.forEach(function(v, k) {
+ if (v !== k) {
+ throw new Error();
+ }
+ });
+}
var MapBenchmark = new BenchmarkSuite('WeakMap', [1000], [
- new Benchmark('Set', false, false, 0, WeakMapSet),
+ new Benchmark('Set', false, false, 0, WeakMapSet, WeakMapSetupBase,
+ WeakMapTearDown),
new Benchmark('Has', false, false, 0, WeakMapHas, WeakMapSetup,
WeakMapTearDown),
new Benchmark('Get', false, false, 0, WeakMapGet, WeakMapSetup,
var wm;
-var N = 10;
-var keys = [];
-for (var i = 0; i < N * 2; i++) {
- keys[i] = {};
+function WeakMapSetupBase() {
+ SetupObjectKeys();
+ wm = new WeakMap;
}
function WeakMapSetup() {
- wm = new WeakMap;
- for (var i = 0; i < N; i++) {
- wm.set(keys[i], i);
- }
+ WeakMapSetupBase();
+ WeakMapSet();
}
function WeakMapSet() {
- WeakMapSetup();
- WeakMapTearDown();
+ for (var i = 0; i < N; i++) {
+ wm.set(keys[i], i);
+ }
}
var SetBenchmark = new BenchmarkSuite('WeakSet', [1000], [
- new Benchmark('Add', false, false, 0, WeakSetAdd),
+ new Benchmark('Add', false, false, 0, WeakSetAdd, WeakSetSetupBase,
+ WeakSetTearDown),
new Benchmark('Has', false, false, 0, WeakSetHas, WeakSetSetup,
WeakSetTearDown),
new Benchmark('Delete', false, false, 0, WeakSetDelete, WeakSetSetup,
var ws;
-var N = 10;
-var keys = [];
-for (var i = 0; i < N * 2; i++) {
- keys[i] = {};
+function WeakSetSetupBase() {
+ SetupObjectKeys();
+ ws = new WeakSet;
}
function WeakSetSetup() {
- ws = new WeakSet;
- for (var i = 0; i < N; i++) {
- ws.add(keys[i]);
- }
+ WeakSetSetupBase();
+ WeakSetAdd();
}
function WeakSetAdd() {
- WeakSetSetup();
- WeakSetTearDown();
+ for (var i = 0; i < N; i++) {
+ ws.add(keys[i]);
+ }
}
--- /dev/null
+{
+ "name": "JSTests/Iterators",
+ "path": ["."],
+ "main": "run.js",
+ "run_count": 5,
+ "units": "score",
+ "results_regexp": "^%s\\-Iterators\\(Score\\): (.+)$",
+ "total": true,
+ "tests": [
+ {"name": "ForOf"}
+ ]
+}
--- /dev/null
+// 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.
+
+new BenchmarkSuite('ForOf', [1000], [
+ new Benchmark('ArrayValues', false, false, 0,
+ ForOf, ForOfArraySetup, ForOfTearDown),
+ new Benchmark('ArrayKeys', false, false, 0,
+ ForOf, ForOfArrayKeysSetup, ForOfTearDown),
+ new Benchmark('ArrayEntries', false, false, 0,
+ ForOf, ForOfArrayEntriesSetup, ForOfTearDown),
+ new Benchmark('Uint8Array', false, false, 0,
+ ForOf, ForOfUint8ArraySetup, ForOfTearDown),
+ new Benchmark('Float64Array', false, false, 0,
+ ForOf, ForOfFloat64ArraySetup, ForOfTearDown),
+ new Benchmark('String', false, false, 0,
+ ForOf, ForOfStringSetup, ForOfTearDown),
+]);
+
+
+var iterable;
+var N = 100;
+var expected, result;
+
+
+function ForOfArraySetupHelper(constructor) {
+ iterable = new constructor(N);
+ for (var i = 0; i < N; i++) iterable[i] = i;
+ expected = N - 1;
+}
+
+
+function ForOfArraySetup() {
+ ForOfArraySetupHelper(Array);
+ // Default iterator is values().
+}
+
+
+function ForOfArrayKeysSetup() {
+ ForOfArraySetupHelper(Array);
+ iterable = iterable.keys();
+}
+
+
+function ForOfArrayEntriesSetup() {
+ ForOfArraySetupHelper(Array);
+ iterable = iterable.entries();
+ expected = [N-1, N-1];
+}
+
+
+function ForOfUint8ArraySetup() {
+ ForOfArraySetupHelper(Uint8Array);
+}
+
+
+function ForOfFloat64ArraySetup() {
+ ForOfArraySetupHelper(Float64Array);
+}
+
+
+function ForOfStringSetup() {
+ iterable = "abcdefhijklmnopqrstuvwxyzABCDEFHIJKLMNOPQRSTUVWXYZ0123456789";
+ expected = "9";
+}
+
+
+function Equals(expected, actual) {
+ if (expected === actual) return true;
+ if (typeof expected !== typeof actual) return false;
+ if (typeof expected !== 'object') return false;
+ for (var k of Object.keys(expected)) {
+ if (!(k in actual)) return false;
+ if (!Equals(expected[k], actual[k])) return false;
+ }
+ for (var k of Object.keys(actual)) {
+ if (!(k in expected)) return false;
+ }
+ return true;
+}
+
+function ForOfTearDown() {
+ iterable = null;
+ if (!Equals(expected, result)) {
+ throw new Error("Bad result: " + result);
+ }
+}
+
+
+function ForOf() {
+ for (var x of iterable) {
+ result = x;
+ }
+}
--- /dev/null
+// 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.
+
+
+load('../base.js');
+load('forof.js');
+
+
+var success = true;
+
+function PrintResult(name, result) {
+ print(name + '-Iterators(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 });
--- /dev/null
+{
+ "name": "JSTests/Strings",
+ "path": ["."],
+ "main": "run.js",
+ "flags": ["--harmony-strings"],
+ "run_count": 5,
+ "units": "score",
+ "results_regexp": "^%s\\-Strings\\(Score\\): (.+)$",
+ "total": true,
+ "tests": [
+ {"name": "StringFunctions"}
+ ]
+}
--- /dev/null
+// 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.
+
+new BenchmarkSuite('StringFunctions', [1000], [
+ new Benchmark('StringRepeat', false, false, 0,
+ Repeat, RepeatSetup, RepeatTearDown),
+ new Benchmark('StringStartsWith', false, false, 0,
+ StartsWith, WithSetup, WithTearDown),
+ new Benchmark('StringEndsWith', false, false, 0,
+ EndsWith, WithSetup, WithTearDown),
+ new Benchmark('StringContains', false, false, 0,
+ Contains, ContainsSetup, WithTearDown),
+ new Benchmark('StringFromCodePoint', false, false, 0,
+ FromCodePoint, FromCodePointSetup, FromCodePointTearDown),
+ new Benchmark('StringCodePointAt', false, false, 0,
+ CodePointAt, CodePointAtSetup, CodePointAtTearDown),
+]);
+
+
+var result;
+
+var stringRepeatSource = "abc";
+
+function RepeatSetup() {
+ result = undefined;
+}
+
+function Repeat() {
+ result = stringRepeatSource.repeat(500);
+}
+
+function RepeatTearDown() {
+ var expected = "";
+ for(var i = 0; i < 1000; i++) {
+ expected += stringRepeatSource;
+ }
+ return result === expected;
+}
+
+
+var str;
+var substr;
+
+function WithSetup() {
+ str = "abc".repeat(500);
+ substr = "abc".repeat(200);
+ result = undefined;
+}
+
+function WithTearDown() {
+ return !!result;
+}
+
+function StartsWith() {
+ result = str.startsWith(substr);
+}
+
+function EndsWith() {
+ result = str.endsWith(substr);
+}
+
+function ContainsSetup() {
+ str = "def".repeat(100) + "abc".repeat(100) + "qqq".repeat(100);
+ substr = "abc".repeat(100);
+}
+
+function Contains() {
+ result = str.contains(substr);
+}
+
+var MAX_CODE_POINT = 0xFFFFF;
+
+function FromCodePointSetup() {
+ result = new Array(MAX_CODE_POINT + 1);
+}
+
+function FromCodePoint() {
+ for (var i = 0; i <= MAX_CODE_POINT; i++) {
+ result[i] = String.fromCodePoint(i);
+ }
+}
+
+function FromCodePointTearDown() {
+ for (var i = 0; i <= MAX_CODE_POINT; i++) {
+ if (i !== result[i].codePointAt(0)) return false;
+ }
+ return true;
+}
+
+
+var allCodePoints;
+
+function CodePointAtSetup() {
+ allCodePoints = new Array(MAX_CODE_POINT + 1);
+ for (var i = 0; i <= MAX_CODE_POINT; i++) {
+ allCodePoints = String.fromCodePoint(i);
+ }
+ result = undefined;
+}
+
+function CodePointAt() {
+ result = 0;
+ for (var i = 0; i <= MAX_CODE_POINT; i++) {
+ result += allCodePoints.codePointAt(i);
+ }
+}
+
+function CodePointAtTearDown() {
+ return result === MAX_CODE_POINT * (MAX_CODE_POINT + 1) / 2;
+}
--- /dev/null
+// 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.
+
+
+load('../base.js');
+load('harmony-string.js');
+
+
+var success = true;
+
+function PrintResult(name, result) {
+ print(name + '-Strings(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 });
assertEquals(3, count);
for (var i in a) assertEquals(2, a[i]);
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].filter(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].filter(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].filter(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
a.forEach(function(n) { count++; });
assertEquals(1, count);
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].forEach(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].forEach(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].forEach(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
assertTrue(a.every(function(n) { count++; return n == 2; }));
assertEquals(2, count);
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].every(function() { a.push(this); return true; }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].every(function() { a.push(this); return true; }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].every(function() { 'use strict'; a.push(this); return true; }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
//
a = a.map(function(n) { return 2*n; });
for (var i in a) assertEquals(4, a[i]);
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].map(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].map(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].map(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
//
assertTrue(a.some(function(n) { count++; return n == 2; }));
assertEquals(2, count);
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].some(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].some(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].some(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
assertEquals([1,1,2,3], a4);
a4 = [1,2,3];
a4.unshift(1.1);
- // TODO(verwaest): We'll want to support double unshifting as well.
- // assertTrue(%HasFastDoubleElements(a4));
- assertTrue(%HasFastObjectElements(a4));
+ assertTrue(%HasFastDoubleElements(a4));
assertEquals([1.1,1,2,3], a4);
a4 = [1.1,2,3];
a4.unshift(1);
- // assertTrue(%HasFastDoubleElements(a4));
- assertTrue(%HasFastObjectElements(a4));
+ assertTrue(%HasFastDoubleElements(a4));
assertEquals([1,1.1,2,3], a4);
a4 = [{},2,3];
a4.unshift(1);
[3, 3, 2, [1, 2, 3, 4, 4, 5], 6],
[6, 4, 3, [1, 2, 3, 4, 4, 5, 6], 10],
], arr, extender, 0);
+
+var arr = [];
+Object.defineProperty(arr, "0", { get: function() { delete this[0] },
+ configurable: true });
+assertEquals(undefined, arr.reduce(function(val) { return val }));
+
+var arr = [];
+Object.defineProperty(arr, "0", { get: function() { delete this[0] },
+ configurable: true});
+assertEquals(undefined, arr.reduceRight(function(val) { return val }));
array.shift();
return array;
}
-assertEquals(["element 1",2], test(["0",,2]));
-assertEquals(["element 1",{}], test([{},,{}]));
+
+var result = test(["0",,2]);
+assertEquals(["element 1","element 1"], result);
+assertTrue(result.hasOwnProperty("0"));
+assertFalse(result.hasOwnProperty("1"));
+result = test([{},,{}]);
+assertEquals(["element 1","element 1"], result);
+assertTrue(result.hasOwnProperty("0"));
+assertFalse(result.hasOwnProperty("1"));
%OptimizeFunctionOnNextCall(test);
-assertEquals(["element 1",0], test([{},,0]));
+result = test([{},,0]);
+assertEquals(["element 1","element 1"], result);
+assertTrue(result.hasOwnProperty("0"));
+assertFalse(result.hasOwnProperty("1"));
})();
-// Check that unshift with no args has a side-effect of
-// filling the holes with elements from the prototype
-// (if present, of course)
+// Check that unshift with no args has no side-effects.
(function() {
var len = 3;
var array = new Array(len);
assertTrue(delete Array.prototype[0]);
assertTrue(delete Array.prototype[2]);
- // unshift makes array own 0 and 2...
- assertTrue(array.hasOwnProperty(0));
+ // array still owns nothing...
+ assertFalse(array.hasOwnProperty(0));
assertFalse(array.hasOwnProperty(1));
- assertTrue(array.hasOwnProperty(2));
+ assertFalse(array.hasOwnProperty(2));
// ... so they are not affected be delete.
- assertEquals(array[0], at0);
+ assertEquals(array[0], undefined);
assertEquals(array[1], undefined);
- assertEquals(array[2], at2);
+ assertEquals(array[2], undefined);
})();
assertTrue(delete Array.prototype[7]);
})();
-// Check that unshift with no args has a side-effect of
-// filling the holes with elements from the prototype
-// (if present, of course)
+// Check that unshift with no args has no side-effects.
(function() {
var len = 3;
var array = new Array(len);
assertEquals(len, array.unshift());
- // unshift makes array own 0 and 2...
- assertTrue(array.hasOwnProperty(0));
+ // array still owns nothing.
+ assertFalse(array.hasOwnProperty(0));
assertFalse(array.hasOwnProperty(1));
- assertTrue(array.hasOwnProperty(2));
+ assertFalse(array.hasOwnProperty(2));
- // ... so they are not affected be delete.
+ // ... but still sees values from array_proto.
assertEquals(array[0], at0);
assertEquals(array[1], undefined);
assertEquals(array[2], at2);
--- /dev/null
+// 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.
+
+function Module() {
+ "use asm";
+
+ function d0() {
+ do { } while(false);
+ return 110;
+ }
+
+ function d1() {
+ do { return 111; } while(false);
+ return 112;
+ }
+
+ function d2() {
+ do { break; } while(false);
+ return 113;
+ }
+
+ function d3(a) {
+ a = a | 0;
+ do { if (a) return 114; } while(false);
+ return 115;
+ }
+
+ function d4(a) {
+ a = a | 0;
+ do { if (a) return 116; else break; } while(false);
+ return 117;
+ }
+
+ function d5(a) {
+ a = a | 0;
+ do { if (a) return 118; } while(false);
+ return 119;
+ }
+
+ function d6(a) {
+ a = a | 0;
+ do {
+ if (a == 0) return 120;
+ if (a == 1) break;
+ if (a == 2) return 122;
+ if (a == 3) continue;
+ if (a == 4) return 124;
+ } while(false);
+ return 125;
+ }
+
+ return {d0: d0, d1: d1, d2: d2, d3: d3, d4: d4, d5: d5, d6: d6};
+}
+
+var m = Module();
+
+assertEquals(110, m.d0());
+
+assertEquals(111, m.d1());
+
+assertEquals(113, m.d2());
+
+assertEquals(114, m.d3(1));
+assertEquals(115, m.d3(0));
+
+assertEquals(116, m.d4(1));
+assertEquals(117, m.d4(0));
+
+assertEquals(118, m.d5(1));
+assertEquals(119, m.d5(0));
+
+assertEquals(120, m.d6(0));
+assertEquals(125, m.d6(1));
+assertEquals(122, m.d6(2));
+assertEquals(125, m.d6(3));
+assertEquals(124, m.d6(4));
+assertEquals(125, m.d6(5));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, buffer) {
+ "use asm";
+ function f(i) {
+ var j;
+ i = i|0;
+ do {
+ if (i > 0) {
+ j = i != 0;
+ i = (i - 1) | 0;
+ } else {
+ j = 0;
+ }
+ } while (j);
+ return i;
+ }
+ return {f:f};
+}
+
+var m = Module(this, {}, new ArrayBuffer(64*1024));
+
+assertEquals(-1, m.f("-1"));
+assertEquals(0, m.f(-Math.infinity));
+assertEquals(0, m.f(undefined));
+assertEquals(0, m.f(0));
+assertEquals(0, m.f(1));
+assertEquals(0, m.f(100));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT =
+ /frame averages: .+ \+- .+, range: .+ to .+ \n/;
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertTrue(EXPECTED_OUTPUT.test(Module.printBuffer));
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+var __ZTVN10__cxxabiv117__class_type_infoE = 7024;
+var __ZTVN10__cxxabiv120__si_class_type_infoE = 7064;
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(7731);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,232,118,72,0,0,0,0,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,114,114,111,114,58,32,37,100,92,110,0,0,0,0,0,102,114,97,109,101,32,97,118,101,114,97,103,101,115,58,32,37,46,51,102,32,43,45,32,37,46,51,102,44,32,114,97,110,103,101,58,32,37,46,51,102,32,116,111,32,37,46,51,102,32,10,0,0,0,0,0,105,102,32,40,77,111,100,117,108,101,46,114,101,112,111,114,116,67,111,109,112,108,101,116,105,111,110,41,32,77,111,100,117,108,101,46,114,101,112,111,114,116,67,111,109,112,108,101,116,105,111,110,40,41,0,0,114,101,115,112,111,110,115,105,118,101,32,109,97,105,110,32,108,111,111,112,0,0,0,0,0,0,0,0,56,1,0,0,1,0,0,0,2,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,49,49,98,50,69,100,103,101,83,104,97,112,101,0,0,0,55,98,50,83,104,97,112,101,0,0,0,0,0,0,0,0,120,27,0,0,32,1,0,0,160,27,0,0,16,1,0,0,48,1,0,0,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,83,104,97,112,101,115,47,98,50,80,111,108,121,103,111,110,83,104,97,112,101,46,99,112,112,0,0,0,0,0,0,0,48,46,48,102,32,60,61,32,108,111,119,101,114,32,38,38,32,108,111,119,101,114,32,60,61,32,105,110,112,117,116,46,109,97,120,70,114,97,99,116,105,111,110,0,0,0,0,0,82,97,121,67,97,115,116,0,109,95,118,101,114,116,101,120,67,111,117,110,116,32,62,61,32,51,0,0,0,0,0,0,67,111,109,112,117,116,101,77,97,115,115,0,0,0,0,0,97,114,101,97,32,62,32,49,46,49,57,50,48,57,50,57,48,101,45,48,55,70,0,0,0,0,0,0,48,2,0,0,3,0,0,0,4,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,49,52,98,50,80,111,108,121,103,111,110,83,104,97,112,101,0,0,0,0,0,0,0,0,160,27,0,0,24,2,0,0,48,1,0,0,0,0,0,0,16,0,0,0,32,0,0,0,64,0,0,0,96,0,0,0,128,0,0,0,160,0,0,0,192,0,0,0,224,0,0,0,0,1,0,0,64,1,0,0,128,1,0,0,192,1,0,0,0,2,0,0,128,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,32,60,32,98,50,95,98,108,111,99,107,83,105,122,101,115,0,0,0,0,0,0,0,66,111,120,50,68,47,67,111,109,109,111,110,47,98,50,66,108,111,99,107,65,108,108,111,99,97,116,111,114,46,99,112,112,0,0,0,0,0,0,0,98,50,66,108,111,99,107,65,108,108,111,99,97,116,111,114,0,0,0,0,0,0,0,0,48,32,60,32,115,105,122,101,0,0,0,0,0,0,0,0,65,108,108,111,99,97,116,101,0,0,0,0,0,0,0,0,48,32,60,61,32,105,110,100,101,120,32,38,38,32,105,110,100,101,120,32,60,32,98,50,95,98,108,111,99,107,83,105,122,101,115,0,0,0,0,0,98,108,111,99,107,67,111,117,110,116,32,42,32,98,108,111,99,107,83,105,122,101,32,60,61,32,98,50,95,99,104,117,110,107,83,105,122,101,0,0,70,114,101,101,0,0,0,0,98,100,45,62,112,111,115,105,116,105,111,110,46,73,115,86,97,108,105,100,40,41,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,98,50,66,111,100,121,46,99,112,112,0,0,0,0,0,0,0,98,50,66,111,100,121,0,0,98,100,45,62,108,105,110,101,97,114,86,101,108,111,99,105,116,121,46,73,115,86,97,108,105,100,40,41,0,0,0,0,98,50,73,115,86,97,108,105,100,40,98,100,45,62,97,110,103,108,101,41,0,0,0,0,98,50,73,115,86,97,108,105,100,40,98,100,45,62,97,110,103,117,108,97,114,86,101,108,111,99,105,116,121,41,0,0,98,50,73,115,86,97,108,105,100,40,98,100,45,62,97,110,103,117,108,97,114,68,97,109,112,105,110,103,41,32,38,38,32,98,100,45,62,97,110,103,117,108,97,114,68,97,109,112,105,110,103,32,62,61,32,48,46,48,102,0,0,0,0,0,98,50,73,115,86,97,108,105,100,40,98,100,45,62,108,105,110,101,97,114,68,97,109,112,105,110,103,41,32,38,38,32,98,100,45,62,108,105,110,101,97,114,68,97,109,112,105,110,103,32,62,61,32,48,46,48,102,0,0,0,0,0,0,0,109,95,119,111,114,108,100,45,62,73,115,76,111,99,107,101,100,40,41,32,61,61,32,102,97,108,115,101,0,0,0,0,67,114,101,97,116,101,70,105,120,116,117,114,101,0,0,0,109,95,116,121,112,101,32,61,61,32,98,50,95,100,121,110,97,109,105,99,66,111,100,121,0,0,0,0,0,0,0,0,82,101,115,101,116,77,97,115,115,68,97,116,97,0,0,0,109,95,73,32,62,32,48,46,48,102,0,0,0,0,0,0,0,10,0,0,0,0,0,0,240,7,0,0,0,0,0,0,48,32,60,61,32,112,114,111,120,121,73,100,32,38,38,32,112,114,111,120,121,73,100,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,0,0,0,0,0,0,46,47,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,68,121,110,97,109,105,99,84,114,101,101,46,104,0,0,0,0,0,0,0,71,101,116,85,115,101,114,68,97,116,97,0,0,0,0,0,71,101,116,70,97,116,65,65,66,66,0,0,0,0,0,0,0,0,0,0,32,8,0,0,5,0,0,0,6,0,0,0,1,0,0,0,2,0,0,0,1,0,0,0,2,0,0,0,49,55,98,50,67,111,110,116,97,99,116,76,105,115,116,101,110,101,114,0,0,0,0,0,120,27,0,0,8,8,0,0,109,95,112,114,111,120,121,67,111,117,110,116,32,61,61,32,48,0,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,98,50,70,105,120,116,117,114,101,46,99,112,112,0,0,0,0,67,114,101,97,116,101,80,114,111,120,105,101,115,0,0,0,73,115,76,111,99,107,101,100,40,41,32,61,61,32,102,97,108,115,101,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,98,50,87,111,114,108,100,46,99,112,112,0,0,0,0,0,0,67,114,101,97,116,101,66,111,100,121,0,0,0,0,0,0,98,45,62,73,115,65,99,116,105,118,101,40,41,32,61,61,32,116,114,117,101,0,0,0,83,111,108,118,101,0,0,0,115,116,97,99,107,67,111,117,110,116,32,60,32,115,116,97,99,107,83,105,122,101,0,0,116,121,112,101,65,32,61,61,32,98,50,95,100,121,110,97,109,105,99,66,111,100,121,32,124,124,32,116,121,112,101,66,32,61,61,32,98,50,95,100,121,110,97,109,105,99,66,111,100,121,0,0,0,0,0,0,83,111,108,118,101,84,79,73,0,0,0,0,0,0,0,0,97,108,112,104,97,48,32,60,32,49,46,48,102,0,0,0,46,47,66,111,120,50,68,47,67,111,109,109,111,110,47,98,50,77,97,116,104,46,104,0,65,100,118,97,110,99,101,0,109,95,106,111,105,110,116,67,111,117,110,116,32,60,32,109,95,106,111,105,110,116,67,97,112,97,99,105,116,121,0,0,46,47,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,98,50,73,115,108,97,110,100,46,104,0,0,0,0,0,65,100,100,0,0,0,0,0,109,95,99,111,110,116,97,99,116,67,111,117,110,116,32,60,32,109,95,99,111,110,116,97,99,116,67,97,112,97,99,105,116,121,0,0,0,0,0,0,109,95,98,111,100,121,67,111,117,110,116,32,60,32,109,95,98,111,100,121,67,97,112,97,99,105,116,121,0,0,0,0,0,0,0,0,40,10,0,0,7,0,0,0,8,0,0,0,3,0,0,0,0,0,0,0,49,53,98,50,67,111,110,116,97,99,116,70,105,108,116,101,114,0,0,0,0,0,0,0,120,27,0,0,16,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,32,60,61,32,105,110,100,101,120,32,38,38,32,105,110,100,101,120,32,60,32,99,104,97,105,110,45,62,109,95,99,111,117,110,116,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,68,105,115,116,97,110,99,101,46,99,112,112,0,0,83,101,116,0,0,0,0,0,102,97,108,115,101,0,0,0,98,50,68,105,115,116,97,110,99,101,0,0,0,0,0,0,71,101,116,77,101,116,114,105,99,0,0,0,0,0,0,0,71,101,116,87,105,116,110,101,115,115,80,111,105,110,116,115,0,0,0,0,0,0,0,0,48,32,60,61,32,105,110,100,101,120,32,38,38,32,105,110,100,101,120,32,60,32,109,95,99,111,117,110,116,0,0,0,46,47,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,68,105,115,116,97,110,99,101,46,104,0,0,71,101,116,86,101,114,116,101,120,0,0,0,0,0,0,0,71,101,116,67,108,111,115,101,115,116,80,111,105,110,116,0,99,97,99,104,101,45,62,99,111,117,110,116,32,60,61,32,51,0,0,0,0,0,0,0,82,101,97,100,67,97,99,104,101,0,0,0,0,0,0,0,109,95,110,111,100,101,67,111,117,110,116,32,61,61,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,68,121,110,97,109,105,99,84,114,101,101,46,99,112,112,0,0,0,0,0,0,0,65,108,108,111,99,97,116,101,78,111,100,101,0,0,0,0,48,32,60,61,32,110,111,100,101,73,100,32,38,38,32,110,111,100,101,73,100,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,70,114,101,101,78,111,100,101,0,0,0,0,0,0,0,0,48,32,60,32,109,95,110,111,100,101,67,111,117,110,116,0,48,32,60,61,32,112,114,111,120,121,73,100,32,38,38,32,112,114,111,120,121,73,100,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,0,0,0,0,0,0,109,95,110,111,100,101,115,91,112,114,111,120,121,73,100,93,46,73,115,76,101,97,102,40,41,0,0,0,0,0,0,0,77,111,118,101,80,114,111,120,121,0,0,0,0,0,0,0,99,104,105,108,100,49,32,33,61,32,40,45,49,41,0,0,73,110,115,101,114,116,76,101,97,102,0,0,0,0,0,0,99,104,105,108,100,50,32,33,61,32,40,45,49,41,0,0,105,65,32,33,61,32,40,45,49,41,0,0,0,0,0,0,66,97,108,97,110,99,101,0,48,32,60,61,32,105,66,32,38,38,32,105,66,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,48,32,60,61,32,105,67,32,38,38,32,105,67,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,48,32,60,61,32,105,70,32,38,38,32,105,70,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,48,32,60,61,32,105,71,32,38,38,32,105,71,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,109,95,110,111,100,101,115,91,67,45,62,112,97,114,101,110,116,93,46,99,104,105,108,100,50,32,61,61,32,105,65,0,48,32,60,61,32,105,68,32,38,38,32,105,68,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,48,32,60,61,32,105,69,32,38,38,32,105,69,32,60,32,109,95,110,111,100,101,67,97,112,97,99,105,116,121,0,0,109,95,110,111,100,101,115,91,66,45,62,112,97,114,101,110,116,93,46,99,104,105,108,100,50,32,61,61,32,105,65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,116,97,114,103,101,116,32,62,32,116,111,108,101,114,97,110,99,101,0,0,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,84,105,109,101,79,102,73,109,112,97,99,116,46,99,112,112,0,0,0,0,0,0,98,50,84,105,109,101,79,102,73,109,112,97,99,116,0,0,102,97,108,115,101,0,0,0,69,118,97,108,117,97,116,101,0,0,0,0,0,0,0,0,48,32,60,61,32,105,110,100,101,120,32,38,38,32,105,110,100,101,120,32,60,32,109,95,99,111,117,110,116,0,0,0,46,47,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,68,105,115,116,97,110,99,101,46,104,0,0,71,101,116,86,101,114,116,101,120,0,0,0,0,0,0,0,70,105,110,100,77,105,110,83,101,112,97,114,97,116,105,111,110,0,0,0,0,0,0,0,48,32,60,32,99,111,117,110,116,32,38,38,32,99,111,117,110,116,32,60,32,51,0,0,73,110,105,116,105,97,108,105,122,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,109,95,105,110,100,101,120,32,61,61,32,48,0,0,0,0,66,111,120,50,68,47,67,111,109,109,111,110,47,98,50,83,116,97,99,107,65,108,108,111,99,97,116,111,114,46,99,112,112,0,0,0,0,0,0,0,126,98,50,83,116,97,99,107,65,108,108,111,99,97,116,111,114,0,0,0,0,0,0,0,109,95,101,110,116,114,121,67,111,117,110,116,32,61,61,32,48,0,0,0,0,0,0,0,109,95,101,110,116,114,121,67,111,117,110,116,32,60,32,98,50,95,109,97,120,83,116,97,99,107,69,110,116,114,105,101,115,0,0,0,0,0,0,0,65,108,108,111,99,97,116,101,0,0,0,0,0,0,0,0,109,95,101,110,116,114,121,67,111,117,110,116,32,62,32,48,0,0,0,0,0,0,0,0,70,114,101,101,0,0,0,0,112,32,61,61,32,101,110,116,114,121,45,62,100,97,116,97,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,32,60,61,32,116,121,112,101,49,32,38,38,32,116,121,112,101,49,32,60,32,98,50,83,104,97,112,101,58,58,101,95,116,121,112,101,67,111,117,110,116,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,67,111,110,116,97,99,116,46,99,112,112,0,0,0,48,32,60,61,32,116,121,112,101,50,32,38,38,32,116,121,112,101,50,32,60,32,98,50,83,104,97,112,101,58,58,101,95,116,121,112,101,67,111,117,110,116,0,0,0,0,0,0,67,114,101,97,116,101,0,0,115,95,105,110,105,116,105,97,108,105,122,101,100,32,61,61,32,116,114,117,101,0,0,0,68,101,115,116,114,111,121,0,48,32,60,61,32,116,121,112,101,65,32,38,38,32,116,121,112,101,66,32,60,32,98,50,83,104,97,112,101,58,58,101,95,116,121,112,101,67,111,117,110,116,0,0,0,0,0,0,0,0,0,0,120,17,0,0,1,0,0,0,9,0,0,0,10,0,0,0,0,0,0,0,57,98,50,67,111,110,116,97,99,116,0,0,0,0,0,0,120,27,0,0,104,17,0,0,0,0,0,0,104,18,0,0,3,0,0,0,11,0,0,0,12,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,101,100,103,101,0,0,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,69,100,103,101,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,0,0,98,50,69,100,103,101,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,105,114,99,108,101,0,0,0,0,0,0,50,50,98,50,69,100,103,101,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,0,0,0,0,0,0,160,27,0,0,72,18,0,0,120,17,0,0,0,0,0,0,0,0,0,0,96,19,0,0,4,0,0,0,13,0,0,0,14,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,101,100,103,101,0,0,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,69,100,103,101,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,0,98,50,69,100,103,101,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,112,111,108,121,103,111,110,0,0,0,0,0,50,51,98,50,69,100,103,101,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,0,0,0,0,0,0,160,27,0,0,64,19,0,0,120,17,0,0,0,0,0,0,0,0,0,0,96,20,0,0,5,0,0,0,15,0,0,0,16,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,112,111,108,121,103,111,110,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,80,111,108,121,103,111,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,46,99,112,112,0,0,0,98,50,80,111,108,121,103,111,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,105,114,99,108,101,0,0,0,0,0,0,50,53,98,50,80,111,108,121,103,111,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,0,0,0,160,27,0,0,64,20,0,0,120,17,0,0,0,0,0,0,0,0,0,0,72,21,0,0,6,0,0,0,17,0,0,0,18,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,112,111,108,121,103,111,110,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,80,111,108,121,103,111,110,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,98,50,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,112,111,108,121,103,111,110,0,0,0,0,0,49,54,98,50,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,0,0,0,0,0,160,27,0,0,48,21,0,0,120,17,0,0,0,0,0,0,116,111,105,73,110,100,101,120,65,32,60,32,109,95,98,111,100,121,67,111,117,110,116,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,98,50,73,115,108,97,110,100,46,99,112,112,0,0,0,0,0,83,111,108,118,101,84,79,73,0,0,0,0,0,0,0,0,116,111,105,73,110,100,101,120,66,32,60,32,109,95,98,111,100,121,67,111,117,110,116,0,100,101,110,32,62,32,48,46,48,102,0,0,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,67,111,108,108,105,100,101,69,100,103,101,46,99,112,112,0,0,0,0,0,0,0,98,50,67,111,108,108,105,100,101,69,100,103,101,65,110,100,67,105,114,99,108,101,0,0,48,32,60,61,32,101,100,103,101,49,32,38,38,32,101,100,103,101,49,32,60,32,112,111,108,121,49,45,62,109,95,118,101,114,116,101,120,67,111,117,110,116,0,0,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,98,50,67,111,108,108,105,100,101,80,111,108,121,103,111,110,46,99,112,112,0,0,0,0,98,50,70,105,110,100,73,110,99,105,100,101,110,116,69,100,103,101,0,0,0,0,0,0,98,50,69,100,103,101,83,101,112,97,114,97,116,105,111,110,0,0,0,0,0,0,0,0,0,0,0,0,120,23,0,0,7,0,0,0,19,0,0,0,20,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,104,97,105,110,0,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,67,104,97,105,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,0,98,50,67,104,97,105,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,105,114,99,108,101,0,0,0,0,0,0,50,51,98,50,67,104,97,105,110,65,110,100,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,0,0,0,0,0,160,27,0,0,88,23,0,0,120,17,0,0,0,0,0,0,0,0,0,0,120,24,0,0,8,0,0,0,21,0,0,0,22,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,104,97,105,110,0,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,67,104,97,105,110,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,98,50,67,104,97,105,110,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,112,111,108,121,103,111,110,0,0,0,0,0,50,52,98,50,67,104,97,105,110,65,110,100,80,111,108,121,103,111,110,67,111,110,116,97,99,116,0,0,0,0,0,0,160,27,0,0,88,24,0,0,120,17,0,0,0,0,0,0,0,0,0,0,88,25,0,0,9,0,0,0,23,0,0,0,24,0,0,0,0,0,0,0,109,95,102,105,120,116,117,114,101,65,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,105,114,99,108,101,0,0,0,0,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,67,105,114,99,108,101,67,111,110,116,97,99,116,46,99,112,112,0,0,0,0,0,98,50,67,105,114,99,108,101,67,111,110,116,97,99,116,0,109,95,102,105,120,116,117,114,101,66,45,62,71,101,116,84,121,112,101,40,41,32,61,61,32,98,50,83,104,97,112,101,58,58,101,95,99,105,114,99,108,101,0,0,0,0,0,0,49,53,98,50,67,105,114,99,108,101,67,111,110,116,97,99,116,0,0,0,0,0,0,0,160,27,0,0,64,25,0,0,120,17,0,0,0,0,0,0,112,111,105,110,116,67,111,117,110,116,32,62,32,48,0,0,66,111,120,50,68,47,68,121,110,97,109,105,99,115,47,67,111,110,116,97,99,116,115,47,98,50,67,111,110,116,97,99,116,83,111,108,118,101,114,46,99,112,112,0,0,0,0,0,98,50,67,111,110,116,97,99,116,83,111,108,118,101,114,0,109,97,110,105,102,111,108,100,45,62,112,111,105,110,116,67,111,117,110,116,32,62,32,48,0,0,0,0,0,0,0,0,73,110,105,116,105,97,108,105,122,101,86,101,108,111,99,105,116,121,67,111,110,115,116,114,97,105,110,116,115,0,0,0,112,111,105,110,116,67,111,117,110,116,32,61,61,32,49,32,124,124,32,112,111,105,110,116,67,111,117,110,116,32,61,61,32,50,0,0,0,0,0,0,83,111,108,118,101,86,101,108,111,99,105,116,121,67,111,110,115,116,114,97,105,110,116,115,0,0,0,0,0,0,0,0,97,46,120,32,62,61,32,48,46,48,102,32,38,38,32,97,46,121,32,62,61,32,48,46,48,102,0,0,0,0,0,0,112,99,45,62,112,111,105,110,116,67,111,117,110,116,32,62,32,48,0,0,0,0,0,0,73,110,105,116,105,97,108,105,122,101,0,0,0,0,0,0,66,111,120,50,68,47,67,111,108,108,105,115,105,111,110,47,83,104,97,112,101,115,47,98,50,67,104,97,105,110,83,104,97,112,101,46,99,112,112,0,48,32,60,61,32,105,110,100,101,120,32,38,38,32,105,110,100,101,120,32,60,32,109,95,99,111,117,110,116,32,45,32,49,0,0,0,0,0,0,0,71,101,116,67,104,105,108,100,69,100,103,101,0,0,0,0,83,116,57,116,121,112,101,95,105,110,102,111,0,0,0,0,120,27,0,0,232,26,0,0,78,49,48,95,95,99,120,120,97,98,105,118,49,49,54,95,95,115,104,105,109,95,116,121,112,101,95,105,110,102,111,69,0,0,0,0,0,0,0,0,160,27,0,0,0,27,0,0,248,26,0,0,0,0,0,0,78,49,48,95,95,99,120,120,97,98,105,118,49,49,55,95,95,99,108,97,115,115,95,116,121,112,101,95,105,110,102,111,69,0,0,0,0,0,0,0,160,27,0,0,56,27,0,0,40,27,0,0,0,0,0,0,0,0,0,0,96,27,0,0,25,0,0,0,26,0,0,0,27,0,0,0,28,0,0,0,4,0,0,0,1,0,0,0,1,0,0,0,10,0,0,0,0,0,0,0,232,27,0,0,25,0,0,0,29,0,0,0,27,0,0,0,28,0,0,0,4,0,0,0,2,0,0,0,2,0,0,0,11,0,0,0,78,49,48,95,95,99,120,120,97,98,105,118,49,50,48,95,95,115,105,95,99,108,97,115,115,95,116,121,112,101,95,105,110,102,111,69,0,0,0,0,160,27,0,0,192,27,0,0,96,27,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,30,0,0,30,0,0,0,31,0,0,0,3,0,0,0,0,0,0,0,115,116,100,58,58,98,97,100,95,97,108,108,111,99,0,0,83,116,57,98,97,100,95,97,108,108,111,99,0,0,0,0,160,27,0,0,24,30,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+ function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg) {
+ Module['noExitRuntime'] = true;
+
+ Browser.mainLoop.runner = function Browser_mainLoop_runner() {
+ if (ABORT) return;
+ if (Browser.mainLoop.queue.length > 0) {
+ var start = Date.now();
+ var blocker = Browser.mainLoop.queue.shift();
+ blocker.func(blocker.arg);
+ if (Browser.mainLoop.remainingBlockers) {
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var next = remaining%1 == 0 ? remaining-1 : Math.floor(remaining);
+ if (blocker.counted) {
+ Browser.mainLoop.remainingBlockers = next;
+ } else {
+ // not counted, but move the progress along a tiny bit
+ next = next + 0.5; // do not steal all the next one's progress
+ Browser.mainLoop.remainingBlockers = (8*remaining + next)/9;
+ }
+ }
+ console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + ' ms'); //, left: ' + Browser.mainLoop.remainingBlockers);
+ Browser.mainLoop.updateStatus();
+ setTimeout(Browser.mainLoop.runner, 0);
+ return;
+ }
+ if (Browser.mainLoop.shouldPause) {
+ // catch pauses from non-main loop sources
+ Browser.mainLoop.paused = true;
+ Browser.mainLoop.shouldPause = false;
+ return;
+ }
+
+ // Signal GL rendering layer that processing of a new frame is about to start. This helps it optimize
+ // VBO double-buffering and reduce GPU stalls.
+
+ if (Browser.mainLoop.method === 'timeout' && Module.ctx) {
+ Module.printErr('Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!');
+ Browser.mainLoop.method = ''; // just warn once per call to set main loop
+ }
+
+ if (Module['preMainLoop']) {
+ Module['preMainLoop']();
+ }
+
+ try {
+ if (typeof arg !== 'undefined') {
+ Runtime.dynCall('vi', func, [arg]);
+ } else {
+ Runtime.dynCall('v', func);
+ }
+ } catch (e) {
+ if (e instanceof ExitStatus) {
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ }
+
+ if (Module['postMainLoop']) {
+ Module['postMainLoop']();
+ }
+
+ if (Browser.mainLoop.shouldPause) {
+ // catch pauses from the main loop itself
+ Browser.mainLoop.paused = true;
+ Browser.mainLoop.shouldPause = false;
+ return;
+ }
+ Browser.mainLoop.scheduler();
+ }
+ if (fps && fps > 0) {
+ Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() {
+ setTimeout(Browser.mainLoop.runner, 1000/fps); // doing this each time means that on exception, we stop
+ };
+ Browser.mainLoop.method = 'timeout';
+ } else {
+ Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() {
+ Browser.requestAnimationFrame(Browser.mainLoop.runner);
+ };
+ Browser.mainLoop.method = 'rAF';
+ }
+ Browser.mainLoop.scheduler();
+
+ if (simulateInfiniteLoop) {
+ throw 'SimulateInfiniteLoop';
+ }
+ }
+
+ var _cosf=Math_cos;
+
+ function ___cxa_pure_virtual() {
+ ABORT = true;
+ throw 'Pure virtual function called!';
+ }
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+ function ___assert_fail(condition, filename, line, func) {
+ ABORT = true;
+ throw 'Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + stackTrace();
+ }
+
+
+ function __ZSt18uncaught_exceptionv() { // std::uncaught_exception()
+ return !!__ZSt18uncaught_exceptionv.uncaught_exception;
+ }
+
+
+
+ function ___cxa_is_number_type(type) {
+ var isNumber = false;
+ try { if (type == __ZTIi) isNumber = true } catch(e){}
+ try { if (type == __ZTIj) isNumber = true } catch(e){}
+ try { if (type == __ZTIl) isNumber = true } catch(e){}
+ try { if (type == __ZTIm) isNumber = true } catch(e){}
+ try { if (type == __ZTIx) isNumber = true } catch(e){}
+ try { if (type == __ZTIy) isNumber = true } catch(e){}
+ try { if (type == __ZTIf) isNumber = true } catch(e){}
+ try { if (type == __ZTId) isNumber = true } catch(e){}
+ try { if (type == __ZTIe) isNumber = true } catch(e){}
+ try { if (type == __ZTIc) isNumber = true } catch(e){}
+ try { if (type == __ZTIa) isNumber = true } catch(e){}
+ try { if (type == __ZTIh) isNumber = true } catch(e){}
+ try { if (type == __ZTIs) isNumber = true } catch(e){}
+ try { if (type == __ZTIt) isNumber = true } catch(e){}
+ return isNumber;
+ }function ___cxa_does_inherit(definiteType, possibilityType, possibility) {
+ if (possibility == 0) return false;
+ if (possibilityType == 0 || possibilityType == definiteType)
+ return true;
+ var possibility_type_info;
+ if (___cxa_is_number_type(possibilityType)) {
+ possibility_type_info = possibilityType;
+ } else {
+ var possibility_type_infoAddr = HEAP32[((possibilityType)>>2)] - 8;
+ possibility_type_info = HEAP32[((possibility_type_infoAddr)>>2)];
+ }
+ switch (possibility_type_info) {
+ case 0: // possibility is a pointer
+ // See if definite type is a pointer
+ var definite_type_infoAddr = HEAP32[((definiteType)>>2)] - 8;
+ var definite_type_info = HEAP32[((definite_type_infoAddr)>>2)];
+ if (definite_type_info == 0) {
+ // Also a pointer; compare base types of pointers
+ var defPointerBaseAddr = definiteType+8;
+ var defPointerBaseType = HEAP32[((defPointerBaseAddr)>>2)];
+ var possPointerBaseAddr = possibilityType+8;
+ var possPointerBaseType = HEAP32[((possPointerBaseAddr)>>2)];
+ return ___cxa_does_inherit(defPointerBaseType, possPointerBaseType, possibility);
+ } else
+ return false; // one pointer and one non-pointer
+ case 1: // class with no base class
+ return false;
+ case 2: // class with base class
+ var parentTypeAddr = possibilityType + 8;
+ var parentType = HEAP32[((parentTypeAddr)>>2)];
+ return ___cxa_does_inherit(definiteType, parentType, possibility);
+ default:
+ return false; // some unencountered type
+ }
+ }
+
+
+
+ var ___cxa_last_thrown_exception=0;function ___resumeException(ptr) {
+ if (!___cxa_last_thrown_exception) { ___cxa_last_thrown_exception = ptr; }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
+ }
+
+ var ___cxa_exception_header_size=8;function ___cxa_find_matching_catch(thrown, throwntype) {
+ if (thrown == -1) thrown = ___cxa_last_thrown_exception;
+ header = thrown - ___cxa_exception_header_size;
+ if (throwntype == -1) throwntype = HEAP32[((header)>>2)];
+ var typeArray = Array.prototype.slice.call(arguments, 2);
+
+ // If throwntype is a pointer, this means a pointer has been
+ // thrown. When a pointer is thrown, actually what's thrown
+ // is a pointer to the pointer. We'll dereference it.
+ if (throwntype != 0 && !___cxa_is_number_type(throwntype)) {
+ var throwntypeInfoAddr= HEAP32[((throwntype)>>2)] - 8;
+ var throwntypeInfo= HEAP32[((throwntypeInfoAddr)>>2)];
+ if (throwntypeInfo == 0)
+ thrown = HEAP32[((thrown)>>2)];
+ }
+ // The different catch blocks are denoted by different types.
+ // Due to inheritance, those types may not precisely match the
+ // type of the thrown object. Find one which matches, and
+ // return the type of the catch block which should be called.
+ for (var i = 0; i < typeArray.length; i++) {
+ if (___cxa_does_inherit(typeArray[i], throwntype, thrown))
+ return ((asm["setTempRet0"](typeArray[i]),thrown)|0);
+ }
+ // Shouldn't happen unless we have bogus data in typeArray
+ // or encounter a type for which emscripten doesn't have suitable
+ // typeinfo defined. Best-efforts match just in case.
+ return ((asm["setTempRet0"](throwntype),thrown)|0);
+ }function ___cxa_throw(ptr, type, destructor) {
+ if (!___cxa_throw.initialized) {
+ try {
+ HEAP32[((__ZTVN10__cxxabiv119__pointer_type_infoE)>>2)]=0; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ try {
+ HEAP32[((__ZTVN10__cxxabiv117__class_type_infoE)>>2)]=1; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ try {
+ HEAP32[((__ZTVN10__cxxabiv120__si_class_type_infoE)>>2)]=2; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ ___cxa_throw.initialized = true;
+ }
+ var header = ptr - ___cxa_exception_header_size;
+ HEAP32[((header)>>2)]=type;
+ HEAP32[(((header)+(4))>>2)]=destructor;
+ ___cxa_last_thrown_exception = ptr;
+ if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
+ __ZSt18uncaught_exceptionv.uncaught_exception = 1;
+ } else {
+ __ZSt18uncaught_exceptionv.uncaught_exception++;
+ }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
+ }
+
+
+ Module["_memset"] = _memset;
+
+
+
+ function __exit(status) {
+ // void _exit(int status);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
+ Module['exit'](status);
+ }function _exit(status) {
+ __exit(status);
+ }function __ZSt9terminatev() {
+ _exit(-1234);
+ }
+
+ function _abort() {
+ Module['abort']();
+ }
+
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+ var _sinf=Math_sin;
+
+
+ var _sqrtf=Math_sqrt;
+
+ var _floorf=Math_floor;
+
+
+ function _fputs(s, stream) {
+ // int fputs(const char *restrict s, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
+ var fd = _fileno(stream);
+ return _write(fd, s, _strlen(s));
+ }
+
+ function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret)|0)]=chr;
+ var fd = _fileno(stream);
+ var ret = _write(fd, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+ }function _puts(s) {
+ // int puts(const char *s);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/puts.html
+ // NOTE: puts() always writes an extra newline.
+ var stdout = HEAP32[((_stdout)>>2)];
+ var ret = _fputs(s, stdout);
+ if (ret < 0) {
+ return ret;
+ } else {
+ var newlineRet = _fputc(10, stdout);
+ return (newlineRet < 0) ? -1 : ret + 1;
+ }
+ }
+
+ function _clock() {
+ if (_clock.start === undefined) _clock.start = Date.now();
+ return Math.floor((Date.now() - _clock.start) * (1000000/1000));
+ }
+
+
+ var ___cxa_caught_exceptions=[];function ___cxa_begin_catch(ptr) {
+ __ZSt18uncaught_exceptionv.uncaught_exception--;
+ ___cxa_caught_exceptions.push(___cxa_last_thrown_exception);
+ return ptr;
+ }
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+ function __ZNSt9exceptionD2Ev() {}
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+ function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+ function _emscripten_run_script(ptr) {
+ eval(Pointer_stringify(ptr));
+ }
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;function ___cxa_allocate_exception(size) {
+ var ptr = _malloc(size + ___cxa_exception_header_size);
+ return ptr + ___cxa_exception_header_size;
+ }
+
+ function _emscripten_cancel_main_loop() {
+ Browser.mainLoop.scheduler = null;
+ Browser.mainLoop.shouldPause = true;
+ }
+
+ var __ZTISt9exception=allocate([allocate([1,0,0,0,0,0,0], "i8", ALLOC_STATIC)+8, 0], "i32", ALLOC_STATIC);
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function invoke_iiii(index,a1,a2,a3) {
+ try {
+ return Module["dynCall_iiii"](index,a1,a2,a3);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_viiiii(index,a1,a2,a3,a4,a5) {
+ try {
+ Module["dynCall_viiiii"](index,a1,a2,a3,a4,a5);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vi(index,a1) {
+ try {
+ Module["dynCall_vi"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vii(index,a1,a2) {
+ try {
+ Module["dynCall_vii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_ii(index,a1) {
+ try {
+ return Module["dynCall_ii"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_viii(index,a1,a2,a3) {
+ try {
+ Module["dynCall_viii"](index,a1,a2,a3);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_v(index) {
+ try {
+ Module["dynCall_v"](index);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_viid(index,a1,a2,a3) {
+ try {
+ Module["dynCall_viid"](index,a1,a2,a3);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6) {
+ try {
+ Module["dynCall_viiiiii"](index,a1,a2,a3,a4,a5,a6);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iii(index,a1,a2) {
+ try {
+ return Module["dynCall_iii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iiiiii(index,a1,a2,a3,a4,a5) {
+ try {
+ return Module["dynCall_iiiiii"](index,a1,a2,a3,a4,a5);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_viiii(index,a1,a2,a3,a4) {
+ try {
+ Module["dynCall_viiii"](index,a1,a2,a3,a4);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+ var __ZTISt9exception=env.__ZTISt9exception|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var invoke_iiii=env.invoke_iiii;
+ var invoke_viiiii=env.invoke_viiiii;
+ var invoke_vi=env.invoke_vi;
+ var invoke_vii=env.invoke_vii;
+ var invoke_ii=env.invoke_ii;
+ var invoke_viii=env.invoke_viii;
+ var invoke_v=env.invoke_v;
+ var invoke_viid=env.invoke_viid;
+ var invoke_viiiiii=env.invoke_viiiiii;
+ var invoke_iii=env.invoke_iii;
+ var invoke_iiiiii=env.invoke_iiiiii;
+ var invoke_viiii=env.invoke_viiii;
+ var ___cxa_throw=env.___cxa_throw;
+ var _emscripten_run_script=env._emscripten_run_script;
+ var _cosf=env._cosf;
+ var _send=env._send;
+ var __ZSt9terminatev=env.__ZSt9terminatev;
+ var __reallyNegative=env.__reallyNegative;
+ var ___cxa_is_number_type=env.___cxa_is_number_type;
+ var ___assert_fail=env.___assert_fail;
+ var ___cxa_allocate_exception=env.___cxa_allocate_exception;
+ var ___cxa_find_matching_catch=env.___cxa_find_matching_catch;
+ var _fflush=env._fflush;
+ var _pwrite=env._pwrite;
+ var ___setErrNo=env.___setErrNo;
+ var _sbrk=env._sbrk;
+ var ___cxa_begin_catch=env.___cxa_begin_catch;
+ var _sinf=env._sinf;
+ var _fileno=env._fileno;
+ var ___resumeException=env.___resumeException;
+ var __ZSt18uncaught_exceptionv=env.__ZSt18uncaught_exceptionv;
+ var _sysconf=env._sysconf;
+ var _clock=env._clock;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _puts=env._puts;
+ var _mkport=env._mkport;
+ var _floorf=env._floorf;
+ var _sqrtf=env._sqrtf;
+ var _write=env._write;
+ var _emscripten_set_main_loop=env._emscripten_set_main_loop;
+ var ___errno_location=env.___errno_location;
+ var __ZNSt9exceptionD2Ev=env.__ZNSt9exceptionD2Ev;
+ var _printf=env._printf;
+ var ___cxa_does_inherit=env.___cxa_does_inherit;
+ var __exit=env.__exit;
+ var _fputc=env._fputc;
+ var _abort=env._abort;
+ var _fwrite=env._fwrite;
+ var _time=env._time;
+ var _fprintf=env._fprintf;
+ var _emscripten_cancel_main_loop=env._emscripten_cancel_main_loop;
+ var __formatString=env.__formatString;
+ var _fputs=env._fputs;
+ var _exit=env._exit;
+ var ___cxa_pure_virtual=env.___cxa_pure_virtual;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[1790] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 7200 + (i5 << 2) | 0;
+ i5 = 7200 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[1790] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[7168 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 7200 + (i7 << 2) | 0;
+ i7 = 7200 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[1790] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[7168 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[7180 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 7200 + (i9 << 2) | 0;
+ i7 = HEAP32[1790] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 7200 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[1790] = i7 | i8;
+ i28 = 7200 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[7168 >> 2] = i4;
+ HEAP32[7180 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[7164 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[7464 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[7176 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 7464 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[7164 >> 2] = HEAP32[7164 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[7168 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[7180 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 7200 + (i9 << 2) | 0;
+ i7 = HEAP32[1790] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 7200 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[1790] = i7 | i8;
+ i25 = 7200 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[7168 >> 2] = i2;
+ HEAP32[7180 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[7164 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[7464 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[7464 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[7168 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[7176 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 7464 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[7164 >> 2] = HEAP32[7164 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 7200 + (i6 << 2) | 0;
+ i5 = HEAP32[1790] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 7200 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[1790] = i5 | i4;
+ i21 = 7200 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 7464 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[7164 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[7164 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[7176 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[7168 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[7180 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[7180 >> 2] = i2 + i12;
+ HEAP32[7168 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[7168 >> 2] = 0;
+ HEAP32[7180 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[7172 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[7172 >> 2] = i31;
+ i32 = HEAP32[7184 >> 2] | 0;
+ HEAP32[7184 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[1908] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[7640 >> 2] = i18;
+ HEAP32[7636 >> 2] = i18;
+ HEAP32[7644 >> 2] = -1;
+ HEAP32[7648 >> 2] = -1;
+ HEAP32[7652 >> 2] = 0;
+ HEAP32[7604 >> 2] = 0;
+ HEAP32[1908] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[7640 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[7600 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[7592 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[7604 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[7184 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 7608 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[7172 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[7636 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[7592 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[7600 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[7640 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[7604 >> 2] = HEAP32[7604 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[7592 >> 2] | 0) + i14 | 0;
+ HEAP32[7592 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[7596 >> 2] | 0) >>> 0) {
+ HEAP32[7596 >> 2] = i15;
+ }
+ i15 = HEAP32[7184 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 7608 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[7172 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[7184 >> 2] = i15 + i3;
+ HEAP32[7172 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[7188 >> 2] = HEAP32[7648 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ HEAP32[7176 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 7608 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[7184 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[7180 >> 2] | 0)) {
+ i32 = (HEAP32[7168 >> 2] | 0) + i10 | 0;
+ HEAP32[7168 >> 2] = i32;
+ HEAP32[7180 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 7464 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[7164 >> 2] = HEAP32[7164 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 7200 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[1790] = HEAP32[1790] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 7200 + (i10 << 2) | 0;
+ i9 = HEAP32[1790] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 7200 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[1790] = i9 | i5;
+ i3 = 7200 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 7464 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[7164 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[7164 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L444 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L444;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[7176 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[7172 >> 2] | 0) + i10 | 0;
+ HEAP32[7172 >> 2] = i32;
+ HEAP32[7184 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 7608 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[7184 >> 2] = i17 + i4;
+ HEAP32[7172 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[7188 >> 2] = HEAP32[7648 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[7608 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[7612 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[7616 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[7620 >> 2];
+ HEAP32[7608 >> 2] = i17;
+ HEAP32[7612 >> 2] = i14;
+ HEAP32[7620 >> 2] = 0;
+ HEAP32[7616 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 7200 + (i4 << 2) | 0;
+ i5 = HEAP32[1790] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 7200 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[1790] = i5 | i3;
+ i7 = 7200 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 7464 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[7164 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[7164 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[7176 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[7176 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[7176 >> 2] = i17;
+ }
+ HEAP32[7608 >> 2] = i17;
+ HEAP32[7612 >> 2] = i14;
+ HEAP32[7620 >> 2] = 0;
+ HEAP32[7196 >> 2] = HEAP32[1908];
+ HEAP32[7192 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 7200 + (i32 << 2) | 0;
+ HEAP32[7200 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[7200 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[7184 >> 2] = i17 + i2;
+ HEAP32[7172 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[7188 >> 2] = HEAP32[7648 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[7172 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[7172 >> 2] = i31;
+ i32 = HEAP32[7184 >> 2] | 0;
+ HEAP32[7184 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_(i12, i2, i16, i5, i8, i6) {
+ i12 = i12 | 0;
+ i2 = i2 | 0;
+ i16 = i16 | 0;
+ i5 = i5 | 0;
+ i8 = i8 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, d27 = 0.0, d28 = 0.0, i29 = 0, d30 = 0.0, d31 = 0.0, d32 = 0.0, d33 = 0.0, i34 = 0, i35 = 0, d36 = 0.0, d37 = 0.0, i38 = 0, d39 = 0.0, i40 = 0, i41 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 144 | 0;
+ i18 = i1 + 128 | 0;
+ i11 = i1 + 24 | 0;
+ i9 = i1 + 72 | 0;
+ i10 = i1 + 48 | 0;
+ i3 = i1;
+ i4 = i12 + 132 | 0;
+ d28 = +HEAPF32[i5 + 12 >> 2];
+ d37 = +HEAPF32[i6 + 8 >> 2];
+ d23 = +HEAPF32[i5 + 8 >> 2];
+ d27 = +HEAPF32[i6 + 12 >> 2];
+ d22 = d28 * d37 - d23 * d27;
+ d27 = d37 * d23 + d28 * d27;
+ d37 = +d22;
+ d26 = +d27;
+ d25 = +HEAPF32[i6 >> 2] - +HEAPF32[i5 >> 2];
+ d36 = +HEAPF32[i6 + 4 >> 2] - +HEAPF32[i5 + 4 >> 2];
+ d24 = d28 * d25 + d23 * d36;
+ d25 = d28 * d36 - d23 * d25;
+ d23 = +d24;
+ d36 = +d25;
+ i5 = i4;
+ HEAPF32[i5 >> 2] = d23;
+ HEAPF32[i5 + 4 >> 2] = d36;
+ i5 = i12 + 140 | 0;
+ HEAPF32[i5 >> 2] = d37;
+ HEAPF32[i5 + 4 >> 2] = d26;
+ i5 = i12 + 144 | 0;
+ d26 = +HEAPF32[i8 + 12 >> 2];
+ i7 = i12 + 140 | 0;
+ d37 = +HEAPF32[i8 + 16 >> 2];
+ d24 = d24 + (d27 * d26 - d22 * d37);
+ i6 = i12 + 136 | 0;
+ d25 = d26 * d22 + d27 * d37 + d25;
+ d37 = +d24;
+ d27 = +d25;
+ i34 = i12 + 148 | 0;
+ HEAPF32[i34 >> 2] = d37;
+ HEAPF32[i34 + 4 >> 2] = d27;
+ i34 = i16 + 28 | 0;
+ i29 = HEAP32[i34 >> 2] | 0;
+ i34 = HEAP32[i34 + 4 >> 2] | 0;
+ i14 = i12 + 156 | 0;
+ HEAP32[i14 >> 2] = i29;
+ HEAP32[i14 + 4 >> 2] = i34;
+ i14 = i12 + 164 | 0;
+ i17 = i16 + 12 | 0;
+ i40 = HEAP32[i17 >> 2] | 0;
+ i17 = HEAP32[i17 + 4 >> 2] | 0;
+ i13 = i14;
+ HEAP32[i13 >> 2] = i40;
+ HEAP32[i13 + 4 >> 2] = i17;
+ i13 = i12 + 172 | 0;
+ i20 = i16 + 20 | 0;
+ i41 = HEAP32[i20 >> 2] | 0;
+ i20 = HEAP32[i20 + 4 >> 2] | 0;
+ i38 = i13;
+ HEAP32[i38 >> 2] = i41;
+ HEAP32[i38 + 4 >> 2] = i20;
+ i38 = i16 + 36 | 0;
+ i35 = HEAP32[i38 >> 2] | 0;
+ i38 = HEAP32[i38 + 4 >> 2] | 0;
+ i19 = i12 + 180 | 0;
+ HEAP32[i19 >> 2] = i35;
+ HEAP32[i19 + 4 >> 2] = i38;
+ i19 = (HEAP8[i16 + 44 | 0] | 0) != 0;
+ i21 = (HEAP8[i16 + 45 | 0] | 0) != 0;
+ d27 = (HEAP32[tempDoublePtr >> 2] = i41, +HEAPF32[tempDoublePtr >> 2]);
+ d37 = (HEAP32[tempDoublePtr >> 2] = i40, +HEAPF32[tempDoublePtr >> 2]);
+ d22 = d27 - d37;
+ d26 = (HEAP32[tempDoublePtr >> 2] = i20, +HEAPF32[tempDoublePtr >> 2]);
+ i20 = i12 + 168 | 0;
+ d36 = (HEAP32[tempDoublePtr >> 2] = i17, +HEAPF32[tempDoublePtr >> 2]);
+ d23 = d26 - d36;
+ d28 = +Math_sqrt(+(d22 * d22 + d23 * d23));
+ d33 = (HEAP32[tempDoublePtr >> 2] = i29, +HEAPF32[tempDoublePtr >> 2]);
+ d32 = (HEAP32[tempDoublePtr >> 2] = i34, +HEAPF32[tempDoublePtr >> 2]);
+ d31 = (HEAP32[tempDoublePtr >> 2] = i35, +HEAPF32[tempDoublePtr >> 2]);
+ d30 = (HEAP32[tempDoublePtr >> 2] = i38, +HEAPF32[tempDoublePtr >> 2]);
+ if (!(d28 < 1.1920928955078125e-7)) {
+ d39 = 1.0 / d28;
+ d22 = d22 * d39;
+ d23 = d23 * d39;
+ }
+ i16 = i12 + 196 | 0;
+ d28 = -d22;
+ HEAPF32[i16 >> 2] = d23;
+ i17 = i12 + 200 | 0;
+ HEAPF32[i17 >> 2] = d28;
+ d28 = (d24 - d37) * d23 + (d25 - d36) * d28;
+ if (i19) {
+ d37 = d37 - d33;
+ d36 = d36 - d32;
+ d39 = +Math_sqrt(+(d37 * d37 + d36 * d36));
+ if (!(d39 < 1.1920928955078125e-7)) {
+ d39 = 1.0 / d39;
+ d37 = d37 * d39;
+ d36 = d36 * d39;
+ }
+ d39 = -d37;
+ HEAPF32[i12 + 188 >> 2] = d36;
+ HEAPF32[i12 + 192 >> 2] = d39;
+ i29 = d23 * d37 - d22 * d36 >= 0.0;
+ d32 = (d24 - d33) * d36 + (d25 - d32) * d39;
+ } else {
+ i29 = 0;
+ d32 = 0.0;
+ }
+ L10 : do {
+ if (!i21) {
+ if (!i19) {
+ i41 = d28 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ i15 = 64;
+ break;
+ } else {
+ i15 = 65;
+ break;
+ }
+ }
+ i19 = d32 >= 0.0;
+ if (i29) {
+ if (!i19) {
+ i41 = d28 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (!i41) {
+ d37 = +-d23;
+ d39 = +d22;
+ i38 = i19;
+ HEAPF32[i38 >> 2] = d37;
+ HEAPF32[i38 + 4 >> 2] = d39;
+ i38 = i16;
+ i40 = HEAP32[i38 >> 2] | 0;
+ i38 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 228 | 0;
+ HEAP32[i41 >> 2] = i40;
+ HEAP32[i41 + 4 >> 2] = i38;
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = -(HEAP32[tempDoublePtr >> 2] = i40, +HEAPF32[tempDoublePtr >> 2]);
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 1;
+ i19 = i12 + 212 | 0;
+ }
+ i41 = i16;
+ i40 = HEAP32[i41 + 4 >> 2] | 0;
+ i38 = i19;
+ HEAP32[i38 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i38 + 4 >> 2] = i40;
+ i38 = i12 + 188 | 0;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 228 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ d37 = +-+HEAPF32[i16 >> 2];
+ d39 = +-+HEAPF32[i17 >> 2];
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ } else {
+ if (i19) {
+ i41 = d28 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ i38 = i16;
+ i41 = HEAP32[i38 >> 2] | 0;
+ i38 = HEAP32[i38 + 4 >> 2] | 0;
+ i40 = i19;
+ HEAP32[i40 >> 2] = i41;
+ HEAP32[i40 + 4 >> 2] = i38;
+ i40 = i12 + 228 | 0;
+ HEAP32[i40 >> 2] = i41;
+ HEAP32[i40 + 4 >> 2] = i38;
+ d37 = +-(HEAP32[tempDoublePtr >> 2] = i41, +HEAPF32[tempDoublePtr >> 2]);
+ d39 = +d22;
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 0;
+ i19 = i12 + 212 | 0;
+ }
+ d39 = +-d23;
+ d37 = +d22;
+ i38 = i19;
+ HEAPF32[i38 >> 2] = d39;
+ HEAPF32[i38 + 4 >> 2] = d37;
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 228 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ d37 = +-+HEAPF32[i12 + 188 >> 2];
+ d39 = +-+HEAPF32[i12 + 192 >> 2];
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ }
+ } else {
+ d33 = d31 - d27;
+ d31 = d30 - d26;
+ d30 = +Math_sqrt(+(d33 * d33 + d31 * d31));
+ if (d30 < 1.1920928955078125e-7) {
+ d30 = d33;
+ } else {
+ d39 = 1.0 / d30;
+ d30 = d33 * d39;
+ d31 = d31 * d39;
+ }
+ d39 = -d30;
+ i34 = i12 + 204 | 0;
+ HEAPF32[i34 >> 2] = d31;
+ i35 = i12 + 208 | 0;
+ HEAPF32[i35 >> 2] = d39;
+ i38 = d22 * d31 - d23 * d30 > 0.0;
+ d24 = (d24 - d27) * d31 + (d25 - d26) * d39;
+ if (!i19) {
+ i19 = d28 >= 0.0;
+ if (!i21) {
+ HEAP8[i12 + 248 | 0] = i19 & 1;
+ i15 = i12 + 212 | 0;
+ if (i19) {
+ i19 = i15;
+ i15 = 64;
+ break;
+ } else {
+ i19 = i15;
+ i15 = 65;
+ break;
+ }
+ }
+ if (i38) {
+ if (!i19) {
+ i41 = d24 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (!i41) {
+ d37 = +-d23;
+ d39 = +d22;
+ i38 = i19;
+ HEAPF32[i38 >> 2] = d37;
+ HEAPF32[i38 + 4 >> 2] = d39;
+ i38 = i12 + 228 | 0;
+ HEAPF32[i38 >> 2] = d37;
+ HEAPF32[i38 + 4 >> 2] = d39;
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 1;
+ i19 = i12 + 212 | 0;
+ }
+ i41 = i16;
+ i40 = HEAP32[i41 + 4 >> 2] | 0;
+ i38 = i19;
+ HEAP32[i38 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i38 + 4 >> 2] = i40;
+ d37 = +-+HEAPF32[i16 >> 2];
+ d39 = +-+HEAPF32[i17 >> 2];
+ i38 = i12 + 228 | 0;
+ HEAPF32[i38 >> 2] = d37;
+ HEAPF32[i38 + 4 >> 2] = d39;
+ i38 = i12 + 204 | 0;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ } else {
+ if (i19) {
+ i41 = d24 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ i40 = i16;
+ i38 = HEAP32[i40 >> 2] | 0;
+ i40 = HEAP32[i40 + 4 >> 2] | 0;
+ i41 = i19;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ d37 = +-(HEAP32[tempDoublePtr >> 2] = i38, +HEAPF32[tempDoublePtr >> 2]);
+ d39 = +d22;
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 0;
+ i19 = i12 + 212 | 0;
+ }
+ d39 = +-d23;
+ d37 = +d22;
+ i38 = i19;
+ HEAPF32[i38 >> 2] = d39;
+ HEAPF32[i38 + 4 >> 2] = d37;
+ d37 = +-+HEAPF32[i12 + 204 >> 2];
+ d39 = +-+HEAPF32[i12 + 208 >> 2];
+ i38 = i12 + 228 | 0;
+ HEAPF32[i38 >> 2] = d37;
+ HEAPF32[i38 + 4 >> 2] = d39;
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ }
+ if (i29 & i38) {
+ if (!(d32 >= 0.0) & !(d28 >= 0.0)) {
+ i41 = d24 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (!i41) {
+ d37 = +-d23;
+ d39 = +d22;
+ i41 = i19;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 1;
+ i19 = i12 + 212 | 0;
+ }
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i19;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i12 + 188 | 0;
+ i40 = HEAP32[i41 + 4 >> 2] | 0;
+ i38 = i12 + 228 | 0;
+ HEAP32[i38 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i38 + 4 >> 2] = i40;
+ i38 = i12 + 204 | 0;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ if (i29) {
+ do {
+ if (!(d32 >= 0.0)) {
+ if (d28 >= 0.0) {
+ i41 = d24 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 0;
+ i19 = i12 + 212 | 0;
+ }
+ d37 = +-d23;
+ d39 = +d22;
+ i41 = i19;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ d39 = +-+HEAPF32[i34 >> 2];
+ d37 = +-+HEAPF32[i35 >> 2];
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d39;
+ HEAPF32[i41 + 4 >> 2] = d37;
+ d37 = +-+HEAPF32[i16 >> 2];
+ d39 = +-+HEAPF32[i17 >> 2];
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break L10;
+ } else {
+ HEAP8[i12 + 248 | 0] = 1;
+ i19 = i12 + 212 | 0;
+ }
+ } while (0);
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i19;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i12 + 188 | 0;
+ i40 = HEAP32[i41 + 4 >> 2] | 0;
+ i38 = i12 + 228 | 0;
+ HEAP32[i38 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i38 + 4 >> 2] = i40;
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ if (!i38) {
+ if (!(!(d32 >= 0.0) | !(d28 >= 0.0))) {
+ i41 = d24 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ i40 = i16;
+ i38 = HEAP32[i40 >> 2] | 0;
+ i40 = HEAP32[i40 + 4 >> 2] | 0;
+ i41 = i19;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i12 + 228 | 0;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 0;
+ i19 = i12 + 212 | 0;
+ }
+ d37 = +-d23;
+ d39 = +d22;
+ i41 = i19;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ d39 = +-+HEAPF32[i34 >> 2];
+ d37 = +-+HEAPF32[i35 >> 2];
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d39;
+ HEAPF32[i41 + 4 >> 2] = d37;
+ d37 = +-+HEAPF32[i12 + 188 >> 2];
+ d39 = +-+HEAPF32[i12 + 192 >> 2];
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break;
+ }
+ do {
+ if (!(d24 >= 0.0)) {
+ if (d32 >= 0.0) {
+ i41 = d28 >= 0.0;
+ HEAP8[i12 + 248 | 0] = i41 & 1;
+ i19 = i12 + 212 | 0;
+ if (i41) {
+ break;
+ }
+ } else {
+ HEAP8[i12 + 248 | 0] = 0;
+ i19 = i12 + 212 | 0;
+ }
+ d37 = +-d23;
+ d39 = +d22;
+ i41 = i19;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ d39 = +-+HEAPF32[i16 >> 2];
+ d37 = +-+HEAPF32[i17 >> 2];
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d39;
+ HEAPF32[i41 + 4 >> 2] = d37;
+ d37 = +-+HEAPF32[i12 + 188 >> 2];
+ d39 = +-+HEAPF32[i12 + 192 >> 2];
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ break L10;
+ } else {
+ HEAP8[i12 + 248 | 0] = 1;
+ i19 = i12 + 212 | 0;
+ }
+ } while (0);
+ i38 = i16;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i19;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i16;
+ i40 = HEAP32[i41 + 4 >> 2] | 0;
+ i38 = i12 + 228 | 0;
+ HEAP32[i38 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i38 + 4 >> 2] = i40;
+ i38 = i12 + 204 | 0;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ }
+ } while (0);
+ if ((i15 | 0) == 64) {
+ i38 = i16;
+ i41 = HEAP32[i38 >> 2] | 0;
+ i38 = HEAP32[i38 + 4 >> 2] | 0;
+ i40 = i19;
+ HEAP32[i40 >> 2] = i41;
+ HEAP32[i40 + 4 >> 2] = i38;
+ d37 = +-(HEAP32[tempDoublePtr >> 2] = i41, +HEAPF32[tempDoublePtr >> 2]);
+ d39 = +d22;
+ i41 = i12 + 228 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ i41 = i12 + 236 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ } else if ((i15 | 0) == 65) {
+ d37 = +-d23;
+ d39 = +d22;
+ i40 = i19;
+ HEAPF32[i40 >> 2] = d37;
+ HEAPF32[i40 + 4 >> 2] = d39;
+ i40 = i16;
+ i38 = HEAP32[i40 >> 2] | 0;
+ i40 = HEAP32[i40 + 4 >> 2] | 0;
+ i41 = i12 + 228 | 0;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ i41 = i12 + 236 | 0;
+ HEAP32[i41 >> 2] = i38;
+ HEAP32[i41 + 4 >> 2] = i40;
+ }
+ i21 = i8 + 148 | 0;
+ i34 = i12 + 128 | 0;
+ HEAP32[i34 >> 2] = HEAP32[i21 >> 2];
+ if ((HEAP32[i21 >> 2] | 0) > 0) {
+ i19 = 0;
+ do {
+ d33 = +HEAPF32[i5 >> 2];
+ d37 = +HEAPF32[i8 + (i19 << 3) + 20 >> 2];
+ d39 = +HEAPF32[i7 >> 2];
+ d36 = +HEAPF32[i8 + (i19 << 3) + 24 >> 2];
+ d32 = +(+HEAPF32[i4 >> 2] + (d33 * d37 - d39 * d36));
+ d36 = +(d37 * d39 + d33 * d36 + +HEAPF32[i6 >> 2]);
+ i41 = i12 + (i19 << 3) | 0;
+ HEAPF32[i41 >> 2] = d32;
+ HEAPF32[i41 + 4 >> 2] = d36;
+ d36 = +HEAPF32[i5 >> 2];
+ d32 = +HEAPF32[i8 + (i19 << 3) + 84 >> 2];
+ d33 = +HEAPF32[i7 >> 2];
+ d39 = +HEAPF32[i8 + (i19 << 3) + 88 >> 2];
+ d37 = +(d36 * d32 - d33 * d39);
+ d39 = +(d32 * d33 + d36 * d39);
+ i41 = i12 + (i19 << 3) + 64 | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ i19 = i19 + 1 | 0;
+ } while ((i19 | 0) < (HEAP32[i21 >> 2] | 0));
+ }
+ i21 = i12 + 244 | 0;
+ HEAPF32[i21 >> 2] = .019999999552965164;
+ i19 = i2 + 60 | 0;
+ HEAP32[i19 >> 2] = 0;
+ i29 = i12 + 248 | 0;
+ i35 = HEAP32[i34 >> 2] | 0;
+ if ((i35 | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ d23 = +HEAPF32[i12 + 164 >> 2];
+ d26 = +HEAPF32[i20 >> 2];
+ d24 = +HEAPF32[i12 + 212 >> 2];
+ d27 = +HEAPF32[i12 + 216 >> 2];
+ d22 = 3.4028234663852886e+38;
+ i20 = 0;
+ do {
+ d25 = d24 * (+HEAPF32[i12 + (i20 << 3) >> 2] - d23) + d27 * (+HEAPF32[i12 + (i20 << 3) + 4 >> 2] - d26);
+ d22 = d25 < d22 ? d25 : d22;
+ i20 = i20 + 1 | 0;
+ } while ((i20 | 0) != (i35 | 0));
+ if (d22 > .019999999552965164) {
+ STACKTOP = i1;
+ return;
+ }
+ __ZN12b2EPCollider24ComputePolygonSeparationEv(i18, i12);
+ i20 = HEAP32[i18 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ d23 = +HEAPF32[i18 + 8 >> 2];
+ if (d23 > +HEAPF32[i21 >> 2]) {
+ STACKTOP = i1;
+ return;
+ }
+ if (d23 > d22 * .9800000190734863 + .0010000000474974513) {
+ i18 = HEAP32[i18 + 4 >> 2] | 0;
+ i35 = i2 + 56 | 0;
+ if ((i20 | 0) == 1) {
+ i18 = i11;
+ i15 = 77;
+ } else {
+ HEAP32[i35 >> 2] = 2;
+ i40 = i14;
+ i41 = HEAP32[i40 + 4 >> 2] | 0;
+ i38 = i11;
+ HEAP32[i38 >> 2] = HEAP32[i40 >> 2];
+ HEAP32[i38 + 4 >> 2] = i41;
+ i38 = i11 + 8 | 0;
+ HEAP8[i38] = 0;
+ i41 = i18 & 255;
+ HEAP8[i38 + 1 | 0] = i41;
+ HEAP8[i38 + 2 | 0] = 0;
+ HEAP8[i38 + 3 | 0] = 1;
+ i38 = i13;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i13 = i11 + 12 | 0;
+ HEAP32[i13 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i13 + 4 >> 2] = i40;
+ i13 = i11 + 20 | 0;
+ HEAP8[i13] = 0;
+ HEAP8[i13 + 1 | 0] = i41;
+ HEAP8[i13 + 2 | 0] = 0;
+ HEAP8[i13 + 3 | 0] = 1;
+ HEAP32[i9 >> 2] = i18;
+ i13 = i18 + 1 | 0;
+ i16 = (i13 | 0) < (HEAP32[i34 >> 2] | 0) ? i13 : 0;
+ HEAP32[i9 + 4 >> 2] = i16;
+ i17 = i12 + (i18 << 3) | 0;
+ i13 = HEAP32[i17 >> 2] | 0;
+ i17 = HEAP32[i17 + 4 >> 2] | 0;
+ i29 = i9 + 8 | 0;
+ HEAP32[i29 >> 2] = i13;
+ HEAP32[i29 + 4 >> 2] = i17;
+ i16 = i12 + (i16 << 3) | 0;
+ i29 = HEAP32[i16 >> 2] | 0;
+ i16 = HEAP32[i16 + 4 >> 2] | 0;
+ i20 = i9 + 16 | 0;
+ HEAP32[i20 >> 2] = i29;
+ HEAP32[i20 + 4 >> 2] = i16;
+ i20 = i12 + (i18 << 3) + 64 | 0;
+ i12 = HEAP32[i20 >> 2] | 0;
+ i20 = HEAP32[i20 + 4 >> 2] | 0;
+ i14 = i9 + 24 | 0;
+ HEAP32[i14 >> 2] = i12;
+ HEAP32[i14 + 4 >> 2] = i20;
+ i14 = 0;
+ }
+ } else {
+ i15 = 75;
+ }
+ } else {
+ i15 = 75;
+ }
+ if ((i15 | 0) == 75) {
+ i18 = i11;
+ i35 = i2 + 56 | 0;
+ i15 = 77;
+ }
+ do {
+ if ((i15 | 0) == 77) {
+ HEAP32[i35 >> 2] = 1;
+ i15 = HEAP32[i34 >> 2] | 0;
+ if ((i15 | 0) > 1) {
+ d23 = +HEAPF32[i12 + 216 >> 2];
+ d22 = +HEAPF32[i12 + 212 >> 2];
+ i34 = 0;
+ d24 = d22 * +HEAPF32[i12 + 64 >> 2] + d23 * +HEAPF32[i12 + 68 >> 2];
+ i35 = 1;
+ while (1) {
+ d25 = d22 * +HEAPF32[i12 + (i35 << 3) + 64 >> 2] + d23 * +HEAPF32[i12 + (i35 << 3) + 68 >> 2];
+ i20 = d25 < d24;
+ i34 = i20 ? i35 : i34;
+ i35 = i35 + 1 | 0;
+ if ((i35 | 0) < (i15 | 0)) {
+ d24 = i20 ? d25 : d24;
+ } else {
+ break;
+ }
+ }
+ } else {
+ i34 = 0;
+ }
+ i20 = i34 + 1 | 0;
+ i40 = (i20 | 0) < (i15 | 0) ? i20 : 0;
+ i41 = i12 + (i34 << 3) | 0;
+ i38 = HEAP32[i41 + 4 >> 2] | 0;
+ i35 = i11;
+ HEAP32[i35 >> 2] = HEAP32[i41 >> 2];
+ HEAP32[i35 + 4 >> 2] = i38;
+ i35 = i11 + 8 | 0;
+ HEAP8[i35] = 0;
+ HEAP8[i35 + 1 | 0] = i34;
+ HEAP8[i35 + 2 | 0] = 1;
+ HEAP8[i35 + 3 | 0] = 0;
+ i35 = i12 + (i40 << 3) | 0;
+ i38 = HEAP32[i35 + 4 >> 2] | 0;
+ i41 = i11 + 12 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i35 >> 2];
+ HEAP32[i41 + 4 >> 2] = i38;
+ i41 = i11 + 20 | 0;
+ HEAP8[i41] = 0;
+ HEAP8[i41 + 1 | 0] = i40;
+ HEAP8[i41 + 2 | 0] = 1;
+ HEAP8[i41 + 3 | 0] = 0;
+ if ((HEAP8[i29] | 0) == 0) {
+ HEAP32[i9 >> 2] = 1;
+ HEAP32[i9 + 4 >> 2] = 0;
+ i11 = i13;
+ i13 = HEAP32[i11 >> 2] | 0;
+ i11 = HEAP32[i11 + 4 >> 2] | 0;
+ i29 = i9 + 8 | 0;
+ HEAP32[i29 >> 2] = i13;
+ HEAP32[i29 + 4 >> 2] = i11;
+ i29 = HEAP32[i14 >> 2] | 0;
+ i14 = HEAP32[i14 + 4 >> 2] | 0;
+ i12 = i9 + 16 | 0;
+ HEAP32[i12 >> 2] = i29;
+ HEAP32[i12 + 4 >> 2] = i14;
+ i12 = (HEAPF32[tempDoublePtr >> 2] = -+HEAPF32[i16 >> 2], HEAP32[tempDoublePtr >> 2] | 0);
+ i20 = (HEAPF32[tempDoublePtr >> 2] = -+HEAPF32[i17 >> 2], HEAP32[tempDoublePtr >> 2] | 0);
+ i16 = i9 + 24 | 0;
+ HEAP32[i16 >> 2] = i12;
+ HEAP32[i16 + 4 >> 2] = i20;
+ i16 = i14;
+ i17 = i11;
+ i11 = i18;
+ i18 = 1;
+ i14 = 1;
+ break;
+ } else {
+ HEAP32[i9 >> 2] = 0;
+ HEAP32[i9 + 4 >> 2] = 1;
+ i17 = i14;
+ i11 = HEAP32[i17 >> 2] | 0;
+ i17 = HEAP32[i17 + 4 >> 2] | 0;
+ i29 = i9 + 8 | 0;
+ HEAP32[i29 >> 2] = i11;
+ HEAP32[i29 + 4 >> 2] = i17;
+ i29 = HEAP32[i13 >> 2] | 0;
+ i13 = HEAP32[i13 + 4 >> 2] | 0;
+ i20 = i9 + 16 | 0;
+ HEAP32[i20 >> 2] = i29;
+ HEAP32[i20 + 4 >> 2] = i13;
+ i20 = i16;
+ i12 = HEAP32[i20 >> 2] | 0;
+ i20 = HEAP32[i20 + 4 >> 2] | 0;
+ i16 = i9 + 24 | 0;
+ HEAP32[i16 >> 2] = i12;
+ HEAP32[i16 + 4 >> 2] = i20;
+ i16 = i13;
+ i13 = i11;
+ i11 = i18;
+ i18 = 0;
+ i14 = 1;
+ break;
+ }
+ }
+ } while (0);
+ d30 = (HEAP32[tempDoublePtr >> 2] = i20, +HEAPF32[tempDoublePtr >> 2]);
+ d39 = (HEAP32[tempDoublePtr >> 2] = i12, +HEAPF32[tempDoublePtr >> 2]);
+ d31 = (HEAP32[tempDoublePtr >> 2] = i13, +HEAPF32[tempDoublePtr >> 2]);
+ d32 = (HEAP32[tempDoublePtr >> 2] = i17, +HEAPF32[tempDoublePtr >> 2]);
+ d33 = (HEAP32[tempDoublePtr >> 2] = i29, +HEAPF32[tempDoublePtr >> 2]);
+ d37 = (HEAP32[tempDoublePtr >> 2] = i16, +HEAPF32[tempDoublePtr >> 2]);
+ i41 = i9 + 32 | 0;
+ i16 = i9 + 24 | 0;
+ i13 = i9 + 28 | 0;
+ d39 = -d39;
+ HEAPF32[i41 >> 2] = d30;
+ HEAPF32[i9 + 36 >> 2] = d39;
+ i20 = i9 + 44 | 0;
+ d36 = -d30;
+ i17 = i20;
+ HEAPF32[i17 >> 2] = d36;
+ HEAP32[i17 + 4 >> 2] = i12;
+ i17 = i9 + 8 | 0;
+ i15 = i9 + 12 | 0;
+ d39 = d30 * d31 + d32 * d39;
+ HEAPF32[i9 + 40 >> 2] = d39;
+ i29 = i9 + 52 | 0;
+ HEAPF32[i29 >> 2] = d33 * d36 + (HEAP32[tempDoublePtr >> 2] = i12, +HEAPF32[tempDoublePtr >> 2]) * d37;
+ if ((__Z19b2ClipSegmentToLineP12b2ClipVertexPKS_RK6b2Vec2fi(i10, i11, i41, d39, i18) | 0) < 2) {
+ STACKTOP = i1;
+ return;
+ }
+ if ((__Z19b2ClipSegmentToLineP12b2ClipVertexPKS_RK6b2Vec2fi(i3, i10, i20, +HEAPF32[i29 >> 2], HEAP32[i9 + 4 >> 2] | 0) | 0) < 2) {
+ STACKTOP = i1;
+ return;
+ }
+ i10 = i2 + 40 | 0;
+ if (i14) {
+ i40 = i16;
+ i41 = HEAP32[i40 >> 2] | 0;
+ i40 = HEAP32[i40 + 4 >> 2] | 0;
+ i35 = i10;
+ HEAP32[i35 >> 2] = i41;
+ HEAP32[i35 + 4 >> 2] = i40;
+ i35 = i17;
+ i40 = HEAP32[i35 >> 2] | 0;
+ i35 = HEAP32[i35 + 4 >> 2] | 0;
+ i38 = i2 + 48 | 0;
+ HEAP32[i38 >> 2] = i40;
+ HEAP32[i38 + 4 >> 2] = i35;
+ d23 = (HEAP32[tempDoublePtr >> 2] = i40, +HEAPF32[tempDoublePtr >> 2]);
+ d22 = (HEAP32[tempDoublePtr >> 2] = i41, +HEAPF32[tempDoublePtr >> 2]);
+ d24 = +HEAPF32[i15 >> 2];
+ d25 = +HEAPF32[i13 >> 2];
+ d28 = +HEAPF32[i3 >> 2];
+ d27 = +HEAPF32[i3 + 4 >> 2];
+ d26 = +HEAPF32[i21 >> 2];
+ if (!((d28 - d23) * d22 + (d27 - d24) * d25 <= d26)) {
+ d28 = d26;
+ i8 = 0;
+ } else {
+ d37 = d28 - +HEAPF32[i4 >> 2];
+ d36 = d27 - +HEAPF32[i6 >> 2];
+ d33 = +HEAPF32[i5 >> 2];
+ d28 = +HEAPF32[i7 >> 2];
+ d39 = +(d37 * d33 + d36 * d28);
+ d28 = +(d33 * d36 - d37 * d28);
+ i8 = i2;
+ HEAPF32[i8 >> 2] = d39;
+ HEAPF32[i8 + 4 >> 2] = d28;
+ HEAP32[i2 + 16 >> 2] = HEAP32[i3 + 8 >> 2];
+ d28 = +HEAPF32[i21 >> 2];
+ i8 = 1;
+ }
+ d26 = +HEAPF32[i3 + 12 >> 2];
+ d27 = +HEAPF32[i3 + 16 >> 2];
+ if ((d26 - d23) * d22 + (d27 - d24) * d25 <= d28) {
+ d36 = d26 - +HEAPF32[i4 >> 2];
+ d33 = d27 - +HEAPF32[i6 >> 2];
+ d32 = +HEAPF32[i5 >> 2];
+ d39 = +HEAPF32[i7 >> 2];
+ d37 = +(d36 * d32 + d33 * d39);
+ d39 = +(d32 * d33 - d36 * d39);
+ i41 = i2 + (i8 * 20 | 0) | 0;
+ HEAPF32[i41 >> 2] = d37;
+ HEAPF32[i41 + 4 >> 2] = d39;
+ HEAP32[i2 + (i8 * 20 | 0) + 16 >> 2] = HEAP32[i3 + 20 >> 2];
+ i8 = i8 + 1 | 0;
+ }
+ } else {
+ i38 = HEAP32[i9 >> 2] | 0;
+ i35 = i8 + (i38 << 3) + 84 | 0;
+ i41 = HEAP32[i35 + 4 >> 2] | 0;
+ i40 = i10;
+ HEAP32[i40 >> 2] = HEAP32[i35 >> 2];
+ HEAP32[i40 + 4 >> 2] = i41;
+ i38 = i8 + (i38 << 3) + 20 | 0;
+ i40 = HEAP32[i38 + 4 >> 2] | 0;
+ i41 = i2 + 48 | 0;
+ HEAP32[i41 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i41 + 4 >> 2] = i40;
+ d22 = +HEAPF32[i17 >> 2];
+ d23 = +HEAPF32[i16 >> 2];
+ d24 = +HEAPF32[i15 >> 2];
+ d25 = +HEAPF32[i13 >> 2];
+ d26 = +HEAPF32[i21 >> 2];
+ if (!((+HEAPF32[i3 >> 2] - d22) * d23 + (+HEAPF32[i3 + 4 >> 2] - d24) * d25 <= d26)) {
+ i8 = 0;
+ } else {
+ i40 = i3;
+ i8 = HEAP32[i40 + 4 >> 2] | 0;
+ i41 = i2;
+ HEAP32[i41 >> 2] = HEAP32[i40 >> 2];
+ HEAP32[i41 + 4 >> 2] = i8;
+ i41 = i3 + 8 | 0;
+ i8 = i2 + 16 | 0;
+ HEAP8[i8 + 2 | 0] = HEAP8[i41 + 3 | 0] | 0;
+ HEAP8[i8 + 3 | 0] = HEAP8[i41 + 2 | 0] | 0;
+ HEAP8[i8] = HEAP8[i41 + 1 | 0] | 0;
+ HEAP8[i8 + 1 | 0] = HEAP8[i41] | 0;
+ d26 = +HEAPF32[i21 >> 2];
+ i8 = 1;
+ }
+ i4 = i3 + 12 | 0;
+ if ((+HEAPF32[i4 >> 2] - d22) * d23 + (+HEAPF32[i3 + 16 >> 2] - d24) * d25 <= d26) {
+ i38 = i4;
+ i41 = HEAP32[i38 + 4 >> 2] | 0;
+ i40 = i2 + (i8 * 20 | 0) | 0;
+ HEAP32[i40 >> 2] = HEAP32[i38 >> 2];
+ HEAP32[i40 + 4 >> 2] = i41;
+ i40 = i3 + 20 | 0;
+ i41 = i2 + (i8 * 20 | 0) + 16 | 0;
+ HEAP8[i41 + 2 | 0] = HEAP8[i40 + 3 | 0] | 0;
+ HEAP8[i41 + 3 | 0] = HEAP8[i40 + 2 | 0] | 0;
+ HEAP8[i41] = HEAP8[i40 + 1 | 0] | 0;
+ HEAP8[i41 + 1 | 0] = HEAP8[i40] | 0;
+ i8 = i8 + 1 | 0;
+ }
+ }
+ HEAP32[i19 >> 2] = i8;
+ STACKTOP = i1;
+ return;
+}
+function __ZN7b2World8SolveTOIERK10b2TimeStep(i30, i11) {
+ i30 = i30 | 0;
+ i11 = i11 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0, i38 = 0, i39 = 0, i40 = 0, i41 = 0, d42 = 0.0, i43 = 0, i44 = 0, i45 = 0, i46 = 0, i47 = 0, i48 = 0, i49 = 0, i50 = 0, i51 = 0, i52 = 0, i53 = 0, i54 = 0, i55 = 0, i56 = 0, i57 = 0, i58 = 0, i59 = 0, i60 = 0, i61 = 0, i62 = 0, i63 = 0, i64 = 0, i65 = 0, i66 = 0, d67 = 0.0, d68 = 0.0, d69 = 0.0, d70 = 0.0, d71 = 0.0, d72 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 336 | 0;
+ i3 = i1 + 284 | 0;
+ i6 = i1 + 152 | 0;
+ i5 = i1 + 144 | 0;
+ i4 = i1 + 108 | 0;
+ i8 = i1 + 72 | 0;
+ i7 = i1 + 64 | 0;
+ i14 = i1 + 24 | 0;
+ i9 = i1;
+ i10 = i30 + 102872 | 0;
+ i13 = i30 + 102944 | 0;
+ __ZN8b2IslandC2EiiiP16b2StackAllocatorP17b2ContactListener(i3, 64, 32, 0, i30 + 68 | 0, HEAP32[i13 >> 2] | 0);
+ i2 = i30 + 102995 | 0;
+ if ((HEAP8[i2] | 0) != 0) {
+ i15 = HEAP32[i30 + 102952 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ do {
+ i66 = i15 + 4 | 0;
+ HEAP16[i66 >> 1] = HEAP16[i66 >> 1] & 65534;
+ HEAPF32[i15 + 60 >> 2] = 0.0;
+ i15 = HEAP32[i15 + 96 >> 2] | 0;
+ } while ((i15 | 0) != 0);
+ }
+ i15 = i30 + 102932 | 0;
+ i16 = HEAP32[i15 >> 2] | 0;
+ if ((i16 | 0) != 0) {
+ do {
+ i66 = i16 + 4 | 0;
+ HEAP32[i66 >> 2] = HEAP32[i66 >> 2] & -34;
+ HEAP32[i16 + 128 >> 2] = 0;
+ HEAPF32[i16 + 132 >> 2] = 1.0;
+ i16 = HEAP32[i16 + 12 >> 2] | 0;
+ } while ((i16 | 0) != 0);
+ }
+ } else {
+ i15 = i30 + 102932 | 0;
+ }
+ i25 = i3 + 28 | 0;
+ i26 = i3 + 36 | 0;
+ i27 = i3 + 32 | 0;
+ i28 = i3 + 40 | 0;
+ i29 = i3 + 8 | 0;
+ i24 = i3 + 44 | 0;
+ i23 = i3 + 12 | 0;
+ i22 = i7 + 4 | 0;
+ i21 = i9 + 4 | 0;
+ i20 = i9 + 8 | 0;
+ i19 = i9 + 16 | 0;
+ i18 = i11 + 12 | 0;
+ i17 = i9 + 12 | 0;
+ i16 = i9 + 20 | 0;
+ i39 = i30 + 102994 | 0;
+ i37 = i6 + 16 | 0;
+ i36 = i6 + 20 | 0;
+ i35 = i6 + 24 | 0;
+ i34 = i6 + 44 | 0;
+ i33 = i6 + 48 | 0;
+ i32 = i6 + 52 | 0;
+ i41 = i6 + 28 | 0;
+ i31 = i6 + 56 | 0;
+ i40 = i6 + 92 | 0;
+ i30 = i6 + 128 | 0;
+ i38 = i5 + 4 | 0;
+ L11 : while (1) {
+ i47 = HEAP32[i15 >> 2] | 0;
+ if ((i47 | 0) == 0) {
+ i4 = 36;
+ break;
+ } else {
+ d42 = 1.0;
+ i44 = 0;
+ }
+ do {
+ i48 = i47 + 4 | 0;
+ i43 = HEAP32[i48 >> 2] | 0;
+ do {
+ if ((i43 & 4 | 0) != 0 ? (HEAP32[i47 + 128 >> 2] | 0) <= 8 : 0) {
+ if ((i43 & 32 | 0) == 0) {
+ i43 = HEAP32[i47 + 48 >> 2] | 0;
+ i45 = HEAP32[i47 + 52 >> 2] | 0;
+ if ((HEAP8[i43 + 38 | 0] | 0) != 0) {
+ break;
+ }
+ if ((HEAP8[i45 + 38 | 0] | 0) != 0) {
+ break;
+ }
+ i46 = HEAP32[i43 + 8 >> 2] | 0;
+ i50 = HEAP32[i45 + 8 >> 2] | 0;
+ i53 = HEAP32[i46 >> 2] | 0;
+ i52 = HEAP32[i50 >> 2] | 0;
+ if (!((i53 | 0) == 2 | (i52 | 0) == 2)) {
+ i4 = 16;
+ break L11;
+ }
+ i51 = HEAP16[i46 + 4 >> 1] | 0;
+ i49 = HEAP16[i50 + 4 >> 1] | 0;
+ if (!((i51 & 2) != 0 & (i53 | 0) != 0 | (i49 & 2) != 0 & (i52 | 0) != 0)) {
+ break;
+ }
+ if (!((i51 & 8) != 0 | (i53 | 0) != 2 | ((i49 & 8) != 0 | (i52 | 0) != 2))) {
+ break;
+ }
+ i51 = i46 + 28 | 0;
+ i52 = i46 + 60 | 0;
+ d68 = +HEAPF32[i52 >> 2];
+ i49 = i50 + 28 | 0;
+ i53 = i50 + 60 | 0;
+ d67 = +HEAPF32[i53 >> 2];
+ if (!(d68 < d67)) {
+ if (d67 < d68) {
+ if (!(d67 < 1.0)) {
+ i4 = 25;
+ break L11;
+ }
+ d67 = (d68 - d67) / (1.0 - d67);
+ i66 = i50 + 36 | 0;
+ d69 = 1.0 - d67;
+ d71 = +(+HEAPF32[i66 >> 2] * d69 + d67 * +HEAPF32[i50 + 44 >> 2]);
+ d70 = +(d69 * +HEAPF32[i50 + 40 >> 2] + d67 * +HEAPF32[i50 + 48 >> 2]);
+ HEAPF32[i66 >> 2] = d71;
+ HEAPF32[i66 + 4 >> 2] = d70;
+ i66 = i50 + 52 | 0;
+ HEAPF32[i66 >> 2] = d69 * +HEAPF32[i66 >> 2] + d67 * +HEAPF32[i50 + 56 >> 2];
+ HEAPF32[i53 >> 2] = d68;
+ d67 = d68;
+ } else {
+ d67 = d68;
+ }
+ } else {
+ if (!(d68 < 1.0)) {
+ i4 = 21;
+ break L11;
+ }
+ d71 = (d67 - d68) / (1.0 - d68);
+ i66 = i46 + 36 | 0;
+ d70 = 1.0 - d71;
+ d68 = +(+HEAPF32[i66 >> 2] * d70 + d71 * +HEAPF32[i46 + 44 >> 2]);
+ d69 = +(d70 * +HEAPF32[i46 + 40 >> 2] + d71 * +HEAPF32[i46 + 48 >> 2]);
+ HEAPF32[i66 >> 2] = d68;
+ HEAPF32[i66 + 4 >> 2] = d69;
+ i66 = i46 + 52 | 0;
+ HEAPF32[i66 >> 2] = d70 * +HEAPF32[i66 >> 2] + d71 * +HEAPF32[i46 + 56 >> 2];
+ HEAPF32[i52 >> 2] = d67;
+ }
+ if (!(d67 < 1.0)) {
+ i4 = 28;
+ break L11;
+ }
+ i66 = HEAP32[i47 + 56 >> 2] | 0;
+ i46 = HEAP32[i47 + 60 >> 2] | 0;
+ HEAP32[i37 >> 2] = 0;
+ HEAP32[i36 >> 2] = 0;
+ HEAPF32[i35 >> 2] = 0.0;
+ HEAP32[i34 >> 2] = 0;
+ HEAP32[i33 >> 2] = 0;
+ HEAPF32[i32 >> 2] = 0.0;
+ __ZN15b2DistanceProxy3SetEPK7b2Shapei(i6, HEAP32[i43 + 12 >> 2] | 0, i66);
+ __ZN15b2DistanceProxy3SetEPK7b2Shapei(i41, HEAP32[i45 + 12 >> 2] | 0, i46);
+ i43 = i31 + 0 | 0;
+ i45 = i51 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ i43 = i40 + 0 | 0;
+ i45 = i49 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ HEAPF32[i30 >> 2] = 1.0;
+ __Z14b2TimeOfImpactP11b2TOIOutputPK10b2TOIInput(i5, i6);
+ if ((HEAP32[i5 >> 2] | 0) == 3) {
+ d67 = d67 + (1.0 - d67) * +HEAPF32[i38 >> 2];
+ d67 = d67 < 1.0 ? d67 : 1.0;
+ } else {
+ d67 = 1.0;
+ }
+ HEAPF32[i47 + 132 >> 2] = d67;
+ HEAP32[i48 >> 2] = HEAP32[i48 >> 2] | 32;
+ } else {
+ d67 = +HEAPF32[i47 + 132 >> 2];
+ }
+ if (d67 < d42) {
+ d42 = d67;
+ i44 = i47;
+ }
+ }
+ } while (0);
+ i47 = HEAP32[i47 + 12 >> 2] | 0;
+ } while ((i47 | 0) != 0);
+ if ((i44 | 0) == 0 | d42 > .9999988079071045) {
+ i4 = 36;
+ break;
+ }
+ i47 = HEAP32[(HEAP32[i44 + 48 >> 2] | 0) + 8 >> 2] | 0;
+ i48 = HEAP32[(HEAP32[i44 + 52 >> 2] | 0) + 8 >> 2] | 0;
+ i49 = i47 + 28 | 0;
+ i43 = i4 + 0 | 0;
+ i45 = i49 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ i50 = i48 + 28 | 0;
+ i43 = i8 + 0 | 0;
+ i45 = i50 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ i43 = i47 + 60 | 0;
+ d67 = +HEAPF32[i43 >> 2];
+ if (!(d67 < 1.0)) {
+ i4 = 38;
+ break;
+ }
+ d70 = (d42 - d67) / (1.0 - d67);
+ i57 = i47 + 36 | 0;
+ d67 = 1.0 - d70;
+ i52 = i47 + 44 | 0;
+ i53 = i47 + 48 | 0;
+ d71 = +HEAPF32[i57 >> 2] * d67 + d70 * +HEAPF32[i52 >> 2];
+ d72 = d67 * +HEAPF32[i47 + 40 >> 2] + d70 * +HEAPF32[i53 >> 2];
+ d69 = +d71;
+ d68 = +d72;
+ HEAPF32[i57 >> 2] = d69;
+ HEAPF32[i57 + 4 >> 2] = d68;
+ i57 = i47 + 52 | 0;
+ i51 = i47 + 56 | 0;
+ d70 = d67 * +HEAPF32[i57 >> 2] + d70 * +HEAPF32[i51 >> 2];
+ HEAPF32[i57 >> 2] = d70;
+ HEAPF32[i43 >> 2] = d42;
+ i57 = i47 + 44 | 0;
+ HEAPF32[i57 >> 2] = d69;
+ HEAPF32[i57 + 4 >> 2] = d68;
+ HEAPF32[i51 >> 2] = d70;
+ d68 = +Math_sin(+d70);
+ i57 = i47 + 20 | 0;
+ HEAPF32[i57 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ i56 = i47 + 24 | 0;
+ HEAPF32[i56 >> 2] = d70;
+ i58 = i47 + 12 | 0;
+ i55 = i47 + 28 | 0;
+ d69 = +HEAPF32[i55 >> 2];
+ i54 = i47 + 32 | 0;
+ d67 = +HEAPF32[i54 >> 2];
+ d71 = +(d71 - (d70 * d69 - d68 * d67));
+ d67 = +(d72 - (d68 * d69 + d70 * d67));
+ i43 = i58;
+ HEAPF32[i43 >> 2] = d71;
+ HEAPF32[i43 + 4 >> 2] = d67;
+ i43 = i48 + 60 | 0;
+ d67 = +HEAPF32[i43 >> 2];
+ if (!(d67 < 1.0)) {
+ i4 = 40;
+ break;
+ }
+ d70 = (d42 - d67) / (1.0 - d67);
+ i64 = i48 + 36 | 0;
+ d72 = 1.0 - d70;
+ i61 = i48 + 44 | 0;
+ i60 = i48 + 48 | 0;
+ d71 = +HEAPF32[i64 >> 2] * d72 + d70 * +HEAPF32[i61 >> 2];
+ d67 = d72 * +HEAPF32[i48 + 40 >> 2] + d70 * +HEAPF32[i60 >> 2];
+ d69 = +d71;
+ d68 = +d67;
+ HEAPF32[i64 >> 2] = d69;
+ HEAPF32[i64 + 4 >> 2] = d68;
+ i64 = i48 + 52 | 0;
+ i59 = i48 + 56 | 0;
+ d70 = d72 * +HEAPF32[i64 >> 2] + d70 * +HEAPF32[i59 >> 2];
+ HEAPF32[i64 >> 2] = d70;
+ HEAPF32[i43 >> 2] = d42;
+ i64 = i48 + 44 | 0;
+ HEAPF32[i64 >> 2] = d69;
+ HEAPF32[i64 + 4 >> 2] = d68;
+ HEAPF32[i59 >> 2] = d70;
+ d68 = +Math_sin(+d70);
+ i64 = i48 + 20 | 0;
+ HEAPF32[i64 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ i63 = i48 + 24 | 0;
+ HEAPF32[i63 >> 2] = d70;
+ i65 = i48 + 12 | 0;
+ i62 = i48 + 28 | 0;
+ d69 = +HEAPF32[i62 >> 2];
+ i66 = i48 + 32 | 0;
+ d72 = +HEAPF32[i66 >> 2];
+ d71 = +(d71 - (d70 * d69 - d68 * d72));
+ d72 = +(d67 - (d68 * d69 + d70 * d72));
+ i43 = i65;
+ HEAPF32[i43 >> 2] = d71;
+ HEAPF32[i43 + 4 >> 2] = d72;
+ __ZN9b2Contact6UpdateEP17b2ContactListener(i44, HEAP32[i13 >> 2] | 0);
+ i43 = i44 + 4 | 0;
+ i45 = HEAP32[i43 >> 2] | 0;
+ HEAP32[i43 >> 2] = i45 & -33;
+ i46 = i44 + 128 | 0;
+ HEAP32[i46 >> 2] = (HEAP32[i46 >> 2] | 0) + 1;
+ if ((i45 & 6 | 0) != 6) {
+ HEAP32[i43 >> 2] = i45 & -37;
+ i43 = i49 + 0 | 0;
+ i45 = i4 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ i43 = i50 + 0 | 0;
+ i45 = i8 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ d69 = +HEAPF32[i51 >> 2];
+ d71 = +Math_sin(+d69);
+ HEAPF32[i57 >> 2] = d71;
+ d69 = +Math_cos(+d69);
+ HEAPF32[i56 >> 2] = d69;
+ d72 = +HEAPF32[i55 >> 2];
+ d70 = +HEAPF32[i54 >> 2];
+ d68 = +(+HEAPF32[i52 >> 2] - (d69 * d72 - d71 * d70));
+ d70 = +(+HEAPF32[i53 >> 2] - (d71 * d72 + d69 * d70));
+ HEAPF32[i58 >> 2] = d68;
+ HEAPF32[i58 + 4 >> 2] = d70;
+ d70 = +HEAPF32[i59 >> 2];
+ d68 = +Math_sin(+d70);
+ HEAPF32[i64 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ HEAPF32[i63 >> 2] = d70;
+ d69 = +HEAPF32[i62 >> 2];
+ d72 = +HEAPF32[i66 >> 2];
+ d71 = +(+HEAPF32[i61 >> 2] - (d70 * d69 - d68 * d72));
+ d72 = +(+HEAPF32[i60 >> 2] - (d68 * d69 + d70 * d72));
+ i66 = i65;
+ HEAPF32[i66 >> 2] = d71;
+ HEAPF32[i66 + 4 >> 2] = d72;
+ continue;
+ }
+ i45 = i47 + 4 | 0;
+ i46 = HEAPU16[i45 >> 1] | 0;
+ if ((i46 & 2 | 0) == 0) {
+ HEAP16[i45 >> 1] = i46 | 2;
+ HEAPF32[i47 + 144 >> 2] = 0.0;
+ }
+ i46 = i48 + 4 | 0;
+ i49 = HEAPU16[i46 >> 1] | 0;
+ if ((i49 & 2 | 0) == 0) {
+ HEAP16[i46 >> 1] = i49 | 2;
+ HEAPF32[i48 + 144 >> 2] = 0.0;
+ }
+ HEAP32[i25 >> 2] = 0;
+ HEAP32[i26 >> 2] = 0;
+ HEAP32[i27 >> 2] = 0;
+ if ((HEAP32[i28 >> 2] | 0) <= 0) {
+ i4 = 48;
+ break;
+ }
+ i49 = i47 + 8 | 0;
+ HEAP32[i49 >> 2] = 0;
+ i51 = HEAP32[i25 >> 2] | 0;
+ HEAP32[(HEAP32[i29 >> 2] | 0) + (i51 << 2) >> 2] = i47;
+ i51 = i51 + 1 | 0;
+ HEAP32[i25 >> 2] = i51;
+ if ((i51 | 0) >= (HEAP32[i28 >> 2] | 0)) {
+ i4 = 50;
+ break;
+ }
+ i50 = i48 + 8 | 0;
+ HEAP32[i50 >> 2] = i51;
+ i51 = HEAP32[i25 >> 2] | 0;
+ HEAP32[(HEAP32[i29 >> 2] | 0) + (i51 << 2) >> 2] = i48;
+ HEAP32[i25 >> 2] = i51 + 1;
+ i51 = HEAP32[i26 >> 2] | 0;
+ if ((i51 | 0) >= (HEAP32[i24 >> 2] | 0)) {
+ i4 = 52;
+ break;
+ }
+ HEAP32[i26 >> 2] = i51 + 1;
+ HEAP32[(HEAP32[i23 >> 2] | 0) + (i51 << 2) >> 2] = i44;
+ HEAP16[i45 >> 1] = HEAPU16[i45 >> 1] | 1;
+ HEAP16[i46 >> 1] = HEAPU16[i46 >> 1] | 1;
+ HEAP32[i43 >> 2] = HEAP32[i43 >> 2] | 1;
+ HEAP32[i7 >> 2] = i47;
+ HEAP32[i22 >> 2] = i48;
+ i44 = 1;
+ while (1) {
+ L58 : do {
+ if ((HEAP32[i47 >> 2] | 0) == 2 ? (i12 = HEAP32[i47 + 112 >> 2] | 0, (i12 | 0) != 0) : 0) {
+ i47 = i47 + 4 | 0;
+ i51 = i12;
+ do {
+ if ((HEAP32[i25 >> 2] | 0) == (HEAP32[i28 >> 2] | 0)) {
+ break L58;
+ }
+ if ((HEAP32[i26 >> 2] | 0) == (HEAP32[i24 >> 2] | 0)) {
+ break L58;
+ }
+ i52 = HEAP32[i51 + 4 >> 2] | 0;
+ i53 = i52 + 4 | 0;
+ do {
+ if ((HEAP32[i53 >> 2] & 1 | 0) == 0) {
+ i48 = HEAP32[i51 >> 2] | 0;
+ if (((HEAP32[i48 >> 2] | 0) == 2 ? (HEAP16[i47 >> 1] & 8) == 0 : 0) ? (HEAP16[i48 + 4 >> 1] & 8) == 0 : 0) {
+ break;
+ }
+ if ((HEAP8[(HEAP32[i52 + 48 >> 2] | 0) + 38 | 0] | 0) == 0 ? (HEAP8[(HEAP32[i52 + 52 >> 2] | 0) + 38 | 0] | 0) == 0 : 0) {
+ i54 = i48 + 28 | 0;
+ i43 = i14 + 0 | 0;
+ i45 = i54 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ i43 = i48 + 4 | 0;
+ if ((HEAP16[i43 >> 1] & 1) == 0) {
+ i45 = i48 + 60 | 0;
+ d67 = +HEAPF32[i45 >> 2];
+ if (!(d67 < 1.0)) {
+ i4 = 67;
+ break L11;
+ }
+ d70 = (d42 - d67) / (1.0 - d67);
+ i65 = i48 + 36 | 0;
+ d72 = 1.0 - d70;
+ d71 = +HEAPF32[i65 >> 2] * d72 + d70 * +HEAPF32[i48 + 44 >> 2];
+ d67 = d72 * +HEAPF32[i48 + 40 >> 2] + d70 * +HEAPF32[i48 + 48 >> 2];
+ d69 = +d71;
+ d68 = +d67;
+ HEAPF32[i65 >> 2] = d69;
+ HEAPF32[i65 + 4 >> 2] = d68;
+ i65 = i48 + 52 | 0;
+ i66 = i48 + 56 | 0;
+ d70 = d72 * +HEAPF32[i65 >> 2] + d70 * +HEAPF32[i66 >> 2];
+ HEAPF32[i65 >> 2] = d70;
+ HEAPF32[i45 >> 2] = d42;
+ i65 = i48 + 44 | 0;
+ HEAPF32[i65 >> 2] = d69;
+ HEAPF32[i65 + 4 >> 2] = d68;
+ HEAPF32[i66 >> 2] = d70;
+ d68 = +Math_sin(+d70);
+ HEAPF32[i48 + 20 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ HEAPF32[i48 + 24 >> 2] = d70;
+ d69 = +HEAPF32[i48 + 28 >> 2];
+ d72 = +HEAPF32[i48 + 32 >> 2];
+ d71 = +(d71 - (d70 * d69 - d68 * d72));
+ d72 = +(d67 - (d68 * d69 + d70 * d72));
+ i66 = i48 + 12 | 0;
+ HEAPF32[i66 >> 2] = d71;
+ HEAPF32[i66 + 4 >> 2] = d72;
+ }
+ __ZN9b2Contact6UpdateEP17b2ContactListener(i52, HEAP32[i13 >> 2] | 0);
+ i45 = HEAP32[i53 >> 2] | 0;
+ if ((i45 & 4 | 0) == 0) {
+ i43 = i54 + 0 | 0;
+ i45 = i14 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ d70 = +HEAPF32[i48 + 56 >> 2];
+ d68 = +Math_sin(+d70);
+ HEAPF32[i48 + 20 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ HEAPF32[i48 + 24 >> 2] = d70;
+ d69 = +HEAPF32[i48 + 28 >> 2];
+ d72 = +HEAPF32[i48 + 32 >> 2];
+ d71 = +(+HEAPF32[i48 + 44 >> 2] - (d70 * d69 - d68 * d72));
+ d72 = +(+HEAPF32[i48 + 48 >> 2] - (d68 * d69 + d70 * d72));
+ i66 = i48 + 12 | 0;
+ HEAPF32[i66 >> 2] = d71;
+ HEAPF32[i66 + 4 >> 2] = d72;
+ break;
+ }
+ if ((i45 & 2 | 0) == 0) {
+ i43 = i54 + 0 | 0;
+ i45 = i14 + 0 | 0;
+ i46 = i43 + 36 | 0;
+ do {
+ HEAP32[i43 >> 2] = HEAP32[i45 >> 2];
+ i43 = i43 + 4 | 0;
+ i45 = i45 + 4 | 0;
+ } while ((i43 | 0) < (i46 | 0));
+ d70 = +HEAPF32[i48 + 56 >> 2];
+ d68 = +Math_sin(+d70);
+ HEAPF32[i48 + 20 >> 2] = d68;
+ d70 = +Math_cos(+d70);
+ HEAPF32[i48 + 24 >> 2] = d70;
+ d69 = +HEAPF32[i48 + 28 >> 2];
+ d72 = +HEAPF32[i48 + 32 >> 2];
+ d71 = +(+HEAPF32[i48 + 44 >> 2] - (d70 * d69 - d68 * d72));
+ d72 = +(+HEAPF32[i48 + 48 >> 2] - (d68 * d69 + d70 * d72));
+ i66 = i48 + 12 | 0;
+ HEAPF32[i66 >> 2] = d71;
+ HEAPF32[i66 + 4 >> 2] = d72;
+ break;
+ }
+ HEAP32[i53 >> 2] = i45 | 1;
+ i45 = HEAP32[i26 >> 2] | 0;
+ if ((i45 | 0) >= (HEAP32[i24 >> 2] | 0)) {
+ i4 = 74;
+ break L11;
+ }
+ HEAP32[i26 >> 2] = i45 + 1;
+ HEAP32[(HEAP32[i23 >> 2] | 0) + (i45 << 2) >> 2] = i52;
+ i45 = HEAPU16[i43 >> 1] | 0;
+ if ((i45 & 1 | 0) == 0) {
+ HEAP16[i43 >> 1] = i45 | 1;
+ if ((HEAP32[i48 >> 2] | 0) != 0 ? (i45 & 2 | 0) == 0 : 0) {
+ HEAP16[i43 >> 1] = i45 | 3;
+ HEAPF32[i48 + 144 >> 2] = 0.0;
+ }
+ i43 = HEAP32[i25 >> 2] | 0;
+ if ((i43 | 0) >= (HEAP32[i28 >> 2] | 0)) {
+ i4 = 80;
+ break L11;
+ }
+ HEAP32[i48 + 8 >> 2] = i43;
+ i66 = HEAP32[i25 >> 2] | 0;
+ HEAP32[(HEAP32[i29 >> 2] | 0) + (i66 << 2) >> 2] = i48;
+ HEAP32[i25 >> 2] = i66 + 1;
+ }
+ }
+ }
+ } while (0);
+ i51 = HEAP32[i51 + 12 >> 2] | 0;
+ } while ((i51 | 0) != 0);
+ }
+ } while (0);
+ if ((i44 | 0) >= 2) {
+ break;
+ }
+ i47 = HEAP32[i7 + (i44 << 2) >> 2] | 0;
+ i44 = i44 + 1 | 0;
+ }
+ d72 = (1.0 - d42) * +HEAPF32[i11 >> 2];
+ HEAPF32[i9 >> 2] = d72;
+ HEAPF32[i21 >> 2] = 1.0 / d72;
+ HEAPF32[i20 >> 2] = 1.0;
+ HEAP32[i19 >> 2] = 20;
+ HEAP32[i17 >> 2] = HEAP32[i18 >> 2];
+ HEAP8[i16] = 0;
+ __ZN8b2Island8SolveTOIERK10b2TimeStepii(i3, i9, HEAP32[i49 >> 2] | 0, HEAP32[i50 >> 2] | 0);
+ i44 = HEAP32[i25 >> 2] | 0;
+ if ((i44 | 0) > 0) {
+ i43 = 0;
+ do {
+ i45 = HEAP32[(HEAP32[i29 >> 2] | 0) + (i43 << 2) >> 2] | 0;
+ i66 = i45 + 4 | 0;
+ HEAP16[i66 >> 1] = HEAP16[i66 >> 1] & 65534;
+ if ((HEAP32[i45 >> 2] | 0) == 2) {
+ __ZN6b2Body19SynchronizeFixturesEv(i45);
+ i44 = HEAP32[i45 + 112 >> 2] | 0;
+ if ((i44 | 0) != 0) {
+ do {
+ i66 = (HEAP32[i44 + 4 >> 2] | 0) + 4 | 0;
+ HEAP32[i66 >> 2] = HEAP32[i66 >> 2] & -34;
+ i44 = HEAP32[i44 + 12 >> 2] | 0;
+ } while ((i44 | 0) != 0);
+ }
+ i44 = HEAP32[i25 >> 2] | 0;
+ }
+ i43 = i43 + 1 | 0;
+ } while ((i43 | 0) < (i44 | 0));
+ }
+ __ZN16b2ContactManager15FindNewContactsEv(i10);
+ if ((HEAP8[i39] | 0) != 0) {
+ i4 = 92;
+ break;
+ }
+ }
+ if ((i4 | 0) == 16) {
+ ___assert_fail(2288, 2184, 641, 2344);
+ } else if ((i4 | 0) == 21) {
+ ___assert_fail(2360, 2376, 723, 2400);
+ } else if ((i4 | 0) == 25) {
+ ___assert_fail(2360, 2376, 723, 2400);
+ } else if ((i4 | 0) == 28) {
+ ___assert_fail(2360, 2184, 676, 2344);
+ } else if ((i4 | 0) == 36) {
+ HEAP8[i2] = 1;
+ __ZN8b2IslandD2Ev(i3);
+ STACKTOP = i1;
+ return;
+ } else if ((i4 | 0) == 38) {
+ ___assert_fail(2360, 2376, 723, 2400);
+ } else if ((i4 | 0) == 40) {
+ ___assert_fail(2360, 2376, 723, 2400);
+ } else if ((i4 | 0) == 48) {
+ ___assert_fail(2520, 2440, 54, 2472);
+ } else if ((i4 | 0) == 50) {
+ ___assert_fail(2520, 2440, 54, 2472);
+ } else if ((i4 | 0) == 52) {
+ ___assert_fail(2480, 2440, 62, 2472);
+ } else if ((i4 | 0) == 67) {
+ ___assert_fail(2360, 2376, 723, 2400);
+ } else if ((i4 | 0) == 74) {
+ ___assert_fail(2480, 2440, 62, 2472);
+ } else if ((i4 | 0) == 80) {
+ ___assert_fail(2520, 2440, 54, 2472);
+ } else if ((i4 | 0) == 92) {
+ HEAP8[i2] = 0;
+ __ZN8b2IslandD2Ev(i3);
+ STACKTOP = i1;
+ return;
+ }
+}
+function __ZNSt3__16__sortIRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i5, i8, i1) {
+ i5 = i5 | 0;
+ i8 = i8 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i3;
+ L1 : while (1) {
+ i7 = i8;
+ i4 = i8 + -12 | 0;
+ L3 : while (1) {
+ i9 = i5;
+ i11 = i7 - i9 | 0;
+ switch ((i11 | 0) / 12 | 0 | 0) {
+ case 4:
+ {
+ i6 = 14;
+ break L1;
+ }
+ case 2:
+ {
+ i6 = 4;
+ break L1;
+ }
+ case 3:
+ {
+ i6 = 6;
+ break L1;
+ }
+ case 5:
+ {
+ i6 = 15;
+ break L1;
+ }
+ case 1:
+ case 0:
+ {
+ i6 = 67;
+ break L1;
+ }
+ default:
+ {}
+ }
+ if ((i11 | 0) < 372) {
+ i6 = 21;
+ break L1;
+ }
+ i12 = (i11 | 0) / 24 | 0;
+ i10 = i5 + (i12 * 12 | 0) | 0;
+ do {
+ if ((i11 | 0) > 11988) {
+ i14 = (i11 | 0) / 48 | 0;
+ i11 = i5 + (i14 * 12 | 0) | 0;
+ i14 = i5 + ((i14 + i12 | 0) * 12 | 0) | 0;
+ i12 = __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i5, i11, i10, i14, i1) | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i14) | 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i14 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i14 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i14 + 8 >> 2];
+ HEAP32[i14 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i14 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i14 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i13 = i12 + 1 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i14, i10) | 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i14 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i14 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i14 + 8 >> 2];
+ HEAP32[i14 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i14 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i14 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i13 = i12 + 2 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i10, i11) | 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i11 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i11 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i11 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i11, i5) | 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i11 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i11 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i11 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = i12 + 4 | 0;
+ } else {
+ i12 = i12 + 3 | 0;
+ }
+ } else {
+ i12 = i13;
+ }
+ } else {
+ i12 = i13;
+ }
+ }
+ } else {
+ i15 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i10, i5) | 0;
+ i11 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i10) | 0;
+ if (!i15) {
+ if (!i11) {
+ i12 = 0;
+ break;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i10, i5) | 0)) {
+ i12 = 1;
+ break;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = 2;
+ break;
+ }
+ if (i11) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = 1;
+ break;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i10) | 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = 2;
+ } else {
+ i12 = 1;
+ }
+ }
+ } while (0);
+ do {
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i10) | 0) {
+ i13 = i4;
+ } else {
+ i13 = i4;
+ while (1) {
+ i13 = i13 + -12 | 0;
+ if ((i5 | 0) == (i13 | 0)) {
+ break;
+ }
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i13, i10) | 0) {
+ i6 = 50;
+ break;
+ }
+ }
+ if ((i6 | 0) == 50) {
+ i6 = 0;
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i13 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i13 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i13 + 8 >> 2];
+ HEAP32[i13 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i13 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i13 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = i12 + 1 | 0;
+ break;
+ }
+ i10 = i5 + 12 | 0;
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i4) | 0)) {
+ if ((i10 | 0) == (i4 | 0)) {
+ i6 = 67;
+ break L1;
+ }
+ while (1) {
+ i9 = i10 + 12 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i10) | 0) {
+ break;
+ }
+ if ((i9 | 0) == (i4 | 0)) {
+ i6 = 67;
+ break L1;
+ } else {
+ i10 = i9;
+ }
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i10 = i9;
+ }
+ if ((i10 | 0) == (i4 | 0)) {
+ i6 = 67;
+ break L1;
+ } else {
+ i9 = i4;
+ }
+ while (1) {
+ while (1) {
+ i11 = i10 + 12 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i10) | 0) {
+ break;
+ } else {
+ i10 = i11;
+ }
+ }
+ do {
+ i9 = i9 + -12 | 0;
+ } while (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i9) | 0);
+ if (!(i10 >>> 0 < i9 >>> 0)) {
+ i5 = i10;
+ continue L3;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i9 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i9 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ HEAP32[i9 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i9 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i10 = i11;
+ }
+ }
+ } while (0);
+ i11 = i5 + 12 | 0;
+ L47 : do {
+ if (i11 >>> 0 < i13 >>> 0) {
+ while (1) {
+ i15 = i11;
+ while (1) {
+ i11 = i15 + 12 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i15, i10) | 0) {
+ i15 = i11;
+ } else {
+ i14 = i13;
+ break;
+ }
+ }
+ do {
+ i14 = i14 + -12 | 0;
+ } while (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i14, i10) | 0));
+ if (i15 >>> 0 > i14 >>> 0) {
+ i11 = i15;
+ break L47;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i15 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i15 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i15 + 8 >> 2];
+ HEAP32[i15 + 0 >> 2] = HEAP32[i14 + 0 >> 2];
+ HEAP32[i15 + 4 >> 2] = HEAP32[i14 + 4 >> 2];
+ HEAP32[i15 + 8 >> 2] = HEAP32[i14 + 8 >> 2];
+ HEAP32[i14 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i14 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i14 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i13 = i14;
+ i10 = (i10 | 0) == (i15 | 0) ? i14 : i10;
+ i12 = i12 + 1 | 0;
+ }
+ }
+ } while (0);
+ if ((i11 | 0) != (i10 | 0) ? FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i10, i11) | 0 : 0) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i11 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i11 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i11 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i12 = i12 + 1 | 0;
+ }
+ if ((i12 | 0) == 0) {
+ i12 = __ZNSt3__127__insertion_sort_incompleteIRPFbRK6b2PairS3_EPS1_EEbT0_S8_T_(i5, i11, i1) | 0;
+ i10 = i11 + 12 | 0;
+ if (__ZNSt3__127__insertion_sort_incompleteIRPFbRK6b2PairS3_EPS1_EEbT0_S8_T_(i10, i8, i1) | 0) {
+ i6 = 62;
+ break;
+ }
+ if (i12) {
+ i5 = i10;
+ continue;
+ }
+ }
+ i15 = i11;
+ if ((i15 - i9 | 0) >= (i7 - i15 | 0)) {
+ i6 = 66;
+ break;
+ }
+ __ZNSt3__16__sortIRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i5, i11, i1);
+ i5 = i11 + 12 | 0;
+ }
+ if ((i6 | 0) == 62) {
+ i6 = 0;
+ if (i12) {
+ i6 = 67;
+ break;
+ } else {
+ i8 = i11;
+ continue;
+ }
+ } else if ((i6 | 0) == 66) {
+ i6 = 0;
+ __ZNSt3__16__sortIRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i11 + 12 | 0, i8, i1);
+ i8 = i11;
+ continue;
+ }
+ }
+ if ((i6 | 0) == 4) {
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i5) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ STACKTOP = i3;
+ return;
+ } else if ((i6 | 0) == 6) {
+ i6 = i5 + 12 | 0;
+ i15 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i6, i5) | 0;
+ i7 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i6) | 0;
+ if (!i15) {
+ if (!i7) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i6, i5) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ STACKTOP = i3;
+ return;
+ }
+ if (i7) {
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i6) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ STACKTOP = i3;
+ return;
+ } else if ((i6 | 0) == 14) {
+ __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i5, i5 + 12 | 0, i5 + 24 | 0, i4, i1) | 0;
+ STACKTOP = i3;
+ return;
+ } else if ((i6 | 0) == 15) {
+ i6 = i5 + 12 | 0;
+ i7 = i5 + 24 | 0;
+ i8 = i5 + 36 | 0;
+ __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i5, i6, i7, i8, i1) | 0;
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i8) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i8, i7) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i7, i6) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i6, i5) | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i2 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ STACKTOP = i3;
+ return;
+ } else if ((i6 | 0) == 21) {
+ __ZNSt3__118__insertion_sort_3IRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i5, i8, i1);
+ STACKTOP = i3;
+ return;
+ } else if ((i6 | 0) == 67) {
+ STACKTOP = i3;
+ return;
+ }
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[7176 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[7180 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[7168 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 7200 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[1790] = HEAP32[1790] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 7464 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[7164 >> 2] = HEAP32[7164 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[7184 >> 2] | 0)) {
+ i21 = (HEAP32[7172 >> 2] | 0) + i11 | 0;
+ HEAP32[7172 >> 2] = i21;
+ HEAP32[7184 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[7180 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[7180 >> 2] = 0;
+ HEAP32[7168 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[7180 >> 2] | 0)) {
+ i21 = (HEAP32[7168 >> 2] | 0) + i11 | 0;
+ HEAP32[7168 >> 2] = i21;
+ HEAP32[7180 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 7464 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[7164 >> 2] = HEAP32[7164 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 7200 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[1790] = HEAP32[1790] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[7180 >> 2] | 0)) {
+ HEAP32[7168 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 7200 + (i7 << 2) | 0;
+ i8 = HEAP32[1790] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 7200 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[1790] = i8 | i6;
+ i4 = 7200 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 7464 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[7164 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L204 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L204;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[7176 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[7176 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[7164 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[7192 >> 2] | 0) + -1 | 0;
+ HEAP32[7192 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 7616 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[7192 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function __ZNSt3__127__insertion_sort_incompleteIRPFbRK6b2PairS3_EPS1_EEbT0_S8_T_(i3, i4, i2) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i7 = i1 + 12 | 0;
+ i6 = i1;
+ switch ((i4 - i3 | 0) / 12 | 0 | 0) {
+ case 5:
+ {
+ i6 = i3 + 12 | 0;
+ i8 = i3 + 24 | 0;
+ i5 = i3 + 36 | 0;
+ i4 = i4 + -12 | 0;
+ __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i3, i6, i8, i5, i2) | 0;
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i4, i5) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i5, i8) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i8, i6) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i6, i3) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ case 4:
+ {
+ __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i3, i3 + 12 | 0, i3 + 24 | 0, i4 + -12 | 0, i2) | 0;
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ case 3:
+ {
+ i5 = i3 + 12 | 0;
+ i4 = i4 + -12 | 0;
+ i10 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i5, i3) | 0;
+ i6 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i4, i5) | 0;
+ if (!i10) {
+ if (!i6) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i5, i3) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ if (i6) {
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i4, i5) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ case 2:
+ {
+ i4 = i4 + -12 | 0;
+ if (!(FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i4, i3) | 0)) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ case 1:
+ case 0:
+ {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ default:
+ {
+ i9 = i3 + 24 | 0;
+ i10 = i3 + 12 | 0;
+ i11 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i10, i3) | 0;
+ i8 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i9, i10) | 0;
+ do {
+ if (i11) {
+ if (i8) {
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i9 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i9 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ HEAP32[i9 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i9 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ break;
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i9, i10) | 0) {
+ HEAP32[i7 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i9 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i9 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ HEAP32[i9 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i9 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ }
+ } else {
+ if (i8) {
+ HEAP32[i7 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i9 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i9 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ HEAP32[i9 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i9 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i10, i3) | 0) {
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i3 + 0 >> 2] = HEAP32[i10 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i10 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i10 + 8 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ }
+ }
+ }
+ } while (0);
+ i7 = i3 + 36 | 0;
+ if ((i7 | 0) == (i4 | 0)) {
+ i11 = 1;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i8 = 0;
+ while (1) {
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i7, i9) | 0) {
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i10 = i7;
+ while (1) {
+ HEAP32[i10 + 0 >> 2] = HEAP32[i9 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i9 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ if ((i9 | 0) == (i3 | 0)) {
+ break;
+ }
+ i10 = i9 + -12 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i6, i10) | 0) {
+ i11 = i9;
+ i9 = i10;
+ i10 = i11;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i9 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i9 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i8 = i8 + 1 | 0;
+ if ((i8 | 0) == 8) {
+ break;
+ }
+ }
+ i9 = i7 + 12 | 0;
+ if ((i9 | 0) == (i4 | 0)) {
+ i2 = 1;
+ i5 = 35;
+ break;
+ } else {
+ i11 = i7;
+ i7 = i9;
+ i9 = i11;
+ }
+ }
+ if ((i5 | 0) == 35) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ i11 = (i7 + 12 | 0) == (i4 | 0);
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ }
+ return 0;
+}
+function __ZN13b2DynamicTree7BalanceEi(i11, i6) {
+ i11 = i11 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, d19 = 0.0, i20 = 0, i21 = 0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0;
+ i1 = STACKTOP;
+ if ((i6 | 0) == -1) {
+ ___assert_fail(3216, 2944, 382, 3232);
+ }
+ i5 = HEAP32[i11 + 4 >> 2] | 0;
+ i13 = i5 + (i6 * 36 | 0) | 0;
+ i18 = i5 + (i6 * 36 | 0) + 24 | 0;
+ i8 = HEAP32[i18 >> 2] | 0;
+ if ((i8 | 0) == -1) {
+ i21 = i6;
+ STACKTOP = i1;
+ return i21 | 0;
+ }
+ i2 = i5 + (i6 * 36 | 0) + 32 | 0;
+ if ((HEAP32[i2 >> 2] | 0) < 2) {
+ i21 = i6;
+ STACKTOP = i1;
+ return i21 | 0;
+ }
+ i20 = i5 + (i6 * 36 | 0) + 28 | 0;
+ i7 = HEAP32[i20 >> 2] | 0;
+ if (!((i8 | 0) > -1)) {
+ ___assert_fail(3240, 2944, 392, 3232);
+ }
+ i12 = HEAP32[i11 + 12 >> 2] | 0;
+ if ((i8 | 0) >= (i12 | 0)) {
+ ___assert_fail(3240, 2944, 392, 3232);
+ }
+ if (!((i7 | 0) > -1 & (i7 | 0) < (i12 | 0))) {
+ ___assert_fail(3272, 2944, 393, 3232);
+ }
+ i9 = i5 + (i8 * 36 | 0) | 0;
+ i10 = i5 + (i7 * 36 | 0) | 0;
+ i3 = i5 + (i7 * 36 | 0) + 32 | 0;
+ i4 = i5 + (i8 * 36 | 0) + 32 | 0;
+ i14 = (HEAP32[i3 >> 2] | 0) - (HEAP32[i4 >> 2] | 0) | 0;
+ if ((i14 | 0) > 1) {
+ i21 = i5 + (i7 * 36 | 0) + 24 | 0;
+ i14 = HEAP32[i21 >> 2] | 0;
+ i18 = i5 + (i7 * 36 | 0) + 28 | 0;
+ i15 = HEAP32[i18 >> 2] | 0;
+ i16 = i5 + (i14 * 36 | 0) | 0;
+ i17 = i5 + (i15 * 36 | 0) | 0;
+ if (!((i14 | 0) > -1 & (i14 | 0) < (i12 | 0))) {
+ ___assert_fail(3304, 2944, 407, 3232);
+ }
+ if (!((i15 | 0) > -1 & (i15 | 0) < (i12 | 0))) {
+ ___assert_fail(3336, 2944, 408, 3232);
+ }
+ HEAP32[i21 >> 2] = i6;
+ i21 = i5 + (i6 * 36 | 0) + 20 | 0;
+ i12 = i5 + (i7 * 36 | 0) + 20 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i21 >> 2];
+ HEAP32[i21 >> 2] = i7;
+ i12 = HEAP32[i12 >> 2] | 0;
+ do {
+ if (!((i12 | 0) == -1)) {
+ i11 = i5 + (i12 * 36 | 0) + 24 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i11 >> 2] = i7;
+ break;
+ }
+ i11 = i5 + (i12 * 36 | 0) + 28 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i11 >> 2] = i7;
+ break;
+ } else {
+ ___assert_fail(3368, 2944, 424, 3232);
+ }
+ } else {
+ HEAP32[i11 >> 2] = i7;
+ }
+ } while (0);
+ i11 = i5 + (i14 * 36 | 0) + 32 | 0;
+ i12 = i5 + (i15 * 36 | 0) + 32 | 0;
+ if ((HEAP32[i11 >> 2] | 0) > (HEAP32[i12 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i14;
+ HEAP32[i20 >> 2] = i15;
+ HEAP32[i5 + (i15 * 36 | 0) + 20 >> 2] = i6;
+ d19 = +HEAPF32[i9 >> 2];
+ d22 = +HEAPF32[i17 >> 2];
+ d19 = d19 < d22 ? d19 : d22;
+ d23 = +HEAPF32[i5 + (i8 * 36 | 0) + 4 >> 2];
+ d22 = +HEAPF32[i5 + (i15 * 36 | 0) + 4 >> 2];
+ d24 = +d19;
+ d23 = +(d23 < d22 ? d23 : d22);
+ i21 = i13;
+ HEAPF32[i21 >> 2] = d24;
+ HEAPF32[i21 + 4 >> 2] = d23;
+ d23 = +HEAPF32[i5 + (i8 * 36 | 0) + 8 >> 2];
+ d24 = +HEAPF32[i5 + (i15 * 36 | 0) + 8 >> 2];
+ d22 = +HEAPF32[i5 + (i8 * 36 | 0) + 12 >> 2];
+ d25 = +HEAPF32[i5 + (i15 * 36 | 0) + 12 >> 2];
+ d23 = +(d23 > d24 ? d23 : d24);
+ d24 = +(d22 > d25 ? d22 : d25);
+ i21 = i5 + (i6 * 36 | 0) + 8 | 0;
+ HEAPF32[i21 >> 2] = d23;
+ HEAPF32[i21 + 4 >> 2] = d24;
+ d24 = +HEAPF32[i16 >> 2];
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 4 >> 2];
+ d23 = +HEAPF32[i5 + (i14 * 36 | 0) + 4 >> 2];
+ d19 = +(d19 < d24 ? d19 : d24);
+ d22 = +(d22 < d23 ? d22 : d23);
+ i21 = i10;
+ HEAPF32[i21 >> 2] = d19;
+ HEAPF32[i21 + 4 >> 2] = d22;
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 8 >> 2];
+ d19 = +HEAPF32[i5 + (i14 * 36 | 0) + 8 >> 2];
+ d23 = +HEAPF32[i5 + (i6 * 36 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i5 + (i14 * 36 | 0) + 12 >> 2];
+ d19 = +(d22 > d19 ? d22 : d19);
+ d25 = +(d23 > d24 ? d23 : d24);
+ i5 = i5 + (i7 * 36 | 0) + 8 | 0;
+ HEAPF32[i5 >> 2] = d19;
+ HEAPF32[i5 + 4 >> 2] = d25;
+ i4 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[i12 >> 2] | 0;
+ i4 = ((i4 | 0) > (i5 | 0) ? i4 : i5) + 1 | 0;
+ HEAP32[i2 >> 2] = i4;
+ i2 = HEAP32[i11 >> 2] | 0;
+ i2 = (i4 | 0) > (i2 | 0) ? i4 : i2;
+ } else {
+ HEAP32[i18 >> 2] = i15;
+ HEAP32[i20 >> 2] = i14;
+ HEAP32[i5 + (i14 * 36 | 0) + 20 >> 2] = i6;
+ d19 = +HEAPF32[i9 >> 2];
+ d22 = +HEAPF32[i16 >> 2];
+ d19 = d19 < d22 ? d19 : d22;
+ d23 = +HEAPF32[i5 + (i8 * 36 | 0) + 4 >> 2];
+ d24 = +HEAPF32[i5 + (i14 * 36 | 0) + 4 >> 2];
+ d22 = +d19;
+ d23 = +(d23 < d24 ? d23 : d24);
+ i21 = i13;
+ HEAPF32[i21 >> 2] = d22;
+ HEAPF32[i21 + 4 >> 2] = d23;
+ d23 = +HEAPF32[i5 + (i8 * 36 | 0) + 8 >> 2];
+ d24 = +HEAPF32[i5 + (i14 * 36 | 0) + 8 >> 2];
+ d22 = +HEAPF32[i5 + (i8 * 36 | 0) + 12 >> 2];
+ d25 = +HEAPF32[i5 + (i14 * 36 | 0) + 12 >> 2];
+ d23 = +(d23 > d24 ? d23 : d24);
+ d24 = +(d22 > d25 ? d22 : d25);
+ i21 = i5 + (i6 * 36 | 0) + 8 | 0;
+ HEAPF32[i21 >> 2] = d23;
+ HEAPF32[i21 + 4 >> 2] = d24;
+ d24 = +HEAPF32[i17 >> 2];
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 4 >> 2];
+ d23 = +HEAPF32[i5 + (i15 * 36 | 0) + 4 >> 2];
+ d19 = +(d19 < d24 ? d19 : d24);
+ d23 = +(d22 < d23 ? d22 : d23);
+ i21 = i10;
+ HEAPF32[i21 >> 2] = d19;
+ HEAPF32[i21 + 4 >> 2] = d23;
+ d23 = +HEAPF32[i5 + (i6 * 36 | 0) + 8 >> 2];
+ d19 = +HEAPF32[i5 + (i15 * 36 | 0) + 8 >> 2];
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i5 + (i15 * 36 | 0) + 12 >> 2];
+ d19 = +(d23 > d19 ? d23 : d19);
+ d25 = +(d22 > d24 ? d22 : d24);
+ i5 = i5 + (i7 * 36 | 0) + 8 | 0;
+ HEAPF32[i5 >> 2] = d19;
+ HEAPF32[i5 + 4 >> 2] = d25;
+ i4 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[i11 >> 2] | 0;
+ i4 = ((i4 | 0) > (i5 | 0) ? i4 : i5) + 1 | 0;
+ HEAP32[i2 >> 2] = i4;
+ i2 = HEAP32[i12 >> 2] | 0;
+ i2 = (i4 | 0) > (i2 | 0) ? i4 : i2;
+ }
+ HEAP32[i3 >> 2] = i2 + 1;
+ i21 = i7;
+ STACKTOP = i1;
+ return i21 | 0;
+ }
+ if (!((i14 | 0) < -1)) {
+ i21 = i6;
+ STACKTOP = i1;
+ return i21 | 0;
+ }
+ i21 = i5 + (i8 * 36 | 0) + 24 | 0;
+ i14 = HEAP32[i21 >> 2] | 0;
+ i20 = i5 + (i8 * 36 | 0) + 28 | 0;
+ i15 = HEAP32[i20 >> 2] | 0;
+ i17 = i5 + (i14 * 36 | 0) | 0;
+ i16 = i5 + (i15 * 36 | 0) | 0;
+ if (!((i14 | 0) > -1 & (i14 | 0) < (i12 | 0))) {
+ ___assert_fail(3400, 2944, 467, 3232);
+ }
+ if (!((i15 | 0) > -1 & (i15 | 0) < (i12 | 0))) {
+ ___assert_fail(3432, 2944, 468, 3232);
+ }
+ HEAP32[i21 >> 2] = i6;
+ i21 = i5 + (i6 * 36 | 0) + 20 | 0;
+ i12 = i5 + (i8 * 36 | 0) + 20 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i21 >> 2];
+ HEAP32[i21 >> 2] = i8;
+ i12 = HEAP32[i12 >> 2] | 0;
+ do {
+ if (!((i12 | 0) == -1)) {
+ i11 = i5 + (i12 * 36 | 0) + 24 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i11 >> 2] = i8;
+ break;
+ }
+ i11 = i5 + (i12 * 36 | 0) + 28 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i11 >> 2] = i8;
+ break;
+ } else {
+ ___assert_fail(3464, 2944, 484, 3232);
+ }
+ } else {
+ HEAP32[i11 >> 2] = i8;
+ }
+ } while (0);
+ i12 = i5 + (i14 * 36 | 0) + 32 | 0;
+ i11 = i5 + (i15 * 36 | 0) + 32 | 0;
+ if ((HEAP32[i12 >> 2] | 0) > (HEAP32[i11 >> 2] | 0)) {
+ HEAP32[i20 >> 2] = i14;
+ HEAP32[i18 >> 2] = i15;
+ HEAP32[i5 + (i15 * 36 | 0) + 20 >> 2] = i6;
+ d19 = +HEAPF32[i10 >> 2];
+ d22 = +HEAPF32[i16 >> 2];
+ d19 = d19 < d22 ? d19 : d22;
+ d23 = +HEAPF32[i5 + (i7 * 36 | 0) + 4 >> 2];
+ d22 = +HEAPF32[i5 + (i15 * 36 | 0) + 4 >> 2];
+ d24 = +d19;
+ d23 = +(d23 < d22 ? d23 : d22);
+ i21 = i13;
+ HEAPF32[i21 >> 2] = d24;
+ HEAPF32[i21 + 4 >> 2] = d23;
+ d23 = +HEAPF32[i5 + (i7 * 36 | 0) + 8 >> 2];
+ d22 = +HEAPF32[i5 + (i15 * 36 | 0) + 8 >> 2];
+ d24 = +HEAPF32[i5 + (i7 * 36 | 0) + 12 >> 2];
+ d25 = +HEAPF32[i5 + (i15 * 36 | 0) + 12 >> 2];
+ d22 = +(d23 > d22 ? d23 : d22);
+ d24 = +(d24 > d25 ? d24 : d25);
+ i21 = i5 + (i6 * 36 | 0) + 8 | 0;
+ HEAPF32[i21 >> 2] = d22;
+ HEAPF32[i21 + 4 >> 2] = d24;
+ d24 = +HEAPF32[i17 >> 2];
+ d23 = +HEAPF32[i5 + (i6 * 36 | 0) + 4 >> 2];
+ d22 = +HEAPF32[i5 + (i14 * 36 | 0) + 4 >> 2];
+ d19 = +(d19 < d24 ? d19 : d24);
+ d22 = +(d23 < d22 ? d23 : d22);
+ i21 = i9;
+ HEAPF32[i21 >> 2] = d19;
+ HEAPF32[i21 + 4 >> 2] = d22;
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 8 >> 2];
+ d23 = +HEAPF32[i5 + (i14 * 36 | 0) + 8 >> 2];
+ d19 = +HEAPF32[i5 + (i6 * 36 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i5 + (i14 * 36 | 0) + 12 >> 2];
+ d22 = +(d22 > d23 ? d22 : d23);
+ d25 = +(d19 > d24 ? d19 : d24);
+ i5 = i5 + (i8 * 36 | 0) + 8 | 0;
+ HEAPF32[i5 >> 2] = d22;
+ HEAPF32[i5 + 4 >> 2] = d25;
+ i3 = HEAP32[i3 >> 2] | 0;
+ i5 = HEAP32[i11 >> 2] | 0;
+ i3 = ((i3 | 0) > (i5 | 0) ? i3 : i5) + 1 | 0;
+ HEAP32[i2 >> 2] = i3;
+ i2 = HEAP32[i12 >> 2] | 0;
+ i2 = (i3 | 0) > (i2 | 0) ? i3 : i2;
+ } else {
+ HEAP32[i20 >> 2] = i15;
+ HEAP32[i18 >> 2] = i14;
+ HEAP32[i5 + (i14 * 36 | 0) + 20 >> 2] = i6;
+ d19 = +HEAPF32[i10 >> 2];
+ d22 = +HEAPF32[i17 >> 2];
+ d19 = d19 < d22 ? d19 : d22;
+ d23 = +HEAPF32[i5 + (i7 * 36 | 0) + 4 >> 2];
+ d24 = +HEAPF32[i5 + (i14 * 36 | 0) + 4 >> 2];
+ d22 = +d19;
+ d24 = +(d23 < d24 ? d23 : d24);
+ i21 = i13;
+ HEAPF32[i21 >> 2] = d22;
+ HEAPF32[i21 + 4 >> 2] = d24;
+ d24 = +HEAPF32[i5 + (i7 * 36 | 0) + 8 >> 2];
+ d23 = +HEAPF32[i5 + (i14 * 36 | 0) + 8 >> 2];
+ d22 = +HEAPF32[i5 + (i7 * 36 | 0) + 12 >> 2];
+ d25 = +HEAPF32[i5 + (i14 * 36 | 0) + 12 >> 2];
+ d23 = +(d24 > d23 ? d24 : d23);
+ d24 = +(d22 > d25 ? d22 : d25);
+ i21 = i5 + (i6 * 36 | 0) + 8 | 0;
+ HEAPF32[i21 >> 2] = d23;
+ HEAPF32[i21 + 4 >> 2] = d24;
+ d24 = +HEAPF32[i16 >> 2];
+ d23 = +HEAPF32[i5 + (i6 * 36 | 0) + 4 >> 2];
+ d22 = +HEAPF32[i5 + (i15 * 36 | 0) + 4 >> 2];
+ d19 = +(d19 < d24 ? d19 : d24);
+ d22 = +(d23 < d22 ? d23 : d22);
+ i21 = i9;
+ HEAPF32[i21 >> 2] = d19;
+ HEAPF32[i21 + 4 >> 2] = d22;
+ d22 = +HEAPF32[i5 + (i6 * 36 | 0) + 8 >> 2];
+ d23 = +HEAPF32[i5 + (i15 * 36 | 0) + 8 >> 2];
+ d19 = +HEAPF32[i5 + (i6 * 36 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i5 + (i15 * 36 | 0) + 12 >> 2];
+ d22 = +(d22 > d23 ? d22 : d23);
+ d25 = +(d19 > d24 ? d19 : d24);
+ i5 = i5 + (i8 * 36 | 0) + 8 | 0;
+ HEAPF32[i5 >> 2] = d22;
+ HEAPF32[i5 + 4 >> 2] = d25;
+ i3 = HEAP32[i3 >> 2] | 0;
+ i5 = HEAP32[i12 >> 2] | 0;
+ i3 = ((i3 | 0) > (i5 | 0) ? i3 : i5) + 1 | 0;
+ HEAP32[i2 >> 2] = i3;
+ i2 = HEAP32[i11 >> 2] | 0;
+ i2 = (i3 | 0) > (i2 | 0) ? i3 : i2;
+ }
+ HEAP32[i4 >> 2] = i2 + 1;
+ i21 = i8;
+ STACKTOP = i1;
+ return i21 | 0;
+}
+function __Z10b2DistanceP16b2DistanceOutputP14b2SimplexCachePK15b2DistanceInput(i2, i5, i3) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i6 = 0, d7 = 0.0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, i20 = 0, d21 = 0.0, d22 = 0.0, i23 = 0, d24 = 0.0, d25 = 0.0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, d36 = 0.0, d37 = 0.0, d38 = 0.0, i39 = 0, i40 = 0, i41 = 0, i42 = 0, d43 = 0.0, d44 = 0.0, d45 = 0.0, i46 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 176 | 0;
+ i11 = i1 + 152 | 0;
+ i10 = i1 + 136 | 0;
+ i4 = i1 + 24 | 0;
+ i14 = i1 + 12 | 0;
+ i15 = i1;
+ HEAP32[652] = (HEAP32[652] | 0) + 1;
+ i9 = i3 + 28 | 0;
+ i31 = i3 + 56 | 0;
+ HEAP32[i11 + 0 >> 2] = HEAP32[i31 + 0 >> 2];
+ HEAP32[i11 + 4 >> 2] = HEAP32[i31 + 4 >> 2];
+ HEAP32[i11 + 8 >> 2] = HEAP32[i31 + 8 >> 2];
+ HEAP32[i11 + 12 >> 2] = HEAP32[i31 + 12 >> 2];
+ i31 = i3 + 72 | 0;
+ HEAP32[i10 + 0 >> 2] = HEAP32[i31 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i31 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i31 + 8 >> 2];
+ HEAP32[i10 + 12 >> 2] = HEAP32[i31 + 12 >> 2];
+ __ZN9b2Simplex9ReadCacheEPK14b2SimplexCachePK15b2DistanceProxyRK11b2TransformS5_S8_(i4, i5, i3, i11, i9, i10);
+ i9 = i4 + 108 | 0;
+ i31 = HEAP32[i9 >> 2] | 0;
+ if ((i31 | 0) == 3 | (i31 | 0) == 2 | (i31 | 0) == 1) {
+ i8 = i4 + 16 | 0;
+ i6 = i4 + 20 | 0;
+ d17 = +HEAPF32[i11 + 12 >> 2];
+ d18 = +HEAPF32[i11 + 8 >> 2];
+ i13 = i3 + 16 | 0;
+ i12 = i3 + 20 | 0;
+ d16 = +HEAPF32[i11 >> 2];
+ d21 = +HEAPF32[i11 + 4 >> 2];
+ d19 = +HEAPF32[i10 + 12 >> 2];
+ d22 = +HEAPF32[i10 + 8 >> 2];
+ i23 = i3 + 44 | 0;
+ i20 = i3 + 48 | 0;
+ d24 = +HEAPF32[i10 >> 2];
+ d25 = +HEAPF32[i10 + 4 >> 2];
+ i11 = i4 + 52 | 0;
+ i10 = i4 + 56 | 0;
+ i30 = i4 + 16 | 0;
+ i27 = i4 + 36 | 0;
+ i26 = i4 + 52 | 0;
+ i29 = i4 + 24 | 0;
+ i28 = i4 + 60 | 0;
+ i33 = 0;
+ L3 : while (1) {
+ i32 = (i31 | 0) > 0;
+ if (i32) {
+ i34 = 0;
+ do {
+ HEAP32[i14 + (i34 << 2) >> 2] = HEAP32[i4 + (i34 * 36 | 0) + 28 >> 2];
+ HEAP32[i15 + (i34 << 2) >> 2] = HEAP32[i4 + (i34 * 36 | 0) + 32 >> 2];
+ i34 = i34 + 1 | 0;
+ } while ((i34 | 0) != (i31 | 0));
+ }
+ do {
+ if ((i31 | 0) == 2) {
+ i46 = i30;
+ d45 = +HEAPF32[i46 >> 2];
+ d36 = +HEAPF32[i46 + 4 >> 2];
+ i46 = i26;
+ d38 = +HEAPF32[i46 >> 2];
+ d37 = +HEAPF32[i46 + 4 >> 2];
+ d43 = d38 - d45;
+ d44 = d37 - d36;
+ d36 = d45 * d43 + d36 * d44;
+ if (d36 >= -0.0) {
+ HEAPF32[i29 >> 2] = 1.0;
+ HEAP32[i9 >> 2] = 1;
+ i35 = 17;
+ break;
+ }
+ d37 = d38 * d43 + d37 * d44;
+ if (!(d37 <= 0.0)) {
+ d45 = 1.0 / (d37 - d36);
+ HEAPF32[i29 >> 2] = d37 * d45;
+ HEAPF32[i28 >> 2] = -(d36 * d45);
+ HEAP32[i9 >> 2] = 2;
+ i35 = 18;
+ break;
+ } else {
+ HEAPF32[i28 >> 2] = 1.0;
+ HEAP32[i9 >> 2] = 1;
+ i34 = i4 + 0 | 0;
+ i39 = i27 + 0 | 0;
+ i35 = i34 + 36 | 0;
+ do {
+ HEAP32[i34 >> 2] = HEAP32[i39 >> 2];
+ i34 = i34 + 4 | 0;
+ i39 = i39 + 4 | 0;
+ } while ((i34 | 0) < (i35 | 0));
+ i35 = 17;
+ break;
+ }
+ } else if ((i31 | 0) == 3) {
+ __ZN9b2Simplex6Solve3Ev(i4);
+ i34 = HEAP32[i9 >> 2] | 0;
+ if ((i34 | 0) == 1) {
+ i35 = 17;
+ } else if ((i34 | 0) == 0) {
+ i35 = 15;
+ break L3;
+ } else if ((i34 | 0) == 2) {
+ i35 = 18;
+ } else if ((i34 | 0) == 3) {
+ i35 = 42;
+ break L3;
+ } else {
+ i35 = 16;
+ break L3;
+ }
+ } else if ((i31 | 0) == 1) {
+ i35 = 17;
+ } else {
+ i35 = 13;
+ break L3;
+ }
+ } while (0);
+ do {
+ if ((i35 | 0) == 17) {
+ d36 = -+HEAPF32[i8 >> 2];
+ d37 = -+HEAPF32[i6 >> 2];
+ i34 = 1;
+ } else if ((i35 | 0) == 18) {
+ d44 = +HEAPF32[i8 >> 2];
+ d37 = +HEAPF32[i11 >> 2] - d44;
+ d45 = +HEAPF32[i6 >> 2];
+ d36 = +HEAPF32[i10 >> 2] - d45;
+ if (d44 * d36 - d37 * d45 > 0.0) {
+ d36 = -d36;
+ i34 = 2;
+ break;
+ } else {
+ d37 = -d37;
+ i34 = 2;
+ break;
+ }
+ }
+ } while (0);
+ if (d37 * d37 + d36 * d36 < 1.4210854715202004e-14) {
+ i35 = 42;
+ break;
+ }
+ i39 = i4 + (i34 * 36 | 0) | 0;
+ d44 = -d36;
+ d45 = -d37;
+ d43 = d17 * d44 + d18 * d45;
+ d44 = d17 * d45 - d18 * d44;
+ i40 = HEAP32[i13 >> 2] | 0;
+ i41 = HEAP32[i12 >> 2] | 0;
+ if ((i41 | 0) > 1) {
+ i42 = 0;
+ d45 = d44 * +HEAPF32[i40 + 4 >> 2] + d43 * +HEAPF32[i40 >> 2];
+ i46 = 1;
+ while (1) {
+ d38 = d43 * +HEAPF32[i40 + (i46 << 3) >> 2] + d44 * +HEAPF32[i40 + (i46 << 3) + 4 >> 2];
+ i35 = d38 > d45;
+ i42 = i35 ? i46 : i42;
+ i46 = i46 + 1 | 0;
+ if ((i46 | 0) == (i41 | 0)) {
+ break;
+ } else {
+ d45 = i35 ? d38 : d45;
+ }
+ }
+ i35 = i4 + (i34 * 36 | 0) + 28 | 0;
+ HEAP32[i35 >> 2] = i42;
+ if (!((i42 | 0) > -1)) {
+ i35 = 28;
+ break;
+ }
+ } else {
+ i35 = i4 + (i34 * 36 | 0) + 28 | 0;
+ HEAP32[i35 >> 2] = 0;
+ i42 = 0;
+ }
+ if ((i41 | 0) <= (i42 | 0)) {
+ i35 = 28;
+ break;
+ }
+ d45 = +HEAPF32[i40 + (i42 << 3) >> 2];
+ d43 = +HEAPF32[i40 + (i42 << 3) + 4 >> 2];
+ d38 = d16 + (d17 * d45 - d18 * d43);
+ d44 = +d38;
+ d43 = +(d45 * d18 + d17 * d43 + d21);
+ i40 = i39;
+ HEAPF32[i40 >> 2] = d44;
+ HEAPF32[i40 + 4 >> 2] = d43;
+ d43 = d36 * d19 + d37 * d22;
+ d44 = d37 * d19 - d36 * d22;
+ i40 = HEAP32[i23 >> 2] | 0;
+ i39 = HEAP32[i20 >> 2] | 0;
+ if ((i39 | 0) > 1) {
+ i41 = 0;
+ d37 = d44 * +HEAPF32[i40 + 4 >> 2] + d43 * +HEAPF32[i40 >> 2];
+ i42 = 1;
+ while (1) {
+ d36 = d43 * +HEAPF32[i40 + (i42 << 3) >> 2] + d44 * +HEAPF32[i40 + (i42 << 3) + 4 >> 2];
+ i46 = d36 > d37;
+ i41 = i46 ? i42 : i41;
+ i42 = i42 + 1 | 0;
+ if ((i42 | 0) == (i39 | 0)) {
+ break;
+ } else {
+ d37 = i46 ? d36 : d37;
+ }
+ }
+ i42 = i4 + (i34 * 36 | 0) + 32 | 0;
+ HEAP32[i42 >> 2] = i41;
+ if (!((i41 | 0) > -1)) {
+ i35 = 35;
+ break;
+ }
+ } else {
+ i42 = i4 + (i34 * 36 | 0) + 32 | 0;
+ HEAP32[i42 >> 2] = 0;
+ i41 = 0;
+ }
+ if ((i39 | 0) <= (i41 | 0)) {
+ i35 = 35;
+ break;
+ }
+ d37 = +HEAPF32[i40 + (i41 << 3) >> 2];
+ d45 = +HEAPF32[i40 + (i41 << 3) + 4 >> 2];
+ d44 = d24 + (d19 * d37 - d22 * d45);
+ d43 = +d44;
+ d45 = +(d37 * d22 + d19 * d45 + d25);
+ i46 = i4 + (i34 * 36 | 0) + 8 | 0;
+ HEAPF32[i46 >> 2] = d43;
+ HEAPF32[i46 + 4 >> 2] = d45;
+ d44 = +(d44 - d38);
+ d45 = +(+HEAPF32[i4 + (i34 * 36 | 0) + 12 >> 2] - +HEAPF32[i4 + (i34 * 36 | 0) + 4 >> 2]);
+ i46 = i4 + (i34 * 36 | 0) + 16 | 0;
+ HEAPF32[i46 >> 2] = d44;
+ HEAPF32[i46 + 4 >> 2] = d45;
+ i33 = i33 + 1 | 0;
+ HEAP32[654] = (HEAP32[654] | 0) + 1;
+ if (i32) {
+ i34 = HEAP32[i35 >> 2] | 0;
+ i32 = 0;
+ do {
+ if ((i34 | 0) == (HEAP32[i14 + (i32 << 2) >> 2] | 0) ? (HEAP32[i42 >> 2] | 0) == (HEAP32[i15 + (i32 << 2) >> 2] | 0) : 0) {
+ i35 = 42;
+ break L3;
+ }
+ i32 = i32 + 1 | 0;
+ } while ((i32 | 0) < (i31 | 0));
+ }
+ i31 = (HEAP32[i9 >> 2] | 0) + 1 | 0;
+ HEAP32[i9 >> 2] = i31;
+ if ((i33 | 0) >= 20) {
+ i35 = 42;
+ break;
+ }
+ }
+ if ((i35 | 0) == 13) {
+ ___assert_fail(2712, 2672, 498, 2720);
+ } else if ((i35 | 0) == 15) {
+ ___assert_fail(2712, 2672, 194, 2856);
+ } else if ((i35 | 0) == 16) {
+ ___assert_fail(2712, 2672, 207, 2856);
+ } else if ((i35 | 0) == 28) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ } else if ((i35 | 0) == 35) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ } else if ((i35 | 0) == 42) {
+ i12 = HEAP32[656] | 0;
+ HEAP32[656] = (i12 | 0) > (i33 | 0) ? i12 : i33;
+ i14 = i2 + 8 | 0;
+ __ZNK9b2Simplex16GetWitnessPointsEP6b2Vec2S1_(i4, i2, i14);
+ d44 = +HEAPF32[i2 >> 2] - +HEAPF32[i14 >> 2];
+ i13 = i2 + 4 | 0;
+ i12 = i2 + 12 | 0;
+ d45 = +HEAPF32[i13 >> 2] - +HEAPF32[i12 >> 2];
+ i15 = i2 + 16 | 0;
+ HEAPF32[i15 >> 2] = +Math_sqrt(+(d44 * d44 + d45 * d45));
+ HEAP32[i2 + 20 >> 2] = i33;
+ i9 = HEAP32[i9 >> 2] | 0;
+ if ((i9 | 0) == 2) {
+ d45 = +HEAPF32[i8 >> 2] - +HEAPF32[i11 >> 2];
+ d7 = +HEAPF32[i6 >> 2] - +HEAPF32[i10 >> 2];
+ d7 = +Math_sqrt(+(d45 * d45 + d7 * d7));
+ } else if ((i9 | 0) == 3) {
+ d7 = +HEAPF32[i8 >> 2];
+ d45 = +HEAPF32[i6 >> 2];
+ d7 = (+HEAPF32[i11 >> 2] - d7) * (+HEAPF32[i4 + 92 >> 2] - d45) - (+HEAPF32[i10 >> 2] - d45) * (+HEAPF32[i4 + 88 >> 2] - d7);
+ } else if ((i9 | 0) == 1) {
+ d7 = 0.0;
+ } else if ((i9 | 0) == 0) {
+ ___assert_fail(2712, 2672, 246, 2736);
+ } else {
+ ___assert_fail(2712, 2672, 259, 2736);
+ }
+ HEAPF32[i5 >> 2] = d7;
+ HEAP16[i5 + 4 >> 1] = i9;
+ i6 = 0;
+ do {
+ HEAP8[i5 + i6 + 6 | 0] = HEAP32[i4 + (i6 * 36 | 0) + 28 >> 2];
+ HEAP8[i5 + i6 + 9 | 0] = HEAP32[i4 + (i6 * 36 | 0) + 32 >> 2];
+ i6 = i6 + 1 | 0;
+ } while ((i6 | 0) < (i9 | 0));
+ if ((HEAP8[i3 + 88 | 0] | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ d7 = +HEAPF32[i3 + 24 >> 2];
+ d16 = +HEAPF32[i3 + 52 >> 2];
+ d18 = +HEAPF32[i15 >> 2];
+ d17 = d7 + d16;
+ if (!(d18 > d17 & d18 > 1.1920928955078125e-7)) {
+ d44 = +((+HEAPF32[i2 >> 2] + +HEAPF32[i14 >> 2]) * .5);
+ d45 = +((+HEAPF32[i13 >> 2] + +HEAPF32[i12 >> 2]) * .5);
+ i46 = i2;
+ HEAPF32[i46 >> 2] = d44;
+ HEAPF32[i46 + 4 >> 2] = d45;
+ i46 = i14;
+ HEAPF32[i46 >> 2] = d44;
+ HEAPF32[i46 + 4 >> 2] = d45;
+ HEAPF32[i15 >> 2] = 0.0;
+ STACKTOP = i1;
+ return;
+ }
+ HEAPF32[i15 >> 2] = d18 - d17;
+ d18 = +HEAPF32[i14 >> 2];
+ d21 = +HEAPF32[i2 >> 2];
+ d24 = d18 - d21;
+ d17 = +HEAPF32[i12 >> 2];
+ d19 = +HEAPF32[i13 >> 2];
+ d22 = d17 - d19;
+ d25 = +Math_sqrt(+(d24 * d24 + d22 * d22));
+ if (!(d25 < 1.1920928955078125e-7)) {
+ d45 = 1.0 / d25;
+ d24 = d24 * d45;
+ d22 = d22 * d45;
+ }
+ HEAPF32[i2 >> 2] = d7 * d24 + d21;
+ HEAPF32[i13 >> 2] = d7 * d22 + d19;
+ HEAPF32[i14 >> 2] = d18 - d16 * d24;
+ HEAPF32[i12 >> 2] = d17 - d16 * d22;
+ STACKTOP = i1;
+ return;
+ }
+ } else if ((i31 | 0) == 0) {
+ ___assert_fail(2712, 2672, 194, 2856);
+ } else {
+ ___assert_fail(2712, 2672, 207, 2856);
+ }
+}
+function __ZN8b2Island5SolveEP9b2ProfileRK10b2TimeStepRK6b2Vec2b(i4, i8, i11, i17, i7) {
+ i4 = i4 | 0;
+ i8 = i8 | 0;
+ i11 = i11 | 0;
+ i17 = i17 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, d5 = 0.0, i6 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0, i22 = 0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, d27 = 0.0, d28 = 0.0, d29 = 0.0, i30 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 160 | 0;
+ i6 = i3 + 128 | 0;
+ i9 = i3 + 148 | 0;
+ i10 = i3 + 96 | 0;
+ i16 = i3 + 52 | 0;
+ i2 = i3;
+ __ZN7b2TimerC2Ev(i9);
+ d5 = +HEAPF32[i11 >> 2];
+ i1 = i4 + 28 | 0;
+ if ((HEAP32[i1 >> 2] | 0) > 0) {
+ i13 = i4 + 8 | 0;
+ i12 = i17 + 4 | 0;
+ i15 = i4 + 20 | 0;
+ i14 = i4 + 24 | 0;
+ i19 = 0;
+ do {
+ i22 = HEAP32[(HEAP32[i13 >> 2] | 0) + (i19 << 2) >> 2] | 0;
+ i18 = i22 + 44 | 0;
+ i20 = HEAP32[i18 >> 2] | 0;
+ i18 = HEAP32[i18 + 4 >> 2] | 0;
+ d21 = +HEAPF32[i22 + 56 >> 2];
+ i30 = i22 + 64 | 0;
+ d27 = +HEAPF32[i30 >> 2];
+ d24 = +HEAPF32[i30 + 4 >> 2];
+ d23 = +HEAPF32[i22 + 72 >> 2];
+ i30 = i22 + 36 | 0;
+ HEAP32[i30 >> 2] = i20;
+ HEAP32[i30 + 4 >> 2] = i18;
+ HEAPF32[i22 + 52 >> 2] = d21;
+ if ((HEAP32[i22 >> 2] | 0) == 2) {
+ d25 = +HEAPF32[i22 + 140 >> 2];
+ d26 = +HEAPF32[i22 + 120 >> 2];
+ d28 = 1.0 - d5 * +HEAPF32[i22 + 132 >> 2];
+ d28 = d28 < 1.0 ? d28 : 1.0;
+ d28 = d28 < 0.0 ? 0.0 : d28;
+ d29 = 1.0 - d5 * +HEAPF32[i22 + 136 >> 2];
+ d29 = d29 < 1.0 ? d29 : 1.0;
+ d27 = (d27 + d5 * (d25 * +HEAPF32[i17 >> 2] + d26 * +HEAPF32[i22 + 76 >> 2])) * d28;
+ d24 = (d24 + d5 * (d25 * +HEAPF32[i12 >> 2] + d26 * +HEAPF32[i22 + 80 >> 2])) * d28;
+ d23 = (d23 + d5 * +HEAPF32[i22 + 128 >> 2] * +HEAPF32[i22 + 84 >> 2]) * (d29 < 0.0 ? 0.0 : d29);
+ }
+ i30 = (HEAP32[i15 >> 2] | 0) + (i19 * 12 | 0) | 0;
+ HEAP32[i30 >> 2] = i20;
+ HEAP32[i30 + 4 >> 2] = i18;
+ HEAPF32[(HEAP32[i15 >> 2] | 0) + (i19 * 12 | 0) + 8 >> 2] = d21;
+ d28 = +d27;
+ d29 = +d24;
+ i30 = (HEAP32[i14 >> 2] | 0) + (i19 * 12 | 0) | 0;
+ HEAPF32[i30 >> 2] = d28;
+ HEAPF32[i30 + 4 >> 2] = d29;
+ HEAPF32[(HEAP32[i14 >> 2] | 0) + (i19 * 12 | 0) + 8 >> 2] = d23;
+ i19 = i19 + 1 | 0;
+ } while ((i19 | 0) < (HEAP32[i1 >> 2] | 0));
+ } else {
+ i14 = i4 + 24 | 0;
+ i15 = i4 + 20 | 0;
+ }
+ HEAP32[i10 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i10 + 12 >> 2] = HEAP32[i11 + 12 >> 2];
+ HEAP32[i10 + 16 >> 2] = HEAP32[i11 + 16 >> 2];
+ HEAP32[i10 + 20 >> 2] = HEAP32[i11 + 20 >> 2];
+ i22 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i10 + 24 >> 2] = i22;
+ i30 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i10 + 28 >> 2] = i30;
+ HEAP32[i16 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i16 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i16 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i16 + 12 >> 2] = HEAP32[i11 + 12 >> 2];
+ HEAP32[i16 + 16 >> 2] = HEAP32[i11 + 16 >> 2];
+ HEAP32[i16 + 20 >> 2] = HEAP32[i11 + 20 >> 2];
+ i13 = i4 + 12 | 0;
+ HEAP32[i16 + 24 >> 2] = HEAP32[i13 >> 2];
+ i12 = i4 + 36 | 0;
+ HEAP32[i16 + 28 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i16 + 32 >> 2] = i22;
+ HEAP32[i16 + 36 >> 2] = i30;
+ HEAP32[i16 + 40 >> 2] = HEAP32[i4 >> 2];
+ __ZN15b2ContactSolverC2EP18b2ContactSolverDef(i2, i16);
+ __ZN15b2ContactSolver29InitializeVelocityConstraintsEv(i2);
+ if ((HEAP8[i11 + 20 | 0] | 0) != 0) {
+ __ZN15b2ContactSolver9WarmStartEv(i2);
+ }
+ i16 = i4 + 32 | 0;
+ if ((HEAP32[i16 >> 2] | 0) > 0) {
+ i18 = i4 + 16 | 0;
+ i17 = 0;
+ do {
+ i30 = HEAP32[(HEAP32[i18 >> 2] | 0) + (i17 << 2) >> 2] | 0;
+ FUNCTION_TABLE_vii[HEAP32[(HEAP32[i30 >> 2] | 0) + 28 >> 2] & 15](i30, i10);
+ i17 = i17 + 1 | 0;
+ } while ((i17 | 0) < (HEAP32[i16 >> 2] | 0));
+ }
+ HEAPF32[i8 + 12 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i9);
+ i17 = i11 + 12 | 0;
+ if ((HEAP32[i17 >> 2] | 0) > 0) {
+ i20 = i4 + 16 | 0;
+ i19 = 0;
+ do {
+ if ((HEAP32[i16 >> 2] | 0) > 0) {
+ i18 = 0;
+ do {
+ i30 = HEAP32[(HEAP32[i20 >> 2] | 0) + (i18 << 2) >> 2] | 0;
+ FUNCTION_TABLE_vii[HEAP32[(HEAP32[i30 >> 2] | 0) + 32 >> 2] & 15](i30, i10);
+ i18 = i18 + 1 | 0;
+ } while ((i18 | 0) < (HEAP32[i16 >> 2] | 0));
+ }
+ __ZN15b2ContactSolver24SolveVelocityConstraintsEv(i2);
+ i19 = i19 + 1 | 0;
+ } while ((i19 | 0) < (HEAP32[i17 >> 2] | 0));
+ }
+ __ZN15b2ContactSolver13StoreImpulsesEv(i2);
+ HEAPF32[i8 + 16 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i9);
+ if ((HEAP32[i1 >> 2] | 0) > 0) {
+ i19 = HEAP32[i14 >> 2] | 0;
+ i18 = 0;
+ do {
+ i30 = HEAP32[i15 >> 2] | 0;
+ i17 = i30 + (i18 * 12 | 0) | 0;
+ i22 = i17;
+ d23 = +HEAPF32[i22 >> 2];
+ d21 = +HEAPF32[i22 + 4 >> 2];
+ d24 = +HEAPF32[i30 + (i18 * 12 | 0) + 8 >> 2];
+ i30 = i19 + (i18 * 12 | 0) | 0;
+ d26 = +HEAPF32[i30 >> 2];
+ d27 = +HEAPF32[i30 + 4 >> 2];
+ d25 = +HEAPF32[i19 + (i18 * 12 | 0) + 8 >> 2];
+ d29 = d5 * d26;
+ d28 = d5 * d27;
+ d28 = d29 * d29 + d28 * d28;
+ if (d28 > 4.0) {
+ d29 = 2.0 / +Math_sqrt(+d28);
+ d26 = d26 * d29;
+ d27 = d27 * d29;
+ }
+ d28 = d5 * d25;
+ if (d28 * d28 > 2.4674012660980225) {
+ if (!(d28 > 0.0)) {
+ d28 = -d28;
+ }
+ d25 = d25 * (1.5707963705062866 / d28);
+ }
+ d29 = +(d23 + d5 * d26);
+ d28 = +(d21 + d5 * d27);
+ i19 = i17;
+ HEAPF32[i19 >> 2] = d29;
+ HEAPF32[i19 + 4 >> 2] = d28;
+ HEAPF32[(HEAP32[i15 >> 2] | 0) + (i18 * 12 | 0) + 8 >> 2] = d24 + d5 * d25;
+ d28 = +d26;
+ d29 = +d27;
+ i19 = (HEAP32[i14 >> 2] | 0) + (i18 * 12 | 0) | 0;
+ HEAPF32[i19 >> 2] = d28;
+ HEAPF32[i19 + 4 >> 2] = d29;
+ i19 = HEAP32[i14 >> 2] | 0;
+ HEAPF32[i19 + (i18 * 12 | 0) + 8 >> 2] = d25;
+ i18 = i18 + 1 | 0;
+ } while ((i18 | 0) < (HEAP32[i1 >> 2] | 0));
+ }
+ i11 = i11 + 16 | 0;
+ L41 : do {
+ if ((HEAP32[i11 >> 2] | 0) > 0) {
+ i17 = i4 + 16 | 0;
+ i19 = 0;
+ while (1) {
+ i18 = __ZN15b2ContactSolver24SolvePositionConstraintsEv(i2) | 0;
+ if ((HEAP32[i16 >> 2] | 0) > 0) {
+ i20 = 0;
+ i22 = 1;
+ do {
+ i30 = HEAP32[(HEAP32[i17 >> 2] | 0) + (i20 << 2) >> 2] | 0;
+ i22 = i22 & (FUNCTION_TABLE_iii[HEAP32[(HEAP32[i30 >> 2] | 0) + 36 >> 2] & 3](i30, i10) | 0);
+ i20 = i20 + 1 | 0;
+ } while ((i20 | 0) < (HEAP32[i16 >> 2] | 0));
+ } else {
+ i22 = 1;
+ }
+ i19 = i19 + 1 | 0;
+ if (i18 & i22) {
+ i10 = 0;
+ break L41;
+ }
+ if ((i19 | 0) >= (HEAP32[i11 >> 2] | 0)) {
+ i10 = 1;
+ break;
+ }
+ }
+ } else {
+ i10 = 1;
+ }
+ } while (0);
+ if ((HEAP32[i1 >> 2] | 0) > 0) {
+ i11 = i4 + 8 | 0;
+ i16 = 0;
+ do {
+ i30 = HEAP32[(HEAP32[i11 >> 2] | 0) + (i16 << 2) >> 2] | 0;
+ i22 = (HEAP32[i15 >> 2] | 0) + (i16 * 12 | 0) | 0;
+ i20 = HEAP32[i22 >> 2] | 0;
+ i22 = HEAP32[i22 + 4 >> 2] | 0;
+ i17 = i30 + 44 | 0;
+ HEAP32[i17 >> 2] = i20;
+ HEAP32[i17 + 4 >> 2] = i22;
+ d27 = +HEAPF32[(HEAP32[i15 >> 2] | 0) + (i16 * 12 | 0) + 8 >> 2];
+ HEAPF32[i30 + 56 >> 2] = d27;
+ i17 = (HEAP32[i14 >> 2] | 0) + (i16 * 12 | 0) | 0;
+ i18 = HEAP32[i17 + 4 >> 2] | 0;
+ i19 = i30 + 64 | 0;
+ HEAP32[i19 >> 2] = HEAP32[i17 >> 2];
+ HEAP32[i19 + 4 >> 2] = i18;
+ HEAPF32[i30 + 72 >> 2] = +HEAPF32[(HEAP32[i14 >> 2] | 0) + (i16 * 12 | 0) + 8 >> 2];
+ d25 = +Math_sin(+d27);
+ HEAPF32[i30 + 20 >> 2] = d25;
+ d27 = +Math_cos(+d27);
+ HEAPF32[i30 + 24 >> 2] = d27;
+ d26 = +HEAPF32[i30 + 28 >> 2];
+ d29 = +HEAPF32[i30 + 32 >> 2];
+ d28 = (HEAP32[tempDoublePtr >> 2] = i20, +HEAPF32[tempDoublePtr >> 2]) - (d27 * d26 - d25 * d29);
+ d29 = (HEAP32[tempDoublePtr >> 2] = i22, +HEAPF32[tempDoublePtr >> 2]) - (d25 * d26 + d27 * d29);
+ d28 = +d28;
+ d29 = +d29;
+ i30 = i30 + 12 | 0;
+ HEAPF32[i30 >> 2] = d28;
+ HEAPF32[i30 + 4 >> 2] = d29;
+ i16 = i16 + 1 | 0;
+ } while ((i16 | 0) < (HEAP32[i1 >> 2] | 0));
+ }
+ HEAPF32[i8 + 20 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i9);
+ i9 = HEAP32[i2 + 40 >> 2] | 0;
+ i8 = i4 + 4 | 0;
+ if ((HEAP32[i8 >> 2] | 0) != 0 ? (HEAP32[i12 >> 2] | 0) > 0 : 0) {
+ i11 = i6 + 16 | 0;
+ i14 = 0;
+ do {
+ i15 = HEAP32[(HEAP32[i13 >> 2] | 0) + (i14 << 2) >> 2] | 0;
+ i16 = HEAP32[i9 + (i14 * 152 | 0) + 144 >> 2] | 0;
+ HEAP32[i11 >> 2] = i16;
+ if ((i16 | 0) > 0) {
+ i17 = 0;
+ do {
+ HEAPF32[i6 + (i17 << 2) >> 2] = +HEAPF32[i9 + (i14 * 152 | 0) + (i17 * 36 | 0) + 16 >> 2];
+ HEAPF32[i6 + (i17 << 2) + 8 >> 2] = +HEAPF32[i9 + (i14 * 152 | 0) + (i17 * 36 | 0) + 20 >> 2];
+ i17 = i17 + 1 | 0;
+ } while ((i17 | 0) != (i16 | 0));
+ }
+ i30 = HEAP32[i8 >> 2] | 0;
+ FUNCTION_TABLE_viii[HEAP32[(HEAP32[i30 >> 2] | 0) + 20 >> 2] & 3](i30, i15, i6);
+ i14 = i14 + 1 | 0;
+ } while ((i14 | 0) < (HEAP32[i12 >> 2] | 0));
+ }
+ if (!i7) {
+ __ZN15b2ContactSolverD2Ev(i2);
+ STACKTOP = i3;
+ return;
+ }
+ i7 = HEAP32[i1 >> 2] | 0;
+ i6 = (i7 | 0) > 0;
+ if (i6) {
+ i8 = HEAP32[i4 + 8 >> 2] | 0;
+ i9 = 0;
+ d21 = 3.4028234663852886e+38;
+ do {
+ i11 = HEAP32[i8 + (i9 << 2) >> 2] | 0;
+ do {
+ if ((HEAP32[i11 >> 2] | 0) != 0) {
+ if ((!((HEAP16[i11 + 4 >> 1] & 4) == 0) ? (d29 = +HEAPF32[i11 + 72 >> 2], !(d29 * d29 > .001218469929881394)) : 0) ? (d28 = +HEAPF32[i11 + 64 >> 2], d29 = +HEAPF32[i11 + 68 >> 2], !(d28 * d28 + d29 * d29 > 9999999747378752.0e-20)) : 0) {
+ i30 = i11 + 144 | 0;
+ d23 = d5 + +HEAPF32[i30 >> 2];
+ HEAPF32[i30 >> 2] = d23;
+ d21 = d21 < d23 ? d21 : d23;
+ break;
+ }
+ HEAPF32[i11 + 144 >> 2] = 0.0;
+ d21 = 0.0;
+ }
+ } while (0);
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) < (i7 | 0));
+ } else {
+ d21 = 3.4028234663852886e+38;
+ }
+ if (!(d21 >= .5) | i10 | i6 ^ 1) {
+ __ZN15b2ContactSolverD2Ev(i2);
+ STACKTOP = i3;
+ return;
+ }
+ i4 = i4 + 8 | 0;
+ i6 = 0;
+ do {
+ i30 = HEAP32[(HEAP32[i4 >> 2] | 0) + (i6 << 2) >> 2] | 0;
+ i22 = i30 + 4 | 0;
+ HEAP16[i22 >> 1] = HEAP16[i22 >> 1] & 65533;
+ HEAPF32[i30 + 144 >> 2] = 0.0;
+ i30 = i30 + 64 | 0;
+ HEAP32[i30 + 0 >> 2] = 0;
+ HEAP32[i30 + 4 >> 2] = 0;
+ HEAP32[i30 + 8 >> 2] = 0;
+ HEAP32[i30 + 12 >> 2] = 0;
+ HEAP32[i30 + 16 >> 2] = 0;
+ HEAP32[i30 + 20 >> 2] = 0;
+ i6 = i6 + 1 | 0;
+ } while ((i6 | 0) < (HEAP32[i1 >> 2] | 0));
+ __ZN15b2ContactSolverD2Ev(i2);
+ STACKTOP = i3;
+ return;
+}
+function __ZN15b2ContactSolver24SolveVelocityConstraintsEv(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, i19 = 0, d20 = 0.0, d21 = 0.0, i22 = 0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, d27 = 0.0, d28 = 0.0, d29 = 0.0, d30 = 0.0, d31 = 0.0, i32 = 0, i33 = 0, d34 = 0.0, d35 = 0.0, d36 = 0.0, d37 = 0.0, d38 = 0.0, d39 = 0.0, d40 = 0.0, i41 = 0, i42 = 0, d43 = 0.0, d44 = 0.0;
+ i1 = STACKTOP;
+ i2 = i4 + 48 | 0;
+ if ((HEAP32[i2 >> 2] | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = i4 + 40 | 0;
+ i4 = i4 + 28 | 0;
+ i42 = HEAP32[i4 >> 2] | 0;
+ i5 = 0;
+ L4 : while (1) {
+ i19 = HEAP32[i3 >> 2] | 0;
+ i22 = i19 + (i5 * 152 | 0) | 0;
+ i8 = HEAP32[i19 + (i5 * 152 | 0) + 112 >> 2] | 0;
+ i6 = HEAP32[i19 + (i5 * 152 | 0) + 116 >> 2] | 0;
+ d12 = +HEAPF32[i19 + (i5 * 152 | 0) + 120 >> 2];
+ d10 = +HEAPF32[i19 + (i5 * 152 | 0) + 128 >> 2];
+ d11 = +HEAPF32[i19 + (i5 * 152 | 0) + 124 >> 2];
+ d9 = +HEAPF32[i19 + (i5 * 152 | 0) + 132 >> 2];
+ i32 = i19 + (i5 * 152 | 0) + 144 | 0;
+ i33 = HEAP32[i32 >> 2] | 0;
+ i7 = i42 + (i8 * 12 | 0) | 0;
+ i41 = i7;
+ d21 = +HEAPF32[i41 >> 2];
+ d20 = +HEAPF32[i41 + 4 >> 2];
+ i41 = i42 + (i6 * 12 | 0) | 0;
+ d14 = +HEAPF32[i41 >> 2];
+ d13 = +HEAPF32[i41 + 4 >> 2];
+ i41 = i19 + (i5 * 152 | 0) + 72 | 0;
+ d17 = +HEAPF32[i41 >> 2];
+ d16 = +HEAPF32[i41 + 4 >> 2];
+ d23 = -d17;
+ d24 = +HEAPF32[i19 + (i5 * 152 | 0) + 136 >> 2];
+ if ((i33 + -1 | 0) >>> 0 < 2) {
+ i41 = 0;
+ d18 = +HEAPF32[i42 + (i8 * 12 | 0) + 8 >> 2];
+ d15 = +HEAPF32[i42 + (i6 * 12 | 0) + 8 >> 2];
+ } else {
+ i2 = 4;
+ break;
+ }
+ do {
+ d30 = +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 12 >> 2];
+ d25 = +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 8 >> 2];
+ d26 = +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 4 >> 2];
+ d27 = +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) >> 2];
+ d34 = d24 * +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 16 >> 2];
+ i42 = i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 20 | 0;
+ d28 = +HEAPF32[i42 >> 2];
+ d31 = d28 - +HEAPF32[i19 + (i5 * 152 | 0) + (i41 * 36 | 0) + 28 >> 2] * (d16 * (d14 - d15 * d30 - d21 + d18 * d26) + (d13 + d15 * d25 - d20 - d18 * d27) * d23);
+ d29 = -d34;
+ d31 = d31 < d34 ? d31 : d34;
+ d40 = d31 < d29 ? d29 : d31;
+ d39 = d40 - d28;
+ HEAPF32[i42 >> 2] = d40;
+ d40 = d16 * d39;
+ d39 = d39 * d23;
+ d21 = d21 - d12 * d40;
+ d20 = d20 - d12 * d39;
+ d18 = d18 - d10 * (d27 * d39 - d26 * d40);
+ d14 = d14 + d11 * d40;
+ d13 = d13 + d11 * d39;
+ d15 = d15 + d9 * (d25 * d39 - d30 * d40);
+ i41 = i41 + 1 | 0;
+ } while ((i41 | 0) != (i33 | 0));
+ do {
+ if ((HEAP32[i32 >> 2] | 0) != 1) {
+ i32 = i19 + (i5 * 152 | 0) + 16 | 0;
+ d31 = +HEAPF32[i32 >> 2];
+ i33 = i19 + (i5 * 152 | 0) + 52 | 0;
+ d34 = +HEAPF32[i33 >> 2];
+ if (!(d31 >= 0.0) | !(d34 >= 0.0)) {
+ i2 = 9;
+ break L4;
+ }
+ d23 = +HEAPF32[i19 + (i5 * 152 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i19 + (i5 * 152 | 0) + 8 >> 2];
+ d26 = +HEAPF32[i19 + (i5 * 152 | 0) + 4 >> 2];
+ d30 = +HEAPF32[i22 >> 2];
+ d27 = +HEAPF32[i19 + (i5 * 152 | 0) + 48 >> 2];
+ d25 = +HEAPF32[i19 + (i5 * 152 | 0) + 44 >> 2];
+ d28 = +HEAPF32[i19 + (i5 * 152 | 0) + 40 >> 2];
+ d29 = +HEAPF32[i19 + (i5 * 152 | 0) + 36 >> 2];
+ d37 = +HEAPF32[i19 + (i5 * 152 | 0) + 104 >> 2];
+ d38 = +HEAPF32[i19 + (i5 * 152 | 0) + 100 >> 2];
+ d35 = d17 * (d14 - d15 * d23 - d21 + d18 * d26) + d16 * (d13 + d15 * d24 - d20 - d18 * d30) - +HEAPF32[i19 + (i5 * 152 | 0) + 32 >> 2] - (d31 * +HEAPF32[i19 + (i5 * 152 | 0) + 96 >> 2] + d34 * d37);
+ d36 = d17 * (d14 - d15 * d27 - d21 + d18 * d28) + d16 * (d13 + d15 * d25 - d20 - d18 * d29) - +HEAPF32[i19 + (i5 * 152 | 0) + 68 >> 2] - (d31 * d38 + d34 * +HEAPF32[i19 + (i5 * 152 | 0) + 108 >> 2]);
+ d44 = +HEAPF32[i19 + (i5 * 152 | 0) + 80 >> 2] * d35 + +HEAPF32[i19 + (i5 * 152 | 0) + 88 >> 2] * d36;
+ d43 = d35 * +HEAPF32[i19 + (i5 * 152 | 0) + 84 >> 2] + d36 * +HEAPF32[i19 + (i5 * 152 | 0) + 92 >> 2];
+ d40 = -d44;
+ d39 = -d43;
+ if (!(!(d44 <= -0.0) | !(d43 <= -0.0))) {
+ d37 = d40 - d31;
+ d43 = d39 - d34;
+ d38 = d17 * d37;
+ d37 = d16 * d37;
+ d44 = d17 * d43;
+ d43 = d16 * d43;
+ d35 = d38 + d44;
+ d36 = d37 + d43;
+ HEAPF32[i32 >> 2] = d40;
+ HEAPF32[i33 >> 2] = d39;
+ d21 = d21 - d12 * d35;
+ d20 = d20 - d12 * d36;
+ d14 = d14 + d11 * d35;
+ d13 = d13 + d11 * d36;
+ d18 = d18 - d10 * (d30 * d37 - d26 * d38 + (d29 * d43 - d28 * d44));
+ d15 = d15 + d9 * (d24 * d37 - d23 * d38 + (d25 * d43 - d27 * d44));
+ break;
+ }
+ d44 = d35 * +HEAPF32[i19 + (i5 * 152 | 0) + 24 >> 2];
+ d39 = -d44;
+ if (d44 <= -0.0 ? d36 + d38 * d39 >= 0.0 : 0) {
+ d38 = d39 - d31;
+ d43 = 0.0 - d34;
+ d40 = d17 * d38;
+ d38 = d16 * d38;
+ d44 = d17 * d43;
+ d43 = d16 * d43;
+ d36 = d44 + d40;
+ d37 = d43 + d38;
+ HEAPF32[i32 >> 2] = d39;
+ HEAPF32[i33 >> 2] = 0.0;
+ d21 = d21 - d12 * d36;
+ d20 = d20 - d12 * d37;
+ d14 = d14 + d11 * d36;
+ d13 = d13 + d11 * d37;
+ d18 = d18 - d10 * (d38 * d30 - d40 * d26 + (d43 * d29 - d44 * d28));
+ d15 = d15 + d9 * (d38 * d24 - d40 * d23 + (d43 * d25 - d44 * d27));
+ break;
+ }
+ d44 = d36 * +HEAPF32[i19 + (i5 * 152 | 0) + 60 >> 2];
+ d38 = -d44;
+ if (d44 <= -0.0 ? d35 + d37 * d38 >= 0.0 : 0) {
+ d39 = 0.0 - d31;
+ d43 = d38 - d34;
+ d40 = d17 * d39;
+ d39 = d16 * d39;
+ d44 = d17 * d43;
+ d43 = d16 * d43;
+ d36 = d40 + d44;
+ d37 = d39 + d43;
+ HEAPF32[i32 >> 2] = 0.0;
+ HEAPF32[i33 >> 2] = d38;
+ d21 = d21 - d12 * d36;
+ d20 = d20 - d12 * d37;
+ d14 = d14 + d11 * d36;
+ d13 = d13 + d11 * d37;
+ d18 = d18 - d10 * (d39 * d30 - d40 * d26 + (d43 * d29 - d44 * d28));
+ d15 = d15 + d9 * (d39 * d24 - d40 * d23 + (d43 * d25 - d44 * d27));
+ break;
+ }
+ if (!(!(d35 >= 0.0) | !(d36 >= 0.0))) {
+ d39 = 0.0 - d31;
+ d43 = 0.0 - d34;
+ d40 = d17 * d39;
+ d39 = d16 * d39;
+ d44 = d17 * d43;
+ d43 = d16 * d43;
+ d37 = d40 + d44;
+ d38 = d39 + d43;
+ HEAPF32[i32 >> 2] = 0.0;
+ HEAPF32[i33 >> 2] = 0.0;
+ d21 = d21 - d12 * d37;
+ d20 = d20 - d12 * d38;
+ d14 = d14 + d11 * d37;
+ d13 = d13 + d11 * d38;
+ d18 = d18 - d10 * (d39 * d30 - d40 * d26 + (d43 * d29 - d44 * d28));
+ d15 = d15 + d9 * (d39 * d24 - d40 * d23 + (d43 * d25 - d44 * d27));
+ }
+ } else {
+ d23 = +HEAPF32[i19 + (i5 * 152 | 0) + 12 >> 2];
+ d24 = +HEAPF32[i19 + (i5 * 152 | 0) + 8 >> 2];
+ d25 = +HEAPF32[i19 + (i5 * 152 | 0) + 4 >> 2];
+ d26 = +HEAPF32[i22 >> 2];
+ i22 = i19 + (i5 * 152 | 0) + 16 | 0;
+ d27 = +HEAPF32[i22 >> 2];
+ d28 = d27 - +HEAPF32[i19 + (i5 * 152 | 0) + 24 >> 2] * (d17 * (d14 - d15 * d23 - d21 + d18 * d25) + d16 * (d13 + d15 * d24 - d20 - d18 * d26) - +HEAPF32[i19 + (i5 * 152 | 0) + 32 >> 2]);
+ d44 = d28 > 0.0 ? d28 : 0.0;
+ d43 = d44 - d27;
+ HEAPF32[i22 >> 2] = d44;
+ d44 = d17 * d43;
+ d43 = d16 * d43;
+ d21 = d21 - d12 * d44;
+ d20 = d20 - d12 * d43;
+ d14 = d14 + d11 * d44;
+ d13 = d13 + d11 * d43;
+ d18 = d18 - d10 * (d26 * d43 - d25 * d44);
+ d15 = d15 + d9 * (d24 * d43 - d23 * d44);
+ }
+ } while (0);
+ d44 = +d21;
+ d43 = +d20;
+ i42 = i7;
+ HEAPF32[i42 >> 2] = d44;
+ HEAPF32[i42 + 4 >> 2] = d43;
+ i42 = HEAP32[i4 >> 2] | 0;
+ HEAPF32[i42 + (i8 * 12 | 0) + 8 >> 2] = d18;
+ d43 = +d14;
+ d44 = +d13;
+ i42 = i42 + (i6 * 12 | 0) | 0;
+ HEAPF32[i42 >> 2] = d43;
+ HEAPF32[i42 + 4 >> 2] = d44;
+ i42 = HEAP32[i4 >> 2] | 0;
+ HEAPF32[i42 + (i6 * 12 | 0) + 8 >> 2] = d15;
+ i5 = i5 + 1 | 0;
+ if ((i5 | 0) >= (HEAP32[i2 >> 2] | 0)) {
+ i2 = 21;
+ break;
+ }
+ }
+ if ((i2 | 0) == 4) {
+ ___assert_fail(6648, 6520, 311, 6688);
+ } else if ((i2 | 0) == 9) {
+ ___assert_fail(6720, 6520, 406, 6688);
+ } else if ((i2 | 0) == 21) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function __Z14b2TimeOfImpactP11b2TOIOutputPK10b2TOIInput(i3, i11) {
+ i3 = i3 | 0;
+ i11 = i11 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, d14 = 0.0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, d28 = 0.0, i29 = 0, d30 = 0.0, d31 = 0.0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0, i38 = 0, i39 = 0, d40 = 0.0, i41 = 0, d42 = 0.0, d43 = 0.0, i44 = 0, i45 = 0, d46 = 0.0, i47 = 0, d48 = 0.0, d49 = 0.0, d50 = 0.0, d51 = 0.0, i52 = 0, d53 = 0.0, d54 = 0.0, d55 = 0.0, d56 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 320 | 0;
+ i12 = i1 + 276 | 0;
+ i10 = i1 + 240 | 0;
+ i13 = i1 + 228 | 0;
+ i5 = i1 + 136 | 0;
+ i7 = i1 + 112 | 0;
+ i8 = i1 + 8 | 0;
+ i9 = i1 + 4 | 0;
+ i4 = i1;
+ HEAP32[874] = (HEAP32[874] | 0) + 1;
+ HEAP32[i3 >> 2] = 0;
+ i19 = i11 + 128 | 0;
+ i2 = i3 + 4 | 0;
+ HEAPF32[i2 >> 2] = +HEAPF32[i19 >> 2];
+ i6 = i11 + 28 | 0;
+ i16 = i12 + 0 | 0;
+ i15 = i11 + 56 | 0;
+ i17 = i16 + 36 | 0;
+ do {
+ HEAP32[i16 >> 2] = HEAP32[i15 >> 2];
+ i16 = i16 + 4 | 0;
+ i15 = i15 + 4 | 0;
+ } while ((i16 | 0) < (i17 | 0));
+ i16 = i10 + 0 | 0;
+ i15 = i11 + 92 | 0;
+ i17 = i16 + 36 | 0;
+ do {
+ HEAP32[i16 >> 2] = HEAP32[i15 >> 2];
+ i16 = i16 + 4 | 0;
+ i15 = i15 + 4 | 0;
+ } while ((i16 | 0) < (i17 | 0));
+ i15 = i12 + 24 | 0;
+ d42 = +HEAPF32[i15 >> 2];
+ d43 = +Math_floor(+(d42 / 6.2831854820251465)) * 6.2831854820251465;
+ d42 = d42 - d43;
+ HEAPF32[i15 >> 2] = d42;
+ i16 = i12 + 28 | 0;
+ d43 = +HEAPF32[i16 >> 2] - d43;
+ HEAPF32[i16 >> 2] = d43;
+ i17 = i10 + 24 | 0;
+ d46 = +HEAPF32[i17 >> 2];
+ d40 = +Math_floor(+(d46 / 6.2831854820251465)) * 6.2831854820251465;
+ d46 = d46 - d40;
+ HEAPF32[i17 >> 2] = d46;
+ i18 = i10 + 28 | 0;
+ d40 = +HEAPF32[i18 >> 2] - d40;
+ HEAPF32[i18 >> 2] = d40;
+ d14 = +HEAPF32[i19 >> 2];
+ d28 = +HEAPF32[i11 + 24 >> 2] + +HEAPF32[i11 + 52 >> 2] + -.014999999664723873;
+ d28 = d28 < .004999999888241291 ? .004999999888241291 : d28;
+ if (!(d28 > .0012499999720603228)) {
+ ___assert_fail(3536, 3560, 280, 3600);
+ }
+ HEAP16[i13 + 4 >> 1] = 0;
+ HEAP32[i5 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i5 + 12 >> 2] = HEAP32[i11 + 12 >> 2];
+ HEAP32[i5 + 16 >> 2] = HEAP32[i11 + 16 >> 2];
+ HEAP32[i5 + 20 >> 2] = HEAP32[i11 + 20 >> 2];
+ HEAP32[i5 + 24 >> 2] = HEAP32[i11 + 24 >> 2];
+ i38 = i5 + 28 | 0;
+ HEAP32[i38 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i38 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i38 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i38 + 12 >> 2] = HEAP32[i6 + 12 >> 2];
+ HEAP32[i38 + 16 >> 2] = HEAP32[i6 + 16 >> 2];
+ HEAP32[i38 + 20 >> 2] = HEAP32[i6 + 20 >> 2];
+ HEAP32[i38 + 24 >> 2] = HEAP32[i6 + 24 >> 2];
+ HEAP8[i5 + 88 | 0] = 0;
+ i38 = i12 + 8 | 0;
+ i27 = i12 + 12 | 0;
+ i29 = i12 + 16 | 0;
+ i22 = i12 + 20 | 0;
+ i32 = i12 + 4 | 0;
+ i34 = i10 + 8 | 0;
+ i36 = i10 + 12 | 0;
+ i35 = i10 + 16 | 0;
+ i37 = i10 + 20 | 0;
+ i33 = i10 + 4 | 0;
+ i26 = i5 + 56 | 0;
+ i25 = i5 + 64 | 0;
+ i24 = i5 + 68 | 0;
+ i23 = i5 + 72 | 0;
+ i20 = i5 + 80 | 0;
+ i19 = i5 + 84 | 0;
+ i21 = i7 + 16 | 0;
+ d30 = d28 + .0012499999720603228;
+ d31 = d28 + -.0012499999720603228;
+ d48 = d40;
+ i39 = 0;
+ d40 = 0.0;
+ L4 : while (1) {
+ d56 = 1.0 - d40;
+ d49 = d56 * d42 + d40 * d43;
+ d43 = +Math_sin(+d49);
+ d49 = +Math_cos(+d49);
+ d55 = +HEAPF32[i12 >> 2];
+ d54 = +HEAPF32[i32 >> 2];
+ d42 = d56 * d46 + d40 * d48;
+ d53 = +Math_sin(+d42);
+ d42 = +Math_cos(+d42);
+ d46 = +HEAPF32[i10 >> 2];
+ d51 = +HEAPF32[i33 >> 2];
+ d50 = d56 * +HEAPF32[i34 >> 2] + d40 * +HEAPF32[i35 >> 2] - (d42 * d46 - d53 * d51);
+ d51 = d56 * +HEAPF32[i36 >> 2] + d40 * +HEAPF32[i37 >> 2] - (d53 * d46 + d42 * d51);
+ d46 = +(d56 * +HEAPF32[i38 >> 2] + d40 * +HEAPF32[i29 >> 2] - (d49 * d55 - d43 * d54));
+ d48 = +(d56 * +HEAPF32[i27 >> 2] + d40 * +HEAPF32[i22 >> 2] - (d43 * d55 + d49 * d54));
+ i52 = i26;
+ HEAPF32[i52 >> 2] = d46;
+ HEAPF32[i52 + 4 >> 2] = d48;
+ HEAPF32[i25 >> 2] = d43;
+ HEAPF32[i24 >> 2] = d49;
+ d50 = +d50;
+ d51 = +d51;
+ i52 = i23;
+ HEAPF32[i52 >> 2] = d50;
+ HEAPF32[i52 + 4 >> 2] = d51;
+ HEAPF32[i20 >> 2] = d53;
+ HEAPF32[i19 >> 2] = d42;
+ __Z10b2DistanceP16b2DistanceOutputP14b2SimplexCachePK15b2DistanceInput(i7, i13, i5);
+ d42 = +HEAPF32[i21 >> 2];
+ if (d42 <= 0.0) {
+ i4 = 5;
+ break;
+ }
+ if (d42 < d30) {
+ i4 = 7;
+ break;
+ }
+ +__ZN20b2SeparationFunction10InitializeEPK14b2SimplexCachePK15b2DistanceProxyRK7b2SweepS5_S8_f(i8, i13, i11, i12, i6, i10, d40);
+ i41 = 0;
+ d42 = d14;
+ do {
+ d50 = +__ZNK20b2SeparationFunction17FindMinSeparationEPiS0_f(i8, i9, i4, d42);
+ if (d50 > d30) {
+ i4 = 10;
+ break L4;
+ }
+ if (d50 > d31) {
+ d40 = d42;
+ break;
+ }
+ i45 = HEAP32[i9 >> 2] | 0;
+ i44 = HEAP32[i4 >> 2] | 0;
+ d48 = +__ZNK20b2SeparationFunction8EvaluateEiif(i8, i45, i44, d40);
+ if (d48 < d31) {
+ i4 = 13;
+ break L4;
+ }
+ if (!(d48 <= d30)) {
+ d43 = d40;
+ d46 = d42;
+ i47 = 0;
+ } else {
+ i4 = 15;
+ break L4;
+ }
+ while (1) {
+ if ((i47 & 1 | 0) == 0) {
+ d49 = (d43 + d46) * .5;
+ } else {
+ d49 = d43 + (d28 - d48) * (d46 - d43) / (d50 - d48);
+ }
+ d51 = +__ZNK20b2SeparationFunction8EvaluateEiif(i8, i45, i44, d49);
+ d53 = d51 - d28;
+ if (!(d53 > 0.0)) {
+ d53 = -d53;
+ }
+ if (d53 < .0012499999720603228) {
+ d42 = d49;
+ break;
+ }
+ i52 = d51 > d28;
+ i47 = i47 + 1 | 0;
+ HEAP32[880] = (HEAP32[880] | 0) + 1;
+ if ((i47 | 0) == 50) {
+ i47 = 50;
+ break;
+ } else {
+ d43 = i52 ? d49 : d43;
+ d46 = i52 ? d46 : d49;
+ d48 = i52 ? d51 : d48;
+ d50 = i52 ? d50 : d51;
+ }
+ }
+ i44 = HEAP32[882] | 0;
+ HEAP32[882] = (i44 | 0) > (i47 | 0) ? i44 : i47;
+ i41 = i41 + 1 | 0;
+ } while ((i41 | 0) != 8);
+ i39 = i39 + 1 | 0;
+ HEAP32[876] = (HEAP32[876] | 0) + 1;
+ if ((i39 | 0) == 20) {
+ i4 = 27;
+ break;
+ }
+ d42 = +HEAPF32[i15 >> 2];
+ d43 = +HEAPF32[i16 >> 2];
+ d46 = +HEAPF32[i17 >> 2];
+ d48 = +HEAPF32[i18 >> 2];
+ }
+ if ((i4 | 0) == 5) {
+ HEAP32[i3 >> 2] = 2;
+ HEAPF32[i2 >> 2] = 0.0;
+ i2 = HEAP32[878] | 0;
+ i52 = (i2 | 0) > (i39 | 0);
+ i52 = i52 ? i2 : i39;
+ HEAP32[878] = i52;
+ STACKTOP = i1;
+ return;
+ } else if ((i4 | 0) == 7) {
+ HEAP32[i3 >> 2] = 3;
+ HEAPF32[i2 >> 2] = d40;
+ i2 = HEAP32[878] | 0;
+ i52 = (i2 | 0) > (i39 | 0);
+ i52 = i52 ? i2 : i39;
+ HEAP32[878] = i52;
+ STACKTOP = i1;
+ return;
+ } else if ((i4 | 0) == 10) {
+ HEAP32[i3 >> 2] = 4;
+ HEAPF32[i2 >> 2] = d14;
+ } else if ((i4 | 0) == 13) {
+ HEAP32[i3 >> 2] = 1;
+ HEAPF32[i2 >> 2] = d40;
+ } else if ((i4 | 0) == 15) {
+ HEAP32[i3 >> 2] = 3;
+ HEAPF32[i2 >> 2] = d40;
+ } else if ((i4 | 0) == 27) {
+ HEAP32[i3 >> 2] = 1;
+ HEAPF32[i2 >> 2] = d40;
+ i39 = 20;
+ i2 = HEAP32[878] | 0;
+ i52 = (i2 | 0) > (i39 | 0);
+ i52 = i52 ? i2 : i39;
+ HEAP32[878] = i52;
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[876] = (HEAP32[876] | 0) + 1;
+ i39 = i39 + 1 | 0;
+ i2 = HEAP32[878] | 0;
+ i52 = (i2 | 0) > (i39 | 0);
+ i52 = i52 ? i2 : i39;
+ HEAP32[878] = i52;
+ STACKTOP = i1;
+ return;
+}
+function __ZN7b2World5SolveERK10b2TimeStep(i5, i15) {
+ i5 = i5 | 0;
+ i15 = i15 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0, i38 = 0, d39 = 0.0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 96 | 0;
+ i4 = i3 + 32 | 0;
+ i9 = i3;
+ i2 = i3 + 84 | 0;
+ i11 = i5 + 103008 | 0;
+ HEAPF32[i11 >> 2] = 0.0;
+ i14 = i5 + 103012 | 0;
+ HEAPF32[i14 >> 2] = 0.0;
+ i8 = i5 + 103016 | 0;
+ HEAPF32[i8 >> 2] = 0.0;
+ i16 = i5 + 102960 | 0;
+ i1 = i5 + 102872 | 0;
+ i6 = i5 + 68 | 0;
+ __ZN8b2IslandC2EiiiP16b2StackAllocatorP17b2ContactListener(i4, HEAP32[i16 >> 2] | 0, HEAP32[i5 + 102936 >> 2] | 0, HEAP32[i5 + 102964 >> 2] | 0, i6, HEAP32[i5 + 102944 >> 2] | 0);
+ i7 = i5 + 102952 | 0;
+ i17 = HEAP32[i7 >> 2] | 0;
+ if ((i17 | 0) != 0) {
+ do {
+ i38 = i17 + 4 | 0;
+ HEAP16[i38 >> 1] = HEAP16[i38 >> 1] & 65534;
+ i17 = HEAP32[i17 + 96 >> 2] | 0;
+ } while ((i17 | 0) != 0);
+ }
+ i17 = HEAP32[i5 + 102932 >> 2] | 0;
+ if ((i17 | 0) != 0) {
+ do {
+ i38 = i17 + 4 | 0;
+ HEAP32[i38 >> 2] = HEAP32[i38 >> 2] & -2;
+ i17 = HEAP32[i17 + 12 >> 2] | 0;
+ } while ((i17 | 0) != 0);
+ }
+ i17 = HEAP32[i5 + 102956 >> 2] | 0;
+ if ((i17 | 0) != 0) {
+ do {
+ HEAP8[i17 + 60 | 0] = 0;
+ i17 = HEAP32[i17 + 12 >> 2] | 0;
+ } while ((i17 | 0) != 0);
+ }
+ i24 = HEAP32[i16 >> 2] | 0;
+ i16 = __ZN16b2StackAllocator8AllocateEi(i6, i24 << 2) | 0;
+ i32 = HEAP32[i7 >> 2] | 0;
+ L13 : do {
+ if ((i32 | 0) != 0) {
+ i18 = i4 + 28 | 0;
+ i30 = i4 + 36 | 0;
+ i27 = i4 + 32 | 0;
+ i17 = i4 + 40 | 0;
+ i23 = i4 + 8 | 0;
+ i29 = i4 + 48 | 0;
+ i28 = i4 + 16 | 0;
+ i26 = i4 + 44 | 0;
+ i31 = i4 + 12 | 0;
+ i25 = i5 + 102968 | 0;
+ i22 = i5 + 102976 | 0;
+ i21 = i9 + 12 | 0;
+ i20 = i9 + 16 | 0;
+ i19 = i9 + 20 | 0;
+ L15 : while (1) {
+ i33 = i32 + 4 | 0;
+ i34 = HEAP16[i33 >> 1] | 0;
+ if ((i34 & 35) == 34 ? (HEAP32[i32 >> 2] | 0) != 0 : 0) {
+ HEAP32[i18 >> 2] = 0;
+ HEAP32[i30 >> 2] = 0;
+ HEAP32[i27 >> 2] = 0;
+ HEAP32[i16 >> 2] = i32;
+ HEAP16[i33 >> 1] = i34 & 65535 | 1;
+ i35 = 1;
+ do {
+ i35 = i35 + -1 | 0;
+ i33 = HEAP32[i16 + (i35 << 2) >> 2] | 0;
+ i34 = i33 + 4 | 0;
+ i36 = HEAP16[i34 >> 1] | 0;
+ if ((i36 & 32) == 0) {
+ i8 = 13;
+ break L15;
+ }
+ i37 = HEAP32[i18 >> 2] | 0;
+ if ((i37 | 0) >= (HEAP32[i17 >> 2] | 0)) {
+ i8 = 15;
+ break L15;
+ }
+ HEAP32[i33 + 8 >> 2] = i37;
+ i38 = HEAP32[i18 >> 2] | 0;
+ HEAP32[(HEAP32[i23 >> 2] | 0) + (i38 << 2) >> 2] = i33;
+ HEAP32[i18 >> 2] = i38 + 1;
+ i36 = i36 & 65535;
+ if ((i36 & 2 | 0) == 0) {
+ HEAP16[i34 >> 1] = i36 | 2;
+ HEAPF32[i33 + 144 >> 2] = 0.0;
+ }
+ if ((HEAP32[i33 >> 2] | 0) != 0) {
+ i34 = HEAP32[i33 + 112 >> 2] | 0;
+ if ((i34 | 0) != 0) {
+ do {
+ i38 = HEAP32[i34 + 4 >> 2] | 0;
+ i36 = i38 + 4 | 0;
+ if (((HEAP32[i36 >> 2] & 7 | 0) == 6 ? (HEAP8[(HEAP32[i38 + 48 >> 2] | 0) + 38 | 0] | 0) == 0 : 0) ? (HEAP8[(HEAP32[i38 + 52 >> 2] | 0) + 38 | 0] | 0) == 0 : 0) {
+ i37 = HEAP32[i30 >> 2] | 0;
+ if ((i37 | 0) >= (HEAP32[i26 >> 2] | 0)) {
+ i8 = 25;
+ break L15;
+ }
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP32[(HEAP32[i31 >> 2] | 0) + (i37 << 2) >> 2] = i38;
+ HEAP32[i36 >> 2] = HEAP32[i36 >> 2] | 1;
+ i38 = HEAP32[i34 >> 2] | 0;
+ i36 = i38 + 4 | 0;
+ i37 = HEAP16[i36 >> 1] | 0;
+ if ((i37 & 1) == 0) {
+ if ((i35 | 0) >= (i24 | 0)) {
+ i8 = 28;
+ break L15;
+ }
+ HEAP32[i16 + (i35 << 2) >> 2] = i38;
+ HEAP16[i36 >> 1] = i37 & 65535 | 1;
+ i35 = i35 + 1 | 0;
+ }
+ }
+ i34 = HEAP32[i34 + 12 >> 2] | 0;
+ } while ((i34 | 0) != 0);
+ }
+ i33 = HEAP32[i33 + 108 >> 2] | 0;
+ if ((i33 | 0) != 0) {
+ do {
+ i37 = i33 + 4 | 0;
+ i36 = HEAP32[i37 >> 2] | 0;
+ if ((HEAP8[i36 + 60 | 0] | 0) == 0 ? (i10 = HEAP32[i33 >> 2] | 0, i13 = i10 + 4 | 0, i12 = HEAP16[i13 >> 1] | 0, !((i12 & 32) == 0)) : 0) {
+ i34 = HEAP32[i27 >> 2] | 0;
+ if ((i34 | 0) >= (HEAP32[i29 >> 2] | 0)) {
+ i8 = 35;
+ break L15;
+ }
+ HEAP32[i27 >> 2] = i34 + 1;
+ HEAP32[(HEAP32[i28 >> 2] | 0) + (i34 << 2) >> 2] = i36;
+ HEAP8[(HEAP32[i37 >> 2] | 0) + 60 | 0] = 1;
+ if ((i12 & 1) == 0) {
+ if ((i35 | 0) >= (i24 | 0)) {
+ i8 = 38;
+ break L15;
+ }
+ HEAP32[i16 + (i35 << 2) >> 2] = i10;
+ HEAP16[i13 >> 1] = i12 & 65535 | 1;
+ i35 = i35 + 1 | 0;
+ }
+ }
+ i33 = HEAP32[i33 + 12 >> 2] | 0;
+ } while ((i33 | 0) != 0);
+ }
+ }
+ } while ((i35 | 0) > 0);
+ __ZN8b2Island5SolveEP9b2ProfileRK10b2TimeStepRK6b2Vec2b(i4, i9, i15, i25, (HEAP8[i22] | 0) != 0);
+ HEAPF32[i11 >> 2] = +HEAPF32[i21 >> 2] + +HEAPF32[i11 >> 2];
+ HEAPF32[i14 >> 2] = +HEAPF32[i20 >> 2] + +HEAPF32[i14 >> 2];
+ HEAPF32[i8 >> 2] = +HEAPF32[i19 >> 2] + +HEAPF32[i8 >> 2];
+ i35 = HEAP32[i18 >> 2] | 0;
+ if ((i35 | 0) > 0) {
+ i33 = HEAP32[i23 >> 2] | 0;
+ i36 = 0;
+ do {
+ i34 = HEAP32[i33 + (i36 << 2) >> 2] | 0;
+ if ((HEAP32[i34 >> 2] | 0) == 0) {
+ i38 = i34 + 4 | 0;
+ HEAP16[i38 >> 1] = HEAP16[i38 >> 1] & 65534;
+ }
+ i36 = i36 + 1 | 0;
+ } while ((i36 | 0) < (i35 | 0));
+ }
+ }
+ i32 = HEAP32[i32 + 96 >> 2] | 0;
+ if ((i32 | 0) == 0) {
+ break L13;
+ }
+ }
+ if ((i8 | 0) == 13) {
+ ___assert_fail(2232, 2184, 445, 2256);
+ } else if ((i8 | 0) == 15) {
+ ___assert_fail(2520, 2440, 54, 2472);
+ } else if ((i8 | 0) == 25) {
+ ___assert_fail(2480, 2440, 62, 2472);
+ } else if ((i8 | 0) == 28) {
+ ___assert_fail(2264, 2184, 495, 2256);
+ } else if ((i8 | 0) == 35) {
+ ___assert_fail(2408, 2440, 68, 2472);
+ } else if ((i8 | 0) == 38) {
+ ___assert_fail(2264, 2184, 524, 2256);
+ }
+ }
+ } while (0);
+ __ZN16b2StackAllocator4FreeEPv(i6, i16);
+ __ZN7b2TimerC2Ev(i2);
+ i6 = HEAP32[i7 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ __ZN16b2ContactManager15FindNewContactsEv(i1);
+ d39 = +__ZNK7b2Timer15GetMillisecondsEv(i2);
+ i38 = i5 + 103020 | 0;
+ HEAPF32[i38 >> 2] = d39;
+ __ZN8b2IslandD2Ev(i4);
+ STACKTOP = i3;
+ return;
+ }
+ do {
+ if (!((HEAP16[i6 + 4 >> 1] & 1) == 0) ? (HEAP32[i6 >> 2] | 0) != 0 : 0) {
+ __ZN6b2Body19SynchronizeFixturesEv(i6);
+ }
+ i6 = HEAP32[i6 + 96 >> 2] | 0;
+ } while ((i6 | 0) != 0);
+ __ZN16b2ContactManager15FindNewContactsEv(i1);
+ d39 = +__ZNK7b2Timer15GetMillisecondsEv(i2);
+ i38 = i5 + 103020 | 0;
+ HEAPF32[i38 >> 2] = d39;
+ __ZN8b2IslandD2Ev(i4);
+ STACKTOP = i3;
+ return;
+}
+function __ZN15b2ContactSolver29InitializeVelocityConstraintsEv(i10) {
+ i10 = i10 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, d27 = 0.0, d28 = 0.0, d29 = 0.0, d30 = 0.0, i31 = 0, d32 = 0.0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0, d38 = 0.0, d39 = 0.0, d40 = 0.0, d41 = 0.0, i42 = 0, d43 = 0.0, d44 = 0.0, d45 = 0.0, d46 = 0.0, d47 = 0.0, d48 = 0.0, i49 = 0, i50 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i8 = i1 + 40 | 0;
+ i3 = i1 + 24 | 0;
+ i5 = i1;
+ i4 = i10 + 48 | 0;
+ if ((HEAP32[i4 >> 2] | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i9 = i10 + 40 | 0;
+ i2 = i10 + 36 | 0;
+ i7 = i10 + 44 | 0;
+ i6 = i10 + 24 | 0;
+ i13 = i10 + 28 | 0;
+ i14 = i8 + 8 | 0;
+ i12 = i8 + 12 | 0;
+ i11 = i3 + 8 | 0;
+ i10 = i3 + 12 | 0;
+ i16 = 0;
+ while (1) {
+ i15 = HEAP32[i9 >> 2] | 0;
+ i33 = HEAP32[i2 >> 2] | 0;
+ i31 = HEAP32[(HEAP32[i7 >> 2] | 0) + (HEAP32[i15 + (i16 * 152 | 0) + 148 >> 2] << 2) >> 2] | 0;
+ i35 = HEAP32[i15 + (i16 * 152 | 0) + 112 >> 2] | 0;
+ i42 = HEAP32[i15 + (i16 * 152 | 0) + 116 >> 2] | 0;
+ d30 = +HEAPF32[i15 + (i16 * 152 | 0) + 120 >> 2];
+ d24 = +HEAPF32[i15 + (i16 * 152 | 0) + 124 >> 2];
+ d17 = +HEAPF32[i15 + (i16 * 152 | 0) + 128 >> 2];
+ d18 = +HEAPF32[i15 + (i16 * 152 | 0) + 132 >> 2];
+ i36 = i33 + (i16 * 88 | 0) + 48 | 0;
+ d39 = +HEAPF32[i36 >> 2];
+ d40 = +HEAPF32[i36 + 4 >> 2];
+ i36 = i33 + (i16 * 88 | 0) + 56 | 0;
+ d41 = +HEAPF32[i36 >> 2];
+ d43 = +HEAPF32[i36 + 4 >> 2];
+ i36 = HEAP32[i6 >> 2] | 0;
+ i37 = i36 + (i35 * 12 | 0) | 0;
+ d26 = +HEAPF32[i37 >> 2];
+ d27 = +HEAPF32[i37 + 4 >> 2];
+ d32 = +HEAPF32[i36 + (i35 * 12 | 0) + 8 >> 2];
+ i37 = HEAP32[i13 >> 2] | 0;
+ i34 = i37 + (i35 * 12 | 0) | 0;
+ d22 = +HEAPF32[i34 >> 2];
+ d25 = +HEAPF32[i34 + 4 >> 2];
+ d23 = +HEAPF32[i37 + (i35 * 12 | 0) + 8 >> 2];
+ i35 = i36 + (i42 * 12 | 0) | 0;
+ d28 = +HEAPF32[i35 >> 2];
+ d29 = +HEAPF32[i35 + 4 >> 2];
+ d38 = +HEAPF32[i36 + (i42 * 12 | 0) + 8 >> 2];
+ i36 = i37 + (i42 * 12 | 0) | 0;
+ d20 = +HEAPF32[i36 >> 2];
+ d19 = +HEAPF32[i36 + 4 >> 2];
+ d21 = +HEAPF32[i37 + (i42 * 12 | 0) + 8 >> 2];
+ if ((HEAP32[i31 + 124 >> 2] | 0) <= 0) {
+ i2 = 4;
+ break;
+ }
+ d44 = +HEAPF32[i33 + (i16 * 88 | 0) + 80 >> 2];
+ d45 = +HEAPF32[i33 + (i16 * 88 | 0) + 76 >> 2];
+ d47 = +Math_sin(+d32);
+ HEAPF32[i14 >> 2] = d47;
+ d48 = +Math_cos(+d32);
+ HEAPF32[i12 >> 2] = d48;
+ d32 = +Math_sin(+d38);
+ HEAPF32[i11 >> 2] = d32;
+ d38 = +Math_cos(+d38);
+ HEAPF32[i10 >> 2] = d38;
+ d46 = +(d26 - (d39 * d48 - d40 * d47));
+ d40 = +(d27 - (d40 * d48 + d39 * d47));
+ i37 = i8;
+ HEAPF32[i37 >> 2] = d46;
+ HEAPF32[i37 + 4 >> 2] = d40;
+ d40 = +(d28 - (d41 * d38 - d43 * d32));
+ d43 = +(d29 - (d43 * d38 + d41 * d32));
+ i37 = i3;
+ HEAPF32[i37 >> 2] = d40;
+ HEAPF32[i37 + 4 >> 2] = d43;
+ __ZN15b2WorldManifold10InitializeEPK10b2ManifoldRK11b2TransformfS5_f(i5, i31 + 64 | 0, i8, d45, i3, d44);
+ i37 = i15 + (i16 * 152 | 0) + 72 | 0;
+ i42 = i5;
+ i33 = HEAP32[i42 + 4 >> 2] | 0;
+ i31 = i37;
+ HEAP32[i31 >> 2] = HEAP32[i42 >> 2];
+ HEAP32[i31 + 4 >> 2] = i33;
+ i31 = i15 + (i16 * 152 | 0) + 144 | 0;
+ i33 = HEAP32[i31 >> 2] | 0;
+ do {
+ if ((i33 | 0) > 0) {
+ i36 = i15 + (i16 * 152 | 0) + 76 | 0;
+ d32 = d30 + d24;
+ i35 = i15 + (i16 * 152 | 0) + 140 | 0;
+ i34 = 0;
+ do {
+ i49 = i5 + (i34 << 3) + 8 | 0;
+ d41 = +HEAPF32[i49 >> 2] - d26;
+ i42 = i5 + (i34 << 3) + 12 | 0;
+ d39 = +d41;
+ d40 = +(+HEAPF32[i42 >> 2] - d27);
+ i50 = i15 + (i16 * 152 | 0) + (i34 * 36 | 0) | 0;
+ HEAPF32[i50 >> 2] = d39;
+ HEAPF32[i50 + 4 >> 2] = d40;
+ d40 = +HEAPF32[i49 >> 2] - d28;
+ d39 = +d40;
+ d47 = +(+HEAPF32[i42 >> 2] - d29);
+ i42 = i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 8 | 0;
+ HEAPF32[i42 >> 2] = d39;
+ HEAPF32[i42 + 4 >> 2] = d47;
+ d47 = +HEAPF32[i36 >> 2];
+ d39 = +HEAPF32[i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 4 >> 2];
+ d43 = +HEAPF32[i37 >> 2];
+ d48 = d41 * d47 - d39 * d43;
+ d38 = +HEAPF32[i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 12 >> 2];
+ d43 = d47 * d40 - d43 * d38;
+ d43 = d32 + d48 * d17 * d48 + d43 * d18 * d43;
+ if (d43 > 0.0) {
+ d43 = 1.0 / d43;
+ } else {
+ d43 = 0.0;
+ }
+ HEAPF32[i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 24 >> 2] = d43;
+ d43 = +HEAPF32[i36 >> 2];
+ d47 = -+HEAPF32[i37 >> 2];
+ d48 = d41 * d47 - d43 * d39;
+ d43 = d40 * d47 - d43 * d38;
+ d43 = d32 + d48 * d17 * d48 + d43 * d18 * d43;
+ if (d43 > 0.0) {
+ d43 = 1.0 / d43;
+ } else {
+ d43 = 0.0;
+ }
+ HEAPF32[i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 28 >> 2] = d43;
+ i42 = i15 + (i16 * 152 | 0) + (i34 * 36 | 0) + 32 | 0;
+ HEAPF32[i42 >> 2] = 0.0;
+ d38 = +HEAPF32[i37 >> 2] * (d20 - d21 * d38 - d22 + d23 * d39) + +HEAPF32[i36 >> 2] * (d19 + d21 * d40 - d25 - d23 * d41);
+ if (d38 < -1.0) {
+ HEAPF32[i42 >> 2] = -(d38 * +HEAPF32[i35 >> 2]);
+ }
+ i34 = i34 + 1 | 0;
+ } while ((i34 | 0) != (i33 | 0));
+ if ((HEAP32[i31 >> 2] | 0) == 2) {
+ d45 = +HEAPF32[i15 + (i16 * 152 | 0) + 76 >> 2];
+ d20 = +HEAPF32[i37 >> 2];
+ d44 = +HEAPF32[i15 + (i16 * 152 | 0) >> 2] * d45 - +HEAPF32[i15 + (i16 * 152 | 0) + 4 >> 2] * d20;
+ d19 = d45 * +HEAPF32[i15 + (i16 * 152 | 0) + 8 >> 2] - d20 * +HEAPF32[i15 + (i16 * 152 | 0) + 12 >> 2];
+ d47 = d45 * +HEAPF32[i15 + (i16 * 152 | 0) + 36 >> 2] - d20 * +HEAPF32[i15 + (i16 * 152 | 0) + 40 >> 2];
+ d20 = d45 * +HEAPF32[i15 + (i16 * 152 | 0) + 44 >> 2] - d20 * +HEAPF32[i15 + (i16 * 152 | 0) + 48 >> 2];
+ d45 = d30 + d24;
+ d46 = d17 * d44;
+ d48 = d18 * d19;
+ d19 = d45 + d44 * d46 + d19 * d48;
+ d18 = d45 + d47 * d17 * d47 + d20 * d18 * d20;
+ d17 = d45 + d46 * d47 + d48 * d20;
+ d20 = d19 * d18 - d17 * d17;
+ if (!(d19 * d19 < d20 * 1.0e3)) {
+ HEAP32[i31 >> 2] = 1;
+ break;
+ }
+ HEAPF32[i15 + (i16 * 152 | 0) + 96 >> 2] = d19;
+ HEAPF32[i15 + (i16 * 152 | 0) + 100 >> 2] = d17;
+ HEAPF32[i15 + (i16 * 152 | 0) + 104 >> 2] = d17;
+ HEAPF32[i15 + (i16 * 152 | 0) + 108 >> 2] = d18;
+ if (d20 != 0.0) {
+ d20 = 1.0 / d20;
+ }
+ d48 = -(d20 * d17);
+ HEAPF32[i15 + (i16 * 152 | 0) + 80 >> 2] = d18 * d20;
+ HEAPF32[i15 + (i16 * 152 | 0) + 84 >> 2] = d48;
+ HEAPF32[i15 + (i16 * 152 | 0) + 88 >> 2] = d48;
+ HEAPF32[i15 + (i16 * 152 | 0) + 92 >> 2] = d19 * d20;
+ }
+ }
+ } while (0);
+ i16 = i16 + 1 | 0;
+ if ((i16 | 0) >= (HEAP32[i4 >> 2] | 0)) {
+ i2 = 21;
+ break;
+ }
+ }
+ if ((i2 | 0) == 4) {
+ ___assert_fail(6584, 6520, 168, 6616);
+ } else if ((i2 | 0) == 21) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function __Z17b2CollidePolygonsP10b2ManifoldPK14b2PolygonShapeRK11b2TransformS3_S6_(i5, i27, i28, i24, i14) {
+ i5 = i5 | 0;
+ i27 = i27 | 0;
+ i28 = i28 | 0;
+ i24 = i24 | 0;
+ i14 = i14 | 0;
+ var i1 = 0, i2 = 0, d3 = 0.0, i4 = 0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d9 = 0.0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d15 = 0.0, d16 = 0.0, i17 = 0, d18 = 0.0, d19 = 0.0, i20 = 0, d21 = 0.0, d22 = 0.0, d23 = 0.0, d25 = 0.0, d26 = 0.0, d29 = 0.0, d30 = 0.0, i31 = 0, d32 = 0.0, i33 = 0, i34 = 0, d35 = 0.0, d36 = 0.0, d37 = 0.0, d38 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 96 | 0;
+ i17 = i1 + 92 | 0;
+ i20 = i1 + 88 | 0;
+ i13 = i1;
+ i11 = i1 + 80 | 0;
+ i12 = i1 + 56 | 0;
+ i4 = i1 + 32 | 0;
+ i10 = i1 + 24 | 0;
+ i2 = i5 + 60 | 0;
+ HEAP32[i2 >> 2] = 0;
+ d3 = +HEAPF32[i27 + 8 >> 2] + +HEAPF32[i24 + 8 >> 2];
+ HEAP32[i17 >> 2] = 0;
+ d7 = +__ZL19b2FindMaxSeparationPiPK14b2PolygonShapeRK11b2TransformS2_S5_(i17, i27, i28, i24, i14);
+ if (d7 > d3) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i20 >> 2] = 0;
+ d6 = +__ZL19b2FindMaxSeparationPiPK14b2PolygonShapeRK11b2TransformS2_S5_(i20, i24, i14, i27, i28);
+ if (d6 > d3) {
+ STACKTOP = i1;
+ return;
+ }
+ if (d6 > d7 * .9800000190734863 + .0010000000474974513) {
+ d18 = +HEAPF32[i14 >> 2];
+ d19 = +HEAPF32[i14 + 4 >> 2];
+ d15 = +HEAPF32[i14 + 8 >> 2];
+ d16 = +HEAPF32[i14 + 12 >> 2];
+ d9 = +HEAPF32[i28 >> 2];
+ d6 = +HEAPF32[i28 + 4 >> 2];
+ d7 = +HEAPF32[i28 + 8 >> 2];
+ d8 = +HEAPF32[i28 + 12 >> 2];
+ i17 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i5 + 56 >> 2] = 2;
+ i14 = 1;
+ i20 = i24;
+ } else {
+ d18 = +HEAPF32[i28 >> 2];
+ d19 = +HEAPF32[i28 + 4 >> 2];
+ d15 = +HEAPF32[i28 + 8 >> 2];
+ d16 = +HEAPF32[i28 + 12 >> 2];
+ d9 = +HEAPF32[i14 >> 2];
+ d6 = +HEAPF32[i14 + 4 >> 2];
+ d7 = +HEAPF32[i14 + 8 >> 2];
+ d8 = +HEAPF32[i14 + 12 >> 2];
+ i17 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i5 + 56 >> 2] = 1;
+ i14 = 0;
+ i20 = i27;
+ i27 = i24;
+ }
+ i28 = HEAP32[i27 + 148 >> 2] | 0;
+ if (!((i17 | 0) > -1)) {
+ ___assert_fail(5640, 5688, 151, 5728);
+ }
+ i24 = HEAP32[i20 + 148 >> 2] | 0;
+ if ((i24 | 0) <= (i17 | 0)) {
+ ___assert_fail(5640, 5688, 151, 5728);
+ }
+ d21 = +HEAPF32[i20 + (i17 << 3) + 84 >> 2];
+ d36 = +HEAPF32[i20 + (i17 << 3) + 88 >> 2];
+ d22 = d16 * d21 - d15 * d36;
+ d36 = d15 * d21 + d16 * d36;
+ d21 = d8 * d22 + d7 * d36;
+ d22 = d8 * d36 - d7 * d22;
+ if ((i28 | 0) > 0) {
+ i33 = 0;
+ i34 = 0;
+ d23 = 3.4028234663852886e+38;
+ while (1) {
+ d25 = d21 * +HEAPF32[i27 + (i33 << 3) + 84 >> 2] + d22 * +HEAPF32[i27 + (i33 << 3) + 88 >> 2];
+ i31 = d25 < d23;
+ i34 = i31 ? i33 : i34;
+ i33 = i33 + 1 | 0;
+ if ((i33 | 0) == (i28 | 0)) {
+ break;
+ } else {
+ d23 = i31 ? d25 : d23;
+ }
+ }
+ } else {
+ i34 = 0;
+ }
+ i31 = i34 + 1 | 0;
+ i33 = (i31 | 0) < (i28 | 0) ? i31 : 0;
+ d35 = +HEAPF32[i27 + (i34 << 3) + 20 >> 2];
+ d32 = +HEAPF32[i27 + (i34 << 3) + 24 >> 2];
+ d36 = +(d9 + (d8 * d35 - d7 * d32));
+ d32 = +(d6 + (d7 * d35 + d8 * d32));
+ i31 = i13;
+ HEAPF32[i31 >> 2] = d36;
+ HEAPF32[i31 + 4 >> 2] = d32;
+ i31 = i17 & 255;
+ i28 = i13 + 8 | 0;
+ HEAP8[i28] = i31;
+ HEAP8[i28 + 1 | 0] = i34;
+ HEAP8[i28 + 2 | 0] = 1;
+ HEAP8[i28 + 3 | 0] = 0;
+ d32 = +HEAPF32[i27 + (i33 << 3) + 20 >> 2];
+ d36 = +HEAPF32[i27 + (i33 << 3) + 24 >> 2];
+ d35 = +(d9 + (d8 * d32 - d7 * d36));
+ d36 = +(d6 + (d7 * d32 + d8 * d36));
+ i27 = i13 + 12 | 0;
+ HEAPF32[i27 >> 2] = d35;
+ HEAPF32[i27 + 4 >> 2] = d36;
+ i27 = i13 + 20 | 0;
+ HEAP8[i27] = i31;
+ HEAP8[i27 + 1 | 0] = i33;
+ HEAP8[i27 + 2 | 0] = 1;
+ HEAP8[i27 + 3 | 0] = 0;
+ i27 = i17 + 1 | 0;
+ i24 = (i27 | 0) < (i24 | 0) ? i27 : 0;
+ i34 = i20 + (i17 << 3) + 20 | 0;
+ d26 = +HEAPF32[i34 >> 2];
+ d25 = +HEAPF32[i34 + 4 >> 2];
+ i34 = i20 + (i24 << 3) + 20 | 0;
+ d30 = +HEAPF32[i34 >> 2];
+ d29 = +HEAPF32[i34 + 4 >> 2];
+ d32 = d30 - d26;
+ d35 = d29 - d25;
+ d21 = +Math_sqrt(+(d32 * d32 + d35 * d35));
+ if (!(d21 < 1.1920928955078125e-7)) {
+ d36 = 1.0 / d21;
+ d32 = d32 * d36;
+ d35 = d35 * d36;
+ }
+ d36 = d16 * d32 - d15 * d35;
+ d21 = d16 * d35 + d15 * d32;
+ HEAPF32[i11 >> 2] = d36;
+ HEAPF32[i11 + 4 >> 2] = d21;
+ d22 = -d36;
+ d38 = d18 + (d16 * d26 - d15 * d25);
+ d37 = d19 + (d15 * d26 + d16 * d25);
+ d23 = d38 * d21 + d37 * d22;
+ HEAPF32[i10 >> 2] = d22;
+ HEAPF32[i10 + 4 >> 2] = -d21;
+ if ((__Z19b2ClipSegmentToLineP12b2ClipVertexPKS_RK6b2Vec2fi(i12, i13, i10, d3 - (d38 * d36 + d37 * d21), i17) | 0) < 2) {
+ STACKTOP = i1;
+ return;
+ }
+ if ((__Z19b2ClipSegmentToLineP12b2ClipVertexPKS_RK6b2Vec2fi(i4, i12, i11, d3 + ((d18 + (d16 * d30 - d15 * d29)) * d36 + (d19 + (d15 * d30 + d16 * d29)) * d21), i24) | 0) < 2) {
+ STACKTOP = i1;
+ return;
+ }
+ d16 = +d35;
+ d15 = +-d32;
+ i10 = i5 + 40 | 0;
+ HEAPF32[i10 >> 2] = d16;
+ HEAPF32[i10 + 4 >> 2] = d15;
+ d15 = +((d26 + d30) * .5);
+ d16 = +((d25 + d29) * .5);
+ i10 = i5 + 48 | 0;
+ HEAPF32[i10 >> 2] = d15;
+ HEAPF32[i10 + 4 >> 2] = d16;
+ d16 = +HEAPF32[i4 >> 2];
+ d15 = +HEAPF32[i4 + 4 >> 2];
+ i10 = !(d21 * d16 + d15 * d22 - d23 <= d3);
+ if (i14 << 24 >> 24 == 0) {
+ if (i10) {
+ i10 = 0;
+ } else {
+ d38 = d16 - d9;
+ d36 = d15 - d6;
+ d37 = +(d8 * d38 + d7 * d36);
+ d38 = +(d8 * d36 - d7 * d38);
+ i10 = i5;
+ HEAPF32[i10 >> 2] = d37;
+ HEAPF32[i10 + 4 >> 2] = d38;
+ HEAP32[i5 + 16 >> 2] = HEAP32[i4 + 8 >> 2];
+ i10 = 1;
+ }
+ d16 = +HEAPF32[i4 + 12 >> 2];
+ d15 = +HEAPF32[i4 + 16 >> 2];
+ if (d21 * d16 + d15 * d22 - d23 <= d3) {
+ d38 = d16 - d9;
+ d36 = d15 - d6;
+ d37 = +(d8 * d38 + d7 * d36);
+ d38 = +(d8 * d36 - d7 * d38);
+ i34 = i5 + (i10 * 20 | 0) | 0;
+ HEAPF32[i34 >> 2] = d37;
+ HEAPF32[i34 + 4 >> 2] = d38;
+ HEAP32[i5 + (i10 * 20 | 0) + 16 >> 2] = HEAP32[i4 + 20 >> 2];
+ i10 = i10 + 1 | 0;
+ }
+ } else {
+ if (i10) {
+ i10 = 0;
+ } else {
+ d38 = d16 - d9;
+ d36 = d15 - d6;
+ d37 = +(d8 * d38 + d7 * d36);
+ d38 = +(d8 * d36 - d7 * d38);
+ i10 = i5;
+ HEAPF32[i10 >> 2] = d37;
+ HEAPF32[i10 + 4 >> 2] = d38;
+ i10 = i5 + 16 | 0;
+ i34 = HEAP32[i4 + 8 >> 2] | 0;
+ HEAP32[i10 >> 2] = i34;
+ HEAP8[i10] = i34 >>> 8;
+ HEAP8[i10 + 1 | 0] = i34;
+ HEAP8[i10 + 2 | 0] = i34 >>> 24;
+ HEAP8[i10 + 3 | 0] = i34 >>> 16;
+ i10 = 1;
+ }
+ d16 = +HEAPF32[i4 + 12 >> 2];
+ d15 = +HEAPF32[i4 + 16 >> 2];
+ if (d21 * d16 + d15 * d22 - d23 <= d3) {
+ d38 = d16 - d9;
+ d36 = d15 - d6;
+ d37 = +(d8 * d38 + d7 * d36);
+ d38 = +(d8 * d36 - d7 * d38);
+ i34 = i5 + (i10 * 20 | 0) | 0;
+ HEAPF32[i34 >> 2] = d37;
+ HEAPF32[i34 + 4 >> 2] = d38;
+ i34 = i5 + (i10 * 20 | 0) + 16 | 0;
+ i33 = HEAP32[i4 + 20 >> 2] | 0;
+ HEAP32[i34 >> 2] = i33;
+ HEAP8[i34] = i33 >>> 8;
+ HEAP8[i34 + 1 | 0] = i33;
+ HEAP8[i34 + 2 | 0] = i33 >>> 24;
+ HEAP8[i34 + 3 | 0] = i33 >>> 16;
+ i10 = i10 + 1 | 0;
+ }
+ }
+ HEAP32[i2 >> 2] = i10;
+ STACKTOP = i1;
+ return;
+}
+function __ZN8b2Island8SolveTOIERK10b2TimeStepii(i4, i11, i15, i18) {
+ i4 = i4 | 0;
+ i11 = i11 | 0;
+ i15 = i15 | 0;
+ i18 = i18 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d12 = 0.0, d13 = 0.0, d14 = 0.0, d16 = 0.0, d17 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, d26 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 128 | 0;
+ i2 = i1 + 96 | 0;
+ i10 = i1 + 52 | 0;
+ i3 = i1;
+ i6 = i4 + 28 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) <= (i15 | 0)) {
+ ___assert_fail(5464, 5488, 386, 5520);
+ }
+ if ((i5 | 0) <= (i18 | 0)) {
+ ___assert_fail(5536, 5488, 387, 5520);
+ }
+ if ((i5 | 0) > 0) {
+ i9 = i4 + 8 | 0;
+ i8 = i4 + 20 | 0;
+ i7 = i4 + 24 | 0;
+ i22 = 0;
+ while (1) {
+ i23 = HEAP32[(HEAP32[i9 >> 2] | 0) + (i22 << 2) >> 2] | 0;
+ i5 = i23 + 44 | 0;
+ i24 = HEAP32[i5 + 4 >> 2] | 0;
+ i25 = (HEAP32[i8 >> 2] | 0) + (i22 * 12 | 0) | 0;
+ HEAP32[i25 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i25 + 4 >> 2] = i24;
+ HEAPF32[(HEAP32[i8 >> 2] | 0) + (i22 * 12 | 0) + 8 >> 2] = +HEAPF32[i23 + 56 >> 2];
+ i25 = i23 + 64 | 0;
+ i24 = HEAP32[i25 + 4 >> 2] | 0;
+ i5 = (HEAP32[i7 >> 2] | 0) + (i22 * 12 | 0) | 0;
+ HEAP32[i5 >> 2] = HEAP32[i25 >> 2];
+ HEAP32[i5 + 4 >> 2] = i24;
+ i5 = HEAP32[i7 >> 2] | 0;
+ HEAPF32[i5 + (i22 * 12 | 0) + 8 >> 2] = +HEAPF32[i23 + 72 >> 2];
+ i22 = i22 + 1 | 0;
+ if ((i22 | 0) >= (HEAP32[i6 >> 2] | 0)) {
+ i22 = i5;
+ break;
+ }
+ }
+ } else {
+ i8 = i4 + 20 | 0;
+ i22 = HEAP32[i4 + 24 >> 2] | 0;
+ }
+ i5 = i4 + 12 | 0;
+ HEAP32[i10 + 24 >> 2] = HEAP32[i5 >> 2];
+ i7 = i4 + 36 | 0;
+ HEAP32[i10 + 28 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i10 + 40 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i10 + 0 >> 2] = HEAP32[i11 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i11 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i10 + 12 >> 2] = HEAP32[i11 + 12 >> 2];
+ HEAP32[i10 + 16 >> 2] = HEAP32[i11 + 16 >> 2];
+ HEAP32[i10 + 20 >> 2] = HEAP32[i11 + 20 >> 2];
+ HEAP32[i10 + 32 >> 2] = HEAP32[i8 >> 2];
+ i9 = i4 + 24 | 0;
+ HEAP32[i10 + 36 >> 2] = i22;
+ __ZN15b2ContactSolverC2EP18b2ContactSolverDef(i3, i10);
+ i10 = i11 + 16 | 0;
+ L13 : do {
+ if ((HEAP32[i10 >> 2] | 0) > 0) {
+ i22 = 0;
+ do {
+ i22 = i22 + 1 | 0;
+ if (__ZN15b2ContactSolver27SolveTOIPositionConstraintsEii(i3, i15, i18) | 0) {
+ break L13;
+ }
+ } while ((i22 | 0) < (HEAP32[i10 >> 2] | 0));
+ }
+ } while (0);
+ i10 = i4 + 8 | 0;
+ i24 = (HEAP32[i8 >> 2] | 0) + (i15 * 12 | 0) | 0;
+ i25 = HEAP32[i24 + 4 >> 2] | 0;
+ i23 = (HEAP32[(HEAP32[i10 >> 2] | 0) + (i15 << 2) >> 2] | 0) + 36 | 0;
+ HEAP32[i23 >> 2] = HEAP32[i24 >> 2];
+ HEAP32[i23 + 4 >> 2] = i25;
+ i23 = HEAP32[i8 >> 2] | 0;
+ i25 = HEAP32[i10 >> 2] | 0;
+ HEAPF32[(HEAP32[i25 + (i15 << 2) >> 2] | 0) + 52 >> 2] = +HEAPF32[i23 + (i15 * 12 | 0) + 8 >> 2];
+ i23 = i23 + (i18 * 12 | 0) | 0;
+ i24 = HEAP32[i23 + 4 >> 2] | 0;
+ i25 = (HEAP32[i25 + (i18 << 2) >> 2] | 0) + 36 | 0;
+ HEAP32[i25 >> 2] = HEAP32[i23 >> 2];
+ HEAP32[i25 + 4 >> 2] = i24;
+ HEAPF32[(HEAP32[(HEAP32[i10 >> 2] | 0) + (i18 << 2) >> 2] | 0) + 52 >> 2] = +HEAPF32[(HEAP32[i8 >> 2] | 0) + (i18 * 12 | 0) + 8 >> 2];
+ __ZN15b2ContactSolver29InitializeVelocityConstraintsEv(i3);
+ i18 = i11 + 12 | 0;
+ if ((HEAP32[i18 >> 2] | 0) > 0) {
+ i15 = 0;
+ do {
+ __ZN15b2ContactSolver24SolveVelocityConstraintsEv(i3);
+ i15 = i15 + 1 | 0;
+ } while ((i15 | 0) < (HEAP32[i18 >> 2] | 0));
+ }
+ d16 = +HEAPF32[i11 >> 2];
+ if ((HEAP32[i6 >> 2] | 0) > 0) {
+ i15 = 0;
+ do {
+ i25 = HEAP32[i8 >> 2] | 0;
+ i11 = i25 + (i15 * 12 | 0) | 0;
+ i24 = i11;
+ d12 = +HEAPF32[i24 >> 2];
+ d14 = +HEAPF32[i24 + 4 >> 2];
+ d13 = +HEAPF32[i25 + (i15 * 12 | 0) + 8 >> 2];
+ i25 = HEAP32[i9 >> 2] | 0;
+ i24 = i25 + (i15 * 12 | 0) | 0;
+ d19 = +HEAPF32[i24 >> 2];
+ d20 = +HEAPF32[i24 + 4 >> 2];
+ d17 = +HEAPF32[i25 + (i15 * 12 | 0) + 8 >> 2];
+ d26 = d16 * d19;
+ d21 = d16 * d20;
+ d21 = d26 * d26 + d21 * d21;
+ if (d21 > 4.0) {
+ d26 = 2.0 / +Math_sqrt(+d21);
+ d19 = d19 * d26;
+ d20 = d20 * d26;
+ }
+ d21 = d16 * d17;
+ if (d21 * d21 > 2.4674012660980225) {
+ if (!(d21 > 0.0)) {
+ d21 = -d21;
+ }
+ d17 = d17 * (1.5707963705062866 / d21);
+ }
+ d21 = d12 + d16 * d19;
+ d14 = d14 + d16 * d20;
+ d26 = d13 + d16 * d17;
+ d12 = +d21;
+ d13 = +d14;
+ i25 = i11;
+ HEAPF32[i25 >> 2] = d12;
+ HEAPF32[i25 + 4 >> 2] = d13;
+ HEAPF32[(HEAP32[i8 >> 2] | 0) + (i15 * 12 | 0) + 8 >> 2] = d26;
+ d19 = +d19;
+ d20 = +d20;
+ i25 = (HEAP32[i9 >> 2] | 0) + (i15 * 12 | 0) | 0;
+ HEAPF32[i25 >> 2] = d19;
+ HEAPF32[i25 + 4 >> 2] = d20;
+ HEAPF32[(HEAP32[i9 >> 2] | 0) + (i15 * 12 | 0) + 8 >> 2] = d17;
+ i25 = HEAP32[(HEAP32[i10 >> 2] | 0) + (i15 << 2) >> 2] | 0;
+ i24 = i25 + 44 | 0;
+ HEAPF32[i24 >> 2] = d12;
+ HEAPF32[i24 + 4 >> 2] = d13;
+ HEAPF32[i25 + 56 >> 2] = d26;
+ i24 = i25 + 64 | 0;
+ HEAPF32[i24 >> 2] = d19;
+ HEAPF32[i24 + 4 >> 2] = d20;
+ HEAPF32[i25 + 72 >> 2] = d17;
+ d17 = +Math_sin(+d26);
+ HEAPF32[i25 + 20 >> 2] = d17;
+ d20 = +Math_cos(+d26);
+ HEAPF32[i25 + 24 >> 2] = d20;
+ d19 = +HEAPF32[i25 + 28 >> 2];
+ d26 = +HEAPF32[i25 + 32 >> 2];
+ d21 = +(d21 - (d20 * d19 - d17 * d26));
+ d26 = +(d14 - (d17 * d19 + d20 * d26));
+ i25 = i25 + 12 | 0;
+ HEAPF32[i25 >> 2] = d21;
+ HEAPF32[i25 + 4 >> 2] = d26;
+ i15 = i15 + 1 | 0;
+ } while ((i15 | 0) < (HEAP32[i6 >> 2] | 0));
+ }
+ i6 = HEAP32[i3 + 40 >> 2] | 0;
+ i4 = i4 + 4 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ __ZN15b2ContactSolverD2Ev(i3);
+ STACKTOP = i1;
+ return;
+ }
+ if ((HEAP32[i7 >> 2] | 0) <= 0) {
+ __ZN15b2ContactSolverD2Ev(i3);
+ STACKTOP = i1;
+ return;
+ }
+ i8 = i2 + 16 | 0;
+ i9 = 0;
+ do {
+ i10 = HEAP32[(HEAP32[i5 >> 2] | 0) + (i9 << 2) >> 2] | 0;
+ i11 = HEAP32[i6 + (i9 * 152 | 0) + 144 >> 2] | 0;
+ HEAP32[i8 >> 2] = i11;
+ if ((i11 | 0) > 0) {
+ i15 = 0;
+ do {
+ HEAPF32[i2 + (i15 << 2) >> 2] = +HEAPF32[i6 + (i9 * 152 | 0) + (i15 * 36 | 0) + 16 >> 2];
+ HEAPF32[i2 + (i15 << 2) + 8 >> 2] = +HEAPF32[i6 + (i9 * 152 | 0) + (i15 * 36 | 0) + 20 >> 2];
+ i15 = i15 + 1 | 0;
+ } while ((i15 | 0) != (i11 | 0));
+ }
+ i25 = HEAP32[i4 >> 2] | 0;
+ FUNCTION_TABLE_viii[HEAP32[(HEAP32[i25 >> 2] | 0) + 20 >> 2] & 3](i25, i10, i2);
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) < (HEAP32[i7 >> 2] | 0));
+ __ZN15b2ContactSolverD2Ev(i3);
+ STACKTOP = i1;
+ return;
+}
+function __ZN20b2SeparationFunction10InitializeEPK14b2SimplexCachePK15b2DistanceProxyRK7b2SweepS5_S8_f(i2, i11, i13, i21, i12, i24, d9) {
+ i2 = i2 | 0;
+ i11 = i11 | 0;
+ i13 = i13 | 0;
+ i21 = i21 | 0;
+ i12 = i12 | 0;
+ i24 = i24 | 0;
+ d9 = +d9;
+ var i1 = 0, d3 = 0.0, d4 = 0.0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d10 = 0.0, i14 = 0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d22 = 0.0, i23 = 0, i25 = 0, i26 = 0, i27 = 0, d28 = 0.0, d29 = 0.0;
+ i1 = STACKTOP;
+ HEAP32[i2 >> 2] = i13;
+ HEAP32[i2 + 4 >> 2] = i12;
+ i14 = HEAP16[i11 + 4 >> 1] | 0;
+ if (!(i14 << 16 >> 16 != 0 & (i14 & 65535) < 3)) {
+ ___assert_fail(3744, 3560, 50, 3768);
+ }
+ i23 = i2 + 8 | 0;
+ i25 = i23 + 0 | 0;
+ i27 = i21 + 0 | 0;
+ i26 = i25 + 36 | 0;
+ do {
+ HEAP32[i25 >> 2] = HEAP32[i27 >> 2];
+ i25 = i25 + 4 | 0;
+ i27 = i27 + 4 | 0;
+ } while ((i25 | 0) < (i26 | 0));
+ i21 = i2 + 44 | 0;
+ i25 = i21 + 0 | 0;
+ i27 = i24 + 0 | 0;
+ i26 = i25 + 36 | 0;
+ do {
+ HEAP32[i25 >> 2] = HEAP32[i27 >> 2];
+ i25 = i25 + 4 | 0;
+ i27 = i27 + 4 | 0;
+ } while ((i25 | 0) < (i26 | 0));
+ d19 = 1.0 - d9;
+ d4 = d19 * +HEAPF32[i2 + 32 >> 2] + +HEAPF32[i2 + 36 >> 2] * d9;
+ d3 = +Math_sin(+d4);
+ d4 = +Math_cos(+d4);
+ d7 = +HEAPF32[i23 >> 2];
+ d5 = +HEAPF32[i2 + 12 >> 2];
+ d8 = d19 * +HEAPF32[i2 + 16 >> 2] + +HEAPF32[i2 + 24 >> 2] * d9 - (d4 * d7 - d3 * d5);
+ d5 = d19 * +HEAPF32[i2 + 20 >> 2] + +HEAPF32[i2 + 28 >> 2] * d9 - (d3 * d7 + d4 * d5);
+ d7 = d19 * +HEAPF32[i2 + 68 >> 2] + +HEAPF32[i2 + 72 >> 2] * d9;
+ d6 = +Math_sin(+d7);
+ d7 = +Math_cos(+d7);
+ d20 = +HEAPF32[i21 >> 2];
+ d22 = +HEAPF32[i2 + 48 >> 2];
+ d10 = d19 * +HEAPF32[i2 + 52 >> 2] + +HEAPF32[i2 + 60 >> 2] * d9 - (d7 * d20 - d6 * d22);
+ d9 = d19 * +HEAPF32[i2 + 56 >> 2] + +HEAPF32[i2 + 64 >> 2] * d9 - (d6 * d20 + d7 * d22);
+ if (i14 << 16 >> 16 == 1) {
+ HEAP32[i2 + 80 >> 2] = 0;
+ i14 = HEAPU8[i11 + 6 | 0] | 0;
+ if ((HEAP32[i13 + 20 >> 2] | 0) <= (i14 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = (HEAP32[i13 + 16 >> 2] | 0) + (i14 << 3) | 0;
+ d15 = +HEAPF32[i27 >> 2];
+ d16 = +HEAPF32[i27 + 4 >> 2];
+ i11 = HEAPU8[i11 + 9 | 0] | 0;
+ if ((HEAP32[i12 + 20 >> 2] | 0) <= (i11 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i11 = (HEAP32[i12 + 16 >> 2] | 0) + (i11 << 3) | 0;
+ d20 = +HEAPF32[i11 >> 2];
+ d22 = +HEAPF32[i11 + 4 >> 2];
+ i11 = i2 + 92 | 0;
+ d8 = d10 + (d7 * d20 - d6 * d22) - (d8 + (d4 * d15 - d3 * d16));
+ d4 = d9 + (d6 * d20 + d7 * d22) - (d5 + (d3 * d15 + d4 * d16));
+ d22 = +d8;
+ d3 = +d4;
+ i27 = i11;
+ HEAPF32[i27 >> 2] = d22;
+ HEAPF32[i27 + 4 >> 2] = d3;
+ d3 = +Math_sqrt(+(d8 * d8 + d4 * d4));
+ if (d3 < 1.1920928955078125e-7) {
+ d22 = 0.0;
+ STACKTOP = i1;
+ return +d22;
+ }
+ d22 = 1.0 / d3;
+ HEAPF32[i11 >> 2] = d8 * d22;
+ HEAPF32[i2 + 96 >> 2] = d4 * d22;
+ d22 = d3;
+ STACKTOP = i1;
+ return +d22;
+ }
+ i14 = i11 + 6 | 0;
+ i21 = i11 + 7 | 0;
+ i23 = i2 + 80 | 0;
+ if ((HEAP8[i14] | 0) == (HEAP8[i21] | 0)) {
+ HEAP32[i23 >> 2] = 2;
+ i23 = HEAPU8[i11 + 9 | 0] | 0;
+ i21 = HEAP32[i12 + 20 >> 2] | 0;
+ if ((i21 | 0) <= (i23 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i12 = HEAP32[i12 + 16 >> 2] | 0;
+ i27 = i12 + (i23 << 3) | 0;
+ d16 = +HEAPF32[i27 >> 2];
+ d15 = +HEAPF32[i27 + 4 >> 2];
+ i11 = HEAPU8[i11 + 10 | 0] | 0;
+ if ((i21 | 0) <= (i11 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i11 = i12 + (i11 << 3) | 0;
+ d20 = +HEAPF32[i11 >> 2];
+ d18 = +HEAPF32[i11 + 4 >> 2];
+ i11 = i2 + 92 | 0;
+ d22 = d20 - d16;
+ d19 = d18 - d15;
+ d17 = -d22;
+ d29 = +d19;
+ d28 = +d17;
+ i27 = i11;
+ HEAPF32[i27 >> 2] = d29;
+ HEAPF32[i27 + 4 >> 2] = d28;
+ d22 = +Math_sqrt(+(d19 * d19 + d22 * d22));
+ if (!(d22 < 1.1920928955078125e-7)) {
+ d29 = 1.0 / d22;
+ d19 = d19 * d29;
+ HEAPF32[i11 >> 2] = d19;
+ d17 = d29 * d17;
+ HEAPF32[i2 + 96 >> 2] = d17;
+ }
+ d16 = (d16 + d20) * .5;
+ d15 = (d15 + d18) * .5;
+ d28 = +d16;
+ d29 = +d15;
+ i2 = i2 + 84 | 0;
+ HEAPF32[i2 >> 2] = d28;
+ HEAPF32[i2 + 4 >> 2] = d29;
+ i2 = HEAPU8[i14] | 0;
+ if ((HEAP32[i13 + 20 >> 2] | 0) <= (i2 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = (HEAP32[i13 + 16 >> 2] | 0) + (i2 << 3) | 0;
+ d28 = +HEAPF32[i27 >> 2];
+ d29 = +HEAPF32[i27 + 4 >> 2];
+ d3 = (d7 * d19 - d6 * d17) * (d8 + (d4 * d28 - d3 * d29) - (d10 + (d7 * d16 - d6 * d15))) + (d6 * d19 + d7 * d17) * (d5 + (d3 * d28 + d4 * d29) - (d9 + (d6 * d16 + d7 * d15)));
+ if (!(d3 < 0.0)) {
+ d29 = d3;
+ STACKTOP = i1;
+ return +d29;
+ }
+ d28 = +-d19;
+ d29 = +-d17;
+ i27 = i11;
+ HEAPF32[i27 >> 2] = d28;
+ HEAPF32[i27 + 4 >> 2] = d29;
+ d29 = -d3;
+ STACKTOP = i1;
+ return +d29;
+ } else {
+ HEAP32[i23 >> 2] = 1;
+ i23 = HEAPU8[i14] | 0;
+ i14 = HEAP32[i13 + 20 >> 2] | 0;
+ if ((i14 | 0) <= (i23 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i13 = HEAP32[i13 + 16 >> 2] | 0;
+ i27 = i13 + (i23 << 3) | 0;
+ d16 = +HEAPF32[i27 >> 2];
+ d15 = +HEAPF32[i27 + 4 >> 2];
+ i21 = HEAPU8[i21] | 0;
+ if ((i14 | 0) <= (i21 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i13 = i13 + (i21 << 3) | 0;
+ d20 = +HEAPF32[i13 >> 2];
+ d18 = +HEAPF32[i13 + 4 >> 2];
+ i13 = i2 + 92 | 0;
+ d22 = d20 - d16;
+ d19 = d18 - d15;
+ d17 = -d22;
+ d28 = +d19;
+ d29 = +d17;
+ i27 = i13;
+ HEAPF32[i27 >> 2] = d28;
+ HEAPF32[i27 + 4 >> 2] = d29;
+ d22 = +Math_sqrt(+(d19 * d19 + d22 * d22));
+ if (!(d22 < 1.1920928955078125e-7)) {
+ d29 = 1.0 / d22;
+ d19 = d19 * d29;
+ HEAPF32[i13 >> 2] = d19;
+ d17 = d29 * d17;
+ HEAPF32[i2 + 96 >> 2] = d17;
+ }
+ d16 = (d16 + d20) * .5;
+ d15 = (d15 + d18) * .5;
+ d28 = +d16;
+ d29 = +d15;
+ i2 = i2 + 84 | 0;
+ HEAPF32[i2 >> 2] = d28;
+ HEAPF32[i2 + 4 >> 2] = d29;
+ i2 = HEAPU8[i11 + 9 | 0] | 0;
+ if ((HEAP32[i12 + 20 >> 2] | 0) <= (i2 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = (HEAP32[i12 + 16 >> 2] | 0) + (i2 << 3) | 0;
+ d28 = +HEAPF32[i27 >> 2];
+ d29 = +HEAPF32[i27 + 4 >> 2];
+ d3 = (d4 * d19 - d3 * d17) * (d10 + (d7 * d28 - d6 * d29) - (d8 + (d4 * d16 - d3 * d15))) + (d3 * d19 + d4 * d17) * (d9 + (d6 * d28 + d7 * d29) - (d5 + (d3 * d16 + d4 * d15)));
+ if (!(d3 < 0.0)) {
+ d29 = d3;
+ STACKTOP = i1;
+ return +d29;
+ }
+ d28 = +-d19;
+ d29 = +-d17;
+ i27 = i13;
+ HEAPF32[i27 >> 2] = d28;
+ HEAPF32[i27 + 4 >> 2] = d29;
+ d29 = -d3;
+ STACKTOP = i1;
+ return +d29;
+ }
+ return 0.0;
+}
+function __ZNK20b2SeparationFunction17FindMinSeparationEPiS0_f(i12, i10, i9, d5) {
+ i12 = i12 | 0;
+ i10 = i10 | 0;
+ i9 = i9 | 0;
+ d5 = +d5;
+ var i1 = 0, d2 = 0.0, d3 = 0.0, d4 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d11 = 0.0, d13 = 0.0, d14 = 0.0, i15 = 0, i16 = 0, d17 = 0.0, d18 = 0.0, i19 = 0, d20 = 0.0, d21 = 0.0, i22 = 0, d23 = 0.0, d24 = 0.0, i25 = 0, i26 = 0, i27 = 0;
+ i1 = STACKTOP;
+ d21 = 1.0 - d5;
+ d6 = d21 * +HEAPF32[i12 + 32 >> 2] + +HEAPF32[i12 + 36 >> 2] * d5;
+ d7 = +Math_sin(+d6);
+ d6 = +Math_cos(+d6);
+ d3 = +HEAPF32[i12 + 8 >> 2];
+ d8 = +HEAPF32[i12 + 12 >> 2];
+ d11 = d21 * +HEAPF32[i12 + 16 >> 2] + +HEAPF32[i12 + 24 >> 2] * d5 - (d6 * d3 - d7 * d8);
+ d8 = d21 * +HEAPF32[i12 + 20 >> 2] + +HEAPF32[i12 + 28 >> 2] * d5 - (d7 * d3 + d6 * d8);
+ d3 = d21 * +HEAPF32[i12 + 68 >> 2] + +HEAPF32[i12 + 72 >> 2] * d5;
+ d2 = +Math_sin(+d3);
+ d3 = +Math_cos(+d3);
+ d23 = +HEAPF32[i12 + 44 >> 2];
+ d24 = +HEAPF32[i12 + 48 >> 2];
+ d4 = d21 * +HEAPF32[i12 + 52 >> 2] + +HEAPF32[i12 + 60 >> 2] * d5 - (d3 * d23 - d2 * d24);
+ d5 = d21 * +HEAPF32[i12 + 56 >> 2] + +HEAPF32[i12 + 64 >> 2] * d5 - (d2 * d23 + d3 * d24);
+ i19 = HEAP32[i12 + 80 >> 2] | 0;
+ if ((i19 | 0) == 1) {
+ d23 = +HEAPF32[i12 + 92 >> 2];
+ d14 = +HEAPF32[i12 + 96 >> 2];
+ d13 = d6 * d23 - d7 * d14;
+ d14 = d7 * d23 + d6 * d14;
+ d23 = +HEAPF32[i12 + 84 >> 2];
+ d24 = +HEAPF32[i12 + 88 >> 2];
+ d11 = d11 + (d6 * d23 - d7 * d24);
+ d6 = d8 + (d7 * d23 + d6 * d24);
+ d7 = -d13;
+ d24 = -d14;
+ d8 = d3 * d7 + d2 * d24;
+ d7 = d3 * d24 - d2 * d7;
+ HEAP32[i10 >> 2] = -1;
+ i25 = i12 + 4 | 0;
+ i22 = HEAP32[i25 >> 2] | 0;
+ i19 = HEAP32[i22 + 16 >> 2] | 0;
+ i22 = HEAP32[i22 + 20 >> 2] | 0;
+ if ((i22 | 0) > 1) {
+ i10 = 0;
+ d18 = d7 * +HEAPF32[i19 + 4 >> 2] + d8 * +HEAPF32[i19 >> 2];
+ i12 = 1;
+ while (1) {
+ d17 = d8 * +HEAPF32[i19 + (i12 << 3) >> 2] + d7 * +HEAPF32[i19 + (i12 << 3) + 4 >> 2];
+ i16 = d17 > d18;
+ i10 = i16 ? i12 : i10;
+ i12 = i12 + 1 | 0;
+ if ((i12 | 0) == (i22 | 0)) {
+ break;
+ } else {
+ d18 = i16 ? d17 : d18;
+ }
+ }
+ HEAP32[i9 >> 2] = i10;
+ if ((i10 | 0) > -1) {
+ i15 = i10;
+ } else {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ } else {
+ HEAP32[i9 >> 2] = 0;
+ i15 = 0;
+ }
+ i9 = HEAP32[i25 >> 2] | 0;
+ if ((HEAP32[i9 + 20 >> 2] | 0) <= (i15 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = (HEAP32[i9 + 16 >> 2] | 0) + (i15 << 3) | 0;
+ d23 = +HEAPF32[i27 >> 2];
+ d24 = +HEAPF32[i27 + 4 >> 2];
+ d24 = d13 * (d4 + (d3 * d23 - d2 * d24) - d11) + d14 * (d5 + (d2 * d23 + d3 * d24) - d6);
+ STACKTOP = i1;
+ return +d24;
+ } else if ((i19 | 0) == 0) {
+ d13 = +HEAPF32[i12 + 92 >> 2];
+ d14 = +HEAPF32[i12 + 96 >> 2];
+ d21 = d6 * d13 + d7 * d14;
+ d24 = d6 * d14 - d7 * d13;
+ d17 = -d13;
+ d23 = -d14;
+ d18 = d3 * d17 + d2 * d23;
+ d17 = d3 * d23 - d2 * d17;
+ i15 = HEAP32[i12 >> 2] | 0;
+ i16 = HEAP32[i15 + 16 >> 2] | 0;
+ i15 = i15 + 20 | 0;
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i19 | 0) > 1) {
+ i25 = 0;
+ d23 = d24 * +HEAPF32[i16 + 4 >> 2] + d21 * +HEAPF32[i16 >> 2];
+ i26 = 1;
+ while (1) {
+ d20 = d21 * +HEAPF32[i16 + (i26 << 3) >> 2] + d24 * +HEAPF32[i16 + (i26 << 3) + 4 >> 2];
+ i22 = d20 > d23;
+ i25 = i22 ? i26 : i25;
+ i26 = i26 + 1 | 0;
+ if ((i26 | 0) == (i19 | 0)) {
+ break;
+ } else {
+ d23 = i22 ? d20 : d23;
+ }
+ }
+ } else {
+ i25 = 0;
+ }
+ HEAP32[i10 >> 2] = i25;
+ i19 = HEAP32[i12 + 4 >> 2] | 0;
+ i12 = HEAP32[i19 + 16 >> 2] | 0;
+ i19 = i19 + 20 | 0;
+ i25 = HEAP32[i19 >> 2] | 0;
+ if ((i25 | 0) > 1) {
+ i27 = 0;
+ d20 = d17 * +HEAPF32[i12 + 4 >> 2] + d18 * +HEAPF32[i12 >> 2];
+ i26 = 1;
+ while (1) {
+ d21 = d18 * +HEAPF32[i12 + (i26 << 3) >> 2] + d17 * +HEAPF32[i12 + (i26 << 3) + 4 >> 2];
+ i22 = d21 > d20;
+ i27 = i22 ? i26 : i27;
+ i26 = i26 + 1 | 0;
+ if ((i26 | 0) == (i25 | 0)) {
+ break;
+ } else {
+ d20 = i22 ? d21 : d20;
+ }
+ }
+ } else {
+ i27 = 0;
+ }
+ HEAP32[i9 >> 2] = i27;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if (!((i9 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i15 >> 2] | 0) <= (i9 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i26 = i16 + (i9 << 3) | 0;
+ d18 = +HEAPF32[i26 >> 2];
+ d17 = +HEAPF32[i26 + 4 >> 2];
+ if (!((i27 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i19 >> 2] | 0) <= (i27 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = i12 + (i27 << 3) | 0;
+ d23 = +HEAPF32[i27 >> 2];
+ d24 = +HEAPF32[i27 + 4 >> 2];
+ d24 = d13 * (d4 + (d3 * d23 - d2 * d24) - (d11 + (d6 * d18 - d7 * d17))) + d14 * (d5 + (d2 * d23 + d3 * d24) - (d8 + (d7 * d18 + d6 * d17)));
+ STACKTOP = i1;
+ return +d24;
+ } else if ((i19 | 0) == 2) {
+ d23 = +HEAPF32[i12 + 92 >> 2];
+ d13 = +HEAPF32[i12 + 96 >> 2];
+ d14 = d3 * d23 - d2 * d13;
+ d13 = d2 * d23 + d3 * d13;
+ d23 = +HEAPF32[i12 + 84 >> 2];
+ d24 = +HEAPF32[i12 + 88 >> 2];
+ d4 = d4 + (d3 * d23 - d2 * d24);
+ d2 = d5 + (d2 * d23 + d3 * d24);
+ d3 = -d14;
+ d24 = -d13;
+ d5 = d6 * d3 + d7 * d24;
+ d3 = d6 * d24 - d7 * d3;
+ HEAP32[i9 >> 2] = -1;
+ i22 = HEAP32[i12 >> 2] | 0;
+ i15 = HEAP32[i22 + 16 >> 2] | 0;
+ i22 = HEAP32[i22 + 20 >> 2] | 0;
+ if ((i22 | 0) > 1) {
+ i9 = 0;
+ d17 = d3 * +HEAPF32[i15 + 4 >> 2] + d5 * +HEAPF32[i15 >> 2];
+ i19 = 1;
+ while (1) {
+ d18 = d5 * +HEAPF32[i15 + (i19 << 3) >> 2] + d3 * +HEAPF32[i15 + (i19 << 3) + 4 >> 2];
+ i25 = d18 > d17;
+ i9 = i25 ? i19 : i9;
+ i19 = i19 + 1 | 0;
+ if ((i19 | 0) == (i22 | 0)) {
+ break;
+ } else {
+ d17 = i25 ? d18 : d17;
+ }
+ }
+ HEAP32[i10 >> 2] = i9;
+ if ((i9 | 0) > -1) {
+ i16 = i9;
+ } else {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ } else {
+ HEAP32[i10 >> 2] = 0;
+ i16 = 0;
+ }
+ i9 = HEAP32[i12 >> 2] | 0;
+ if ((HEAP32[i9 + 20 >> 2] | 0) <= (i16 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i27 = (HEAP32[i9 + 16 >> 2] | 0) + (i16 << 3) | 0;
+ d23 = +HEAPF32[i27 >> 2];
+ d24 = +HEAPF32[i27 + 4 >> 2];
+ d24 = d14 * (d11 + (d6 * d23 - d7 * d24) - d4) + d13 * (d8 + (d7 * d23 + d6 * d24) - d2);
+ STACKTOP = i1;
+ return +d24;
+ } else {
+ ___assert_fail(3616, 3560, 183, 3720);
+ }
+ return 0.0;
+}
+function __ZN13b2DynamicTree10InsertLeafEi(i3, i4) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, d22 = 0.0, d23 = 0.0, i24 = 0;
+ i1 = STACKTOP;
+ i11 = i3 + 24 | 0;
+ HEAP32[i11 >> 2] = (HEAP32[i11 >> 2] | 0) + 1;
+ i11 = HEAP32[i3 >> 2] | 0;
+ if ((i11 | 0) == -1) {
+ HEAP32[i3 >> 2] = i4;
+ HEAP32[(HEAP32[i3 + 4 >> 2] | 0) + (i4 * 36 | 0) + 20 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+ }
+ i2 = i3 + 4 | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ d8 = +HEAPF32[i9 + (i4 * 36 | 0) >> 2];
+ d7 = +HEAPF32[i9 + (i4 * 36 | 0) + 4 >> 2];
+ d6 = +HEAPF32[i9 + (i4 * 36 | 0) + 8 >> 2];
+ d5 = +HEAPF32[i9 + (i4 * 36 | 0) + 12 >> 2];
+ i10 = HEAP32[i9 + (i11 * 36 | 0) + 24 >> 2] | 0;
+ L5 : do {
+ if (!((i10 | 0) == -1)) {
+ do {
+ i12 = HEAP32[i9 + (i11 * 36 | 0) + 28 >> 2] | 0;
+ d14 = +HEAPF32[i9 + (i11 * 36 | 0) + 8 >> 2];
+ d15 = +HEAPF32[i9 + (i11 * 36 | 0) >> 2];
+ d17 = +HEAPF32[i9 + (i11 * 36 | 0) + 12 >> 2];
+ d16 = +HEAPF32[i9 + (i11 * 36 | 0) + 4 >> 2];
+ d21 = ((d14 > d6 ? d14 : d6) - (d15 < d8 ? d15 : d8) + ((d17 > d5 ? d17 : d5) - (d16 < d7 ? d16 : d7))) * 2.0;
+ d13 = d21 * 2.0;
+ d14 = (d21 - (d14 - d15 + (d17 - d16)) * 2.0) * 2.0;
+ d21 = +HEAPF32[i9 + (i10 * 36 | 0) >> 2];
+ d16 = d8 < d21 ? d8 : d21;
+ d17 = +HEAPF32[i9 + (i10 * 36 | 0) + 4 >> 2];
+ d18 = d7 < d17 ? d7 : d17;
+ d19 = +HEAPF32[i9 + (i10 * 36 | 0) + 8 >> 2];
+ d20 = d6 > d19 ? d6 : d19;
+ d15 = +HEAPF32[i9 + (i10 * 36 | 0) + 12 >> 2];
+ d22 = d5 > d15 ? d5 : d15;
+ if ((HEAP32[i9 + (i10 * 36 | 0) + 24 >> 2] | 0) == -1) {
+ d15 = (d20 - d16 + (d22 - d18)) * 2.0;
+ } else {
+ d15 = (d20 - d16 + (d22 - d18)) * 2.0 - (d19 - d21 + (d15 - d17)) * 2.0;
+ }
+ d15 = d14 + d15;
+ d17 = +HEAPF32[i9 + (i12 * 36 | 0) >> 2];
+ d18 = d8 < d17 ? d8 : d17;
+ d23 = +HEAPF32[i9 + (i12 * 36 | 0) + 4 >> 2];
+ d22 = d7 < d23 ? d7 : d23;
+ d21 = +HEAPF32[i9 + (i12 * 36 | 0) + 8 >> 2];
+ d20 = d6 > d21 ? d6 : d21;
+ d19 = +HEAPF32[i9 + (i12 * 36 | 0) + 12 >> 2];
+ d16 = d5 > d19 ? d5 : d19;
+ if ((HEAP32[i9 + (i12 * 36 | 0) + 24 >> 2] | 0) == -1) {
+ d16 = (d20 - d18 + (d16 - d22)) * 2.0;
+ } else {
+ d16 = (d20 - d18 + (d16 - d22)) * 2.0 - (d21 - d17 + (d19 - d23)) * 2.0;
+ }
+ d14 = d14 + d16;
+ if (d13 < d15 & d13 < d14) {
+ break L5;
+ }
+ i11 = d15 < d14 ? i10 : i12;
+ i10 = HEAP32[i9 + (i11 * 36 | 0) + 24 >> 2] | 0;
+ } while (!((i10 | 0) == -1));
+ }
+ } while (0);
+ i9 = HEAP32[i9 + (i11 * 36 | 0) + 20 >> 2] | 0;
+ i10 = __ZN13b2DynamicTree12AllocateNodeEv(i3) | 0;
+ i12 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i12 + (i10 * 36 | 0) + 20 >> 2] = i9;
+ HEAP32[i12 + (i10 * 36 | 0) + 16 >> 2] = 0;
+ i12 = HEAP32[i2 >> 2] | 0;
+ d14 = +HEAPF32[i12 + (i11 * 36 | 0) >> 2];
+ d13 = +HEAPF32[i12 + (i11 * 36 | 0) + 4 >> 2];
+ d8 = +(d8 < d14 ? d8 : d14);
+ d7 = +(d7 < d13 ? d7 : d13);
+ i24 = i12 + (i10 * 36 | 0) | 0;
+ HEAPF32[i24 >> 2] = d8;
+ HEAPF32[i24 + 4 >> 2] = d7;
+ d8 = +HEAPF32[i12 + (i11 * 36 | 0) + 8 >> 2];
+ d7 = +HEAPF32[i12 + (i11 * 36 | 0) + 12 >> 2];
+ d6 = +(d6 > d8 ? d6 : d8);
+ d23 = +(d5 > d7 ? d5 : d7);
+ i12 = i12 + (i10 * 36 | 0) + 8 | 0;
+ HEAPF32[i12 >> 2] = d6;
+ HEAPF32[i12 + 4 >> 2] = d23;
+ i12 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i12 + (i10 * 36 | 0) + 32 >> 2] = (HEAP32[i12 + (i11 * 36 | 0) + 32 >> 2] | 0) + 1;
+ if ((i9 | 0) == -1) {
+ HEAP32[i12 + (i10 * 36 | 0) + 24 >> 2] = i11;
+ HEAP32[i12 + (i10 * 36 | 0) + 28 >> 2] = i4;
+ HEAP32[i12 + (i11 * 36 | 0) + 20 >> 2] = i10;
+ i24 = i12 + (i4 * 36 | 0) + 20 | 0;
+ HEAP32[i24 >> 2] = i10;
+ HEAP32[i3 >> 2] = i10;
+ i10 = HEAP32[i24 >> 2] | 0;
+ } else {
+ i24 = i12 + (i9 * 36 | 0) + 24 | 0;
+ if ((HEAP32[i24 >> 2] | 0) == (i11 | 0)) {
+ HEAP32[i24 >> 2] = i10;
+ } else {
+ HEAP32[i12 + (i9 * 36 | 0) + 28 >> 2] = i10;
+ }
+ HEAP32[i12 + (i10 * 36 | 0) + 24 >> 2] = i11;
+ HEAP32[i12 + (i10 * 36 | 0) + 28 >> 2] = i4;
+ HEAP32[i12 + (i11 * 36 | 0) + 20 >> 2] = i10;
+ HEAP32[i12 + (i4 * 36 | 0) + 20 >> 2] = i10;
+ }
+ if ((i10 | 0) == -1) {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i9 = __ZN13b2DynamicTree7BalanceEi(i3, i10) | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ i11 = HEAP32[i4 + (i9 * 36 | 0) + 24 >> 2] | 0;
+ i10 = HEAP32[i4 + (i9 * 36 | 0) + 28 >> 2] | 0;
+ if ((i11 | 0) == -1) {
+ i2 = 20;
+ break;
+ }
+ if ((i10 | 0) == -1) {
+ i2 = 22;
+ break;
+ }
+ i12 = HEAP32[i4 + (i11 * 36 | 0) + 32 >> 2] | 0;
+ i24 = HEAP32[i4 + (i10 * 36 | 0) + 32 >> 2] | 0;
+ HEAP32[i4 + (i9 * 36 | 0) + 32 >> 2] = ((i12 | 0) > (i24 | 0) ? i12 : i24) + 1;
+ d7 = +HEAPF32[i4 + (i11 * 36 | 0) >> 2];
+ d8 = +HEAPF32[i4 + (i10 * 36 | 0) >> 2];
+ d5 = +HEAPF32[i4 + (i11 * 36 | 0) + 4 >> 2];
+ d6 = +HEAPF32[i4 + (i10 * 36 | 0) + 4 >> 2];
+ d7 = +(d7 < d8 ? d7 : d8);
+ d5 = +(d5 < d6 ? d5 : d6);
+ i24 = i4 + (i9 * 36 | 0) | 0;
+ HEAPF32[i24 >> 2] = d7;
+ HEAPF32[i24 + 4 >> 2] = d5;
+ d5 = +HEAPF32[i4 + (i11 * 36 | 0) + 8 >> 2];
+ d6 = +HEAPF32[i4 + (i10 * 36 | 0) + 8 >> 2];
+ d7 = +HEAPF32[i4 + (i11 * 36 | 0) + 12 >> 2];
+ d8 = +HEAPF32[i4 + (i10 * 36 | 0) + 12 >> 2];
+ d5 = +(d5 > d6 ? d5 : d6);
+ d23 = +(d7 > d8 ? d7 : d8);
+ i10 = i4 + (i9 * 36 | 0) + 8 | 0;
+ HEAPF32[i10 >> 2] = d5;
+ HEAPF32[i10 + 4 >> 2] = d23;
+ i10 = HEAP32[(HEAP32[i2 >> 2] | 0) + (i9 * 36 | 0) + 20 >> 2] | 0;
+ if ((i10 | 0) == -1) {
+ i2 = 24;
+ break;
+ }
+ }
+ if ((i2 | 0) == 20) {
+ ___assert_fail(3168, 2944, 307, 3184);
+ } else if ((i2 | 0) == 22) {
+ ___assert_fail(3200, 2944, 308, 3184);
+ } else if ((i2 | 0) == 24) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function __ZN15b2ContactSolverC2EP18b2ContactSolverDef(i7, i5) {
+ i7 = i7 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, d15 = 0.0, d16 = 0.0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
+ i1 = STACKTOP;
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i7 + 12 >> 2] = HEAP32[i5 + 12 >> 2];
+ HEAP32[i7 + 16 >> 2] = HEAP32[i5 + 16 >> 2];
+ HEAP32[i7 + 20 >> 2] = HEAP32[i5 + 20 >> 2];
+ i14 = HEAP32[i5 + 40 >> 2] | 0;
+ i9 = i7 + 32 | 0;
+ HEAP32[i9 >> 2] = i14;
+ i2 = HEAP32[i5 + 28 >> 2] | 0;
+ i4 = i7 + 48 | 0;
+ HEAP32[i4 >> 2] = i2;
+ i3 = i7 + 36 | 0;
+ HEAP32[i3 >> 2] = __ZN16b2StackAllocator8AllocateEi(i14, i2 * 88 | 0) | 0;
+ i2 = i7 + 40 | 0;
+ HEAP32[i2 >> 2] = __ZN16b2StackAllocator8AllocateEi(HEAP32[i9 >> 2] | 0, (HEAP32[i4 >> 2] | 0) * 152 | 0) | 0;
+ HEAP32[i7 + 24 >> 2] = HEAP32[i5 + 32 >> 2];
+ HEAP32[i7 + 28 >> 2] = HEAP32[i5 + 36 >> 2];
+ i9 = HEAP32[i5 + 24 >> 2] | 0;
+ i5 = i7 + 44 | 0;
+ HEAP32[i5 >> 2] = i9;
+ if ((HEAP32[i4 >> 2] | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i6 = i7 + 20 | 0;
+ i7 = i7 + 8 | 0;
+ i8 = 0;
+ while (1) {
+ i10 = HEAP32[i9 + (i8 << 2) >> 2] | 0;
+ i11 = HEAP32[i10 + 48 >> 2] | 0;
+ i12 = HEAP32[i10 + 52 >> 2] | 0;
+ i14 = HEAP32[i11 + 8 >> 2] | 0;
+ i13 = HEAP32[i12 + 8 >> 2] | 0;
+ i9 = HEAP32[i10 + 124 >> 2] | 0;
+ if ((i9 | 0) <= 0) {
+ i2 = 4;
+ break;
+ }
+ d15 = +HEAPF32[(HEAP32[i12 + 12 >> 2] | 0) + 8 >> 2];
+ d16 = +HEAPF32[(HEAP32[i11 + 12 >> 2] | 0) + 8 >> 2];
+ i12 = HEAP32[i2 >> 2] | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + 136 >> 2] = +HEAPF32[i10 + 136 >> 2];
+ HEAPF32[i12 + (i8 * 152 | 0) + 140 >> 2] = +HEAPF32[i10 + 140 >> 2];
+ i22 = i14 + 8 | 0;
+ HEAP32[i12 + (i8 * 152 | 0) + 112 >> 2] = HEAP32[i22 >> 2];
+ i21 = i13 + 8 | 0;
+ HEAP32[i12 + (i8 * 152 | 0) + 116 >> 2] = HEAP32[i21 >> 2];
+ i19 = i14 + 120 | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + 120 >> 2] = +HEAPF32[i19 >> 2];
+ i20 = i13 + 120 | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + 124 >> 2] = +HEAPF32[i20 >> 2];
+ i18 = i14 + 128 | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + 128 >> 2] = +HEAPF32[i18 >> 2];
+ i17 = i13 + 128 | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + 132 >> 2] = +HEAPF32[i17 >> 2];
+ HEAP32[i12 + (i8 * 152 | 0) + 148 >> 2] = i8;
+ HEAP32[i12 + (i8 * 152 | 0) + 144 >> 2] = i9;
+ i11 = i12 + (i8 * 152 | 0) + 80 | 0;
+ HEAP32[i11 + 0 >> 2] = 0;
+ HEAP32[i11 + 4 >> 2] = 0;
+ HEAP32[i11 + 8 >> 2] = 0;
+ HEAP32[i11 + 12 >> 2] = 0;
+ HEAP32[i11 + 16 >> 2] = 0;
+ HEAP32[i11 + 20 >> 2] = 0;
+ HEAP32[i11 + 24 >> 2] = 0;
+ HEAP32[i11 + 28 >> 2] = 0;
+ i11 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i11 + (i8 * 88 | 0) + 32 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i11 + (i8 * 88 | 0) + 36 >> 2] = HEAP32[i21 >> 2];
+ HEAPF32[i11 + (i8 * 88 | 0) + 40 >> 2] = +HEAPF32[i19 >> 2];
+ HEAPF32[i11 + (i8 * 88 | 0) + 44 >> 2] = +HEAPF32[i20 >> 2];
+ i20 = i14 + 28 | 0;
+ i14 = HEAP32[i20 + 4 >> 2] | 0;
+ i19 = i11 + (i8 * 88 | 0) + 48 | 0;
+ HEAP32[i19 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i19 + 4 >> 2] = i14;
+ i19 = i13 + 28 | 0;
+ i14 = HEAP32[i19 + 4 >> 2] | 0;
+ i13 = i11 + (i8 * 88 | 0) + 56 | 0;
+ HEAP32[i13 >> 2] = HEAP32[i19 >> 2];
+ HEAP32[i13 + 4 >> 2] = i14;
+ HEAPF32[i11 + (i8 * 88 | 0) + 64 >> 2] = +HEAPF32[i18 >> 2];
+ HEAPF32[i11 + (i8 * 88 | 0) + 68 >> 2] = +HEAPF32[i17 >> 2];
+ i13 = i10 + 104 | 0;
+ i14 = HEAP32[i13 + 4 >> 2] | 0;
+ i17 = i11 + (i8 * 88 | 0) + 16 | 0;
+ HEAP32[i17 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i17 + 4 >> 2] = i14;
+ i17 = i10 + 112 | 0;
+ i14 = HEAP32[i17 + 4 >> 2] | 0;
+ i13 = i11 + (i8 * 88 | 0) + 24 | 0;
+ HEAP32[i13 >> 2] = HEAP32[i17 >> 2];
+ HEAP32[i13 + 4 >> 2] = i14;
+ HEAP32[i11 + (i8 * 88 | 0) + 84 >> 2] = i9;
+ HEAPF32[i11 + (i8 * 88 | 0) + 76 >> 2] = d16;
+ HEAPF32[i11 + (i8 * 88 | 0) + 80 >> 2] = d15;
+ HEAP32[i11 + (i8 * 88 | 0) + 72 >> 2] = HEAP32[i10 + 120 >> 2];
+ i13 = 0;
+ do {
+ i14 = i10 + (i13 * 20 | 0) + 64 | 0;
+ if ((HEAP8[i6] | 0) == 0) {
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 16 >> 2] = 0.0;
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 20 >> 2] = 0.0;
+ } else {
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 16 >> 2] = +HEAPF32[i7 >> 2] * +HEAPF32[i10 + (i13 * 20 | 0) + 72 >> 2];
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 20 >> 2] = +HEAPF32[i7 >> 2] * +HEAPF32[i10 + (i13 * 20 | 0) + 76 >> 2];
+ }
+ i20 = i12 + (i8 * 152 | 0) + (i13 * 36 | 0) | 0;
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 24 >> 2] = 0.0;
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 28 >> 2] = 0.0;
+ HEAPF32[i12 + (i8 * 152 | 0) + (i13 * 36 | 0) + 32 >> 2] = 0.0;
+ i22 = i11 + (i8 * 88 | 0) + (i13 << 3) | 0;
+ HEAP32[i20 + 0 >> 2] = 0;
+ HEAP32[i20 + 4 >> 2] = 0;
+ HEAP32[i20 + 8 >> 2] = 0;
+ HEAP32[i20 + 12 >> 2] = 0;
+ i20 = i14;
+ i21 = HEAP32[i20 + 4 >> 2] | 0;
+ HEAP32[i22 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i22 + 4 >> 2] = i21;
+ i13 = i13 + 1 | 0;
+ } while ((i13 | 0) != (i9 | 0));
+ i8 = i8 + 1 | 0;
+ if ((i8 | 0) >= (HEAP32[i4 >> 2] | 0)) {
+ i2 = 12;
+ break;
+ }
+ i9 = HEAP32[i5 >> 2] | 0;
+ }
+ if ((i2 | 0) == 4) {
+ ___assert_fail(6504, 6520, 71, 6568);
+ } else if ((i2 | 0) == 12) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function __Z25b2CollidePolygonAndCircleP10b2ManifoldPK14b2PolygonShapeRK11b2TransformPK13b2CircleShapeS6_(i1, i4, i11, i9, i10) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i11 = i11 | 0;
+ i9 = i9 | 0;
+ i10 = i10 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, d6 = 0.0, d7 = 0.0, d8 = 0.0, i12 = 0, d13 = 0.0, d14 = 0.0, i15 = 0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, i22 = 0;
+ i3 = STACKTOP;
+ i5 = i1 + 60 | 0;
+ HEAP32[i5 >> 2] = 0;
+ i2 = i9 + 12 | 0;
+ d20 = +HEAPF32[i10 + 12 >> 2];
+ d7 = +HEAPF32[i2 >> 2];
+ d6 = +HEAPF32[i10 + 8 >> 2];
+ d21 = +HEAPF32[i9 + 16 >> 2];
+ d8 = +HEAPF32[i10 >> 2] + (d20 * d7 - d6 * d21) - +HEAPF32[i11 >> 2];
+ d21 = d7 * d6 + d20 * d21 + +HEAPF32[i10 + 4 >> 2] - +HEAPF32[i11 + 4 >> 2];
+ d20 = +HEAPF32[i11 + 12 >> 2];
+ d6 = +HEAPF32[i11 + 8 >> 2];
+ d7 = d8 * d20 + d21 * d6;
+ d6 = d20 * d21 - d8 * d6;
+ d8 = +HEAPF32[i4 + 8 >> 2] + +HEAPF32[i9 + 8 >> 2];
+ i12 = HEAP32[i4 + 148 >> 2] | 0;
+ do {
+ if ((i12 | 0) > 0) {
+ i10 = 0;
+ i9 = 0;
+ d13 = -3.4028234663852886e+38;
+ while (1) {
+ d14 = (d7 - +HEAPF32[i4 + (i10 << 3) + 20 >> 2]) * +HEAPF32[i4 + (i10 << 3) + 84 >> 2] + (d6 - +HEAPF32[i4 + (i10 << 3) + 24 >> 2]) * +HEAPF32[i4 + (i10 << 3) + 88 >> 2];
+ if (d14 > d8) {
+ i10 = 19;
+ break;
+ }
+ i11 = d14 > d13;
+ d13 = i11 ? d14 : d13;
+ i9 = i11 ? i10 : i9;
+ i10 = i10 + 1 | 0;
+ if ((i10 | 0) >= (i12 | 0)) {
+ i10 = 4;
+ break;
+ }
+ }
+ if ((i10 | 0) == 4) {
+ i22 = d13 < 1.1920928955078125e-7;
+ break;
+ } else if ((i10 | 0) == 19) {
+ STACKTOP = i3;
+ return;
+ }
+ } else {
+ i9 = 0;
+ i22 = 1;
+ }
+ } while (0);
+ i15 = i9 + 1 | 0;
+ i11 = i4 + (i9 << 3) + 20 | 0;
+ i10 = HEAP32[i11 >> 2] | 0;
+ i11 = HEAP32[i11 + 4 >> 2] | 0;
+ d14 = (HEAP32[tempDoublePtr >> 2] = i10, +HEAPF32[tempDoublePtr >> 2]);
+ d13 = (HEAP32[tempDoublePtr >> 2] = i11, +HEAPF32[tempDoublePtr >> 2]);
+ i12 = i4 + (((i15 | 0) < (i12 | 0) ? i15 : 0) << 3) + 20 | 0;
+ i15 = HEAP32[i12 >> 2] | 0;
+ i12 = HEAP32[i12 + 4 >> 2] | 0;
+ d21 = (HEAP32[tempDoublePtr >> 2] = i15, +HEAPF32[tempDoublePtr >> 2]);
+ d18 = (HEAP32[tempDoublePtr >> 2] = i12, +HEAPF32[tempDoublePtr >> 2]);
+ if (i22) {
+ HEAP32[i5 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 1;
+ i22 = i4 + (i9 << 3) + 84 | 0;
+ i15 = HEAP32[i22 + 4 >> 2] | 0;
+ i12 = i1 + 40 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i12 + 4 >> 2] = i15;
+ d20 = +((d14 + d21) * .5);
+ d21 = +((d13 + d18) * .5);
+ i12 = i1 + 48 | 0;
+ HEAPF32[i12 >> 2] = d20;
+ HEAPF32[i12 + 4 >> 2] = d21;
+ i12 = i2;
+ i15 = HEAP32[i12 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ HEAP32[i1 + 16 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+ }
+ d16 = d7 - d14;
+ d20 = d6 - d13;
+ d19 = d7 - d21;
+ d17 = d6 - d18;
+ if (d16 * (d21 - d14) + d20 * (d18 - d13) <= 0.0) {
+ if (d16 * d16 + d20 * d20 > d8 * d8) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i5 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 1;
+ i4 = i1 + 40 | 0;
+ d21 = +d16;
+ d6 = +d20;
+ i22 = i4;
+ HEAPF32[i22 >> 2] = d21;
+ HEAPF32[i22 + 4 >> 2] = d6;
+ d6 = +Math_sqrt(+(d16 * d16 + d20 * d20));
+ if (!(d6 < 1.1920928955078125e-7)) {
+ d21 = 1.0 / d6;
+ HEAPF32[i4 >> 2] = d16 * d21;
+ HEAPF32[i1 + 44 >> 2] = d20 * d21;
+ }
+ i12 = i1 + 48 | 0;
+ HEAP32[i12 >> 2] = i10;
+ HEAP32[i12 + 4 >> 2] = i11;
+ i12 = i2;
+ i15 = HEAP32[i12 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ HEAP32[i1 + 16 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+ }
+ if (!(d19 * (d14 - d21) + d17 * (d13 - d18) <= 0.0)) {
+ d14 = (d14 + d21) * .5;
+ d13 = (d13 + d18) * .5;
+ i10 = i4 + (i9 << 3) + 84 | 0;
+ if ((d7 - d14) * +HEAPF32[i10 >> 2] + (d6 - d13) * +HEAPF32[i4 + (i9 << 3) + 88 >> 2] > d8) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i5 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 1;
+ i22 = i10;
+ i15 = HEAP32[i22 + 4 >> 2] | 0;
+ i12 = i1 + 40 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i12 + 4 >> 2] = i15;
+ d20 = +d14;
+ d21 = +d13;
+ i12 = i1 + 48 | 0;
+ HEAPF32[i12 >> 2] = d20;
+ HEAPF32[i12 + 4 >> 2] = d21;
+ i12 = i2;
+ i15 = HEAP32[i12 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ HEAP32[i1 + 16 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+ }
+ if (d19 * d19 + d17 * d17 > d8 * d8) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i5 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 1;
+ i4 = i1 + 40 | 0;
+ d21 = +d19;
+ d6 = +d17;
+ i22 = i4;
+ HEAPF32[i22 >> 2] = d21;
+ HEAPF32[i22 + 4 >> 2] = d6;
+ d6 = +Math_sqrt(+(d19 * d19 + d17 * d17));
+ if (!(d6 < 1.1920928955078125e-7)) {
+ d21 = 1.0 / d6;
+ HEAPF32[i4 >> 2] = d19 * d21;
+ HEAPF32[i1 + 44 >> 2] = d17 * d21;
+ }
+ i22 = i1 + 48 | 0;
+ HEAP32[i22 >> 2] = i15;
+ HEAP32[i22 + 4 >> 2] = i12;
+ i12 = i2;
+ i15 = HEAP32[i12 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ HEAP32[i1 + 16 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+}
+function __ZN15b2WorldManifold10InitializeEPK10b2ManifoldRK11b2TransformfS5_f(i1, i5, i7, d4, i8, d3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i7 = i7 | 0;
+ d4 = +d4;
+ i8 = i8 | 0;
+ d3 = +d3;
+ var i2 = 0, i6 = 0, d9 = 0.0, d10 = 0.0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0, d15 = 0.0, i16 = 0, d17 = 0.0, d18 = 0.0, d19 = 0.0, i20 = 0, d21 = 0.0, d22 = 0.0;
+ i2 = STACKTOP;
+ i6 = i5 + 60 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i11 = HEAP32[i5 + 56 >> 2] | 0;
+ if ((i11 | 0) == 2) {
+ i13 = i8 + 12 | 0;
+ d17 = +HEAPF32[i13 >> 2];
+ d18 = +HEAPF32[i5 + 40 >> 2];
+ i16 = i8 + 8 | 0;
+ d19 = +HEAPF32[i16 >> 2];
+ d15 = +HEAPF32[i5 + 44 >> 2];
+ d14 = d17 * d18 - d19 * d15;
+ d15 = d18 * d19 + d17 * d15;
+ d17 = +d14;
+ d19 = +d15;
+ i12 = i1;
+ HEAPF32[i12 >> 2] = d17;
+ HEAPF32[i12 + 4 >> 2] = d19;
+ d19 = +HEAPF32[i13 >> 2];
+ d17 = +HEAPF32[i5 + 48 >> 2];
+ d18 = +HEAPF32[i16 >> 2];
+ d10 = +HEAPF32[i5 + 52 >> 2];
+ d9 = +HEAPF32[i8 >> 2] + (d19 * d17 - d18 * d10);
+ d10 = d17 * d18 + d19 * d10 + +HEAPF32[i8 + 4 >> 2];
+ if ((HEAP32[i6 >> 2] | 0) > 0) {
+ i8 = i7 + 12 | 0;
+ i11 = i7 + 8 | 0;
+ i12 = i7 + 4 | 0;
+ i13 = i1 + 4 | 0;
+ i16 = 0;
+ do {
+ d18 = +HEAPF32[i8 >> 2];
+ d22 = +HEAPF32[i5 + (i16 * 20 | 0) >> 2];
+ d21 = +HEAPF32[i11 >> 2];
+ d17 = +HEAPF32[i5 + (i16 * 20 | 0) + 4 >> 2];
+ d19 = +HEAPF32[i7 >> 2] + (d18 * d22 - d21 * d17);
+ d17 = d22 * d21 + d18 * d17 + +HEAPF32[i12 >> 2];
+ d18 = d3 - (d14 * (d19 - d9) + (d17 - d10) * d15);
+ d19 = +((d19 - d14 * d4 + (d19 + d14 * d18)) * .5);
+ d14 = +((d17 - d15 * d4 + (d17 + d15 * d18)) * .5);
+ i20 = i1 + (i16 << 3) + 8 | 0;
+ HEAPF32[i20 >> 2] = d19;
+ HEAPF32[i20 + 4 >> 2] = d14;
+ i16 = i16 + 1 | 0;
+ d14 = +HEAPF32[i1 >> 2];
+ d15 = +HEAPF32[i13 >> 2];
+ } while ((i16 | 0) < (HEAP32[i6 >> 2] | 0));
+ }
+ d21 = +-d14;
+ d22 = +-d15;
+ i20 = i1;
+ HEAPF32[i20 >> 2] = d21;
+ HEAPF32[i20 + 4 >> 2] = d22;
+ STACKTOP = i2;
+ return;
+ } else if ((i11 | 0) == 1) {
+ i16 = i7 + 12 | 0;
+ d19 = +HEAPF32[i16 >> 2];
+ d21 = +HEAPF32[i5 + 40 >> 2];
+ i20 = i7 + 8 | 0;
+ d22 = +HEAPF32[i20 >> 2];
+ d15 = +HEAPF32[i5 + 44 >> 2];
+ d14 = d19 * d21 - d22 * d15;
+ d15 = d21 * d22 + d19 * d15;
+ d19 = +d14;
+ d22 = +d15;
+ i13 = i1;
+ HEAPF32[i13 >> 2] = d19;
+ HEAPF32[i13 + 4 >> 2] = d22;
+ d22 = +HEAPF32[i16 >> 2];
+ d19 = +HEAPF32[i5 + 48 >> 2];
+ d21 = +HEAPF32[i20 >> 2];
+ d10 = +HEAPF32[i5 + 52 >> 2];
+ d9 = +HEAPF32[i7 >> 2] + (d22 * d19 - d21 * d10);
+ d10 = d19 * d21 + d22 * d10 + +HEAPF32[i7 + 4 >> 2];
+ if ((HEAP32[i6 >> 2] | 0) <= 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i12 = i8 + 12 | 0;
+ i11 = i8 + 8 | 0;
+ i7 = i8 + 4 | 0;
+ i13 = i1 + 4 | 0;
+ i16 = 0;
+ while (1) {
+ d22 = +HEAPF32[i12 >> 2];
+ d17 = +HEAPF32[i5 + (i16 * 20 | 0) >> 2];
+ d18 = +HEAPF32[i11 >> 2];
+ d19 = +HEAPF32[i5 + (i16 * 20 | 0) + 4 >> 2];
+ d21 = +HEAPF32[i8 >> 2] + (d22 * d17 - d18 * d19);
+ d19 = d17 * d18 + d22 * d19 + +HEAPF32[i7 >> 2];
+ d22 = d4 - (d14 * (d21 - d9) + (d19 - d10) * d15);
+ d21 = +((d21 - d14 * d3 + (d21 + d14 * d22)) * .5);
+ d22 = +((d19 - d15 * d3 + (d19 + d15 * d22)) * .5);
+ i20 = i1 + (i16 << 3) + 8 | 0;
+ HEAPF32[i20 >> 2] = d21;
+ HEAPF32[i20 + 4 >> 2] = d22;
+ i16 = i16 + 1 | 0;
+ if ((i16 | 0) >= (HEAP32[i6 >> 2] | 0)) {
+ break;
+ }
+ d14 = +HEAPF32[i1 >> 2];
+ d15 = +HEAPF32[i13 >> 2];
+ }
+ STACKTOP = i2;
+ return;
+ } else if ((i11 | 0) == 0) {
+ HEAPF32[i1 >> 2] = 1.0;
+ i6 = i1 + 4 | 0;
+ HEAPF32[i6 >> 2] = 0.0;
+ d21 = +HEAPF32[i7 + 12 >> 2];
+ d22 = +HEAPF32[i5 + 48 >> 2];
+ d19 = +HEAPF32[i7 + 8 >> 2];
+ d10 = +HEAPF32[i5 + 52 >> 2];
+ d9 = +HEAPF32[i7 >> 2] + (d21 * d22 - d19 * d10);
+ d10 = d22 * d19 + d21 * d10 + +HEAPF32[i7 + 4 >> 2];
+ d21 = +HEAPF32[i8 + 12 >> 2];
+ d19 = +HEAPF32[i5 >> 2];
+ d22 = +HEAPF32[i8 + 8 >> 2];
+ d15 = +HEAPF32[i5 + 4 >> 2];
+ d14 = +HEAPF32[i8 >> 2] + (d21 * d19 - d22 * d15);
+ d15 = d19 * d22 + d21 * d15 + +HEAPF32[i8 + 4 >> 2];
+ d21 = d9 - d14;
+ d22 = d10 - d15;
+ if (d21 * d21 + d22 * d22 > 1.4210854715202004e-14) {
+ d19 = d14 - d9;
+ d17 = d15 - d10;
+ d22 = +d19;
+ d18 = +d17;
+ i20 = i1;
+ HEAPF32[i20 >> 2] = d22;
+ HEAPF32[i20 + 4 >> 2] = d18;
+ d18 = +Math_sqrt(+(d19 * d19 + d17 * d17));
+ if (!(d18 < 1.1920928955078125e-7)) {
+ d22 = 1.0 / d18;
+ d19 = d19 * d22;
+ HEAPF32[i1 >> 2] = d19;
+ d17 = d17 * d22;
+ HEAPF32[i6 >> 2] = d17;
+ }
+ } else {
+ d19 = 1.0;
+ d17 = 0.0;
+ }
+ d21 = +((d9 + d19 * d4 + (d14 - d19 * d3)) * .5);
+ d22 = +((d10 + d17 * d4 + (d15 - d17 * d3)) * .5);
+ i20 = i1 + 8 | 0;
+ HEAPF32[i20 >> 2] = d21;
+ HEAPF32[i20 + 4 >> 2] = d22;
+ STACKTOP = i2;
+ return;
+ } else {
+ STACKTOP = i2;
+ return;
+ }
+}
+function _main(i3, i2) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, d6 = 0.0, d7 = 0.0, i8 = 0, i9 = 0, d10 = 0.0, d11 = 0.0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, d22 = 0.0, d23 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 240 | 0;
+ i5 = i1;
+ i12 = i1 + 224 | 0;
+ i4 = i1 + 168 | 0;
+ i9 = i1 + 160 | 0;
+ i8 = i1 + 152 | 0;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i14 = HEAP8[HEAP32[i2 + 4 >> 2] | 0] | 0;
+ switch (i14 | 0) {
+ case 49:
+ {
+ HEAP32[2] = 5;
+ HEAP32[4] = 35;
+ i15 = 35;
+ i14 = 5;
+ break L1;
+ }
+ case 50:
+ {
+ HEAP32[2] = 32;
+ HEAP32[4] = 161;
+ i15 = 161;
+ i14 = 32;
+ break L1;
+ }
+ case 51:
+ {
+ i13 = 5;
+ break L1;
+ }
+ case 52:
+ {
+ HEAP32[2] = 320;
+ HEAP32[4] = 2331;
+ i15 = 2331;
+ i14 = 320;
+ break L1;
+ }
+ case 53:
+ {
+ HEAP32[2] = 640;
+ HEAP32[4] = 5661;
+ i15 = 5661;
+ i14 = 640;
+ break L1;
+ }
+ case 48:
+ {
+ i20 = 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ default:
+ {
+ HEAP32[i5 >> 2] = i14 + -48;
+ _printf(80, i5 | 0) | 0;
+ i20 = -1;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ }
+ } else {
+ i13 = 5;
+ }
+ } while (0);
+ if ((i13 | 0) == 5) {
+ HEAP32[2] = 64;
+ HEAP32[4] = 333;
+ i15 = 333;
+ i14 = 64;
+ }
+ i13 = i15 + i14 | 0;
+ HEAP32[4] = i13;
+ HEAP32[2] = 0;
+ HEAP32[8] = __Znaj(i13 >>> 0 > 1073741823 ? -1 : i13 << 2) | 0;
+ HEAPF32[i12 >> 2] = 0.0;
+ HEAPF32[i12 + 4 >> 2] = -10.0;
+ i15 = __Znwj(103028) | 0;
+ __ZN7b2WorldC2ERK6b2Vec2(i15, i12);
+ HEAP32[6] = i15;
+ __ZN7b2World16SetAllowSleepingEb(i15, 0);
+ HEAP32[i5 + 44 >> 2] = 0;
+ i15 = i5 + 4 | 0;
+ i14 = i5 + 36 | 0;
+ HEAP32[i15 + 0 >> 2] = 0;
+ HEAP32[i15 + 4 >> 2] = 0;
+ HEAP32[i15 + 8 >> 2] = 0;
+ HEAP32[i15 + 12 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 24 >> 2] = 0;
+ HEAP32[i15 + 28 >> 2] = 0;
+ HEAP8[i14] = 1;
+ HEAP8[i5 + 37 | 0] = 1;
+ HEAP8[i5 + 38 | 0] = 0;
+ HEAP8[i5 + 39 | 0] = 0;
+ HEAP32[i5 >> 2] = 0;
+ HEAP8[i5 + 40 | 0] = 1;
+ HEAPF32[i5 + 48 >> 2] = 1.0;
+ i14 = __ZN7b2World10CreateBodyEPK9b2BodyDef(HEAP32[6] | 0, i5) | 0;
+ HEAP32[i4 >> 2] = 240;
+ HEAP32[i4 + 4 >> 2] = 1;
+ HEAPF32[i4 + 8 >> 2] = .009999999776482582;
+ i15 = i4 + 28 | 0;
+ HEAP32[i15 + 0 >> 2] = 0;
+ HEAP32[i15 + 4 >> 2] = 0;
+ HEAP32[i15 + 8 >> 2] = 0;
+ HEAP32[i15 + 12 >> 2] = 0;
+ HEAP16[i15 + 16 >> 1] = 0;
+ HEAPF32[i9 >> 2] = -40.0;
+ HEAPF32[i9 + 4 >> 2] = 0.0;
+ HEAPF32[i8 >> 2] = 40.0;
+ HEAPF32[i8 + 4 >> 2] = 0.0;
+ __ZN11b2EdgeShape3SetERK6b2Vec2S2_(i4, i9, i8);
+ __ZN6b2Body13CreateFixtureEPK7b2Shapef(i14, i4, 0.0) | 0;
+ HEAP32[i5 >> 2] = 504;
+ HEAP32[i5 + 4 >> 2] = 2;
+ HEAPF32[i5 + 8 >> 2] = .009999999776482582;
+ HEAP32[i5 + 148 >> 2] = 0;
+ HEAPF32[i5 + 12 >> 2] = 0.0;
+ HEAPF32[i5 + 16 >> 2] = 0.0;
+ __ZN14b2PolygonShape8SetAsBoxEff(i5, .5, .5);
+ i14 = i4 + 44 | 0;
+ i15 = i4 + 4 | 0;
+ i8 = i4 + 36 | 0;
+ i17 = i4 + 37 | 0;
+ i18 = i4 + 38 | 0;
+ i19 = i4 + 39 | 0;
+ i20 = i4 + 40 | 0;
+ i13 = i4 + 48 | 0;
+ i12 = i4 + 4 | 0;
+ d11 = -7.0;
+ d10 = .75;
+ i9 = 0;
+ while (1) {
+ d7 = d11;
+ d6 = d10;
+ i16 = i9;
+ while (1) {
+ HEAP32[i14 >> 2] = 0;
+ HEAP32[i15 + 0 >> 2] = 0;
+ HEAP32[i15 + 4 >> 2] = 0;
+ HEAP32[i15 + 8 >> 2] = 0;
+ HEAP32[i15 + 12 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 24 >> 2] = 0;
+ HEAP32[i15 + 28 >> 2] = 0;
+ HEAP8[i8] = 1;
+ HEAP8[i17] = 1;
+ HEAP8[i18] = 0;
+ HEAP8[i19] = 0;
+ HEAP8[i20] = 1;
+ HEAPF32[i13 >> 2] = 1.0;
+ HEAP32[i4 >> 2] = 2;
+ d23 = +d7;
+ d22 = +d6;
+ i21 = i12;
+ HEAPF32[i21 >> 2] = d23;
+ HEAPF32[i21 + 4 >> 2] = d22;
+ i21 = __ZN7b2World10CreateBodyEPK9b2BodyDef(HEAP32[6] | 0, i4) | 0;
+ __ZN6b2Body13CreateFixtureEPK7b2Shapef(i21, i5, 5.0) | 0;
+ HEAP32[14] = i21;
+ i16 = i16 + 1 | 0;
+ if ((i16 | 0) >= 40) {
+ break;
+ } else {
+ d7 = d7 + 1.125;
+ d6 = d6 + 0.0;
+ }
+ }
+ i9 = i9 + 1 | 0;
+ if ((i9 | 0) >= 40) {
+ break;
+ } else {
+ d11 = d11 + .5625;
+ d10 = d10 + 1.0;
+ }
+ }
+ if ((HEAP32[2] | 0) > 0) {
+ i4 = 0;
+ do {
+ __ZN7b2World4StepEfii(HEAP32[6] | 0, .01666666753590107, 3, 3);
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) < (HEAP32[2] | 0));
+ }
+ if ((i3 | 0) > 2) {
+ i21 = (HEAP8[HEAP32[i2 + 8 >> 2] | 0] | 0) + -48 | 0;
+ HEAP32[18] = i21;
+ if ((i21 | 0) != 0) {
+ _puts(208) | 0;
+ _emscripten_set_main_loop(2, 60, 1);
+ i21 = 0;
+ STACKTOP = i1;
+ return i21 | 0;
+ }
+ } else {
+ HEAP32[18] = 0;
+ }
+ while (1) {
+ __Z4iterv();
+ if ((HEAP32[16] | 0) > (HEAP32[4] | 0)) {
+ i2 = 0;
+ break;
+ }
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function __ZN9b2Simplex9ReadCacheEPK14b2SimplexCachePK15b2DistanceProxyRK11b2TransformS5_S8_(i2, i11, i10, i4, i3, i5) {
+ i2 = i2 | 0;
+ i11 = i11 | 0;
+ i10 = i10 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i6 = 0, i7 = 0, d8 = 0.0, i9 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, d24 = 0.0, d25 = 0.0, i26 = 0, d27 = 0.0, d28 = 0.0, d29 = 0.0, d30 = 0.0, d31 = 0.0, d32 = 0.0;
+ i1 = STACKTOP;
+ i13 = HEAP16[i11 + 4 >> 1] | 0;
+ if (!((i13 & 65535) < 4)) {
+ ___assert_fail(2872, 2672, 102, 2896);
+ }
+ i12 = i13 & 65535;
+ i6 = i2 + 108 | 0;
+ HEAP32[i6 >> 2] = i12;
+ L4 : do {
+ if (!(i13 << 16 >> 16 == 0)) {
+ i17 = i10 + 20 | 0;
+ i21 = i10 + 16 | 0;
+ i13 = i3 + 20 | 0;
+ i14 = i3 + 16 | 0;
+ i15 = i4 + 12 | 0;
+ i16 = i4 + 8 | 0;
+ i12 = i4 + 4 | 0;
+ i18 = i5 + 12 | 0;
+ i19 = i5 + 8 | 0;
+ i20 = i5 + 4 | 0;
+ i22 = 0;
+ while (1) {
+ i26 = HEAPU8[i11 + i22 + 6 | 0] | 0;
+ HEAP32[i2 + (i22 * 36 | 0) + 28 >> 2] = i26;
+ i23 = HEAPU8[i11 + i22 + 9 | 0] | 0;
+ HEAP32[i2 + (i22 * 36 | 0) + 32 >> 2] = i23;
+ if ((HEAP32[i17 >> 2] | 0) <= (i26 | 0)) {
+ i9 = 6;
+ break;
+ }
+ i26 = (HEAP32[i21 >> 2] | 0) + (i26 << 3) | 0;
+ d25 = +HEAPF32[i26 >> 2];
+ d24 = +HEAPF32[i26 + 4 >> 2];
+ if ((HEAP32[i13 >> 2] | 0) <= (i23 | 0)) {
+ i9 = 8;
+ break;
+ }
+ i23 = (HEAP32[i14 >> 2] | 0) + (i23 << 3) | 0;
+ d29 = +HEAPF32[i23 >> 2];
+ d31 = +HEAPF32[i23 + 4 >> 2];
+ d32 = +HEAPF32[i15 >> 2];
+ d30 = +HEAPF32[i16 >> 2];
+ d27 = +HEAPF32[i4 >> 2] + (d25 * d32 - d24 * d30);
+ d28 = +d27;
+ d30 = +(d24 * d32 + d25 * d30 + +HEAPF32[i12 >> 2]);
+ i23 = i2 + (i22 * 36 | 0) | 0;
+ HEAPF32[i23 >> 2] = d28;
+ HEAPF32[i23 + 4 >> 2] = d30;
+ d30 = +HEAPF32[i18 >> 2];
+ d25 = +HEAPF32[i19 >> 2];
+ d24 = +HEAPF32[i5 >> 2] + (d29 * d30 - d31 * d25);
+ d28 = +d24;
+ d25 = +(d31 * d30 + d29 * d25 + +HEAPF32[i20 >> 2]);
+ i23 = i2 + (i22 * 36 | 0) + 8 | 0;
+ HEAPF32[i23 >> 2] = d28;
+ HEAPF32[i23 + 4 >> 2] = d25;
+ d24 = +(d24 - d27);
+ d25 = +(+HEAPF32[i2 + (i22 * 36 | 0) + 12 >> 2] - +HEAPF32[i2 + (i22 * 36 | 0) + 4 >> 2]);
+ i23 = i2 + (i22 * 36 | 0) + 16 | 0;
+ HEAPF32[i23 >> 2] = d24;
+ HEAPF32[i23 + 4 >> 2] = d25;
+ HEAPF32[i2 + (i22 * 36 | 0) + 24 >> 2] = 0.0;
+ i22 = i22 + 1 | 0;
+ i23 = HEAP32[i6 >> 2] | 0;
+ if ((i22 | 0) >= (i23 | 0)) {
+ i7 = i23;
+ break L4;
+ }
+ }
+ if ((i9 | 0) == 6) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ } else if ((i9 | 0) == 8) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ }
+ } else {
+ i7 = i12;
+ }
+ } while (0);
+ do {
+ if ((i7 | 0) > 1) {
+ d24 = +HEAPF32[i11 >> 2];
+ if ((i7 | 0) == 2) {
+ d32 = +HEAPF32[i2 + 16 >> 2] - +HEAPF32[i2 + 52 >> 2];
+ d8 = +HEAPF32[i2 + 20 >> 2] - +HEAPF32[i2 + 56 >> 2];
+ d8 = +Math_sqrt(+(d32 * d32 + d8 * d8));
+ } else if ((i7 | 0) == 3) {
+ d8 = +HEAPF32[i2 + 16 >> 2];
+ d32 = +HEAPF32[i2 + 20 >> 2];
+ d8 = (+HEAPF32[i2 + 52 >> 2] - d8) * (+HEAPF32[i2 + 92 >> 2] - d32) - (+HEAPF32[i2 + 56 >> 2] - d32) * (+HEAPF32[i2 + 88 >> 2] - d8);
+ } else {
+ ___assert_fail(2712, 2672, 259, 2736);
+ }
+ if (!(d8 < d24 * .5) ? !(d24 * 2.0 < d8 | d8 < 1.1920928955078125e-7) : 0) {
+ i9 = 18;
+ break;
+ }
+ HEAP32[i6 >> 2] = 0;
+ } else {
+ i9 = 18;
+ }
+ } while (0);
+ if ((i9 | 0) == 18 ? (i7 | 0) != 0 : 0) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i2 + 28 >> 2] = 0;
+ HEAP32[i2 + 32 >> 2] = 0;
+ if ((HEAP32[i10 + 20 >> 2] | 0) <= 0) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ }
+ i26 = HEAP32[i10 + 16 >> 2] | 0;
+ d8 = +HEAPF32[i26 >> 2];
+ d24 = +HEAPF32[i26 + 4 >> 2];
+ if ((HEAP32[i3 + 20 >> 2] | 0) <= 0) {
+ ___assert_fail(2776, 2808, 103, 2840);
+ }
+ i26 = HEAP32[i3 + 16 >> 2] | 0;
+ d27 = +HEAPF32[i26 >> 2];
+ d25 = +HEAPF32[i26 + 4 >> 2];
+ d30 = +HEAPF32[i4 + 12 >> 2];
+ d32 = +HEAPF32[i4 + 8 >> 2];
+ d31 = +HEAPF32[i4 >> 2] + (d8 * d30 - d24 * d32);
+ d32 = d24 * d30 + d8 * d32 + +HEAPF32[i4 + 4 >> 2];
+ d30 = +d31;
+ d28 = +d32;
+ i26 = i2;
+ HEAPF32[i26 >> 2] = d30;
+ HEAPF32[i26 + 4 >> 2] = d28;
+ d28 = +HEAPF32[i5 + 12 >> 2];
+ d30 = +HEAPF32[i5 + 8 >> 2];
+ d29 = +HEAPF32[i5 >> 2] + (d27 * d28 - d25 * d30);
+ d30 = d25 * d28 + d27 * d30 + +HEAPF32[i5 + 4 >> 2];
+ d27 = +d29;
+ d28 = +d30;
+ i26 = i2 + 8 | 0;
+ HEAPF32[i26 >> 2] = d27;
+ HEAPF32[i26 + 4 >> 2] = d28;
+ d31 = +(d29 - d31);
+ d32 = +(d30 - d32);
+ i26 = i2 + 16 | 0;
+ HEAPF32[i26 >> 2] = d31;
+ HEAPF32[i26 + 4 >> 2] = d32;
+ HEAP32[i6 >> 2] = 1;
+ STACKTOP = i1;
+ return;
+}
+function __ZNSt3__17__sort4IRPFbRK6b2PairS3_EPS1_EEjT0_S8_S8_S8_T_(i6, i7, i5, i4, i1) {
+ i6 = i6 | 0;
+ i7 = i7 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i9 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i7, i6) | 0;
+ i8 = FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i7) | 0;
+ do {
+ if (i9) {
+ if (i8) {
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ i8 = 1;
+ break;
+ }
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i7) | 0) {
+ HEAP32[i3 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ i8 = 2;
+ } else {
+ i8 = 1;
+ }
+ } else {
+ if (i8) {
+ HEAP32[i3 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i7, i6) | 0) {
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ i8 = 2;
+ } else {
+ i8 = 1;
+ }
+ } else {
+ i8 = 0;
+ }
+ }
+ } while (0);
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i4, i5) | 0)) {
+ i9 = i8;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ HEAP32[i3 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i4 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i5, i7) | 0)) {
+ i9 = i8 + 1 | 0;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ HEAP32[i3 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ if (!(FUNCTION_TABLE_iii[HEAP32[i1 >> 2] & 3](i7, i6) | 0)) {
+ i9 = i8 + 2 | 0;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ HEAP32[i6 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ i9 = i8 + 3 | 0;
+ STACKTOP = i2;
+ return i9 | 0;
+}
+function __ZN15b2ContactSolver27SolveTOIPositionConstraintsEii(i9, i2, i5) {
+ i9 = i9 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, d27 = 0.0, d28 = 0.0, d29 = 0.0, d30 = 0.0, d31 = 0.0, d32 = 0.0, d33 = 0.0, d34 = 0.0, d35 = 0.0, d36 = 0.0, i37 = 0, d38 = 0.0, d39 = 0.0, d40 = 0.0, d41 = 0.0, d42 = 0.0, d43 = 0.0, d44 = 0.0, d45 = 0.0, i46 = 0, d47 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i8 = i1 + 40 | 0;
+ i3 = i1 + 24 | 0;
+ i4 = i1;
+ i6 = i9 + 48 | 0;
+ if ((HEAP32[i6 >> 2] | 0) <= 0) {
+ d45 = 0.0;
+ i37 = d45 >= -.007499999832361937;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ i7 = i9 + 36 | 0;
+ i14 = i9 + 24 | 0;
+ i9 = i8 + 8 | 0;
+ i15 = i8 + 12 | 0;
+ i10 = i3 + 8 | 0;
+ i11 = i3 + 12 | 0;
+ i12 = i4 + 8 | 0;
+ i13 = i4 + 16 | 0;
+ i16 = 0;
+ d34 = 0.0;
+ do {
+ i37 = HEAP32[i7 >> 2] | 0;
+ i19 = i37 + (i16 * 88 | 0) | 0;
+ i17 = HEAP32[i37 + (i16 * 88 | 0) + 32 >> 2] | 0;
+ i18 = HEAP32[i37 + (i16 * 88 | 0) + 36 >> 2] | 0;
+ i20 = i37 + (i16 * 88 | 0) + 48 | 0;
+ d21 = +HEAPF32[i20 >> 2];
+ d22 = +HEAPF32[i20 + 4 >> 2];
+ i20 = i37 + (i16 * 88 | 0) + 56 | 0;
+ d23 = +HEAPF32[i20 >> 2];
+ d24 = +HEAPF32[i20 + 4 >> 2];
+ i20 = HEAP32[i37 + (i16 * 88 | 0) + 84 >> 2] | 0;
+ if ((i17 | 0) == (i2 | 0) | (i17 | 0) == (i5 | 0)) {
+ d26 = +HEAPF32[i37 + (i16 * 88 | 0) + 64 >> 2];
+ d27 = +HEAPF32[i37 + (i16 * 88 | 0) + 40 >> 2];
+ } else {
+ d26 = 0.0;
+ d27 = 0.0;
+ }
+ d25 = +HEAPF32[i37 + (i16 * 88 | 0) + 44 >> 2];
+ d28 = +HEAPF32[i37 + (i16 * 88 | 0) + 68 >> 2];
+ i37 = HEAP32[i14 >> 2] | 0;
+ i46 = i37 + (i17 * 12 | 0) | 0;
+ d33 = +HEAPF32[i46 >> 2];
+ d35 = +HEAPF32[i46 + 4 >> 2];
+ d29 = +HEAPF32[i37 + (i17 * 12 | 0) + 8 >> 2];
+ i46 = i37 + (i18 * 12 | 0) | 0;
+ d32 = +HEAPF32[i46 >> 2];
+ d36 = +HEAPF32[i46 + 4 >> 2];
+ d31 = +HEAPF32[i37 + (i18 * 12 | 0) + 8 >> 2];
+ if ((i20 | 0) > 0) {
+ d30 = d27 + d25;
+ i37 = 0;
+ do {
+ d38 = +Math_sin(+d29);
+ HEAPF32[i9 >> 2] = d38;
+ d44 = +Math_cos(+d29);
+ HEAPF32[i15 >> 2] = d44;
+ d43 = +Math_sin(+d31);
+ HEAPF32[i10 >> 2] = d43;
+ d41 = +Math_cos(+d31);
+ HEAPF32[i11 >> 2] = d41;
+ d40 = +(d33 - (d21 * d44 - d22 * d38));
+ d38 = +(d35 - (d22 * d44 + d21 * d38));
+ i46 = i8;
+ HEAPF32[i46 >> 2] = d40;
+ HEAPF32[i46 + 4 >> 2] = d38;
+ d38 = +(d32 - (d23 * d41 - d24 * d43));
+ d43 = +(d36 - (d24 * d41 + d23 * d43));
+ i46 = i3;
+ HEAPF32[i46 >> 2] = d38;
+ HEAPF32[i46 + 4 >> 2] = d43;
+ __ZN24b2PositionSolverManifold10InitializeEP27b2ContactPositionConstraintRK11b2TransformS4_i(i4, i19, i8, i3, i37);
+ i46 = i4;
+ d43 = +HEAPF32[i46 >> 2];
+ d38 = +HEAPF32[i46 + 4 >> 2];
+ i46 = i12;
+ d41 = +HEAPF32[i46 >> 2];
+ d40 = +HEAPF32[i46 + 4 >> 2];
+ d44 = +HEAPF32[i13 >> 2];
+ d39 = d41 - d33;
+ d42 = d40 - d35;
+ d41 = d41 - d32;
+ d40 = d40 - d36;
+ d34 = d34 < d44 ? d34 : d44;
+ d44 = (d44 + .004999999888241291) * .75;
+ d44 = d44 < 0.0 ? d44 : 0.0;
+ d45 = d38 * d39 - d43 * d42;
+ d47 = d38 * d41 - d43 * d40;
+ d45 = d47 * d28 * d47 + (d30 + d45 * d26 * d45);
+ if (d45 > 0.0) {
+ d44 = -(d44 < -.20000000298023224 ? -.20000000298023224 : d44) / d45;
+ } else {
+ d44 = 0.0;
+ }
+ d47 = d43 * d44;
+ d45 = d38 * d44;
+ d33 = d33 - d27 * d47;
+ d35 = d35 - d27 * d45;
+ d29 = d29 - d26 * (d39 * d45 - d42 * d47);
+ d32 = d32 + d25 * d47;
+ d36 = d36 + d25 * d45;
+ d31 = d31 + d28 * (d41 * d45 - d40 * d47);
+ i37 = i37 + 1 | 0;
+ } while ((i37 | 0) != (i20 | 0));
+ i37 = HEAP32[i14 >> 2] | 0;
+ }
+ d47 = +d33;
+ d45 = +d35;
+ i46 = i37 + (i17 * 12 | 0) | 0;
+ HEAPF32[i46 >> 2] = d47;
+ HEAPF32[i46 + 4 >> 2] = d45;
+ i46 = HEAP32[i14 >> 2] | 0;
+ HEAPF32[i46 + (i17 * 12 | 0) + 8 >> 2] = d29;
+ d45 = +d32;
+ d47 = +d36;
+ i46 = i46 + (i18 * 12 | 0) | 0;
+ HEAPF32[i46 >> 2] = d45;
+ HEAPF32[i46 + 4 >> 2] = d47;
+ HEAPF32[(HEAP32[i14 >> 2] | 0) + (i18 * 12 | 0) + 8 >> 2] = d31;
+ i16 = i16 + 1 | 0;
+ } while ((i16 | 0) < (HEAP32[i6 >> 2] | 0));
+ i46 = d34 >= -.007499999832361937;
+ STACKTOP = i1;
+ return i46 | 0;
+}
+function __ZN15b2ContactSolver24SolvePositionConstraintsEv(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, i21 = 0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0, i26 = 0, d27 = 0.0, d28 = 0.0, d29 = 0.0, d30 = 0.0, d31 = 0.0, d32 = 0.0, d33 = 0.0, d34 = 0.0, i35 = 0, d36 = 0.0, d37 = 0.0, d38 = 0.0, d39 = 0.0, d40 = 0.0, d41 = 0.0, d42 = 0.0, d43 = 0.0, i44 = 0, d45 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i4 = i1 + 40 | 0;
+ i5 = i1 + 24 | 0;
+ i3 = i1;
+ i2 = i7 + 48 | 0;
+ if ((HEAP32[i2 >> 2] | 0) <= 0) {
+ d43 = 0.0;
+ i35 = d43 >= -.014999999664723873;
+ STACKTOP = i1;
+ return i35 | 0;
+ }
+ i6 = i7 + 36 | 0;
+ i9 = i7 + 24 | 0;
+ i13 = i4 + 8 | 0;
+ i7 = i4 + 12 | 0;
+ i8 = i5 + 8 | 0;
+ i12 = i5 + 12 | 0;
+ i10 = i3 + 8 | 0;
+ i11 = i3 + 16 | 0;
+ i35 = HEAP32[i9 >> 2] | 0;
+ i15 = 0;
+ d32 = 0.0;
+ do {
+ i21 = HEAP32[i6 >> 2] | 0;
+ i26 = i21 + (i15 * 88 | 0) | 0;
+ i16 = HEAP32[i21 + (i15 * 88 | 0) + 32 >> 2] | 0;
+ i14 = HEAP32[i21 + (i15 * 88 | 0) + 36 >> 2] | 0;
+ i44 = i21 + (i15 * 88 | 0) + 48 | 0;
+ d22 = +HEAPF32[i44 >> 2];
+ d23 = +HEAPF32[i44 + 4 >> 2];
+ d25 = +HEAPF32[i21 + (i15 * 88 | 0) + 40 >> 2];
+ d18 = +HEAPF32[i21 + (i15 * 88 | 0) + 64 >> 2];
+ i44 = i21 + (i15 * 88 | 0) + 56 | 0;
+ d24 = +HEAPF32[i44 >> 2];
+ d19 = +HEAPF32[i44 + 4 >> 2];
+ d17 = +HEAPF32[i21 + (i15 * 88 | 0) + 44 >> 2];
+ d20 = +HEAPF32[i21 + (i15 * 88 | 0) + 68 >> 2];
+ i21 = HEAP32[i21 + (i15 * 88 | 0) + 84 >> 2] | 0;
+ i44 = i35 + (i16 * 12 | 0) | 0;
+ d28 = +HEAPF32[i44 >> 2];
+ d33 = +HEAPF32[i44 + 4 >> 2];
+ d29 = +HEAPF32[i35 + (i16 * 12 | 0) + 8 >> 2];
+ i44 = i35 + (i14 * 12 | 0) | 0;
+ d30 = +HEAPF32[i44 >> 2];
+ d34 = +HEAPF32[i44 + 4 >> 2];
+ d31 = +HEAPF32[i35 + (i14 * 12 | 0) + 8 >> 2];
+ if ((i21 | 0) > 0) {
+ d27 = d25 + d17;
+ i35 = 0;
+ do {
+ d41 = +Math_sin(+d29);
+ HEAPF32[i13 >> 2] = d41;
+ d42 = +Math_cos(+d29);
+ HEAPF32[i7 >> 2] = d42;
+ d39 = +Math_sin(+d31);
+ HEAPF32[i8 >> 2] = d39;
+ d38 = +Math_cos(+d31);
+ HEAPF32[i12 >> 2] = d38;
+ d40 = +(d28 - (d22 * d42 - d23 * d41));
+ d41 = +(d33 - (d23 * d42 + d22 * d41));
+ i44 = i4;
+ HEAPF32[i44 >> 2] = d40;
+ HEAPF32[i44 + 4 >> 2] = d41;
+ d41 = +(d30 - (d24 * d38 - d19 * d39));
+ d39 = +(d34 - (d19 * d38 + d24 * d39));
+ i44 = i5;
+ HEAPF32[i44 >> 2] = d41;
+ HEAPF32[i44 + 4 >> 2] = d39;
+ __ZN24b2PositionSolverManifold10InitializeEP27b2ContactPositionConstraintRK11b2TransformS4_i(i3, i26, i4, i5, i35);
+ i44 = i3;
+ d39 = +HEAPF32[i44 >> 2];
+ d41 = +HEAPF32[i44 + 4 >> 2];
+ i44 = i10;
+ d38 = +HEAPF32[i44 >> 2];
+ d40 = +HEAPF32[i44 + 4 >> 2];
+ d42 = +HEAPF32[i11 >> 2];
+ d36 = d38 - d28;
+ d37 = d40 - d33;
+ d38 = d38 - d30;
+ d40 = d40 - d34;
+ d32 = d32 < d42 ? d32 : d42;
+ d42 = (d42 + .004999999888241291) * .20000000298023224;
+ d43 = d42 < 0.0 ? d42 : 0.0;
+ d42 = d41 * d36 - d39 * d37;
+ d45 = d41 * d38 - d39 * d40;
+ d42 = d45 * d20 * d45 + (d27 + d42 * d18 * d42);
+ if (d42 > 0.0) {
+ d42 = -(d43 < -.20000000298023224 ? -.20000000298023224 : d43) / d42;
+ } else {
+ d42 = 0.0;
+ }
+ d45 = d39 * d42;
+ d43 = d41 * d42;
+ d28 = d28 - d25 * d45;
+ d33 = d33 - d25 * d43;
+ d29 = d29 - d18 * (d36 * d43 - d37 * d45);
+ d30 = d30 + d17 * d45;
+ d34 = d34 + d17 * d43;
+ d31 = d31 + d20 * (d38 * d43 - d40 * d45);
+ i35 = i35 + 1 | 0;
+ } while ((i35 | 0) != (i21 | 0));
+ i35 = HEAP32[i9 >> 2] | 0;
+ }
+ d45 = +d28;
+ d43 = +d33;
+ i35 = i35 + (i16 * 12 | 0) | 0;
+ HEAPF32[i35 >> 2] = d45;
+ HEAPF32[i35 + 4 >> 2] = d43;
+ i35 = HEAP32[i9 >> 2] | 0;
+ HEAPF32[i35 + (i16 * 12 | 0) + 8 >> 2] = d29;
+ d43 = +d30;
+ d45 = +d34;
+ i35 = i35 + (i14 * 12 | 0) | 0;
+ HEAPF32[i35 >> 2] = d43;
+ HEAPF32[i35 + 4 >> 2] = d45;
+ i35 = HEAP32[i9 >> 2] | 0;
+ HEAPF32[i35 + (i14 * 12 | 0) + 8 >> 2] = d31;
+ i15 = i15 + 1 | 0;
+ } while ((i15 | 0) < (HEAP32[i2 >> 2] | 0));
+ i44 = d32 >= -.014999999664723873;
+ STACKTOP = i1;
+ return i44 | 0;
+}
+function __Z22b2CollideEdgeAndCircleP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK13b2CircleShapeS6_(i1, i7, i6, i22, i5) {
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i22 = i22 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, i14 = 0, i15 = 0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, d23 = 0.0, d24 = 0.0;
+ i4 = STACKTOP;
+ i2 = i1 + 60 | 0;
+ HEAP32[i2 >> 2] = 0;
+ i3 = i22 + 12 | 0;
+ d9 = +HEAPF32[i5 + 12 >> 2];
+ d23 = +HEAPF32[i3 >> 2];
+ d17 = +HEAPF32[i5 + 8 >> 2];
+ d18 = +HEAPF32[i22 + 16 >> 2];
+ d21 = +HEAPF32[i5 >> 2] + (d9 * d23 - d17 * d18) - +HEAPF32[i6 >> 2];
+ d18 = d23 * d17 + d9 * d18 + +HEAPF32[i5 + 4 >> 2] - +HEAPF32[i6 + 4 >> 2];
+ d9 = +HEAPF32[i6 + 12 >> 2];
+ d17 = +HEAPF32[i6 + 8 >> 2];
+ d23 = d21 * d9 + d18 * d17;
+ d17 = d9 * d18 - d21 * d17;
+ i6 = i7 + 12 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i6 = HEAP32[i6 + 4 >> 2] | 0;
+ d21 = (HEAP32[tempDoublePtr >> 2] = i5, +HEAPF32[tempDoublePtr >> 2]);
+ d18 = (HEAP32[tempDoublePtr >> 2] = i6, +HEAPF32[tempDoublePtr >> 2]);
+ i15 = i7 + 20 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ i15 = HEAP32[i15 + 4 >> 2] | 0;
+ d9 = (HEAP32[tempDoublePtr >> 2] = i14, +HEAPF32[tempDoublePtr >> 2]);
+ d10 = (HEAP32[tempDoublePtr >> 2] = i15, +HEAPF32[tempDoublePtr >> 2]);
+ d8 = d9 - d21;
+ d16 = d10 - d18;
+ d19 = d8 * (d9 - d23) + d16 * (d10 - d17);
+ d13 = d23 - d21;
+ d12 = d17 - d18;
+ d20 = d13 * d8 + d12 * d16;
+ d11 = +HEAPF32[i7 + 8 >> 2] + +HEAPF32[i22 + 8 >> 2];
+ if (d20 <= 0.0) {
+ if (d13 * d13 + d12 * d12 > d11 * d11) {
+ STACKTOP = i4;
+ return;
+ }
+ if ((HEAP8[i7 + 44 | 0] | 0) != 0 ? (i22 = i7 + 28 | 0, d24 = +HEAPF32[i22 >> 2], (d21 - d23) * (d21 - d24) + (d18 - d17) * (d18 - +HEAPF32[i22 + 4 >> 2]) > 0.0) : 0) {
+ STACKTOP = i4;
+ return;
+ }
+ HEAP32[i2 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 0;
+ HEAPF32[i1 + 40 >> 2] = 0.0;
+ HEAPF32[i1 + 44 >> 2] = 0.0;
+ i14 = i1 + 48 | 0;
+ HEAP32[i14 >> 2] = i5;
+ HEAP32[i14 + 4 >> 2] = i6;
+ i14 = i1 + 16 | 0;
+ HEAP32[i14 >> 2] = 0;
+ HEAP8[i14] = 0;
+ HEAP8[i14 + 1 | 0] = 0;
+ HEAP8[i14 + 2 | 0] = 0;
+ HEAP8[i14 + 3 | 0] = 0;
+ i14 = i3;
+ i15 = HEAP32[i14 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ STACKTOP = i4;
+ return;
+ }
+ if (d19 <= 0.0) {
+ d8 = d23 - d9;
+ d12 = d17 - d10;
+ if (d8 * d8 + d12 * d12 > d11 * d11) {
+ STACKTOP = i4;
+ return;
+ }
+ if ((HEAP8[i7 + 45 | 0] | 0) != 0 ? (i22 = i7 + 36 | 0, d24 = +HEAPF32[i22 >> 2], d8 * (d24 - d9) + d12 * (+HEAPF32[i22 + 4 >> 2] - d10) > 0.0) : 0) {
+ STACKTOP = i4;
+ return;
+ }
+ HEAP32[i2 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 0;
+ HEAPF32[i1 + 40 >> 2] = 0.0;
+ HEAPF32[i1 + 44 >> 2] = 0.0;
+ i22 = i1 + 48 | 0;
+ HEAP32[i22 >> 2] = i14;
+ HEAP32[i22 + 4 >> 2] = i15;
+ i14 = i1 + 16 | 0;
+ HEAP32[i14 >> 2] = 0;
+ HEAP8[i14] = 1;
+ HEAP8[i14 + 1 | 0] = 0;
+ HEAP8[i14 + 2 | 0] = 0;
+ HEAP8[i14 + 3 | 0] = 0;
+ i14 = i3;
+ i15 = HEAP32[i14 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ STACKTOP = i4;
+ return;
+ }
+ d24 = d8 * d8 + d16 * d16;
+ if (!(d24 > 0.0)) {
+ ___assert_fail(5560, 5576, 127, 5616);
+ }
+ d24 = 1.0 / d24;
+ d23 = d23 - (d21 * d19 + d9 * d20) * d24;
+ d24 = d17 - (d18 * d19 + d10 * d20) * d24;
+ if (d23 * d23 + d24 * d24 > d11 * d11) {
+ STACKTOP = i4;
+ return;
+ }
+ d9 = -d16;
+ if (d8 * d12 + d13 * d9 < 0.0) {
+ d8 = -d8;
+ } else {
+ d16 = d9;
+ }
+ d9 = +Math_sqrt(+(d8 * d8 + d16 * d16));
+ if (!(d9 < 1.1920928955078125e-7)) {
+ d24 = 1.0 / d9;
+ d16 = d16 * d24;
+ d8 = d8 * d24;
+ }
+ HEAP32[i2 >> 2] = 1;
+ HEAP32[i1 + 56 >> 2] = 1;
+ d23 = +d16;
+ d24 = +d8;
+ i14 = i1 + 40 | 0;
+ HEAPF32[i14 >> 2] = d23;
+ HEAPF32[i14 + 4 >> 2] = d24;
+ i14 = i1 + 48 | 0;
+ HEAP32[i14 >> 2] = i5;
+ HEAP32[i14 + 4 >> 2] = i6;
+ i14 = i1 + 16 | 0;
+ HEAP32[i14 >> 2] = 0;
+ HEAP8[i14] = 0;
+ HEAP8[i14 + 1 | 0] = 0;
+ HEAP8[i14 + 2 | 0] = 1;
+ HEAP8[i14 + 3 | 0] = 0;
+ i14 = i3;
+ i15 = HEAP32[i14 + 4 >> 2] | 0;
+ i22 = i1;
+ HEAP32[i22 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i22 + 4 >> 2] = i15;
+ STACKTOP = i4;
+ return;
+}
+function __ZN6b2BodyC2EPK9b2BodyDefP7b2World(i1, i2, i5) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, d13 = 0.0;
+ i3 = STACKTOP;
+ i9 = i2 + 4 | 0;
+ d13 = +HEAPF32[i9 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1496, 1520, 27, 1552);
+ }
+ d13 = +HEAPF32[i2 + 8 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1496, 1520, 27, 1552);
+ }
+ i6 = i2 + 16 | 0;
+ d13 = +HEAPF32[i6 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1560, 1520, 28, 1552);
+ }
+ d13 = +HEAPF32[i2 + 20 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1560, 1520, 28, 1552);
+ }
+ i7 = i2 + 12 | 0;
+ d13 = +HEAPF32[i7 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1592, 1520, 29, 1552);
+ }
+ i8 = i2 + 24 | 0;
+ d13 = +HEAPF32[i8 >> 2];
+ if (!(d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf)) {
+ ___assert_fail(1616, 1520, 30, 1552);
+ }
+ i4 = i2 + 32 | 0;
+ d13 = +HEAPF32[i4 >> 2];
+ if (!(d13 >= 0.0) | d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf ^ 1) {
+ ___assert_fail(1648, 1520, 31, 1552);
+ }
+ i10 = i2 + 28 | 0;
+ d13 = +HEAPF32[i10 >> 2];
+ if (!(d13 >= 0.0) | d13 == d13 & 0.0 == 0.0 & d13 > -inf & d13 < inf ^ 1) {
+ ___assert_fail(1712, 1520, 32, 1552);
+ }
+ i11 = i1 + 4 | 0;
+ i12 = (HEAP8[i2 + 39 | 0] | 0) == 0 ? 0 : 8;
+ HEAP16[i11 >> 1] = i12;
+ if ((HEAP8[i2 + 38 | 0] | 0) != 0) {
+ i12 = (i12 & 65535 | 16) & 65535;
+ HEAP16[i11 >> 1] = i12;
+ }
+ if ((HEAP8[i2 + 36 | 0] | 0) != 0) {
+ i12 = (i12 & 65535 | 4) & 65535;
+ HEAP16[i11 >> 1] = i12;
+ }
+ if ((HEAP8[i2 + 37 | 0] | 0) != 0) {
+ i12 = (i12 & 65535 | 2) & 65535;
+ HEAP16[i11 >> 1] = i12;
+ }
+ if ((HEAP8[i2 + 40 | 0] | 0) != 0) {
+ HEAP16[i11 >> 1] = i12 & 65535 | 32;
+ }
+ HEAP32[i1 + 88 >> 2] = i5;
+ i11 = i9;
+ i12 = HEAP32[i11 >> 2] | 0;
+ i11 = HEAP32[i11 + 4 >> 2] | 0;
+ i9 = i1 + 12 | 0;
+ HEAP32[i9 >> 2] = i12;
+ HEAP32[i9 + 4 >> 2] = i11;
+ d13 = +HEAPF32[i7 >> 2];
+ HEAPF32[i1 + 20 >> 2] = +Math_sin(+d13);
+ HEAPF32[i1 + 24 >> 2] = +Math_cos(+d13);
+ HEAPF32[i1 + 28 >> 2] = 0.0;
+ HEAPF32[i1 + 32 >> 2] = 0.0;
+ i9 = i1 + 36 | 0;
+ HEAP32[i9 >> 2] = i12;
+ HEAP32[i9 + 4 >> 2] = i11;
+ i9 = i1 + 44 | 0;
+ HEAP32[i9 >> 2] = i12;
+ HEAP32[i9 + 4 >> 2] = i11;
+ HEAPF32[i1 + 52 >> 2] = +HEAPF32[i7 >> 2];
+ HEAPF32[i1 + 56 >> 2] = +HEAPF32[i7 >> 2];
+ HEAPF32[i1 + 60 >> 2] = 0.0;
+ HEAP32[i1 + 108 >> 2] = 0;
+ HEAP32[i1 + 112 >> 2] = 0;
+ HEAP32[i1 + 92 >> 2] = 0;
+ HEAP32[i1 + 96 >> 2] = 0;
+ i9 = i6;
+ i11 = HEAP32[i9 + 4 >> 2] | 0;
+ i12 = i1 + 64 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAPF32[i1 + 72 >> 2] = +HEAPF32[i8 >> 2];
+ HEAPF32[i1 + 132 >> 2] = +HEAPF32[i10 >> 2];
+ HEAPF32[i1 + 136 >> 2] = +HEAPF32[i4 >> 2];
+ HEAPF32[i1 + 140 >> 2] = +HEAPF32[i2 + 48 >> 2];
+ HEAPF32[i1 + 76 >> 2] = 0.0;
+ HEAPF32[i1 + 80 >> 2] = 0.0;
+ HEAPF32[i1 + 84 >> 2] = 0.0;
+ HEAPF32[i1 + 144 >> 2] = 0.0;
+ i12 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i1 >> 2] = i12;
+ i4 = i1 + 116 | 0;
+ if ((i12 | 0) == 2) {
+ HEAPF32[i4 >> 2] = 1.0;
+ HEAPF32[i1 + 120 >> 2] = 1.0;
+ i11 = i1 + 124 | 0;
+ HEAPF32[i11 >> 2] = 0.0;
+ i11 = i1 + 128 | 0;
+ HEAPF32[i11 >> 2] = 0.0;
+ i11 = i2 + 44 | 0;
+ i11 = HEAP32[i11 >> 2] | 0;
+ i12 = i1 + 148 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = i1 + 100 | 0;
+ HEAP32[i12 >> 2] = 0;
+ i12 = i1 + 104 | 0;
+ HEAP32[i12 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+ } else {
+ HEAPF32[i4 >> 2] = 0.0;
+ HEAPF32[i1 + 120 >> 2] = 0.0;
+ i11 = i1 + 124 | 0;
+ HEAPF32[i11 >> 2] = 0.0;
+ i11 = i1 + 128 | 0;
+ HEAPF32[i11 >> 2] = 0.0;
+ i11 = i2 + 44 | 0;
+ i11 = HEAP32[i11 >> 2] | 0;
+ i12 = i1 + 148 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = i1 + 100 | 0;
+ HEAP32[i12 >> 2] = 0;
+ i12 = i1 + 104 | 0;
+ HEAP32[i12 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+ }
+}
+function __ZN24b2PositionSolverManifold10InitializeEP27b2ContactPositionConstraintRK11b2TransformS4_i(i2, i1, i13, i12, i15) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i13 = i13 | 0;
+ i12 = i12 | 0;
+ i15 = i15 | 0;
+ var i3 = 0, d4 = 0.0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, i14 = 0, d16 = 0.0, d17 = 0.0, d18 = 0.0, i19 = 0, i20 = 0;
+ i3 = STACKTOP;
+ if ((HEAP32[i1 + 84 >> 2] | 0) <= 0) {
+ ___assert_fail(6752, 6520, 617, 6776);
+ }
+ i14 = HEAP32[i1 + 72 >> 2] | 0;
+ if ((i14 | 0) == 1) {
+ i19 = i13 + 12 | 0;
+ d5 = +HEAPF32[i19 >> 2];
+ d6 = +HEAPF32[i1 + 16 >> 2];
+ i14 = i13 + 8 | 0;
+ d7 = +HEAPF32[i14 >> 2];
+ d9 = +HEAPF32[i1 + 20 >> 2];
+ d4 = d5 * d6 - d7 * d9;
+ d9 = d6 * d7 + d5 * d9;
+ d5 = +d4;
+ d7 = +d9;
+ i20 = i2;
+ HEAPF32[i20 >> 2] = d5;
+ HEAPF32[i20 + 4 >> 2] = d7;
+ d7 = +HEAPF32[i19 >> 2];
+ d5 = +HEAPF32[i1 + 24 >> 2];
+ d6 = +HEAPF32[i14 >> 2];
+ d8 = +HEAPF32[i1 + 28 >> 2];
+ d16 = +HEAPF32[i12 + 12 >> 2];
+ d18 = +HEAPF32[i1 + (i15 << 3) >> 2];
+ d17 = +HEAPF32[i12 + 8 >> 2];
+ d11 = +HEAPF32[i1 + (i15 << 3) + 4 >> 2];
+ d10 = +HEAPF32[i12 >> 2] + (d16 * d18 - d17 * d11);
+ d11 = d18 * d17 + d16 * d11 + +HEAPF32[i12 + 4 >> 2];
+ HEAPF32[i2 + 16 >> 2] = d4 * (d10 - (+HEAPF32[i13 >> 2] + (d7 * d5 - d6 * d8))) + (d11 - (d5 * d6 + d7 * d8 + +HEAPF32[i13 + 4 >> 2])) * d9 - +HEAPF32[i1 + 76 >> 2] - +HEAPF32[i1 + 80 >> 2];
+ d10 = +d10;
+ d11 = +d11;
+ i15 = i2 + 8 | 0;
+ HEAPF32[i15 >> 2] = d10;
+ HEAPF32[i15 + 4 >> 2] = d11;
+ STACKTOP = i3;
+ return;
+ } else if ((i14 | 0) == 2) {
+ i19 = i12 + 12 | 0;
+ d7 = +HEAPF32[i19 >> 2];
+ d8 = +HEAPF32[i1 + 16 >> 2];
+ i20 = i12 + 8 | 0;
+ d9 = +HEAPF32[i20 >> 2];
+ d18 = +HEAPF32[i1 + 20 >> 2];
+ d17 = d7 * d8 - d9 * d18;
+ d18 = d8 * d9 + d7 * d18;
+ d7 = +d17;
+ d9 = +d18;
+ i14 = i2;
+ HEAPF32[i14 >> 2] = d7;
+ HEAPF32[i14 + 4 >> 2] = d9;
+ d9 = +HEAPF32[i19 >> 2];
+ d7 = +HEAPF32[i1 + 24 >> 2];
+ d8 = +HEAPF32[i20 >> 2];
+ d10 = +HEAPF32[i1 + 28 >> 2];
+ d6 = +HEAPF32[i13 + 12 >> 2];
+ d4 = +HEAPF32[i1 + (i15 << 3) >> 2];
+ d5 = +HEAPF32[i13 + 8 >> 2];
+ d16 = +HEAPF32[i1 + (i15 << 3) + 4 >> 2];
+ d11 = +HEAPF32[i13 >> 2] + (d6 * d4 - d5 * d16);
+ d16 = d4 * d5 + d6 * d16 + +HEAPF32[i13 + 4 >> 2];
+ HEAPF32[i2 + 16 >> 2] = d17 * (d11 - (+HEAPF32[i12 >> 2] + (d9 * d7 - d8 * d10))) + (d16 - (d7 * d8 + d9 * d10 + +HEAPF32[i12 + 4 >> 2])) * d18 - +HEAPF32[i1 + 76 >> 2] - +HEAPF32[i1 + 80 >> 2];
+ d11 = +d11;
+ d16 = +d16;
+ i20 = i2 + 8 | 0;
+ HEAPF32[i20 >> 2] = d11;
+ HEAPF32[i20 + 4 >> 2] = d16;
+ d17 = +-d17;
+ d18 = +-d18;
+ i20 = i2;
+ HEAPF32[i20 >> 2] = d17;
+ HEAPF32[i20 + 4 >> 2] = d18;
+ STACKTOP = i3;
+ return;
+ } else if ((i14 | 0) == 0) {
+ d7 = +HEAPF32[i13 + 12 >> 2];
+ d8 = +HEAPF32[i1 + 24 >> 2];
+ d18 = +HEAPF32[i13 + 8 >> 2];
+ d6 = +HEAPF32[i1 + 28 >> 2];
+ d4 = +HEAPF32[i13 >> 2] + (d7 * d8 - d18 * d6);
+ d6 = d8 * d18 + d7 * d6 + +HEAPF32[i13 + 4 >> 2];
+ d7 = +HEAPF32[i12 + 12 >> 2];
+ d18 = +HEAPF32[i1 >> 2];
+ d8 = +HEAPF32[i12 + 8 >> 2];
+ d9 = +HEAPF32[i1 + 4 >> 2];
+ d5 = +HEAPF32[i12 >> 2] + (d7 * d18 - d8 * d9);
+ d9 = d18 * d8 + d7 * d9 + +HEAPF32[i12 + 4 >> 2];
+ d7 = d5 - d4;
+ d8 = d9 - d6;
+ d18 = +d7;
+ d10 = +d8;
+ i20 = i2;
+ HEAPF32[i20 >> 2] = d18;
+ HEAPF32[i20 + 4 >> 2] = d10;
+ d10 = +Math_sqrt(+(d7 * d7 + d8 * d8));
+ if (d10 < 1.1920928955078125e-7) {
+ d10 = d7;
+ d11 = d8;
+ } else {
+ d11 = 1.0 / d10;
+ d10 = d7 * d11;
+ HEAPF32[i2 >> 2] = d10;
+ d11 = d8 * d11;
+ HEAPF32[i2 + 4 >> 2] = d11;
+ }
+ d17 = +((d4 + d5) * .5);
+ d18 = +((d6 + d9) * .5);
+ i20 = i2 + 8 | 0;
+ HEAPF32[i20 >> 2] = d17;
+ HEAPF32[i20 + 4 >> 2] = d18;
+ HEAPF32[i2 + 16 >> 2] = d7 * d10 + d8 * d11 - +HEAPF32[i1 + 76 >> 2] - +HEAPF32[i1 + 80 >> 2];
+ STACKTOP = i3;
+ return;
+ } else {
+ STACKTOP = i3;
+ return;
+ }
+}
+function __ZNSt3__118__insertion_sort_3IRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i5, i1, i2) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i6 = i4 + 12 | 0;
+ i3 = i4;
+ i7 = i5 + 24 | 0;
+ i8 = i5 + 12 | 0;
+ i10 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i8, i5) | 0;
+ i9 = FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i7, i8) | 0;
+ do {
+ if (i10) {
+ if (i9) {
+ HEAP32[i6 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ break;
+ }
+ HEAP32[i6 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i7, i8) | 0) {
+ HEAP32[i6 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ }
+ } else {
+ if (i9) {
+ HEAP32[i6 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ HEAP32[i7 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i8, i5) | 0) {
+ HEAP32[i6 + 0 >> 2] = HEAP32[i5 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ HEAP32[i5 + 0 >> 2] = HEAP32[i8 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i8 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i8 + 8 >> 2];
+ HEAP32[i8 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ }
+ }
+ }
+ } while (0);
+ i6 = i5 + 36 | 0;
+ if ((i6 | 0) == (i1 | 0)) {
+ STACKTOP = i4;
+ return;
+ }
+ while (1) {
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i6, i7) | 0) {
+ HEAP32[i3 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i8 = i6;
+ while (1) {
+ HEAP32[i8 + 0 >> 2] = HEAP32[i7 + 0 >> 2];
+ HEAP32[i8 + 4 >> 2] = HEAP32[i7 + 4 >> 2];
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ if ((i7 | 0) == (i5 | 0)) {
+ break;
+ }
+ i8 = i7 + -12 | 0;
+ if (FUNCTION_TABLE_iii[HEAP32[i2 >> 2] & 3](i3, i8) | 0) {
+ i10 = i7;
+ i7 = i8;
+ i8 = i10;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i7 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i7 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ }
+ i7 = i6 + 12 | 0;
+ if ((i7 | 0) == (i1 | 0)) {
+ break;
+ } else {
+ i10 = i6;
+ i6 = i7;
+ i7 = i10;
+ }
+ }
+ STACKTOP = i4;
+ return;
+}
+function __ZNK20b2SeparationFunction8EvaluateEiif(i10, i12, i11, d9) {
+ i10 = i10 | 0;
+ i12 = i12 | 0;
+ i11 = i11 | 0;
+ d9 = +d9;
+ var d1 = 0.0, d2 = 0.0, d3 = 0.0, d4 = 0.0, d5 = 0.0, d6 = 0.0, i7 = 0, d8 = 0.0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0, i17 = 0, d18 = 0.0, d19 = 0.0;
+ i7 = STACKTOP;
+ d14 = 1.0 - d9;
+ d3 = d14 * +HEAPF32[i10 + 32 >> 2] + +HEAPF32[i10 + 36 >> 2] * d9;
+ d4 = +Math_sin(+d3);
+ d3 = +Math_cos(+d3);
+ d5 = +HEAPF32[i10 + 8 >> 2];
+ d6 = +HEAPF32[i10 + 12 >> 2];
+ d2 = d14 * +HEAPF32[i10 + 16 >> 2] + +HEAPF32[i10 + 24 >> 2] * d9 - (d3 * d5 - d4 * d6);
+ d6 = d14 * +HEAPF32[i10 + 20 >> 2] + +HEAPF32[i10 + 28 >> 2] * d9 - (d4 * d5 + d3 * d6);
+ d5 = d14 * +HEAPF32[i10 + 68 >> 2] + +HEAPF32[i10 + 72 >> 2] * d9;
+ d1 = +Math_sin(+d5);
+ d5 = +Math_cos(+d5);
+ d15 = +HEAPF32[i10 + 44 >> 2];
+ d16 = +HEAPF32[i10 + 48 >> 2];
+ d8 = d14 * +HEAPF32[i10 + 52 >> 2] + +HEAPF32[i10 + 60 >> 2] * d9 - (d5 * d15 - d1 * d16);
+ d9 = d14 * +HEAPF32[i10 + 56 >> 2] + +HEAPF32[i10 + 64 >> 2] * d9 - (d1 * d15 + d5 * d16);
+ i17 = HEAP32[i10 + 80 >> 2] | 0;
+ if ((i17 | 0) == 0) {
+ d14 = +HEAPF32[i10 + 92 >> 2];
+ d13 = +HEAPF32[i10 + 96 >> 2];
+ i17 = HEAP32[i10 >> 2] | 0;
+ if (!((i12 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i17 + 20 >> 2] | 0) <= (i12 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i17 = (HEAP32[i17 + 16 >> 2] | 0) + (i12 << 3) | 0;
+ d15 = +HEAPF32[i17 >> 2];
+ d16 = +HEAPF32[i17 + 4 >> 2];
+ i10 = HEAP32[i10 + 4 >> 2] | 0;
+ if (!((i11 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i10 + 20 >> 2] | 0) <= (i11 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i17 = (HEAP32[i10 + 16 >> 2] | 0) + (i11 << 3) | 0;
+ d19 = +HEAPF32[i17 >> 2];
+ d18 = +HEAPF32[i17 + 4 >> 2];
+ d16 = d14 * (d8 + (d5 * d19 - d1 * d18) - (d2 + (d3 * d15 - d4 * d16))) + d13 * (d9 + (d1 * d19 + d5 * d18) - (d6 + (d4 * d15 + d3 * d16)));
+ STACKTOP = i7;
+ return +d16;
+ } else if ((i17 | 0) == 1) {
+ d14 = +HEAPF32[i10 + 92 >> 2];
+ d13 = +HEAPF32[i10 + 96 >> 2];
+ d16 = +HEAPF32[i10 + 84 >> 2];
+ d15 = +HEAPF32[i10 + 88 >> 2];
+ i10 = HEAP32[i10 + 4 >> 2] | 0;
+ if (!((i11 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i10 + 20 >> 2] | 0) <= (i11 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i17 = (HEAP32[i10 + 16 >> 2] | 0) + (i11 << 3) | 0;
+ d18 = +HEAPF32[i17 >> 2];
+ d19 = +HEAPF32[i17 + 4 >> 2];
+ d19 = (d3 * d14 - d4 * d13) * (d8 + (d5 * d18 - d1 * d19) - (d2 + (d3 * d16 - d4 * d15))) + (d4 * d14 + d3 * d13) * (d9 + (d1 * d18 + d5 * d19) - (d6 + (d4 * d16 + d3 * d15)));
+ STACKTOP = i7;
+ return +d19;
+ } else if ((i17 | 0) == 2) {
+ d16 = +HEAPF32[i10 + 92 >> 2];
+ d15 = +HEAPF32[i10 + 96 >> 2];
+ d14 = +HEAPF32[i10 + 84 >> 2];
+ d13 = +HEAPF32[i10 + 88 >> 2];
+ i10 = HEAP32[i10 >> 2] | 0;
+ if (!((i12 | 0) > -1)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ if ((HEAP32[i10 + 20 >> 2] | 0) <= (i12 | 0)) {
+ ___assert_fail(3640, 3672, 103, 3704);
+ }
+ i17 = (HEAP32[i10 + 16 >> 2] | 0) + (i12 << 3) | 0;
+ d18 = +HEAPF32[i17 >> 2];
+ d19 = +HEAPF32[i17 + 4 >> 2];
+ d19 = (d5 * d16 - d1 * d15) * (d2 + (d3 * d18 - d4 * d19) - (d8 + (d5 * d14 - d1 * d13))) + (d1 * d16 + d5 * d15) * (d6 + (d4 * d18 + d3 * d19) - (d9 + (d1 * d14 + d5 * d13)));
+ STACKTOP = i7;
+ return +d19;
+ } else {
+ ___assert_fail(3616, 3560, 242, 3624);
+ }
+ return 0.0;
+}
+function __ZN6b2Body13ResetMassDataEv(i2) {
+ i2 = i2 | 0;
+ var d1 = 0.0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0, d15 = 0.0, d16 = 0.0, i17 = 0, d18 = 0.0, d19 = 0.0, i20 = 0, d21 = 0.0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i10 = i3;
+ i8 = i2 + 116 | 0;
+ i9 = i2 + 120 | 0;
+ i4 = i2 + 124 | 0;
+ i5 = i2 + 128 | 0;
+ i6 = i2 + 28 | 0;
+ HEAPF32[i6 >> 2] = 0.0;
+ HEAPF32[i2 + 32 >> 2] = 0.0;
+ HEAP32[i8 + 0 >> 2] = 0;
+ HEAP32[i8 + 4 >> 2] = 0;
+ HEAP32[i8 + 8 >> 2] = 0;
+ HEAP32[i8 + 12 >> 2] = 0;
+ i11 = HEAP32[i2 >> 2] | 0;
+ if ((i11 | 0) == 2) {
+ i17 = 3784;
+ d16 = +HEAPF32[i17 >> 2];
+ d18 = +HEAPF32[i17 + 4 >> 2];
+ i17 = HEAP32[i2 + 100 >> 2] | 0;
+ if ((i17 | 0) != 0) {
+ i11 = i10 + 4 | 0;
+ i12 = i10 + 8 | 0;
+ i13 = i10 + 12 | 0;
+ d14 = 0.0;
+ d15 = 0.0;
+ do {
+ d19 = +HEAPF32[i17 >> 2];
+ if (!(d19 == 0.0)) {
+ i20 = HEAP32[i17 + 12 >> 2] | 0;
+ FUNCTION_TABLE_viid[HEAP32[(HEAP32[i20 >> 2] | 0) + 28 >> 2] & 3](i20, i10, d19);
+ d14 = +HEAPF32[i10 >> 2];
+ d15 = d14 + +HEAPF32[i8 >> 2];
+ HEAPF32[i8 >> 2] = d15;
+ d16 = d16 + d14 * +HEAPF32[i11 >> 2];
+ d18 = d18 + d14 * +HEAPF32[i12 >> 2];
+ d14 = +HEAPF32[i13 >> 2] + +HEAPF32[i4 >> 2];
+ HEAPF32[i4 >> 2] = d14;
+ }
+ i17 = HEAP32[i17 + 4 >> 2] | 0;
+ } while ((i17 | 0) != 0);
+ if (d15 > 0.0) {
+ d19 = 1.0 / d15;
+ HEAPF32[i9 >> 2] = d19;
+ d16 = d16 * d19;
+ d18 = d18 * d19;
+ } else {
+ i7 = 11;
+ }
+ } else {
+ d14 = 0.0;
+ i7 = 11;
+ }
+ if ((i7 | 0) == 11) {
+ HEAPF32[i8 >> 2] = 1.0;
+ HEAPF32[i9 >> 2] = 1.0;
+ d15 = 1.0;
+ }
+ do {
+ if (d14 > 0.0 ? (HEAP16[i2 + 4 >> 1] & 16) == 0 : 0) {
+ d14 = d14 - (d18 * d18 + d16 * d16) * d15;
+ HEAPF32[i4 >> 2] = d14;
+ if (d14 > 0.0) {
+ d1 = 1.0 / d14;
+ break;
+ } else {
+ ___assert_fail(1872, 1520, 319, 1856);
+ }
+ } else {
+ i7 = 17;
+ }
+ } while (0);
+ if ((i7 | 0) == 17) {
+ HEAPF32[i4 >> 2] = 0.0;
+ d1 = 0.0;
+ }
+ HEAPF32[i5 >> 2] = d1;
+ i20 = i2 + 44 | 0;
+ i17 = i20;
+ d19 = +HEAPF32[i17 >> 2];
+ d14 = +HEAPF32[i17 + 4 >> 2];
+ d21 = +d16;
+ d1 = +d18;
+ i17 = i6;
+ HEAPF32[i17 >> 2] = d21;
+ HEAPF32[i17 + 4 >> 2] = d1;
+ d1 = +HEAPF32[i2 + 24 >> 2];
+ d21 = +HEAPF32[i2 + 20 >> 2];
+ d15 = +HEAPF32[i2 + 12 >> 2] + (d1 * d16 - d21 * d18);
+ d16 = d16 * d21 + d1 * d18 + +HEAPF32[i2 + 16 >> 2];
+ d1 = +d15;
+ d18 = +d16;
+ HEAPF32[i20 >> 2] = d1;
+ HEAPF32[i20 + 4 >> 2] = d18;
+ i20 = i2 + 36 | 0;
+ HEAPF32[i20 >> 2] = d1;
+ HEAPF32[i20 + 4 >> 2] = d18;
+ d18 = +HEAPF32[i2 + 72 >> 2];
+ i20 = i2 + 64 | 0;
+ HEAPF32[i20 >> 2] = +HEAPF32[i20 >> 2] - d18 * (d16 - d14);
+ i20 = i2 + 68 | 0;
+ HEAPF32[i20 >> 2] = d18 * (d15 - d19) + +HEAPF32[i20 >> 2];
+ STACKTOP = i3;
+ return;
+ } else if ((i11 | 0) == 1 | (i11 | 0) == 0) {
+ i17 = i2 + 12 | 0;
+ i13 = HEAP32[i17 >> 2] | 0;
+ i17 = HEAP32[i17 + 4 >> 2] | 0;
+ i20 = i2 + 36 | 0;
+ HEAP32[i20 >> 2] = i13;
+ HEAP32[i20 + 4 >> 2] = i17;
+ i20 = i2 + 44 | 0;
+ HEAP32[i20 >> 2] = i13;
+ HEAP32[i20 + 4 >> 2] = i17;
+ HEAPF32[i2 + 52 >> 2] = +HEAPF32[i2 + 56 >> 2];
+ STACKTOP = i3;
+ return;
+ } else {
+ ___assert_fail(1824, 1520, 284, 1856);
+ }
+}
+function __ZN9b2Contact6UpdateEP17b2ContactListener(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i2 = i3;
+ i10 = i1 + 64 | 0;
+ i6 = i2 + 0 | 0;
+ i7 = i10 + 0 | 0;
+ i5 = i6 + 64 | 0;
+ do {
+ HEAP32[i6 >> 2] = HEAP32[i7 >> 2];
+ i6 = i6 + 4 | 0;
+ i7 = i7 + 4 | 0;
+ } while ((i6 | 0) < (i5 | 0));
+ i6 = i1 + 4 | 0;
+ i11 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i11 | 4;
+ i11 = i11 >>> 1;
+ i14 = HEAP32[i1 + 48 >> 2] | 0;
+ i15 = HEAP32[i1 + 52 >> 2] | 0;
+ i5 = (HEAP8[i15 + 38 | 0] | HEAP8[i14 + 38 | 0]) << 24 >> 24 != 0;
+ i8 = HEAP32[i14 + 8 >> 2] | 0;
+ i7 = HEAP32[i15 + 8 >> 2] | 0;
+ i12 = i8 + 12 | 0;
+ i13 = i7 + 12 | 0;
+ if (!i5) {
+ FUNCTION_TABLE_viiii[HEAP32[HEAP32[i1 >> 2] >> 2] & 15](i1, i10, i12, i13);
+ i12 = i1 + 124 | 0;
+ i10 = (HEAP32[i12 >> 2] | 0) > 0;
+ L4 : do {
+ if (i10) {
+ i19 = HEAP32[i2 + 60 >> 2] | 0;
+ if ((i19 | 0) > 0) {
+ i18 = 0;
+ } else {
+ i9 = 0;
+ while (1) {
+ HEAPF32[i1 + (i9 * 20 | 0) + 72 >> 2] = 0.0;
+ HEAPF32[i1 + (i9 * 20 | 0) + 76 >> 2] = 0.0;
+ i9 = i9 + 1 | 0;
+ if ((i9 | 0) >= (HEAP32[i12 >> 2] | 0)) {
+ break L4;
+ }
+ }
+ }
+ do {
+ i16 = i1 + (i18 * 20 | 0) + 72 | 0;
+ HEAPF32[i16 >> 2] = 0.0;
+ i15 = i1 + (i18 * 20 | 0) + 76 | 0;
+ HEAPF32[i15 >> 2] = 0.0;
+ i14 = HEAP32[i1 + (i18 * 20 | 0) + 80 >> 2] | 0;
+ i17 = 0;
+ while (1) {
+ i13 = i17 + 1 | 0;
+ if ((HEAP32[i2 + (i17 * 20 | 0) + 16 >> 2] | 0) == (i14 | 0)) {
+ i9 = 7;
+ break;
+ }
+ if ((i13 | 0) < (i19 | 0)) {
+ i17 = i13;
+ } else {
+ break;
+ }
+ }
+ if ((i9 | 0) == 7) {
+ i9 = 0;
+ HEAPF32[i16 >> 2] = +HEAPF32[i2 + (i17 * 20 | 0) + 8 >> 2];
+ HEAPF32[i15 >> 2] = +HEAPF32[i2 + (i17 * 20 | 0) + 12 >> 2];
+ }
+ i18 = i18 + 1 | 0;
+ } while ((i18 | 0) < (HEAP32[i12 >> 2] | 0));
+ }
+ } while (0);
+ i9 = i11 & 1;
+ if (i10 ^ (i9 | 0) != 0) {
+ i11 = i8 + 4 | 0;
+ i12 = HEAPU16[i11 >> 1] | 0;
+ if ((i12 & 2 | 0) == 0) {
+ HEAP16[i11 >> 1] = i12 | 2;
+ HEAPF32[i8 + 144 >> 2] = 0.0;
+ }
+ i8 = i7 + 4 | 0;
+ i11 = HEAPU16[i8 >> 1] | 0;
+ if ((i11 & 2 | 0) == 0) {
+ HEAP16[i8 >> 1] = i11 | 2;
+ HEAPF32[i7 + 144 >> 2] = 0.0;
+ }
+ }
+ } else {
+ i10 = __Z13b2TestOverlapPK7b2ShapeiS1_iRK11b2TransformS4_(HEAP32[i14 + 12 >> 2] | 0, HEAP32[i1 + 56 >> 2] | 0, HEAP32[i15 + 12 >> 2] | 0, HEAP32[i1 + 60 >> 2] | 0, i12, i13) | 0;
+ HEAP32[i1 + 124 >> 2] = 0;
+ i9 = i11 & 1;
+ }
+ i7 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i10 ? i7 | 2 : i7 & -3;
+ i8 = (i9 | 0) == 0;
+ i6 = i10 ^ 1;
+ i7 = (i4 | 0) == 0;
+ if (!(i8 ^ 1 | i6 | i7)) {
+ FUNCTION_TABLE_vii[HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] & 15](i4, i1);
+ }
+ if (!(i8 | i10 | i7)) {
+ FUNCTION_TABLE_vii[HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] & 15](i4, i1);
+ }
+ if (i5 | i6 | i7) {
+ STACKTOP = i3;
+ return;
+ }
+ FUNCTION_TABLE_viii[HEAP32[(HEAP32[i4 >> 2] | 0) + 16 >> 2] & 3](i4, i1, i2);
+ STACKTOP = i3;
+ return;
+}
+function __ZN13b2DynamicTree10RemoveLeafEi(i1, i12) {
+ i1 = i1 | 0;
+ i12 = i12 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, i13 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i1 >> 2] | 0) == (i12 | 0)) {
+ HEAP32[i1 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i1 + 4 | 0;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i5 + (i12 * 36 | 0) + 20 >> 2] | 0;
+ i4 = i5 + (i6 * 36 | 0) + 20 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ i13 = HEAP32[i5 + (i6 * 36 | 0) + 24 >> 2] | 0;
+ if ((i13 | 0) == (i12 | 0)) {
+ i13 = HEAP32[i5 + (i6 * 36 | 0) + 28 >> 2] | 0;
+ }
+ if ((i7 | 0) == -1) {
+ HEAP32[i1 >> 2] = i13;
+ HEAP32[i5 + (i13 * 36 | 0) + 20 >> 2] = -1;
+ if (!((i6 | 0) > -1)) {
+ ___assert_fail(3e3, 2944, 97, 3040);
+ }
+ if ((HEAP32[i1 + 12 >> 2] | 0) <= (i6 | 0)) {
+ ___assert_fail(3e3, 2944, 97, 3040);
+ }
+ i3 = i1 + 8 | 0;
+ if ((HEAP32[i3 >> 2] | 0) <= 0) {
+ ___assert_fail(3056, 2944, 98, 3040);
+ }
+ i13 = i1 + 16 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i5 + (i6 * 36 | 0) + 32 >> 2] = -1;
+ HEAP32[i13 >> 2] = i6;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + -1;
+ STACKTOP = i2;
+ return;
+ }
+ i12 = i5 + (i7 * 36 | 0) + 24 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i13;
+ } else {
+ HEAP32[i5 + (i7 * 36 | 0) + 28 >> 2] = i13;
+ }
+ HEAP32[i5 + (i13 * 36 | 0) + 20 >> 2] = i7;
+ if (!((i6 | 0) > -1)) {
+ ___assert_fail(3e3, 2944, 97, 3040);
+ }
+ if ((HEAP32[i1 + 12 >> 2] | 0) <= (i6 | 0)) {
+ ___assert_fail(3e3, 2944, 97, 3040);
+ }
+ i12 = i1 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) <= 0) {
+ ___assert_fail(3056, 2944, 98, 3040);
+ }
+ i13 = i1 + 16 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i5 + (i6 * 36 | 0) + 32 >> 2] = -1;
+ HEAP32[i13 >> 2] = i6;
+ HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + -1;
+ do {
+ i4 = __ZN13b2DynamicTree7BalanceEi(i1, i7) | 0;
+ i7 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i7 + (i4 * 36 | 0) + 24 >> 2] | 0;
+ i5 = HEAP32[i7 + (i4 * 36 | 0) + 28 >> 2] | 0;
+ d10 = +HEAPF32[i7 + (i6 * 36 | 0) >> 2];
+ d11 = +HEAPF32[i7 + (i5 * 36 | 0) >> 2];
+ d9 = +HEAPF32[i7 + (i6 * 36 | 0) + 4 >> 2];
+ d8 = +HEAPF32[i7 + (i5 * 36 | 0) + 4 >> 2];
+ d10 = +(d10 < d11 ? d10 : d11);
+ d11 = +(d9 < d8 ? d9 : d8);
+ i13 = i7 + (i4 * 36 | 0) | 0;
+ HEAPF32[i13 >> 2] = d10;
+ HEAPF32[i13 + 4 >> 2] = d11;
+ d11 = +HEAPF32[i7 + (i6 * 36 | 0) + 8 >> 2];
+ d10 = +HEAPF32[i7 + (i5 * 36 | 0) + 8 >> 2];
+ d9 = +HEAPF32[i7 + (i6 * 36 | 0) + 12 >> 2];
+ d8 = +HEAPF32[i7 + (i5 * 36 | 0) + 12 >> 2];
+ d10 = +(d11 > d10 ? d11 : d10);
+ d11 = +(d9 > d8 ? d9 : d8);
+ i7 = i7 + (i4 * 36 | 0) + 8 | 0;
+ HEAPF32[i7 >> 2] = d10;
+ HEAPF32[i7 + 4 >> 2] = d11;
+ i7 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i7 + (i6 * 36 | 0) + 32 >> 2] | 0;
+ i5 = HEAP32[i7 + (i5 * 36 | 0) + 32 >> 2] | 0;
+ HEAP32[i7 + (i4 * 36 | 0) + 32 >> 2] = ((i6 | 0) > (i5 | 0) ? i6 : i5) + 1;
+ i7 = HEAP32[i7 + (i4 * 36 | 0) + 20 >> 2] | 0;
+ } while (!((i7 | 0) == -1));
+ STACKTOP = i2;
+ return;
+}
+function __ZN9b2Simplex6Solve3Ev(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, d4 = 0.0, d5 = 0.0, d6 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, i22 = 0;
+ i1 = STACKTOP;
+ i2 = i7 + 16 | 0;
+ d17 = +HEAPF32[i2 >> 2];
+ d15 = +HEAPF32[i2 + 4 >> 2];
+ i2 = i7 + 36 | 0;
+ i3 = i7 + 52 | 0;
+ d14 = +HEAPF32[i3 >> 2];
+ d16 = +HEAPF32[i3 + 4 >> 2];
+ i3 = i7 + 72 | 0;
+ i22 = i7 + 88 | 0;
+ d18 = +HEAPF32[i22 >> 2];
+ d11 = +HEAPF32[i22 + 4 >> 2];
+ d20 = d14 - d17;
+ d10 = d16 - d15;
+ d9 = d17 * d20 + d15 * d10;
+ d8 = d14 * d20 + d16 * d10;
+ d4 = d18 - d17;
+ d19 = d11 - d15;
+ d6 = d17 * d4 + d15 * d19;
+ d5 = d18 * d4 + d11 * d19;
+ d21 = d18 - d14;
+ d12 = d11 - d16;
+ d13 = d14 * d21 + d16 * d12;
+ d12 = d18 * d21 + d11 * d12;
+ d4 = d20 * d19 - d10 * d4;
+ d10 = (d14 * d11 - d16 * d18) * d4;
+ d11 = (d15 * d18 - d17 * d11) * d4;
+ d4 = (d17 * d16 - d15 * d14) * d4;
+ if (!(!(d9 >= -0.0) | !(d6 >= -0.0))) {
+ HEAPF32[i7 + 24 >> 2] = 1.0;
+ HEAP32[i7 + 108 >> 2] = 1;
+ STACKTOP = i1;
+ return;
+ }
+ if (!(!(d9 < -0.0) | !(d8 > 0.0) | !(d4 <= 0.0))) {
+ d21 = 1.0 / (d8 - d9);
+ HEAPF32[i7 + 24 >> 2] = d8 * d21;
+ HEAPF32[i7 + 60 >> 2] = -(d9 * d21);
+ HEAP32[i7 + 108 >> 2] = 2;
+ STACKTOP = i1;
+ return;
+ }
+ if (!(!(d6 < -0.0) | !(d5 > 0.0) | !(d11 <= 0.0))) {
+ d21 = 1.0 / (d5 - d6);
+ HEAPF32[i7 + 24 >> 2] = d5 * d21;
+ HEAPF32[i7 + 96 >> 2] = -(d6 * d21);
+ HEAP32[i7 + 108 >> 2] = 2;
+ i7 = i2 + 0 | 0;
+ i3 = i3 + 0 | 0;
+ i2 = i7 + 36 | 0;
+ do {
+ HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
+ i7 = i7 + 4 | 0;
+ i3 = i3 + 4 | 0;
+ } while ((i7 | 0) < (i2 | 0));
+ STACKTOP = i1;
+ return;
+ }
+ if (!(!(d8 <= 0.0) | !(d13 >= -0.0))) {
+ HEAPF32[i7 + 60 >> 2] = 1.0;
+ HEAP32[i7 + 108 >> 2] = 1;
+ i7 = i7 + 0 | 0;
+ i3 = i2 + 0 | 0;
+ i2 = i7 + 36 | 0;
+ do {
+ HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
+ i7 = i7 + 4 | 0;
+ i3 = i3 + 4 | 0;
+ } while ((i7 | 0) < (i2 | 0));
+ STACKTOP = i1;
+ return;
+ }
+ if (!(!(d5 <= 0.0) | !(d12 <= 0.0))) {
+ HEAPF32[i7 + 96 >> 2] = 1.0;
+ HEAP32[i7 + 108 >> 2] = 1;
+ i7 = i7 + 0 | 0;
+ i3 = i3 + 0 | 0;
+ i2 = i7 + 36 | 0;
+ do {
+ HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
+ i7 = i7 + 4 | 0;
+ i3 = i3 + 4 | 0;
+ } while ((i7 | 0) < (i2 | 0));
+ STACKTOP = i1;
+ return;
+ }
+ if (!(d13 < -0.0) | !(d12 > 0.0) | !(d10 <= 0.0)) {
+ d21 = 1.0 / (d4 + (d10 + d11));
+ HEAPF32[i7 + 24 >> 2] = d10 * d21;
+ HEAPF32[i7 + 60 >> 2] = d11 * d21;
+ HEAPF32[i7 + 96 >> 2] = d4 * d21;
+ HEAP32[i7 + 108 >> 2] = 3;
+ STACKTOP = i1;
+ return;
+ } else {
+ d21 = 1.0 / (d12 - d13);
+ HEAPF32[i7 + 60 >> 2] = d12 * d21;
+ HEAPF32[i7 + 96 >> 2] = -(d13 * d21);
+ HEAP32[i7 + 108 >> 2] = 2;
+ i7 = i7 + 0 | 0;
+ i3 = i3 + 0 | 0;
+ i2 = i7 + 36 | 0;
+ do {
+ HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
+ i7 = i7 + 4 | 0;
+ i3 = i3 + 4 | 0;
+ } while ((i7 | 0) < (i2 | 0));
+ STACKTOP = i1;
+ return;
+ }
+}
+function __ZN16b2ContactManager7CollideEv(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i2 = STACKTOP;
+ i8 = HEAP32[i3 + 60 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = i3 + 12 | 0;
+ i6 = i3 + 4 | 0;
+ i5 = i3 + 72 | 0;
+ i4 = i3 + 68 | 0;
+ L4 : while (1) {
+ i12 = HEAP32[i8 + 48 >> 2] | 0;
+ i10 = HEAP32[i8 + 52 >> 2] | 0;
+ i11 = HEAP32[i8 + 56 >> 2] | 0;
+ i9 = HEAP32[i8 + 60 >> 2] | 0;
+ i15 = HEAP32[i12 + 8 >> 2] | 0;
+ i13 = HEAP32[i10 + 8 >> 2] | 0;
+ i16 = i8 + 4 | 0;
+ do {
+ if ((HEAP32[i16 >> 2] & 8 | 0) == 0) {
+ i1 = 11;
+ } else {
+ if (!(__ZNK6b2Body13ShouldCollideEPKS_(i13, i15) | 0)) {
+ i16 = HEAP32[i8 + 12 >> 2] | 0;
+ __ZN16b2ContactManager7DestroyEP9b2Contact(i3, i8);
+ i8 = i16;
+ break;
+ }
+ i14 = HEAP32[i4 >> 2] | 0;
+ if ((i14 | 0) != 0 ? !(FUNCTION_TABLE_iiii[HEAP32[(HEAP32[i14 >> 2] | 0) + 8 >> 2] & 7](i14, i12, i10) | 0) : 0) {
+ i16 = HEAP32[i8 + 12 >> 2] | 0;
+ __ZN16b2ContactManager7DestroyEP9b2Contact(i3, i8);
+ i8 = i16;
+ break;
+ }
+ HEAP32[i16 >> 2] = HEAP32[i16 >> 2] & -9;
+ i1 = 11;
+ }
+ } while (0);
+ do {
+ if ((i1 | 0) == 11) {
+ i1 = 0;
+ if ((HEAP16[i15 + 4 >> 1] & 2) == 0) {
+ i14 = 0;
+ } else {
+ i14 = (HEAP32[i15 >> 2] | 0) != 0;
+ }
+ if ((HEAP16[i13 + 4 >> 1] & 2) == 0) {
+ i13 = 0;
+ } else {
+ i13 = (HEAP32[i13 >> 2] | 0) != 0;
+ }
+ if (!(i14 | i13)) {
+ i8 = HEAP32[i8 + 12 >> 2] | 0;
+ break;
+ }
+ i11 = HEAP32[(HEAP32[i12 + 24 >> 2] | 0) + (i11 * 28 | 0) + 24 >> 2] | 0;
+ i9 = HEAP32[(HEAP32[i10 + 24 >> 2] | 0) + (i9 * 28 | 0) + 24 >> 2] | 0;
+ if (!((i11 | 0) > -1)) {
+ i1 = 19;
+ break L4;
+ }
+ i10 = HEAP32[i7 >> 2] | 0;
+ if ((i10 | 0) <= (i11 | 0)) {
+ i1 = 19;
+ break L4;
+ }
+ i12 = HEAP32[i6 >> 2] | 0;
+ if (!((i9 | 0) > -1 & (i10 | 0) > (i9 | 0))) {
+ i1 = 21;
+ break L4;
+ }
+ if (+HEAPF32[i12 + (i9 * 36 | 0) >> 2] - +HEAPF32[i12 + (i11 * 36 | 0) + 8 >> 2] > 0.0 | +HEAPF32[i12 + (i9 * 36 | 0) + 4 >> 2] - +HEAPF32[i12 + (i11 * 36 | 0) + 12 >> 2] > 0.0 | +HEAPF32[i12 + (i11 * 36 | 0) >> 2] - +HEAPF32[i12 + (i9 * 36 | 0) + 8 >> 2] > 0.0 | +HEAPF32[i12 + (i11 * 36 | 0) + 4 >> 2] - +HEAPF32[i12 + (i9 * 36 | 0) + 12 >> 2] > 0.0) {
+ i16 = HEAP32[i8 + 12 >> 2] | 0;
+ __ZN16b2ContactManager7DestroyEP9b2Contact(i3, i8);
+ i8 = i16;
+ break;
+ } else {
+ __ZN9b2Contact6UpdateEP17b2ContactListener(i8, HEAP32[i5 >> 2] | 0);
+ i8 = HEAP32[i8 + 12 >> 2] | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i8 | 0) == 0) {
+ i1 = 25;
+ break;
+ }
+ }
+ if ((i1 | 0) == 19) {
+ ___assert_fail(1904, 1952, 159, 2008);
+ } else if ((i1 | 0) == 21) {
+ ___assert_fail(1904, 1952, 159, 2008);
+ } else if ((i1 | 0) == 25) {
+ STACKTOP = i2;
+ return;
+ }
+}
+function __ZN16b2ContactManager7AddPairEPvS0_(i1, i5, i6) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i5 + 16 >> 2] | 0;
+ i3 = HEAP32[i6 + 16 >> 2] | 0;
+ i5 = HEAP32[i5 + 20 >> 2] | 0;
+ i6 = HEAP32[i6 + 20 >> 2] | 0;
+ i8 = HEAP32[i4 + 8 >> 2] | 0;
+ i7 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i8 | 0) == (i7 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i10 = HEAP32[i7 + 112 >> 2] | 0;
+ L4 : do {
+ if ((i10 | 0) != 0) {
+ while (1) {
+ if ((HEAP32[i10 >> 2] | 0) == (i8 | 0)) {
+ i9 = HEAP32[i10 + 4 >> 2] | 0;
+ i12 = HEAP32[i9 + 48 >> 2] | 0;
+ i13 = HEAP32[i9 + 52 >> 2] | 0;
+ i11 = HEAP32[i9 + 56 >> 2] | 0;
+ i9 = HEAP32[i9 + 60 >> 2] | 0;
+ if ((i12 | 0) == (i4 | 0) & (i13 | 0) == (i3 | 0) & (i11 | 0) == (i5 | 0) & (i9 | 0) == (i6 | 0)) {
+ i9 = 22;
+ break;
+ }
+ if ((i12 | 0) == (i3 | 0) & (i13 | 0) == (i4 | 0) & (i11 | 0) == (i6 | 0) & (i9 | 0) == (i5 | 0)) {
+ i9 = 22;
+ break;
+ }
+ }
+ i10 = HEAP32[i10 + 12 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ break L4;
+ }
+ }
+ if ((i9 | 0) == 22) {
+ STACKTOP = i2;
+ return;
+ }
+ }
+ } while (0);
+ if (!(__ZNK6b2Body13ShouldCollideEPKS_(i7, i8) | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = HEAP32[i1 + 68 >> 2] | 0;
+ if ((i7 | 0) != 0 ? !(FUNCTION_TABLE_iiii[HEAP32[(HEAP32[i7 >> 2] | 0) + 8 >> 2] & 7](i7, i4, i3) | 0) : 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i5 = __ZN9b2Contact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i4, i5, i3, i6, HEAP32[i1 + 76 >> 2] | 0) | 0;
+ if ((i5 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP32[(HEAP32[i5 + 48 >> 2] | 0) + 8 >> 2] | 0;
+ i3 = HEAP32[(HEAP32[i5 + 52 >> 2] | 0) + 8 >> 2] | 0;
+ HEAP32[i5 + 8 >> 2] = 0;
+ i7 = i1 + 60 | 0;
+ HEAP32[i5 + 12 >> 2] = HEAP32[i7 >> 2];
+ i6 = HEAP32[i7 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ HEAP32[i6 + 8 >> 2] = i5;
+ }
+ HEAP32[i7 >> 2] = i5;
+ i8 = i5 + 16 | 0;
+ HEAP32[i5 + 20 >> 2] = i5;
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 + 24 >> 2] = 0;
+ i6 = i4 + 112 | 0;
+ HEAP32[i5 + 28 >> 2] = HEAP32[i6 >> 2];
+ i7 = HEAP32[i6 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ HEAP32[i7 + 8 >> 2] = i8;
+ }
+ HEAP32[i6 >> 2] = i8;
+ i6 = i5 + 32 | 0;
+ HEAP32[i5 + 36 >> 2] = i5;
+ HEAP32[i6 >> 2] = i4;
+ HEAP32[i5 + 40 >> 2] = 0;
+ i7 = i3 + 112 | 0;
+ HEAP32[i5 + 44 >> 2] = HEAP32[i7 >> 2];
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ HEAP32[i5 + 8 >> 2] = i6;
+ }
+ HEAP32[i7 >> 2] = i6;
+ i5 = i4 + 4 | 0;
+ i6 = HEAPU16[i5 >> 1] | 0;
+ if ((i6 & 2 | 0) == 0) {
+ HEAP16[i5 >> 1] = i6 | 2;
+ HEAPF32[i4 + 144 >> 2] = 0.0;
+ }
+ i4 = i3 + 4 | 0;
+ i5 = HEAPU16[i4 >> 1] | 0;
+ if ((i5 & 2 | 0) == 0) {
+ HEAP16[i4 >> 1] = i5 | 2;
+ HEAPF32[i3 + 144 >> 2] = 0.0;
+ }
+ i13 = i1 + 64 | 0;
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN12b2BroadPhase11UpdatePairsI16b2ContactManagerEEvPT_(i5, i2) {
+ i5 = i5 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i6 = i3;
+ i1 = i5 + 52 | 0;
+ HEAP32[i1 >> 2] = 0;
+ i4 = i5 + 40 | 0;
+ i12 = HEAP32[i4 >> 2] | 0;
+ do {
+ if ((i12 | 0) > 0) {
+ i9 = i5 + 32 | 0;
+ i11 = i5 + 56 | 0;
+ i8 = i5 + 12 | 0;
+ i10 = i5 + 4 | 0;
+ i13 = 0;
+ while (1) {
+ i14 = HEAP32[(HEAP32[i9 >> 2] | 0) + (i13 << 2) >> 2] | 0;
+ HEAP32[i11 >> 2] = i14;
+ if (!((i14 | 0) == -1)) {
+ if (!((i14 | 0) > -1)) {
+ i8 = 6;
+ break;
+ }
+ if ((HEAP32[i8 >> 2] | 0) <= (i14 | 0)) {
+ i8 = 6;
+ break;
+ }
+ __ZNK13b2DynamicTree5QueryI12b2BroadPhaseEEvPT_RK6b2AABB(i5, i5, (HEAP32[i10 >> 2] | 0) + (i14 * 36 | 0) | 0);
+ i12 = HEAP32[i4 >> 2] | 0;
+ }
+ i13 = i13 + 1 | 0;
+ if ((i13 | 0) >= (i12 | 0)) {
+ i8 = 9;
+ break;
+ }
+ }
+ if ((i8 | 0) == 6) {
+ ___assert_fail(1904, 1952, 159, 2008);
+ } else if ((i8 | 0) == 9) {
+ i7 = HEAP32[i1 >> 2] | 0;
+ break;
+ }
+ } else {
+ i7 = 0;
+ }
+ } while (0);
+ HEAP32[i4 >> 2] = 0;
+ i4 = i5 + 44 | 0;
+ i14 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i6 >> 2] = 3;
+ __ZNSt3__16__sortIRPFbRK6b2PairS3_EPS1_EEvT0_S8_T_(i14, i14 + (i7 * 12 | 0) | 0, i6);
+ if ((HEAP32[i1 >> 2] | 0) <= 0) {
+ STACKTOP = i3;
+ return;
+ }
+ i6 = i5 + 12 | 0;
+ i7 = i5 + 4 | 0;
+ i9 = 0;
+ L18 : while (1) {
+ i8 = HEAP32[i4 >> 2] | 0;
+ i5 = i8 + (i9 * 12 | 0) | 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ if (!((i10 | 0) > -1)) {
+ i8 = 14;
+ break;
+ }
+ i12 = HEAP32[i6 >> 2] | 0;
+ if ((i12 | 0) <= (i10 | 0)) {
+ i8 = 14;
+ break;
+ }
+ i11 = HEAP32[i7 >> 2] | 0;
+ i8 = i8 + (i9 * 12 | 0) + 4 | 0;
+ i13 = HEAP32[i8 >> 2] | 0;
+ if (!((i13 | 0) > -1 & (i12 | 0) > (i13 | 0))) {
+ i8 = 16;
+ break;
+ }
+ __ZN16b2ContactManager7AddPairEPvS0_(i2, HEAP32[i11 + (i10 * 36 | 0) + 16 >> 2] | 0, HEAP32[i11 + (i13 * 36 | 0) + 16 >> 2] | 0);
+ i10 = HEAP32[i1 >> 2] | 0;
+ while (1) {
+ i9 = i9 + 1 | 0;
+ if ((i9 | 0) >= (i10 | 0)) {
+ i8 = 21;
+ break L18;
+ }
+ i11 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i11 + (i9 * 12 | 0) >> 2] | 0) != (HEAP32[i5 >> 2] | 0)) {
+ continue L18;
+ }
+ if ((HEAP32[i11 + (i9 * 12 | 0) + 4 >> 2] | 0) != (HEAP32[i8 >> 2] | 0)) {
+ continue L18;
+ }
+ }
+ }
+ if ((i8 | 0) == 14) {
+ ___assert_fail(1904, 1952, 153, 1992);
+ } else if ((i8 | 0) == 16) {
+ ___assert_fail(1904, 1952, 153, 1992);
+ } else if ((i8 | 0) == 21) {
+ STACKTOP = i3;
+ return;
+ }
+}
+function __ZNK13b2DynamicTree5QueryI12b2BroadPhaseEEvPT_RK6b2AABB(i9, i4, i7) {
+ i9 = i9 | 0;
+ i4 = i4 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1040 | 0;
+ i3 = i2;
+ i1 = i3 + 4 | 0;
+ HEAP32[i3 >> 2] = i1;
+ i5 = i3 + 1028 | 0;
+ HEAP32[i5 >> 2] = 0;
+ i6 = i3 + 1032 | 0;
+ HEAP32[i6 >> 2] = 256;
+ i14 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i14 + (HEAP32[i5 >> 2] << 2) >> 2] = HEAP32[i9 >> 2];
+ i15 = HEAP32[i5 >> 2] | 0;
+ i16 = i15 + 1 | 0;
+ HEAP32[i5 >> 2] = i16;
+ L1 : do {
+ if ((i15 | 0) > -1) {
+ i9 = i9 + 4 | 0;
+ i11 = i7 + 4 | 0;
+ i12 = i7 + 8 | 0;
+ i10 = i7 + 12 | 0;
+ while (1) {
+ i16 = i16 + -1 | 0;
+ HEAP32[i5 >> 2] = i16;
+ i13 = HEAP32[i14 + (i16 << 2) >> 2] | 0;
+ do {
+ if (!((i13 | 0) == -1) ? (i8 = HEAP32[i9 >> 2] | 0, !(+HEAPF32[i7 >> 2] - +HEAPF32[i8 + (i13 * 36 | 0) + 8 >> 2] > 0.0 | +HEAPF32[i11 >> 2] - +HEAPF32[i8 + (i13 * 36 | 0) + 12 >> 2] > 0.0 | +HEAPF32[i8 + (i13 * 36 | 0) >> 2] - +HEAPF32[i12 >> 2] > 0.0 | +HEAPF32[i8 + (i13 * 36 | 0) + 4 >> 2] - +HEAPF32[i10 >> 2] > 0.0)) : 0) {
+ i15 = i8 + (i13 * 36 | 0) + 24 | 0;
+ if ((HEAP32[i15 >> 2] | 0) == -1) {
+ if (!(__ZN12b2BroadPhase13QueryCallbackEi(i4, i13) | 0)) {
+ break L1;
+ }
+ i16 = HEAP32[i5 >> 2] | 0;
+ break;
+ }
+ if ((i16 | 0) == (HEAP32[i6 >> 2] | 0) ? (HEAP32[i6 >> 2] = i16 << 1, i16 = __Z7b2Alloci(i16 << 3) | 0, HEAP32[i3 >> 2] = i16, _memcpy(i16 | 0, i14 | 0, HEAP32[i5 >> 2] << 2 | 0) | 0, (i14 | 0) != (i1 | 0)) : 0) {
+ __Z6b2FreePv(i14);
+ }
+ i14 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i14 + (HEAP32[i5 >> 2] << 2) >> 2] = HEAP32[i15 >> 2];
+ i15 = (HEAP32[i5 >> 2] | 0) + 1 | 0;
+ HEAP32[i5 >> 2] = i15;
+ i13 = i8 + (i13 * 36 | 0) + 28 | 0;
+ if ((i15 | 0) == (HEAP32[i6 >> 2] | 0) ? (HEAP32[i6 >> 2] = i15 << 1, i16 = __Z7b2Alloci(i15 << 3) | 0, HEAP32[i3 >> 2] = i16, _memcpy(i16 | 0, i14 | 0, HEAP32[i5 >> 2] << 2 | 0) | 0, (i14 | 0) != (i1 | 0)) : 0) {
+ __Z6b2FreePv(i14);
+ }
+ HEAP32[(HEAP32[i3 >> 2] | 0) + (HEAP32[i5 >> 2] << 2) >> 2] = HEAP32[i13 >> 2];
+ i16 = (HEAP32[i5 >> 2] | 0) + 1 | 0;
+ HEAP32[i5 >> 2] = i16;
+ }
+ } while (0);
+ if ((i16 | 0) <= 0) {
+ break L1;
+ }
+ i14 = HEAP32[i3 >> 2] | 0;
+ }
+ }
+ } while (0);
+ i4 = HEAP32[i3 >> 2] | 0;
+ if ((i4 | 0) == (i1 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ __Z6b2FreePv(i4);
+ HEAP32[i3 >> 2] = 0;
+ STACKTOP = i2;
+ return;
+}
+function __ZN15b2ContactSolver9WarmStartEv(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, d10 = 0.0, d11 = 0.0, d12 = 0.0, i13 = 0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0, d21 = 0.0, i22 = 0, d23 = 0.0, i24 = 0, d25 = 0.0, d26 = 0.0, d27 = 0.0;
+ i1 = STACKTOP;
+ i2 = i4 + 48 | 0;
+ if ((HEAP32[i2 >> 2] | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = i4 + 40 | 0;
+ i5 = i4 + 28 | 0;
+ i22 = HEAP32[i5 >> 2] | 0;
+ i8 = 0;
+ do {
+ i9 = HEAP32[i3 >> 2] | 0;
+ i7 = HEAP32[i9 + (i8 * 152 | 0) + 112 >> 2] | 0;
+ i6 = HEAP32[i9 + (i8 * 152 | 0) + 116 >> 2] | 0;
+ d10 = +HEAPF32[i9 + (i8 * 152 | 0) + 120 >> 2];
+ d14 = +HEAPF32[i9 + (i8 * 152 | 0) + 128 >> 2];
+ d12 = +HEAPF32[i9 + (i8 * 152 | 0) + 124 >> 2];
+ d11 = +HEAPF32[i9 + (i8 * 152 | 0) + 132 >> 2];
+ i13 = HEAP32[i9 + (i8 * 152 | 0) + 144 >> 2] | 0;
+ i4 = i22 + (i7 * 12 | 0) | 0;
+ i24 = i4;
+ d17 = +HEAPF32[i24 >> 2];
+ d19 = +HEAPF32[i24 + 4 >> 2];
+ d20 = +HEAPF32[i22 + (i7 * 12 | 0) + 8 >> 2];
+ i24 = i22 + (i6 * 12 | 0) | 0;
+ d21 = +HEAPF32[i24 >> 2];
+ d23 = +HEAPF32[i24 + 4 >> 2];
+ d18 = +HEAPF32[i22 + (i6 * 12 | 0) + 8 >> 2];
+ i22 = i9 + (i8 * 152 | 0) + 72 | 0;
+ d15 = +HEAPF32[i22 >> 2];
+ d16 = +HEAPF32[i22 + 4 >> 2];
+ if ((i13 | 0) > 0) {
+ i22 = 0;
+ do {
+ d27 = +HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) + 16 >> 2];
+ d25 = +HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) + 20 >> 2];
+ d26 = d15 * d27 + d16 * d25;
+ d25 = d16 * d27 - d15 * d25;
+ d20 = d20 - d14 * (+HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) >> 2] * d25 - +HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) + 4 >> 2] * d26);
+ d17 = d17 - d10 * d26;
+ d19 = d19 - d10 * d25;
+ d18 = d18 + d11 * (d25 * +HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) + 8 >> 2] - d26 * +HEAPF32[i9 + (i8 * 152 | 0) + (i22 * 36 | 0) + 12 >> 2]);
+ d21 = d21 + d12 * d26;
+ d23 = d23 + d12 * d25;
+ i22 = i22 + 1 | 0;
+ } while ((i22 | 0) != (i13 | 0));
+ }
+ d27 = +d17;
+ d26 = +d19;
+ i22 = i4;
+ HEAPF32[i22 >> 2] = d27;
+ HEAPF32[i22 + 4 >> 2] = d26;
+ i22 = HEAP32[i5 >> 2] | 0;
+ HEAPF32[i22 + (i7 * 12 | 0) + 8 >> 2] = d20;
+ d26 = +d21;
+ d27 = +d23;
+ i22 = i22 + (i6 * 12 | 0) | 0;
+ HEAPF32[i22 >> 2] = d26;
+ HEAPF32[i22 + 4 >> 2] = d27;
+ i22 = HEAP32[i5 >> 2] | 0;
+ HEAPF32[i22 + (i6 * 12 | 0) + 8 >> 2] = d18;
+ i8 = i8 + 1 | 0;
+ } while ((i8 | 0) < (HEAP32[i2 >> 2] | 0));
+ STACKTOP = i1;
+ return;
+}
+function __ZNK14b2PolygonShape7RayCastEP15b2RayCastOutputRK14b2RayCastInputRK11b2Transformi(i1, i5, i8, i7, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i8 = i8 | 0;
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, d3 = 0.0, i6 = 0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, i14 = 0, i15 = 0, i16 = 0, d17 = 0.0, d18 = 0.0, d19 = 0.0, d20 = 0.0;
+ i4 = STACKTOP;
+ d10 = +HEAPF32[i7 >> 2];
+ d9 = +HEAPF32[i8 >> 2] - d10;
+ d18 = +HEAPF32[i7 + 4 >> 2];
+ d11 = +HEAPF32[i8 + 4 >> 2] - d18;
+ i6 = i7 + 12 | 0;
+ d17 = +HEAPF32[i6 >> 2];
+ i7 = i7 + 8 | 0;
+ d19 = +HEAPF32[i7 >> 2];
+ d12 = d9 * d17 + d11 * d19;
+ d9 = d17 * d11 - d9 * d19;
+ d10 = +HEAPF32[i8 + 8 >> 2] - d10;
+ d18 = +HEAPF32[i8 + 12 >> 2] - d18;
+ d11 = d17 * d10 + d19 * d18 - d12;
+ d10 = d17 * d18 - d19 * d10 - d9;
+ i8 = i8 + 16 | 0;
+ i14 = HEAP32[i1 + 148 >> 2] | 0;
+ do {
+ if ((i14 | 0) > 0) {
+ i16 = 0;
+ i15 = -1;
+ d13 = 0.0;
+ d17 = +HEAPF32[i8 >> 2];
+ L3 : while (1) {
+ d20 = +HEAPF32[i1 + (i16 << 3) + 84 >> 2];
+ d19 = +HEAPF32[i1 + (i16 << 3) + 88 >> 2];
+ d18 = (+HEAPF32[i1 + (i16 << 3) + 20 >> 2] - d12) * d20 + (+HEAPF32[i1 + (i16 << 3) + 24 >> 2] - d9) * d19;
+ d19 = d11 * d20 + d10 * d19;
+ do {
+ if (d19 == 0.0) {
+ if (d18 < 0.0) {
+ i1 = 0;
+ i14 = 18;
+ break L3;
+ }
+ } else {
+ if (d19 < 0.0 ? d18 < d13 * d19 : 0) {
+ i15 = i16;
+ d13 = d18 / d19;
+ break;
+ }
+ if (d19 > 0.0 ? d18 < d17 * d19 : 0) {
+ d17 = d18 / d19;
+ }
+ }
+ } while (0);
+ i16 = i16 + 1 | 0;
+ if (d17 < d13) {
+ i1 = 0;
+ i14 = 18;
+ break;
+ }
+ if ((i16 | 0) >= (i14 | 0)) {
+ i14 = 13;
+ break;
+ }
+ }
+ if ((i14 | 0) == 13) {
+ if (d13 >= 0.0) {
+ i2 = i15;
+ d3 = d13;
+ break;
+ }
+ ___assert_fail(376, 328, 249, 424);
+ } else if ((i14 | 0) == 18) {
+ STACKTOP = i4;
+ return i1 | 0;
+ }
+ } else {
+ i2 = -1;
+ d3 = 0.0;
+ }
+ } while (0);
+ if (!(d3 <= +HEAPF32[i8 >> 2])) {
+ ___assert_fail(376, 328, 249, 424);
+ }
+ if (!((i2 | 0) > -1)) {
+ i16 = 0;
+ STACKTOP = i4;
+ return i16 | 0;
+ }
+ HEAPF32[i5 + 8 >> 2] = d3;
+ d18 = +HEAPF32[i6 >> 2];
+ d13 = +HEAPF32[i1 + (i2 << 3) + 84 >> 2];
+ d17 = +HEAPF32[i7 >> 2];
+ d20 = +HEAPF32[i1 + (i2 << 3) + 88 >> 2];
+ d19 = +(d18 * d13 - d17 * d20);
+ d20 = +(d13 * d17 + d18 * d20);
+ i16 = i5;
+ HEAPF32[i16 >> 2] = d19;
+ HEAPF32[i16 + 4 >> 2] = d20;
+ i16 = 1;
+ STACKTOP = i4;
+ return i16 | 0;
+}
+function __ZN7b2World4StepEfii(i1, d9, i11, i12) {
+ i1 = i1 | 0;
+ d9 = +d9;
+ i11 = i11 | 0;
+ i12 = i12 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i13 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i4 + 27 | 0;
+ i5 = i4;
+ i8 = i4 + 26 | 0;
+ i10 = i4 + 25 | 0;
+ i7 = i4 + 24 | 0;
+ __ZN7b2TimerC2Ev(i3);
+ i2 = i1 + 102868 | 0;
+ i13 = HEAP32[i2 >> 2] | 0;
+ if ((i13 & 1 | 0) != 0) {
+ __ZN16b2ContactManager15FindNewContactsEv(i1 + 102872 | 0);
+ i13 = HEAP32[i2 >> 2] & -2;
+ HEAP32[i2 >> 2] = i13;
+ }
+ HEAP32[i2 >> 2] = i13 | 2;
+ HEAPF32[i5 >> 2] = d9;
+ HEAP32[i5 + 12 >> 2] = i11;
+ HEAP32[i5 + 16 >> 2] = i12;
+ if (d9 > 0.0) {
+ HEAPF32[i5 + 4 >> 2] = 1.0 / d9;
+ } else {
+ HEAPF32[i5 + 4 >> 2] = 0.0;
+ }
+ i11 = i1 + 102988 | 0;
+ HEAPF32[i5 + 8 >> 2] = +HEAPF32[i11 >> 2] * d9;
+ HEAP8[i5 + 20 | 0] = HEAP8[i1 + 102992 | 0] | 0;
+ __ZN7b2TimerC2Ev(i8);
+ __ZN16b2ContactManager7CollideEv(i1 + 102872 | 0);
+ HEAPF32[i1 + 103e3 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i8);
+ if ((HEAP8[i1 + 102995 | 0] | 0) != 0 ? +HEAPF32[i5 >> 2] > 0.0 : 0) {
+ __ZN7b2TimerC2Ev(i10);
+ __ZN7b2World5SolveERK10b2TimeStep(i1, i5);
+ HEAPF32[i1 + 103004 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i10);
+ }
+ if ((HEAP8[i1 + 102993 | 0] | 0) != 0) {
+ d9 = +HEAPF32[i5 >> 2];
+ if (d9 > 0.0) {
+ __ZN7b2TimerC2Ev(i7);
+ __ZN7b2World8SolveTOIERK10b2TimeStep(i1, i5);
+ HEAPF32[i1 + 103024 >> 2] = +__ZNK7b2Timer15GetMillisecondsEv(i7);
+ i6 = 12;
+ }
+ } else {
+ i6 = 12;
+ }
+ if ((i6 | 0) == 12) {
+ d9 = +HEAPF32[i5 >> 2];
+ }
+ if (d9 > 0.0) {
+ HEAPF32[i11 >> 2] = +HEAPF32[i5 + 4 >> 2];
+ }
+ i5 = HEAP32[i2 >> 2] | 0;
+ if ((i5 & 4 | 0) == 0) {
+ i13 = i5 & -3;
+ HEAP32[i2 >> 2] = i13;
+ d9 = +__ZNK7b2Timer15GetMillisecondsEv(i3);
+ i13 = i1 + 102996 | 0;
+ HEAPF32[i13 >> 2] = d9;
+ STACKTOP = i4;
+ return;
+ }
+ i6 = HEAP32[i1 + 102952 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ i13 = i5 & -3;
+ HEAP32[i2 >> 2] = i13;
+ d9 = +__ZNK7b2Timer15GetMillisecondsEv(i3);
+ i13 = i1 + 102996 | 0;
+ HEAPF32[i13 >> 2] = d9;
+ STACKTOP = i4;
+ return;
+ }
+ do {
+ HEAPF32[i6 + 76 >> 2] = 0.0;
+ HEAPF32[i6 + 80 >> 2] = 0.0;
+ HEAPF32[i6 + 84 >> 2] = 0.0;
+ i6 = HEAP32[i6 + 96 >> 2] | 0;
+ } while ((i6 | 0) != 0);
+ i13 = i5 & -3;
+ HEAP32[i2 >> 2] = i13;
+ d9 = +__ZNK7b2Timer15GetMillisecondsEv(i3);
+ i13 = i1 + 102996 | 0;
+ HEAPF32[i13 >> 2] = d9;
+ STACKTOP = i4;
+ return;
+}
+function __ZL19b2FindMaxSeparationPiPK14b2PolygonShapeRK11b2TransformS2_S5_(i1, i5, i6, i3, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i7 = 0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, i12 = 0, i13 = 0, i14 = 0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0;
+ i2 = STACKTOP;
+ i7 = HEAP32[i5 + 148 >> 2] | 0;
+ d17 = +HEAPF32[i4 + 12 >> 2];
+ d19 = +HEAPF32[i3 + 12 >> 2];
+ d18 = +HEAPF32[i4 + 8 >> 2];
+ d16 = +HEAPF32[i3 + 16 >> 2];
+ d15 = +HEAPF32[i6 + 12 >> 2];
+ d10 = +HEAPF32[i5 + 12 >> 2];
+ d8 = +HEAPF32[i6 + 8 >> 2];
+ d9 = +HEAPF32[i5 + 16 >> 2];
+ d11 = +HEAPF32[i4 >> 2] + (d17 * d19 - d18 * d16) - (+HEAPF32[i6 >> 2] + (d15 * d10 - d8 * d9));
+ d9 = d19 * d18 + d17 * d16 + +HEAPF32[i4 + 4 >> 2] - (d10 * d8 + d15 * d9 + +HEAPF32[i6 + 4 >> 2]);
+ d10 = d15 * d11 + d8 * d9;
+ d8 = d15 * d9 - d11 * d8;
+ if ((i7 | 0) > 0) {
+ i14 = 0;
+ i13 = 0;
+ d9 = -3.4028234663852886e+38;
+ while (1) {
+ d11 = d10 * +HEAPF32[i5 + (i13 << 3) + 84 >> 2] + d8 * +HEAPF32[i5 + (i13 << 3) + 88 >> 2];
+ i12 = d11 > d9;
+ i14 = i12 ? i13 : i14;
+ i13 = i13 + 1 | 0;
+ if ((i13 | 0) == (i7 | 0)) {
+ break;
+ } else {
+ d9 = i12 ? d11 : d9;
+ }
+ }
+ } else {
+ i14 = 0;
+ }
+ d9 = +__ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i5, i6, i14, i3, i4);
+ i12 = ((i14 | 0) > 0 ? i14 : i7) + -1 | 0;
+ d8 = +__ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i5, i6, i12, i3, i4);
+ i13 = i14 + 1 | 0;
+ i13 = (i13 | 0) < (i7 | 0) ? i13 : 0;
+ d10 = +__ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i5, i6, i13, i3, i4);
+ if (d8 > d9 & d8 > d10) {
+ while (1) {
+ i13 = ((i12 | 0) > 0 ? i12 : i7) + -1 | 0;
+ d9 = +__ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i5, i6, i13, i3, i4);
+ if (d9 > d8) {
+ i12 = i13;
+ d8 = d9;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i1 >> 2] = i12;
+ STACKTOP = i2;
+ return +d8;
+ }
+ if (d10 > d9) {
+ i12 = i13;
+ d8 = d10;
+ } else {
+ d19 = d9;
+ HEAP32[i1 >> 2] = i14;
+ STACKTOP = i2;
+ return +d19;
+ }
+ while (1) {
+ i13 = i12 + 1 | 0;
+ i13 = (i13 | 0) < (i7 | 0) ? i13 : 0;
+ d9 = +__ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i5, i6, i13, i3, i4);
+ if (d9 > d8) {
+ i12 = i13;
+ d8 = d9;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i1 >> 2] = i12;
+ STACKTOP = i2;
+ return +d8;
+}
+function __ZN9b2Fixture11SynchronizeEP12b2BroadPhaseRK11b2TransformS4_(i10, i8, i7, i2) {
+ i10 = i10 | 0;
+ i8 = i8 | 0;
+ i7 = i7 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0, i27 = 0;
+ i9 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i5 = i9 + 24 | 0;
+ i6 = i9 + 8 | 0;
+ i3 = i9;
+ i4 = i10 + 28 | 0;
+ if ((HEAP32[i4 >> 2] | 0) <= 0) {
+ STACKTOP = i9;
+ return;
+ }
+ i1 = i10 + 24 | 0;
+ i18 = i10 + 12 | 0;
+ i19 = i5 + 4 | 0;
+ i20 = i6 + 4 | 0;
+ i13 = i5 + 8 | 0;
+ i14 = i6 + 8 | 0;
+ i15 = i5 + 12 | 0;
+ i16 = i6 + 12 | 0;
+ i11 = i2 + 4 | 0;
+ i22 = i7 + 4 | 0;
+ i12 = i3 + 4 | 0;
+ i21 = 0;
+ do {
+ i10 = HEAP32[i1 >> 2] | 0;
+ i27 = HEAP32[i18 >> 2] | 0;
+ i17 = i10 + (i21 * 28 | 0) + 20 | 0;
+ FUNCTION_TABLE_viiii[HEAP32[(HEAP32[i27 >> 2] | 0) + 24 >> 2] & 15](i27, i5, i7, HEAP32[i17 >> 2] | 0);
+ i27 = HEAP32[i18 >> 2] | 0;
+ FUNCTION_TABLE_viiii[HEAP32[(HEAP32[i27 >> 2] | 0) + 24 >> 2] & 15](i27, i6, i2, HEAP32[i17 >> 2] | 0);
+ i17 = i10 + (i21 * 28 | 0) | 0;
+ d25 = +HEAPF32[i5 >> 2];
+ d26 = +HEAPF32[i6 >> 2];
+ d24 = +HEAPF32[i19 >> 2];
+ d23 = +HEAPF32[i20 >> 2];
+ d25 = +(d25 < d26 ? d25 : d26);
+ d26 = +(d24 < d23 ? d24 : d23);
+ i27 = i17;
+ HEAPF32[i27 >> 2] = d25;
+ HEAPF32[i27 + 4 >> 2] = d26;
+ d25 = +HEAPF32[i13 >> 2];
+ d26 = +HEAPF32[i14 >> 2];
+ d23 = +HEAPF32[i15 >> 2];
+ d24 = +HEAPF32[i16 >> 2];
+ d25 = +(d25 > d26 ? d25 : d26);
+ d26 = +(d23 > d24 ? d23 : d24);
+ i27 = i10 + (i21 * 28 | 0) + 8 | 0;
+ HEAPF32[i27 >> 2] = d25;
+ HEAPF32[i27 + 4 >> 2] = d26;
+ d26 = +HEAPF32[i11 >> 2] - +HEAPF32[i22 >> 2];
+ HEAPF32[i3 >> 2] = +HEAPF32[i2 >> 2] - +HEAPF32[i7 >> 2];
+ HEAPF32[i12 >> 2] = d26;
+ __ZN12b2BroadPhase9MoveProxyEiRK6b2AABBRK6b2Vec2(i8, HEAP32[i10 + (i21 * 28 | 0) + 24 >> 2] | 0, i17, i3);
+ i21 = i21 + 1 | 0;
+ } while ((i21 | 0) < (HEAP32[i4 >> 2] | 0));
+ STACKTOP = i9;
+ return;
+}
+function __ZN12b2EPCollider24ComputePolygonSeparationEv(i2, i9) {
+ i2 = i2 | 0;
+ i9 = i9 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = 0.0, d7 = 0.0, i8 = 0, d10 = 0.0, d11 = 0.0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, d16 = 0.0, d17 = 0.0, d18 = 0.0, d19 = 0.0, i20 = 0, d21 = 0.0, d22 = 0.0, d23 = 0.0, d24 = 0.0, d25 = 0.0, d26 = 0.0;
+ i15 = STACKTOP;
+ HEAP32[i2 >> 2] = 0;
+ i3 = i2 + 4 | 0;
+ HEAP32[i3 >> 2] = -1;
+ i4 = i2 + 8 | 0;
+ HEAPF32[i4 >> 2] = -3.4028234663852886e+38;
+ d7 = +HEAPF32[i9 + 216 >> 2];
+ d6 = +HEAPF32[i9 + 212 >> 2];
+ i5 = HEAP32[i9 + 128 >> 2] | 0;
+ if ((i5 | 0) <= 0) {
+ STACKTOP = i15;
+ return;
+ }
+ d17 = +HEAPF32[i9 + 164 >> 2];
+ d18 = +HEAPF32[i9 + 168 >> 2];
+ d11 = +HEAPF32[i9 + 172 >> 2];
+ d10 = +HEAPF32[i9 + 176 >> 2];
+ d16 = +HEAPF32[i9 + 244 >> 2];
+ i12 = i9 + 228 | 0;
+ i13 = i9 + 232 | 0;
+ i14 = i9 + 236 | 0;
+ i1 = i9 + 240 | 0;
+ d19 = -3.4028234663852886e+38;
+ i20 = 0;
+ while (1) {
+ d23 = +HEAPF32[i9 + (i20 << 3) + 64 >> 2];
+ d21 = -d23;
+ d22 = -+HEAPF32[i9 + (i20 << 3) + 68 >> 2];
+ d26 = +HEAPF32[i9 + (i20 << 3) >> 2];
+ d25 = +HEAPF32[i9 + (i20 << 3) + 4 >> 2];
+ d24 = (d26 - d17) * d21 + (d25 - d18) * d22;
+ d25 = (d26 - d11) * d21 + (d25 - d10) * d22;
+ d24 = d24 < d25 ? d24 : d25;
+ if (d24 > d16) {
+ break;
+ }
+ if (!(d7 * d23 + d6 * d22 >= 0.0)) {
+ if (!((d21 - +HEAPF32[i12 >> 2]) * d6 + (d22 - +HEAPF32[i13 >> 2]) * d7 < -.03490658849477768) & d24 > d19) {
+ i8 = 8;
+ }
+ } else {
+ if (!((d21 - +HEAPF32[i14 >> 2]) * d6 + (d22 - +HEAPF32[i1 >> 2]) * d7 < -.03490658849477768) & d24 > d19) {
+ i8 = 8;
+ }
+ }
+ if ((i8 | 0) == 8) {
+ i8 = 0;
+ HEAP32[i2 >> 2] = 2;
+ HEAP32[i3 >> 2] = i20;
+ HEAPF32[i4 >> 2] = d24;
+ d19 = d24;
+ }
+ i20 = i20 + 1 | 0;
+ if ((i20 | 0) >= (i5 | 0)) {
+ i8 = 10;
+ break;
+ }
+ }
+ if ((i8 | 0) == 10) {
+ STACKTOP = i15;
+ return;
+ }
+ HEAP32[i2 >> 2] = 2;
+ HEAP32[i3 >> 2] = i20;
+ HEAPF32[i4 >> 2] = d24;
+ STACKTOP = i15;
+ return;
+}
+function __ZNK11b2EdgeShape7RayCastEP15b2RayCastOutputRK14b2RayCastInputRK11b2Transformi(i17, i1, i2, i18, i3) {
+ i17 = i17 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i18 = i18 | 0;
+ i3 = i3 | 0;
+ var d4 = 0.0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0;
+ i3 = STACKTOP;
+ d6 = +HEAPF32[i18 >> 2];
+ d7 = +HEAPF32[i2 >> 2] - d6;
+ d9 = +HEAPF32[i18 + 4 >> 2];
+ d4 = +HEAPF32[i2 + 4 >> 2] - d9;
+ d11 = +HEAPF32[i18 + 12 >> 2];
+ d5 = +HEAPF32[i18 + 8 >> 2];
+ d8 = d7 * d11 + d4 * d5;
+ d7 = d11 * d4 - d7 * d5;
+ d6 = +HEAPF32[i2 + 8 >> 2] - d6;
+ d9 = +HEAPF32[i2 + 12 >> 2] - d9;
+ d4 = d11 * d6 + d5 * d9 - d8;
+ d6 = d11 * d9 - d5 * d6 - d7;
+ i18 = i17 + 12 | 0;
+ d5 = +HEAPF32[i18 >> 2];
+ d9 = +HEAPF32[i18 + 4 >> 2];
+ i18 = i17 + 20 | 0;
+ d11 = +HEAPF32[i18 >> 2];
+ d11 = d11 - d5;
+ d12 = +HEAPF32[i18 + 4 >> 2] - d9;
+ d15 = -d11;
+ d10 = d11 * d11 + d12 * d12;
+ d13 = +Math_sqrt(+d10);
+ if (d13 < 1.1920928955078125e-7) {
+ d13 = d12;
+ } else {
+ d16 = 1.0 / d13;
+ d13 = d12 * d16;
+ d15 = d16 * d15;
+ }
+ d14 = (d9 - d7) * d15 + (d5 - d8) * d13;
+ d16 = d6 * d15 + d4 * d13;
+ if (d16 == 0.0) {
+ i18 = 0;
+ STACKTOP = i3;
+ return i18 | 0;
+ }
+ d16 = d14 / d16;
+ if (d16 < 0.0) {
+ i18 = 0;
+ STACKTOP = i3;
+ return i18 | 0;
+ }
+ if (+HEAPF32[i2 + 16 >> 2] < d16 | d10 == 0.0) {
+ i18 = 0;
+ STACKTOP = i3;
+ return i18 | 0;
+ }
+ d12 = (d11 * (d8 + d4 * d16 - d5) + d12 * (d7 + d6 * d16 - d9)) / d10;
+ if (d12 < 0.0 | d12 > 1.0) {
+ i18 = 0;
+ STACKTOP = i3;
+ return i18 | 0;
+ }
+ HEAPF32[i1 + 8 >> 2] = d16;
+ if (d14 > 0.0) {
+ d14 = +-d13;
+ d16 = +-d15;
+ i18 = i1;
+ HEAPF32[i18 >> 2] = d14;
+ HEAPF32[i18 + 4 >> 2] = d16;
+ i18 = 1;
+ STACKTOP = i3;
+ return i18 | 0;
+ } else {
+ d14 = +d13;
+ d16 = +d15;
+ i18 = i1;
+ HEAPF32[i18 >> 2] = d14;
+ HEAPF32[i18 + 4 >> 2] = d16;
+ i18 = 1;
+ STACKTOP = i3;
+ return i18 | 0;
+ }
+ return 0;
+}
+function ___dynamic_cast(i7, i6, i11, i5) {
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i11 = i11 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i2 = i1;
+ i3 = HEAP32[i7 >> 2] | 0;
+ i4 = i7 + (HEAP32[i3 + -8 >> 2] | 0) | 0;
+ i3 = HEAP32[i3 + -4 >> 2] | 0;
+ HEAP32[i2 >> 2] = i11;
+ HEAP32[i2 + 4 >> 2] = i7;
+ HEAP32[i2 + 8 >> 2] = i6;
+ HEAP32[i2 + 12 >> 2] = i5;
+ i9 = i2 + 16 | 0;
+ i10 = i2 + 20 | 0;
+ i6 = i2 + 24 | 0;
+ i8 = i2 + 28 | 0;
+ i5 = i2 + 32 | 0;
+ i7 = i2 + 40 | 0;
+ i12 = (i3 | 0) == (i11 | 0);
+ i13 = i9 + 0 | 0;
+ i11 = i13 + 36 | 0;
+ do {
+ HEAP32[i13 >> 2] = 0;
+ i13 = i13 + 4 | 0;
+ } while ((i13 | 0) < (i11 | 0));
+ HEAP16[i9 + 36 >> 1] = 0;
+ HEAP8[i9 + 38 | 0] = 0;
+ if (i12) {
+ HEAP32[i2 + 48 >> 2] = 1;
+ FUNCTION_TABLE_viiiiii[HEAP32[(HEAP32[i3 >> 2] | 0) + 20 >> 2] & 3](i3, i2, i4, i4, 1, 0);
+ i13 = (HEAP32[i6 >> 2] | 0) == 1 ? i4 : 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ FUNCTION_TABLE_viiiii[HEAP32[(HEAP32[i3 >> 2] | 0) + 24 >> 2] & 3](i3, i2, i4, 1, 0);
+ i2 = HEAP32[i2 + 36 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ if ((HEAP32[i7 >> 2] | 0) != 1) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ if ((HEAP32[i8 >> 2] | 0) != 1) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i13 = (HEAP32[i5 >> 2] | 0) == 1 ? HEAP32[i10 >> 2] | 0 : 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else if ((i2 | 0) == 1) {
+ if ((HEAP32[i6 >> 2] | 0) != 1) {
+ if ((HEAP32[i7 >> 2] | 0) != 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ if ((HEAP32[i8 >> 2] | 0) != 1) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ if ((HEAP32[i5 >> 2] | 0) != 1) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ i13 = HEAP32[i9 >> 2] | 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ return 0;
+}
+function __ZNK14b2PolygonShape11ComputeMassEP10b2MassDataf(i4, i1, d2) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ d2 = +d2;
+ var i3 = 0, i5 = 0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, i12 = 0, d13 = 0.0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, d18 = 0.0, i19 = 0, d20 = 0.0, d21 = 0.0, d22 = 0.0, d23 = 0.0;
+ i3 = STACKTOP;
+ i5 = HEAP32[i4 + 148 >> 2] | 0;
+ if ((i5 | 0) > 2) {
+ d7 = 0.0;
+ d6 = 0.0;
+ i12 = 0;
+ } else {
+ ___assert_fail(432, 328, 306, 456);
+ }
+ do {
+ d6 = d6 + +HEAPF32[i4 + (i12 << 3) + 20 >> 2];
+ d7 = d7 + +HEAPF32[i4 + (i12 << 3) + 24 >> 2];
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) < (i5 | 0));
+ d11 = 1.0 / +(i5 | 0);
+ d6 = d6 * d11;
+ d11 = d7 * d11;
+ i16 = i4 + 20 | 0;
+ i19 = i4 + 24 | 0;
+ d9 = 0.0;
+ d10 = 0.0;
+ d7 = 0.0;
+ d8 = 0.0;
+ i17 = 0;
+ do {
+ d18 = +HEAPF32[i4 + (i17 << 3) + 20 >> 2] - d6;
+ d13 = +HEAPF32[i4 + (i17 << 3) + 24 >> 2] - d11;
+ i17 = i17 + 1 | 0;
+ i12 = (i17 | 0) < (i5 | 0);
+ if (i12) {
+ i14 = i4 + (i17 << 3) + 20 | 0;
+ i15 = i4 + (i17 << 3) + 24 | 0;
+ } else {
+ i14 = i16;
+ i15 = i19;
+ }
+ d21 = +HEAPF32[i14 >> 2] - d6;
+ d20 = +HEAPF32[i15 >> 2] - d11;
+ d22 = d18 * d20 - d13 * d21;
+ d23 = d22 * .5;
+ d8 = d8 + d23;
+ d23 = d23 * .3333333432674408;
+ d9 = d9 + (d18 + d21) * d23;
+ d10 = d10 + (d13 + d20) * d23;
+ d7 = d7 + d22 * .0833333358168602 * (d21 * d21 + (d18 * d18 + d18 * d21) + (d20 * d20 + (d13 * d13 + d13 * d20)));
+ } while (i12);
+ d13 = d8 * d2;
+ HEAPF32[i1 >> 2] = d13;
+ if (d8 > 1.1920928955078125e-7) {
+ d23 = 1.0 / d8;
+ d22 = d9 * d23;
+ d23 = d10 * d23;
+ d20 = d6 + d22;
+ d21 = d11 + d23;
+ d11 = +d20;
+ d18 = +d21;
+ i19 = i1 + 4 | 0;
+ HEAPF32[i19 >> 2] = d11;
+ HEAPF32[i19 + 4 >> 2] = d18;
+ HEAPF32[i1 + 12 >> 2] = d7 * d2 + d13 * (d20 * d20 + d21 * d21 - (d22 * d22 + d23 * d23));
+ STACKTOP = i3;
+ return;
+ } else {
+ ___assert_fail(472, 328, 352, 456);
+ }
+}
+function __ZN16b2ContactManager7DestroyEP9b2Contact(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ i5 = HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 8 >> 2] | 0;
+ i4 = HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 8 >> 2] | 0;
+ i6 = HEAP32[i1 + 72 >> 2] | 0;
+ if ((i6 | 0) != 0 ? (HEAP32[i2 + 4 >> 2] & 2 | 0) != 0 : 0) {
+ FUNCTION_TABLE_vii[HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] & 15](i6, i2);
+ }
+ i7 = i2 + 8 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i6 = i2 + 12 | 0;
+ if ((i8 | 0) != 0) {
+ HEAP32[i8 + 12 >> 2] = HEAP32[i6 >> 2];
+ }
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i8 | 0) != 0) {
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 >> 2];
+ }
+ i7 = i1 + 60 | 0;
+ if ((HEAP32[i7 >> 2] | 0) == (i2 | 0)) {
+ HEAP32[i7 >> 2] = HEAP32[i6 >> 2];
+ }
+ i7 = i2 + 24 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i6 = i2 + 28 | 0;
+ if ((i8 | 0) != 0) {
+ HEAP32[i8 + 12 >> 2] = HEAP32[i6 >> 2];
+ }
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i8 | 0) != 0) {
+ HEAP32[i8 + 8 >> 2] = HEAP32[i7 >> 2];
+ }
+ i5 = i5 + 112 | 0;
+ if ((i2 + 16 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = HEAP32[i6 >> 2];
+ }
+ i6 = i2 + 40 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ i5 = i2 + 44 | 0;
+ if ((i7 | 0) != 0) {
+ HEAP32[i7 + 12 >> 2] = HEAP32[i5 >> 2];
+ }
+ i7 = HEAP32[i5 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ HEAP32[i7 + 8 >> 2] = HEAP32[i6 >> 2];
+ }
+ i4 = i4 + 112 | 0;
+ if ((i2 + 32 | 0) != (HEAP32[i4 >> 2] | 0)) {
+ i8 = i1 + 76 | 0;
+ i8 = HEAP32[i8 >> 2] | 0;
+ __ZN9b2Contact7DestroyEPS_P16b2BlockAllocator(i2, i8);
+ i8 = i1 + 64 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ i7 = i7 + -1 | 0;
+ HEAP32[i8 >> 2] = i7;
+ STACKTOP = i3;
+ return;
+ }
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i8 = i1 + 76 | 0;
+ i8 = HEAP32[i8 >> 2] | 0;
+ __ZN9b2Contact7DestroyEPS_P16b2BlockAllocator(i2, i8);
+ i8 = i1 + 64 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ i7 = i7 + -1 | 0;
+ HEAP32[i8 >> 2] = i7;
+ STACKTOP = i3;
+ return;
+}
+function __ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib(i6, i3, i4, i8, i7) {
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i8 = i8 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ if ((i6 | 0) == (HEAP32[i3 + 8 >> 2] | 0)) {
+ if ((HEAP32[i3 + 4 >> 2] | 0) != (i4 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ i2 = i3 + 28 | 0;
+ if ((HEAP32[i2 >> 2] | 0) == 1) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i2 >> 2] = i8;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) != (HEAP32[i3 >> 2] | 0)) {
+ i9 = HEAP32[i6 + 8 >> 2] | 0;
+ FUNCTION_TABLE_viiiii[HEAP32[(HEAP32[i9 >> 2] | 0) + 24 >> 2] & 3](i9, i3, i4, i8, i7);
+ STACKTOP = i1;
+ return;
+ }
+ if ((HEAP32[i3 + 16 >> 2] | 0) != (i4 | 0) ? (i5 = i3 + 20 | 0, (HEAP32[i5 >> 2] | 0) != (i4 | 0)) : 0) {
+ HEAP32[i3 + 32 >> 2] = i8;
+ i8 = i3 + 44 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == 4) {
+ STACKTOP = i1;
+ return;
+ }
+ i9 = i3 + 52 | 0;
+ HEAP8[i9] = 0;
+ i10 = i3 + 53 | 0;
+ HEAP8[i10] = 0;
+ i6 = HEAP32[i6 + 8 >> 2] | 0;
+ FUNCTION_TABLE_viiiiii[HEAP32[(HEAP32[i6 >> 2] | 0) + 20 >> 2] & 3](i6, i3, i4, i4, 1, i7);
+ if ((HEAP8[i10] | 0) != 0) {
+ if ((HEAP8[i9] | 0) == 0) {
+ i6 = 1;
+ i2 = 13;
+ }
+ } else {
+ i6 = 0;
+ i2 = 13;
+ }
+ do {
+ if ((i2 | 0) == 13) {
+ HEAP32[i5 >> 2] = i4;
+ i10 = i3 + 40 | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + 1;
+ if ((HEAP32[i3 + 36 >> 2] | 0) == 1 ? (HEAP32[i3 + 24 >> 2] | 0) == 2 : 0) {
+ HEAP8[i3 + 54 | 0] = 1;
+ if (i6) {
+ break;
+ }
+ } else {
+ i2 = 16;
+ }
+ if ((i2 | 0) == 16 ? i6 : 0) {
+ break;
+ }
+ HEAP32[i8 >> 2] = 4;
+ STACKTOP = i1;
+ return;
+ }
+ } while (0);
+ HEAP32[i8 >> 2] = 3;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i8 | 0) != 1) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i3 + 32 >> 2] = 1;
+ STACKTOP = i1;
+ return;
+}
+function __ZN16b2BlockAllocator8AllocateEi(i4, i2) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i1 = STACKTOP;
+ if ((i2 | 0) == 0) {
+ i9 = 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ if ((i2 | 0) <= 0) {
+ ___assert_fail(1376, 1312, 104, 1392);
+ }
+ if ((i2 | 0) > 640) {
+ i9 = __Z7b2Alloci(i2) | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ i9 = HEAP8[632 + i2 | 0] | 0;
+ i5 = i9 & 255;
+ if (!((i9 & 255) < 14)) {
+ ___assert_fail(1408, 1312, 112, 1392);
+ }
+ i2 = i4 + (i5 << 2) + 12 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ HEAP32[i2 >> 2] = HEAP32[i3 >> 2];
+ i9 = i3;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ i3 = i4 + 4 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i7 = i4 + 8 | 0;
+ if ((i6 | 0) == (HEAP32[i7 >> 2] | 0)) {
+ i9 = HEAP32[i4 >> 2] | 0;
+ i6 = i6 + 128 | 0;
+ HEAP32[i7 >> 2] = i6;
+ i6 = __Z7b2Alloci(i6 << 3) | 0;
+ HEAP32[i4 >> 2] = i6;
+ _memcpy(i6 | 0, i9 | 0, HEAP32[i3 >> 2] << 3 | 0) | 0;
+ _memset((HEAP32[i4 >> 2] | 0) + (HEAP32[i3 >> 2] << 3) | 0, 0, 1024) | 0;
+ __Z6b2FreePv(i9);
+ i6 = HEAP32[i3 >> 2] | 0;
+ }
+ i9 = HEAP32[i4 >> 2] | 0;
+ i7 = __Z7b2Alloci(16384) | 0;
+ i4 = i9 + (i6 << 3) + 4 | 0;
+ HEAP32[i4 >> 2] = i7;
+ i5 = HEAP32[576 + (i5 << 2) >> 2] | 0;
+ HEAP32[i9 + (i6 << 3) >> 2] = i5;
+ i6 = 16384 / (i5 | 0) | 0;
+ if ((Math_imul(i6, i5) | 0) >= 16385) {
+ ___assert_fail(1448, 1312, 140, 1392);
+ }
+ i6 = i6 + -1 | 0;
+ if ((i6 | 0) > 0) {
+ i9 = 0;
+ while (1) {
+ i8 = i9 + 1 | 0;
+ HEAP32[i7 + (Math_imul(i9, i5) | 0) >> 2] = i7 + (Math_imul(i8, i5) | 0);
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i8 | 0) == (i6 | 0)) {
+ break;
+ } else {
+ i9 = i8;
+ }
+ }
+ }
+ HEAP32[i7 + (Math_imul(i6, i5) | 0) >> 2] = 0;
+ HEAP32[i2 >> 2] = HEAP32[HEAP32[i4 >> 2] >> 2];
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 1;
+ i9 = HEAP32[i4 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+}
+function __ZN9b2Contact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i4, i5, i1, i3, i6) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ if ((HEAP8[4200] | 0) == 0) {
+ HEAP32[1002] = 3;
+ HEAP32[4012 >> 2] = 3;
+ HEAP8[4016 | 0] = 1;
+ HEAP32[4104 >> 2] = 4;
+ HEAP32[4108 >> 2] = 4;
+ HEAP8[4112 | 0] = 1;
+ HEAP32[4032 >> 2] = 4;
+ HEAP32[4036 >> 2] = 4;
+ HEAP8[4040 | 0] = 0;
+ HEAP32[4128 >> 2] = 5;
+ HEAP32[4132 >> 2] = 5;
+ HEAP8[4136 | 0] = 1;
+ HEAP32[4056 >> 2] = 6;
+ HEAP32[4060 >> 2] = 6;
+ HEAP8[4064 | 0] = 1;
+ HEAP32[4020 >> 2] = 6;
+ HEAP32[4024 >> 2] = 6;
+ HEAP8[4028 | 0] = 0;
+ HEAP32[4080 >> 2] = 7;
+ HEAP32[4084 >> 2] = 7;
+ HEAP8[4088 | 0] = 1;
+ HEAP32[4116 >> 2] = 7;
+ HEAP32[4120 >> 2] = 7;
+ HEAP8[4124 | 0] = 0;
+ HEAP32[4152 >> 2] = 8;
+ HEAP32[4156 >> 2] = 8;
+ HEAP8[4160 | 0] = 1;
+ HEAP32[4044 >> 2] = 8;
+ HEAP32[4048 >> 2] = 8;
+ HEAP8[4052 | 0] = 0;
+ HEAP32[4176 >> 2] = 9;
+ HEAP32[4180 >> 2] = 9;
+ HEAP8[4184 | 0] = 1;
+ HEAP32[4140 >> 2] = 9;
+ HEAP32[4144 >> 2] = 9;
+ HEAP8[4148 | 0] = 0;
+ HEAP8[4200] = 1;
+ }
+ i7 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 4 >> 2] | 0;
+ i8 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 4 >> 2] | 0;
+ if (!(i7 >>> 0 < 4)) {
+ ___assert_fail(4208, 4256, 80, 4344);
+ }
+ if (!(i8 >>> 0 < 4)) {
+ ___assert_fail(4296, 4256, 81, 4344);
+ }
+ i9 = HEAP32[4008 + (i7 * 48 | 0) + (i8 * 12 | 0) >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = 0;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ if ((HEAP8[4008 + (i7 * 48 | 0) + (i8 * 12 | 0) + 8 | 0] | 0) == 0) {
+ i9 = FUNCTION_TABLE_iiiiii[i9 & 15](i1, i3, i4, i5, i6) | 0;
+ STACKTOP = i2;
+ return i9 | 0;
+ } else {
+ i9 = FUNCTION_TABLE_iiiiii[i9 & 15](i4, i5, i1, i3, i6) | 0;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ return 0;
+}
+function __ZN13b2DynamicTree9MoveProxyEiRK6b2AABBRK6b2Vec2(i1, i2, i13, i9) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i13 = i13 | 0;
+ i9 = i9 | 0;
+ var i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d10 = 0.0, d11 = 0.0, i12 = 0;
+ i4 = STACKTOP;
+ if (!((i2 | 0) > -1)) {
+ ___assert_fail(3072, 2944, 135, 3152);
+ }
+ if ((HEAP32[i1 + 12 >> 2] | 0) <= (i2 | 0)) {
+ ___assert_fail(3072, 2944, 135, 3152);
+ }
+ i3 = i1 + 4 | 0;
+ i12 = HEAP32[i3 >> 2] | 0;
+ if (!((HEAP32[i12 + (i2 * 36 | 0) + 24 >> 2] | 0) == -1)) {
+ ___assert_fail(3120, 2944, 137, 3152);
+ }
+ if (((+HEAPF32[i12 + (i2 * 36 | 0) >> 2] <= +HEAPF32[i13 >> 2] ? +HEAPF32[i12 + (i2 * 36 | 0) + 4 >> 2] <= +HEAPF32[i13 + 4 >> 2] : 0) ? +HEAPF32[i13 + 8 >> 2] <= +HEAPF32[i12 + (i2 * 36 | 0) + 8 >> 2] : 0) ? +HEAPF32[i13 + 12 >> 2] <= +HEAPF32[i12 + (i2 * 36 | 0) + 12 >> 2] : 0) {
+ i13 = 0;
+ STACKTOP = i4;
+ return i13 | 0;
+ }
+ __ZN13b2DynamicTree10RemoveLeafEi(i1, i2);
+ i12 = i13;
+ d6 = +HEAPF32[i12 >> 2];
+ d8 = +HEAPF32[i12 + 4 >> 2];
+ i13 = i13 + 8 | 0;
+ d10 = +HEAPF32[i13 >> 2];
+ d6 = d6 + -.10000000149011612;
+ d8 = d8 + -.10000000149011612;
+ d10 = d10 + .10000000149011612;
+ d5 = +HEAPF32[i13 + 4 >> 2] + .10000000149011612;
+ d11 = +HEAPF32[i9 >> 2] * 2.0;
+ d7 = +HEAPF32[i9 + 4 >> 2] * 2.0;
+ if (d11 < 0.0) {
+ d6 = d6 + d11;
+ } else {
+ d10 = d11 + d10;
+ }
+ if (d7 < 0.0) {
+ d8 = d8 + d7;
+ } else {
+ d5 = d7 + d5;
+ }
+ i13 = HEAP32[i3 >> 2] | 0;
+ d7 = +d6;
+ d11 = +d8;
+ i12 = i13 + (i2 * 36 | 0) | 0;
+ HEAPF32[i12 >> 2] = d7;
+ HEAPF32[i12 + 4 >> 2] = d11;
+ d10 = +d10;
+ d11 = +d5;
+ i13 = i13 + (i2 * 36 | 0) + 8 | 0;
+ HEAPF32[i13 >> 2] = d10;
+ HEAPF32[i13 + 4 >> 2] = d11;
+ __ZN13b2DynamicTree10InsertLeafEi(i1, i2);
+ i13 = 1;
+ STACKTOP = i4;
+ return i13 | 0;
+}
+function __ZNK9b2Simplex16GetWitnessPointsEP6b2Vec2S1_(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, d6 = 0.0, d7 = 0.0, d8 = 0.0, i9 = 0, i10 = 0, d11 = 0.0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i1 + 108 >> 2] | 0;
+ if ((i3 | 0) == 2) {
+ i9 = i1 + 24 | 0;
+ d7 = +HEAPF32[i9 >> 2];
+ i3 = i1 + 60 | 0;
+ d8 = +HEAPF32[i3 >> 2];
+ d6 = +(d7 * +HEAPF32[i1 >> 2] + d8 * +HEAPF32[i1 + 36 >> 2]);
+ d8 = +(d7 * +HEAPF32[i1 + 4 >> 2] + d8 * +HEAPF32[i1 + 40 >> 2]);
+ HEAPF32[i4 >> 2] = d6;
+ HEAPF32[i4 + 4 >> 2] = d8;
+ d8 = +HEAPF32[i9 >> 2];
+ d6 = +HEAPF32[i3 >> 2];
+ d7 = +(d8 * +HEAPF32[i1 + 8 >> 2] + d6 * +HEAPF32[i1 + 44 >> 2]);
+ d6 = +(d8 * +HEAPF32[i1 + 12 >> 2] + d6 * +HEAPF32[i1 + 48 >> 2]);
+ HEAPF32[i5 >> 2] = d7;
+ HEAPF32[i5 + 4 >> 2] = d6;
+ STACKTOP = i2;
+ return;
+ } else if ((i3 | 0) == 1) {
+ i10 = i1;
+ i9 = HEAP32[i10 + 4 >> 2] | 0;
+ i3 = i4;
+ HEAP32[i3 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i3 + 4 >> 2] = i9;
+ i3 = i1 + 8 | 0;
+ i4 = HEAP32[i3 + 4 >> 2] | 0;
+ i9 = i5;
+ HEAP32[i9 >> 2] = HEAP32[i3 >> 2];
+ HEAP32[i9 + 4 >> 2] = i4;
+ STACKTOP = i2;
+ return;
+ } else if ((i3 | 0) == 0) {
+ ___assert_fail(2712, 2672, 217, 2752);
+ } else if ((i3 | 0) == 3) {
+ d11 = +HEAPF32[i1 + 24 >> 2];
+ d6 = +HEAPF32[i1 + 60 >> 2];
+ d8 = +HEAPF32[i1 + 96 >> 2];
+ d7 = +(d11 * +HEAPF32[i1 >> 2] + d6 * +HEAPF32[i1 + 36 >> 2] + d8 * +HEAPF32[i1 + 72 >> 2]);
+ d8 = +(d11 * +HEAPF32[i1 + 4 >> 2] + d6 * +HEAPF32[i1 + 40 >> 2] + d8 * +HEAPF32[i1 + 76 >> 2]);
+ i10 = i4;
+ HEAPF32[i10 >> 2] = d7;
+ HEAPF32[i10 + 4 >> 2] = d8;
+ i10 = i5;
+ HEAPF32[i10 >> 2] = d7;
+ HEAPF32[i10 + 4 >> 2] = d8;
+ STACKTOP = i2;
+ return;
+ } else {
+ ___assert_fail(2712, 2672, 236, 2752);
+ }
+}
+function __ZNK12b2ChainShape12GetChildEdgeEP11b2EdgeShapei(i4, i3, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ if (!((i1 | 0) > -1)) {
+ ___assert_fail(6832, 6792, 89, 6872);
+ }
+ i5 = i4 + 16 | 0;
+ if (((HEAP32[i5 >> 2] | 0) + -1 | 0) <= (i1 | 0)) {
+ ___assert_fail(6832, 6792, 89, 6872);
+ }
+ HEAP32[i3 + 4 >> 2] = 1;
+ HEAPF32[i3 + 8 >> 2] = +HEAPF32[i4 + 8 >> 2];
+ i6 = i4 + 12 | 0;
+ i7 = (HEAP32[i6 >> 2] | 0) + (i1 << 3) | 0;
+ i8 = HEAP32[i7 + 4 >> 2] | 0;
+ i9 = i3 + 12 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ i9 = (HEAP32[i6 >> 2] | 0) + (i1 + 1 << 3) | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i3 + 20 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ i7 = i3 + 28 | 0;
+ if ((i1 | 0) > 0) {
+ i10 = (HEAP32[i6 >> 2] | 0) + (i1 + -1 << 3) | 0;
+ i8 = HEAP32[i10 + 4 >> 2] | 0;
+ i9 = i7;
+ HEAP32[i9 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ HEAP8[i3 + 44 | 0] = 1;
+ } else {
+ i8 = i4 + 20 | 0;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i10 = i7;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP8[i3 + 44 | 0] = HEAP8[i4 + 36 | 0] | 0;
+ }
+ i7 = i3 + 36 | 0;
+ if (((HEAP32[i5 >> 2] | 0) + -2 | 0) > (i1 | 0)) {
+ i8 = (HEAP32[i6 >> 2] | 0) + (i1 + 2 << 3) | 0;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i10 = i7;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP8[i3 + 45 | 0] = 1;
+ STACKTOP = i2;
+ return;
+ } else {
+ i8 = i4 + 28 | 0;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i10 = i7;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP8[i3 + 45 | 0] = HEAP8[i4 + 37 | 0] | 0;
+ STACKTOP = i2;
+ return;
+ }
+}
+function __ZN15b2DistanceProxy3SetEPK7b2Shapei(i3, i1, i5) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 4 >> 2] | 0;
+ if ((i4 | 0) == 1) {
+ HEAP32[i3 + 16 >> 2] = i1 + 12;
+ HEAP32[i3 + 20 >> 2] = 2;
+ HEAPF32[i3 + 24 >> 2] = +HEAPF32[i1 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+ } else if ((i4 | 0) == 3) {
+ if (!((i5 | 0) > -1)) {
+ ___assert_fail(2632, 2672, 53, 2704);
+ }
+ i4 = i1 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) <= (i5 | 0)) {
+ ___assert_fail(2632, 2672, 53, 2704);
+ }
+ i7 = i1 + 12 | 0;
+ i9 = (HEAP32[i7 >> 2] | 0) + (i5 << 3) | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i6 = i3;
+ HEAP32[i6 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i6 + 4 >> 2] = i8;
+ i6 = i5 + 1 | 0;
+ i5 = i3 + 8 | 0;
+ i7 = HEAP32[i7 >> 2] | 0;
+ if ((i6 | 0) < (HEAP32[i4 >> 2] | 0)) {
+ i7 = i7 + (i6 << 3) | 0;
+ i8 = HEAP32[i7 + 4 >> 2] | 0;
+ i9 = i5;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ } else {
+ i8 = HEAP32[i7 + 4 >> 2] | 0;
+ i9 = i5;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ }
+ HEAP32[i3 + 16 >> 2] = i3;
+ HEAP32[i3 + 20 >> 2] = 2;
+ HEAPF32[i3 + 24 >> 2] = +HEAPF32[i1 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+ } else if ((i4 | 0) == 2) {
+ HEAP32[i3 + 16 >> 2] = i1 + 20;
+ HEAP32[i3 + 20 >> 2] = HEAP32[i1 + 148 >> 2];
+ HEAPF32[i3 + 24 >> 2] = +HEAPF32[i1 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+ } else if ((i4 | 0) == 0) {
+ HEAP32[i3 + 16 >> 2] = i1 + 12;
+ HEAP32[i3 + 20 >> 2] = 1;
+ HEAPF32[i3 + 24 >> 2] = +HEAPF32[i1 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+ } else {
+ ___assert_fail(2712, 2672, 81, 2704);
+ }
+}
+function __ZL16b2EdgeSeparationPK14b2PolygonShapeRK11b2TransformiS1_S4_(i2, i7, i4, i5, i6) {
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var d1 = 0.0, d3 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, i12 = 0, i13 = 0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, i18 = 0, i19 = 0, i20 = 0;
+ i12 = STACKTOP;
+ i13 = HEAP32[i5 + 148 >> 2] | 0;
+ if (!((i4 | 0) > -1)) {
+ ___assert_fail(5640, 5688, 32, 5752);
+ }
+ if ((HEAP32[i2 + 148 >> 2] | 0) <= (i4 | 0)) {
+ ___assert_fail(5640, 5688, 32, 5752);
+ }
+ d11 = +HEAPF32[i7 + 12 >> 2];
+ d9 = +HEAPF32[i2 + (i4 << 3) + 84 >> 2];
+ d1 = +HEAPF32[i7 + 8 >> 2];
+ d3 = +HEAPF32[i2 + (i4 << 3) + 88 >> 2];
+ d8 = d11 * d9 - d1 * d3;
+ d3 = d9 * d1 + d11 * d3;
+ d9 = +HEAPF32[i6 + 12 >> 2];
+ d10 = +HEAPF32[i6 + 8 >> 2];
+ d16 = d9 * d8 + d10 * d3;
+ d14 = d9 * d3 - d8 * d10;
+ if ((i13 | 0) > 0) {
+ i19 = 0;
+ i20 = 0;
+ d15 = 3.4028234663852886e+38;
+ while (1) {
+ d17 = d16 * +HEAPF32[i5 + (i19 << 3) + 20 >> 2] + d14 * +HEAPF32[i5 + (i19 << 3) + 24 >> 2];
+ i18 = d17 < d15;
+ i20 = i18 ? i19 : i20;
+ i19 = i19 + 1 | 0;
+ if ((i19 | 0) == (i13 | 0)) {
+ break;
+ } else {
+ d15 = i18 ? d17 : d15;
+ }
+ }
+ } else {
+ i20 = 0;
+ }
+ d16 = +HEAPF32[i2 + (i4 << 3) + 20 >> 2];
+ d17 = +HEAPF32[i2 + (i4 << 3) + 24 >> 2];
+ d14 = +HEAPF32[i5 + (i20 << 3) + 20 >> 2];
+ d15 = +HEAPF32[i5 + (i20 << 3) + 24 >> 2];
+ STACKTOP = i12;
+ return +(d8 * (+HEAPF32[i6 >> 2] + (d9 * d14 - d10 * d15) - (+HEAPF32[i7 >> 2] + (d11 * d16 - d1 * d17))) + d3 * (d14 * d10 + d9 * d15 + +HEAPF32[i6 + 4 >> 2] - (d16 * d1 + d11 * d17 + +HEAPF32[i7 + 4 >> 2])));
+}
+function __Z4iterv() {
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0, d7 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i2 = i1;
+ i3 = i1 + 32 | 0;
+ i4 = HEAP32[16] | 0;
+ if ((i4 | 0) >= (HEAP32[4] | 0)) {
+ HEAP32[16] = i4 + 1;
+ __Z7measurePl(i3, HEAP32[8] | 0);
+ d7 = +HEAPF32[i3 + 4 >> 2];
+ d6 = +(HEAP32[10] | 0) / 1.0e6 * 1.0e3;
+ d5 = +(HEAP32[12] | 0) / 1.0e6 * 1.0e3;
+ HEAPF64[tempDoublePtr >> 3] = +HEAPF32[i3 >> 2];
+ HEAP32[i2 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i4 = i2 + 8 | 0;
+ HEAPF64[tempDoublePtr >> 3] = d7;
+ HEAP32[i4 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i4 = i2 + 16 | 0;
+ HEAPF64[tempDoublePtr >> 3] = d6;
+ HEAP32[i4 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i4 = i2 + 24 | 0;
+ HEAPF64[tempDoublePtr >> 3] = d5;
+ HEAP32[i4 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ _printf(96, i2 | 0) | 0;
+ _emscripten_run_script(152);
+ if ((HEAP32[18] | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ _emscripten_cancel_main_loop();
+ STACKTOP = i1;
+ return;
+ }
+ i3 = _clock() | 0;
+ __ZN7b2World4StepEfii(HEAP32[6] | 0, .01666666753590107, 3, 3);
+ i3 = (_clock() | 0) - i3 | 0;
+ i2 = HEAP32[16] | 0;
+ HEAP32[(HEAP32[8] | 0) + (i2 << 2) >> 2] = i3;
+ if ((i3 | 0) < (HEAP32[10] | 0)) {
+ HEAP32[10] = i3;
+ }
+ if ((i3 | 0) > (HEAP32[12] | 0)) {
+ HEAP32[12] = i3;
+ }
+ HEAP32[16] = i2 + 1;
+ STACKTOP = i1;
+ return;
+}
+function __ZN13b2DynamicTree12AllocateNodeEv(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i2 = i5 + 16 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ if ((i3 | 0) == -1) {
+ i4 = i5 + 8 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ i3 = i5 + 12 | 0;
+ if ((i6 | 0) != (HEAP32[i3 >> 2] | 0)) {
+ ___assert_fail(2912, 2944, 61, 2984);
+ }
+ i5 = i5 + 4 | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i3 >> 2] = i6 << 1;
+ i6 = __Z7b2Alloci(i6 * 72 | 0) | 0;
+ HEAP32[i5 >> 2] = i6;
+ _memcpy(i6 | 0, i7 | 0, (HEAP32[i4 >> 2] | 0) * 36 | 0) | 0;
+ __Z6b2FreePv(i7);
+ i6 = HEAP32[i4 >> 2] | 0;
+ i7 = (HEAP32[i3 >> 2] | 0) + -1 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) < (i7 | 0)) {
+ i7 = i6;
+ while (1) {
+ i6 = i7 + 1 | 0;
+ HEAP32[i5 + (i7 * 36 | 0) + 20 >> 2] = i6;
+ HEAP32[i5 + (i7 * 36 | 0) + 32 >> 2] = -1;
+ i7 = (HEAP32[i3 >> 2] | 0) + -1 | 0;
+ if ((i6 | 0) < (i7 | 0)) {
+ i7 = i6;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP32[i5 + (i7 * 36 | 0) + 20 >> 2] = -1;
+ HEAP32[i5 + (((HEAP32[i3 >> 2] | 0) + -1 | 0) * 36 | 0) + 32 >> 2] = -1;
+ i3 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i2 >> 2] = i3;
+ } else {
+ i4 = i5 + 8 | 0;
+ i5 = HEAP32[i5 + 4 >> 2] | 0;
+ }
+ i7 = i5 + (i3 * 36 | 0) + 20 | 0;
+ HEAP32[i2 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = -1;
+ HEAP32[i5 + (i3 * 36 | 0) + 24 >> 2] = -1;
+ HEAP32[i5 + (i3 * 36 | 0) + 28 >> 2] = -1;
+ HEAP32[i5 + (i3 * 36 | 0) + 32 >> 2] = 0;
+ HEAP32[i5 + (i3 * 36 | 0) + 16 >> 2] = 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 1;
+ STACKTOP = i1;
+ return i3 | 0;
+}
+function __ZN9b2Fixture6CreateEP16b2BlockAllocatorP6b2BodyPK12b2FixtureDef(i1, i5, i4, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i6 = 0, i7 = 0, d8 = 0.0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 40 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAPF32[i1 + 16 >> 2] = +HEAPF32[i3 + 8 >> 2];
+ HEAPF32[i1 + 20 >> 2] = +HEAPF32[i3 + 12 >> 2];
+ HEAP32[i1 + 8 >> 2] = i4;
+ HEAP32[i1 + 4 >> 2] = 0;
+ i4 = i1 + 32 | 0;
+ i6 = i3 + 22 | 0;
+ HEAP16[i4 + 0 >> 1] = HEAP16[i6 + 0 >> 1] | 0;
+ HEAP16[i4 + 2 >> 1] = HEAP16[i6 + 2 >> 1] | 0;
+ HEAP16[i4 + 4 >> 1] = HEAP16[i6 + 4 >> 1] | 0;
+ HEAP8[i1 + 38 | 0] = HEAP8[i3 + 20 | 0] | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ i4 = FUNCTION_TABLE_iii[HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] & 3](i4, i5) | 0;
+ HEAP32[i1 + 12 >> 2] = i4;
+ i4 = FUNCTION_TABLE_ii[HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] & 3](i4) | 0;
+ i6 = __ZN16b2BlockAllocator8AllocateEi(i5, i4 * 28 | 0) | 0;
+ i5 = i1 + 24 | 0;
+ HEAP32[i5 >> 2] = i6;
+ if ((i4 | 0) > 0) {
+ i7 = 0;
+ } else {
+ i7 = i1 + 28 | 0;
+ HEAP32[i7 >> 2] = 0;
+ i7 = i3 + 16 | 0;
+ d8 = +HEAPF32[i7 >> 2];
+ HEAPF32[i1 >> 2] = d8;
+ STACKTOP = i2;
+ return;
+ }
+ do {
+ HEAP32[i6 + (i7 * 28 | 0) + 16 >> 2] = 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i6 + (i7 * 28 | 0) + 24 >> 2] = -1;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != (i4 | 0));
+ i7 = i1 + 28 | 0;
+ HEAP32[i7 >> 2] = 0;
+ i7 = i3 + 16 | 0;
+ d8 = +HEAPF32[i7 >> 2];
+ HEAPF32[i1 >> 2] = d8;
+ STACKTOP = i2;
+ return;
+}
+function __Z19b2ClipSegmentToLineP12b2ClipVertexPKS_RK6b2Vec2fi(i4, i1, i5, d9, i2) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ d9 = +d9;
+ i2 = i2 | 0;
+ var i3 = 0, i6 = 0, d7 = 0.0, i8 = 0, i10 = 0, d11 = 0.0, d12 = 0.0, i13 = 0;
+ i3 = STACKTOP;
+ d12 = +HEAPF32[i5 >> 2];
+ d11 = +HEAPF32[i5 + 4 >> 2];
+ i5 = i1 + 4 | 0;
+ d7 = d12 * +HEAPF32[i1 >> 2] + d11 * +HEAPF32[i5 >> 2] - d9;
+ i6 = i1 + 12 | 0;
+ i8 = i1 + 16 | 0;
+ d9 = d12 * +HEAPF32[i6 >> 2] + d11 * +HEAPF32[i8 >> 2] - d9;
+ if (!(d7 <= 0.0)) {
+ i10 = 0;
+ } else {
+ HEAP32[i4 + 0 >> 2] = HEAP32[i1 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i1 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i1 + 8 >> 2];
+ i10 = 1;
+ }
+ if (d9 <= 0.0) {
+ i13 = i10 + 1 | 0;
+ i10 = i4 + (i10 * 12 | 0) | 0;
+ HEAP32[i10 + 0 >> 2] = HEAP32[i6 + 0 >> 2];
+ HEAP32[i10 + 4 >> 2] = HEAP32[i6 + 4 >> 2];
+ HEAP32[i10 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i10 = i13;
+ }
+ if (!(d7 * d9 < 0.0)) {
+ i13 = i10;
+ STACKTOP = i3;
+ return i13 | 0;
+ }
+ d9 = d7 / (d7 - d9);
+ d11 = +HEAPF32[i1 >> 2];
+ d12 = +HEAPF32[i5 >> 2];
+ d11 = +(d11 + d9 * (+HEAPF32[i6 >> 2] - d11));
+ d12 = +(d12 + d9 * (+HEAPF32[i8 >> 2] - d12));
+ i13 = i4 + (i10 * 12 | 0) | 0;
+ HEAPF32[i13 >> 2] = d11;
+ HEAPF32[i13 + 4 >> 2] = d12;
+ i13 = i4 + (i10 * 12 | 0) + 8 | 0;
+ HEAP8[i13] = i2;
+ HEAP8[i13 + 1 | 0] = HEAP8[i1 + 9 | 0] | 0;
+ HEAP8[i13 + 2 | 0] = 0;
+ HEAP8[i13 + 3 | 0] = 1;
+ i13 = i10 + 1 | 0;
+ STACKTOP = i3;
+ return i13 | 0;
+}
+function __Z16b2CollideCirclesP10b2ManifoldPK13b2CircleShapeRK11b2TransformS3_S6_(i1, i7, i8, i6, i9) {
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ i6 = i6 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, d10 = 0.0, d11 = 0.0, d12 = 0.0, d13 = 0.0, d14 = 0.0, d15 = 0.0, d16 = 0.0, d17 = 0.0, d18 = 0.0;
+ i2 = STACKTOP;
+ i4 = i1 + 60 | 0;
+ HEAP32[i4 >> 2] = 0;
+ i3 = i7 + 12 | 0;
+ d10 = +HEAPF32[i8 + 12 >> 2];
+ d14 = +HEAPF32[i3 >> 2];
+ d13 = +HEAPF32[i8 + 8 >> 2];
+ d11 = +HEAPF32[i7 + 16 >> 2];
+ i5 = i6 + 12 | 0;
+ d16 = +HEAPF32[i9 + 12 >> 2];
+ d18 = +HEAPF32[i5 >> 2];
+ d17 = +HEAPF32[i9 + 8 >> 2];
+ d15 = +HEAPF32[i6 + 16 >> 2];
+ d12 = +HEAPF32[i9 >> 2] + (d16 * d18 - d17 * d15) - (+HEAPF32[i8 >> 2] + (d10 * d14 - d13 * d11));
+ d11 = d18 * d17 + d16 * d15 + +HEAPF32[i9 + 4 >> 2] - (d14 * d13 + d10 * d11 + +HEAPF32[i8 + 4 >> 2]);
+ d10 = +HEAPF32[i7 + 8 >> 2] + +HEAPF32[i6 + 8 >> 2];
+ if (d12 * d12 + d11 * d11 > d10 * d10) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i1 + 56 >> 2] = 0;
+ i9 = i3;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i1 + 48 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ HEAPF32[i1 + 40 >> 2] = 0.0;
+ HEAPF32[i1 + 44 >> 2] = 0.0;
+ HEAP32[i4 >> 2] = 1;
+ i7 = i5;
+ i8 = HEAP32[i7 + 4 >> 2] | 0;
+ i9 = i1;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ HEAP32[i1 + 16 >> 2] = 0;
+ STACKTOP = i2;
+ return;
+}
+function __ZNK14b2PolygonShape11ComputeAABBEP6b2AABBRK11b2Transformi(i1, i2, i7, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ i3 = i3 | 0;
+ var d4 = 0.0, d5 = 0.0, d6 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0, d11 = 0.0, d12 = 0.0, i13 = 0, d14 = 0.0, d15 = 0.0, d16 = 0.0;
+ i3 = STACKTOP;
+ d4 = +HEAPF32[i7 + 12 >> 2];
+ d15 = +HEAPF32[i1 + 20 >> 2];
+ d5 = +HEAPF32[i7 + 8 >> 2];
+ d12 = +HEAPF32[i1 + 24 >> 2];
+ d6 = +HEAPF32[i7 >> 2];
+ d9 = d6 + (d4 * d15 - d5 * d12);
+ d8 = +HEAPF32[i7 + 4 >> 2];
+ d12 = d15 * d5 + d4 * d12 + d8;
+ i7 = HEAP32[i1 + 148 >> 2] | 0;
+ if ((i7 | 0) > 1) {
+ d10 = d9;
+ d11 = d12;
+ i13 = 1;
+ do {
+ d16 = +HEAPF32[i1 + (i13 << 3) + 20 >> 2];
+ d14 = +HEAPF32[i1 + (i13 << 3) + 24 >> 2];
+ d15 = d6 + (d4 * d16 - d5 * d14);
+ d14 = d16 * d5 + d4 * d14 + d8;
+ d10 = d10 < d15 ? d10 : d15;
+ d11 = d11 < d14 ? d11 : d14;
+ d9 = d9 > d15 ? d9 : d15;
+ d12 = d12 > d14 ? d12 : d14;
+ i13 = i13 + 1 | 0;
+ } while ((i13 | 0) < (i7 | 0));
+ } else {
+ d11 = d12;
+ d10 = d9;
+ }
+ d16 = +HEAPF32[i1 + 8 >> 2];
+ d14 = +(d10 - d16);
+ d15 = +(d11 - d16);
+ i13 = i2;
+ HEAPF32[i13 >> 2] = d14;
+ HEAPF32[i13 + 4 >> 2] = d15;
+ d15 = +(d9 + d16);
+ d16 = +(d12 + d16);
+ i13 = i2 + 8 | 0;
+ HEAPF32[i13 >> 2] = d15;
+ HEAPF32[i13 + 4 >> 2] = d16;
+ STACKTOP = i3;
+ return;
+}
+function __ZNK10__cxxabiv120__si_class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib(i5, i1, i4, i6, i3, i7) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i5 | 0) != (HEAP32[i1 + 8 >> 2] | 0)) {
+ i5 = HEAP32[i5 + 8 >> 2] | 0;
+ FUNCTION_TABLE_viiiiii[HEAP32[(HEAP32[i5 >> 2] | 0) + 20 >> 2] & 3](i5, i1, i4, i6, i3, i7);
+ STACKTOP = i2;
+ return;
+ }
+ HEAP8[i1 + 53 | 0] = 1;
+ if ((HEAP32[i1 + 4 >> 2] | 0) != (i6 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP8[i1 + 52 | 0] = 1;
+ i5 = i1 + 16 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i5 >> 2] = i4;
+ HEAP32[i1 + 24 >> 2] = i3;
+ HEAP32[i1 + 36 >> 2] = 1;
+ if (!((HEAP32[i1 + 48 >> 2] | 0) == 1 & (i3 | 0) == 1)) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i2;
+ return;
+ }
+ if ((i6 | 0) != (i4 | 0)) {
+ i7 = i1 + 36 | 0;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i2;
+ return;
+ }
+ i4 = i1 + 24 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) == 2) {
+ HEAP32[i4 >> 2] = i3;
+ } else {
+ i3 = i5;
+ }
+ if (!((HEAP32[i1 + 48 >> 2] | 0) == 1 & (i3 | 0) == 1)) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN6b2Body13CreateFixtureEPK12b2FixtureDef(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i2 = i1 + 88 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if ((HEAP32[i4 + 102868 >> 2] & 2 | 0) != 0) {
+ ___assert_fail(1776, 1520, 153, 1808);
+ }
+ i6 = __ZN16b2BlockAllocator8AllocateEi(i4, 44) | 0;
+ if ((i6 | 0) == 0) {
+ i6 = 0;
+ } else {
+ __ZN9b2FixtureC2Ev(i6);
+ }
+ __ZN9b2Fixture6CreateEP16b2BlockAllocatorP6b2BodyPK12b2FixtureDef(i6, i4, i1, i5);
+ if (!((HEAP16[i1 + 4 >> 1] & 32) == 0)) {
+ __ZN9b2Fixture13CreateProxiesEP12b2BroadPhaseRK11b2Transform(i6, (HEAP32[i2 >> 2] | 0) + 102872 | 0, i1 + 12 | 0);
+ }
+ i5 = i1 + 100 | 0;
+ HEAP32[i6 + 4 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i5 >> 2] = i6;
+ i5 = i1 + 104 | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ HEAP32[i6 + 8 >> 2] = i1;
+ if (!(+HEAPF32[i6 >> 2] > 0.0)) {
+ i5 = HEAP32[i2 >> 2] | 0;
+ i5 = i5 + 102868 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i4 = i4 | 1;
+ HEAP32[i5 >> 2] = i4;
+ STACKTOP = i3;
+ return i6 | 0;
+ }
+ __ZN6b2Body13ResetMassDataEv(i1);
+ i5 = HEAP32[i2 >> 2] | 0;
+ i5 = i5 + 102868 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i4 = i4 | 1;
+ HEAP32[i5 >> 2] = i4;
+ STACKTOP = i3;
+ return i6 | 0;
+}
+function __Z13b2TestOverlapPK7b2ShapeiS1_iRK11b2TransformS4_(i6, i5, i4, i3, i2, i1) {
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i8 = STACKTOP;
+ STACKTOP = STACKTOP + 128 | 0;
+ i9 = i8 + 36 | 0;
+ i10 = i8 + 24 | 0;
+ i7 = i8;
+ HEAP32[i9 + 16 >> 2] = 0;
+ HEAP32[i9 + 20 >> 2] = 0;
+ HEAPF32[i9 + 24 >> 2] = 0.0;
+ HEAP32[i9 + 44 >> 2] = 0;
+ HEAP32[i9 + 48 >> 2] = 0;
+ HEAPF32[i9 + 52 >> 2] = 0.0;
+ __ZN15b2DistanceProxy3SetEPK7b2Shapei(i9, i6, i5);
+ __ZN15b2DistanceProxy3SetEPK7b2Shapei(i9 + 28 | 0, i4, i3);
+ i6 = i9 + 56 | 0;
+ HEAP32[i6 + 0 >> 2] = HEAP32[i2 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i2 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ HEAP32[i6 + 12 >> 2] = HEAP32[i2 + 12 >> 2];
+ i6 = i9 + 72 | 0;
+ HEAP32[i6 + 0 >> 2] = HEAP32[i1 + 0 >> 2];
+ HEAP32[i6 + 4 >> 2] = HEAP32[i1 + 4 >> 2];
+ HEAP32[i6 + 8 >> 2] = HEAP32[i1 + 8 >> 2];
+ HEAP32[i6 + 12 >> 2] = HEAP32[i1 + 12 >> 2];
+ HEAP8[i9 + 88 | 0] = 1;
+ HEAP16[i10 + 4 >> 1] = 0;
+ __Z10b2DistanceP16b2DistanceOutputP14b2SimplexCachePK15b2DistanceInput(i7, i10, i9);
+ STACKTOP = i8;
+ return +HEAPF32[i7 + 16 >> 2] < 11920928955078125.0e-22 | 0;
+}
+function __ZNK10__cxxabiv117__class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib(i6, i1, i4, i5, i2, i3) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i3 = STACKTOP;
+ if ((HEAP32[i1 + 8 >> 2] | 0) != (i6 | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP8[i1 + 53 | 0] = 1;
+ if ((HEAP32[i1 + 4 >> 2] | 0) != (i5 | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP8[i1 + 52 | 0] = 1;
+ i5 = i1 + 16 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i5 >> 2] = i4;
+ HEAP32[i1 + 24 >> 2] = i2;
+ HEAP32[i1 + 36 >> 2] = 1;
+ if (!((HEAP32[i1 + 48 >> 2] | 0) == 1 & (i2 | 0) == 1)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i3;
+ return;
+ }
+ if ((i6 | 0) != (i4 | 0)) {
+ i6 = i1 + 36 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i3;
+ return;
+ }
+ i4 = i1 + 24 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) == 2) {
+ HEAP32[i4 >> 2] = i2;
+ } else {
+ i2 = i5;
+ }
+ if (!((HEAP32[i1 + 48 >> 2] | 0) == 1 & (i2 | 0) == 1)) {
+ STACKTOP = i3;
+ return;
+ }
+ HEAP8[i1 + 54 | 0] = 1;
+ STACKTOP = i3;
+ return;
+}
+function __ZNK11b2EdgeShape5CloneEP16b2BlockAllocator(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 48) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 0;
+ } else {
+ HEAP32[i3 >> 2] = 240;
+ HEAP32[i3 + 4 >> 2] = 1;
+ HEAPF32[i3 + 8 >> 2] = .009999999776482582;
+ i4 = i3 + 28 | 0;
+ HEAP32[i4 + 0 >> 2] = 0;
+ HEAP32[i4 + 4 >> 2] = 0;
+ HEAP32[i4 + 8 >> 2] = 0;
+ HEAP32[i4 + 12 >> 2] = 0;
+ HEAP16[i4 + 16 >> 1] = 0;
+ }
+ i6 = i1 + 4 | 0;
+ i5 = HEAP32[i6 + 4 >> 2] | 0;
+ i4 = i3 + 4 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i4 + 4 >> 2] = i5;
+ i4 = i3 + 12 | 0;
+ i1 = i1 + 12 | 0;
+ HEAP32[i4 + 0 >> 2] = HEAP32[i1 + 0 >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[i1 + 4 >> 2];
+ HEAP32[i4 + 8 >> 2] = HEAP32[i1 + 8 >> 2];
+ HEAP32[i4 + 12 >> 2] = HEAP32[i1 + 12 >> 2];
+ HEAP32[i4 + 16 >> 2] = HEAP32[i1 + 16 >> 2];
+ HEAP32[i4 + 20 >> 2] = HEAP32[i1 + 20 >> 2];
+ HEAP32[i4 + 24 >> 2] = HEAP32[i1 + 24 >> 2];
+ HEAP32[i4 + 28 >> 2] = HEAP32[i1 + 28 >> 2];
+ HEAP16[i4 + 32 >> 1] = HEAP16[i1 + 32 >> 1] | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function __ZN7b2WorldC2ERK6b2Vec2(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ __ZN16b2BlockAllocatorC2Ev(i1);
+ __ZN16b2StackAllocatorC2Ev(i1 + 68 | 0);
+ __ZN16b2ContactManagerC2Ev(i1 + 102872 | 0);
+ i6 = i1 + 102968 | 0;
+ HEAP32[i1 + 102980 >> 2] = 0;
+ HEAP32[i1 + 102984 >> 2] = 0;
+ i4 = i1 + 102952 | 0;
+ i5 = i1 + 102992 | 0;
+ HEAP32[i4 + 0 >> 2] = 0;
+ HEAP32[i4 + 4 >> 2] = 0;
+ HEAP32[i4 + 8 >> 2] = 0;
+ HEAP32[i4 + 12 >> 2] = 0;
+ HEAP8[i5] = 1;
+ HEAP8[i1 + 102993 | 0] = 1;
+ HEAP8[i1 + 102994 | 0] = 0;
+ HEAP8[i1 + 102995 | 0] = 1;
+ HEAP8[i1 + 102976 | 0] = 1;
+ i5 = i2;
+ i4 = HEAP32[i5 + 4 >> 2] | 0;
+ i2 = i6;
+ HEAP32[i2 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i2 + 4 >> 2] = i4;
+ HEAP32[i1 + 102868 >> 2] = 4;
+ HEAPF32[i1 + 102988 >> 2] = 0.0;
+ HEAP32[i1 + 102948 >> 2] = i1;
+ i2 = i1 + 102996 | 0;
+ HEAP32[i2 + 0 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = 0;
+ HEAP32[i2 + 8 >> 2] = 0;
+ HEAP32[i2 + 12 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 24 >> 2] = 0;
+ HEAP32[i2 + 28 >> 2] = 0;
+ STACKTOP = i3;
+ return;
+}
+function __ZNK10__cxxabiv117__class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib(i6, i3, i4, i1, i2) {
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i5 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i3 + 8 >> 2] | 0) == (i6 | 0)) {
+ if ((HEAP32[i3 + 4 >> 2] | 0) != (i4 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i3 + 28 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 1) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i3 >> 2] = i1;
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP32[i3 >> 2] | 0) != (i6 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP32[i3 + 16 >> 2] | 0) != (i4 | 0) ? (i5 = i3 + 20 | 0, (HEAP32[i5 >> 2] | 0) != (i4 | 0)) : 0) {
+ HEAP32[i3 + 32 >> 2] = i1;
+ HEAP32[i5 >> 2] = i4;
+ i6 = i3 + 40 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
+ if ((HEAP32[i3 + 36 >> 2] | 0) == 1 ? (HEAP32[i3 + 24 >> 2] | 0) == 2 : 0) {
+ HEAP8[i3 + 54 | 0] = 1;
+ }
+ HEAP32[i3 + 44 >> 2] = 4;
+ STACKTOP = i2;
+ return;
+ }
+ if ((i1 | 0) != 1) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i3 + 32 >> 2] = 1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN9b2Contact7DestroyEPS_P16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ if ((HEAP8[4200] | 0) == 0) {
+ ___assert_fail(4352, 4256, 103, 4376);
+ }
+ i4 = HEAP32[i1 + 48 >> 2] | 0;
+ if ((HEAP32[i1 + 124 >> 2] | 0) > 0) {
+ i7 = HEAP32[i4 + 8 >> 2] | 0;
+ i6 = i7 + 4 | 0;
+ i5 = HEAPU16[i6 >> 1] | 0;
+ if ((i5 & 2 | 0) == 0) {
+ HEAP16[i6 >> 1] = i5 | 2;
+ HEAPF32[i7 + 144 >> 2] = 0.0;
+ }
+ i7 = HEAP32[i1 + 52 >> 2] | 0;
+ i6 = HEAP32[i7 + 8 >> 2] | 0;
+ i5 = i6 + 4 | 0;
+ i8 = HEAPU16[i5 >> 1] | 0;
+ if ((i8 & 2 | 0) == 0) {
+ HEAP16[i5 >> 1] = i8 | 2;
+ HEAPF32[i6 + 144 >> 2] = 0.0;
+ }
+ } else {
+ i7 = HEAP32[i1 + 52 >> 2] | 0;
+ }
+ i4 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 4 >> 2] | 0;
+ i5 = HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 4 >> 2] | 0;
+ if ((i4 | 0) > -1 & (i5 | 0) < 4) {
+ FUNCTION_TABLE_vii[HEAP32[4008 + (i4 * 48 | 0) + (i5 * 12 | 0) + 4 >> 2] & 15](i1, i2);
+ STACKTOP = i3;
+ return;
+ } else {
+ ___assert_fail(4384, 4256, 114, 4376);
+ }
+}
+function __ZN9b2Fixture13CreateProxiesEP12b2BroadPhaseRK11b2Transform(i5, i4, i1) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ i3 = i5 + 28 | 0;
+ if ((HEAP32[i3 >> 2] | 0) != 0) {
+ ___assert_fail(2088, 2112, 124, 2144);
+ }
+ i6 = i5 + 12 | 0;
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = FUNCTION_TABLE_ii[HEAP32[(HEAP32[i8 >> 2] | 0) + 12 >> 2] & 3](i8) | 0;
+ HEAP32[i3 >> 2] = i8;
+ if ((i8 | 0) <= 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = i5 + 24 | 0;
+ i8 = 0;
+ do {
+ i9 = HEAP32[i7 >> 2] | 0;
+ i10 = i9 + (i8 * 28 | 0) | 0;
+ i11 = HEAP32[i6 >> 2] | 0;
+ FUNCTION_TABLE_viiii[HEAP32[(HEAP32[i11 >> 2] | 0) + 24 >> 2] & 15](i11, i10, i1, i8);
+ HEAP32[i9 + (i8 * 28 | 0) + 24 >> 2] = __ZN12b2BroadPhase11CreateProxyERK6b2AABBPv(i4, i10, i10) | 0;
+ HEAP32[i9 + (i8 * 28 | 0) + 16 >> 2] = i5;
+ HEAP32[i9 + (i8 * 28 | 0) + 20 >> 2] = i8;
+ i8 = i8 + 1 | 0;
+ } while ((i8 | 0) < (HEAP32[i3 >> 2] | 0));
+ STACKTOP = i2;
+ return;
+}
+function __ZNK10__cxxabiv117__class_type_info9can_catchEPKNS_16__shim_type_infoERPv(i1, i5, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i3 = i2;
+ if ((i1 | 0) == (i5 | 0)) {
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ if ((i5 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ i5 = ___dynamic_cast(i5, 6952, 7008, 0) | 0;
+ if ((i5 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ i7 = i3 + 0 | 0;
+ i6 = i7 + 56 | 0;
+ do {
+ HEAP32[i7 >> 2] = 0;
+ i7 = i7 + 4 | 0;
+ } while ((i7 | 0) < (i6 | 0));
+ HEAP32[i3 >> 2] = i5;
+ HEAP32[i3 + 8 >> 2] = i1;
+ HEAP32[i3 + 12 >> 2] = -1;
+ HEAP32[i3 + 48 >> 2] = 1;
+ FUNCTION_TABLE_viiii[HEAP32[(HEAP32[i5 >> 2] | 0) + 28 >> 2] & 15](i5, i3, HEAP32[i4 >> 2] | 0, 1);
+ if ((HEAP32[i3 + 24 >> 2] | 0) != 1) {
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ HEAP32[i4 >> 2] = HEAP32[i3 + 16 >> 2];
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function __ZN8b2IslandC2EiiiP16b2StackAllocatorP17b2ContactListener(i1, i4, i3, i2, i5, i6) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i7 = 0, i8 = 0;
+ i7 = STACKTOP;
+ i8 = i1 + 40 | 0;
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i1 + 44 >> 2] = i3;
+ HEAP32[i1 + 48 >> 2] = i2;
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i1 + 36 >> 2] = 0;
+ HEAP32[i1 + 32 >> 2] = 0;
+ HEAP32[i1 >> 2] = i5;
+ HEAP32[i1 + 4 >> 2] = i6;
+ HEAP32[i1 + 8 >> 2] = __ZN16b2StackAllocator8AllocateEi(i5, i4 << 2) | 0;
+ HEAP32[i1 + 12 >> 2] = __ZN16b2StackAllocator8AllocateEi(HEAP32[i1 >> 2] | 0, i3 << 2) | 0;
+ HEAP32[i1 + 16 >> 2] = __ZN16b2StackAllocator8AllocateEi(HEAP32[i1 >> 2] | 0, i2 << 2) | 0;
+ HEAP32[i1 + 24 >> 2] = __ZN16b2StackAllocator8AllocateEi(HEAP32[i1 >> 2] | 0, (HEAP32[i8 >> 2] | 0) * 12 | 0) | 0;
+ HEAP32[i1 + 20 >> 2] = __ZN16b2StackAllocator8AllocateEi(HEAP32[i1 >> 2] | 0, (HEAP32[i8 >> 2] | 0) * 12 | 0) | 0;
+ STACKTOP = i7;
+ return;
+}
+function __ZNK11b2EdgeShape11ComputeAABBEP6b2AABBRK11b2Transformi(i8, i1, i10, i2) {
+ i8 = i8 | 0;
+ i1 = i1 | 0;
+ i10 = i10 | 0;
+ i2 = i2 | 0;
+ var d3 = 0.0, d4 = 0.0, d5 = 0.0, d6 = 0.0, d7 = 0.0, d9 = 0.0, d11 = 0.0, d12 = 0.0;
+ i2 = STACKTOP;
+ d7 = +HEAPF32[i10 + 12 >> 2];
+ d9 = +HEAPF32[i8 + 12 >> 2];
+ d11 = +HEAPF32[i10 + 8 >> 2];
+ d3 = +HEAPF32[i8 + 16 >> 2];
+ d6 = +HEAPF32[i10 >> 2];
+ d5 = d6 + (d7 * d9 - d11 * d3);
+ d12 = +HEAPF32[i10 + 4 >> 2];
+ d3 = d9 * d11 + d7 * d3 + d12;
+ d9 = +HEAPF32[i8 + 20 >> 2];
+ d4 = +HEAPF32[i8 + 24 >> 2];
+ d6 = d6 + (d7 * d9 - d11 * d4);
+ d4 = d12 + (d11 * d9 + d7 * d4);
+ d7 = +HEAPF32[i8 + 8 >> 2];
+ d9 = +((d5 < d6 ? d5 : d6) - d7);
+ d12 = +((d3 < d4 ? d3 : d4) - d7);
+ i10 = i1;
+ HEAPF32[i10 >> 2] = d9;
+ HEAPF32[i10 + 4 >> 2] = d12;
+ d5 = +(d7 + (d5 > d6 ? d5 : d6));
+ d12 = +(d7 + (d3 > d4 ? d3 : d4));
+ i10 = i1 + 8 | 0;
+ HEAPF32[i10 >> 2] = d5;
+ HEAPF32[i10 + 4 >> 2] = d12;
+ STACKTOP = i2;
+ return;
+}
+function __ZNK14b2PolygonShape9TestPointERK11b2TransformRK6b2Vec2(i2, i3, i6) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, d4 = 0.0, d5 = 0.0, i7 = 0, d8 = 0.0, d9 = 0.0, d10 = 0.0;
+ i1 = STACKTOP;
+ d8 = +HEAPF32[i6 >> 2] - +HEAPF32[i3 >> 2];
+ d9 = +HEAPF32[i6 + 4 >> 2] - +HEAPF32[i3 + 4 >> 2];
+ d10 = +HEAPF32[i3 + 12 >> 2];
+ d5 = +HEAPF32[i3 + 8 >> 2];
+ d4 = d8 * d10 + d9 * d5;
+ d5 = d10 * d9 - d8 * d5;
+ i3 = HEAP32[i2 + 148 >> 2] | 0;
+ if ((i3 | 0) > 0) {
+ i6 = 0;
+ } else {
+ i7 = 1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ while (1) {
+ i7 = i6 + 1 | 0;
+ if ((d4 - +HEAPF32[i2 + (i6 << 3) + 20 >> 2]) * +HEAPF32[i2 + (i6 << 3) + 84 >> 2] + (d5 - +HEAPF32[i2 + (i6 << 3) + 24 >> 2]) * +HEAPF32[i2 + (i6 << 3) + 88 >> 2] > 0.0) {
+ i3 = 0;
+ i2 = 4;
+ break;
+ }
+ if ((i7 | 0) < (i3 | 0)) {
+ i6 = i7;
+ } else {
+ i3 = 1;
+ i2 = 4;
+ break;
+ }
+ }
+ if ((i2 | 0) == 4) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ return 0;
+}
+function __ZN16b2StackAllocator8AllocateEi(i4, i5) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i3 = i4 + 102796 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ if ((i6 | 0) >= 32) {
+ ___assert_fail(3896, 3808, 38, 3936);
+ }
+ i1 = i4 + (i6 * 12 | 0) + 102412 | 0;
+ HEAP32[i4 + (i6 * 12 | 0) + 102416 >> 2] = i5;
+ i7 = i4 + 102400 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 + i5 | 0) > 102400) {
+ HEAP32[i1 >> 2] = __Z7b2Alloci(i5) | 0;
+ HEAP8[i4 + (i6 * 12 | 0) + 102420 | 0] = 1;
+ } else {
+ HEAP32[i1 >> 2] = i4 + i8;
+ HEAP8[i4 + (i6 * 12 | 0) + 102420 | 0] = 0;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + i5;
+ }
+ i6 = i4 + 102404 | 0;
+ i5 = (HEAP32[i6 >> 2] | 0) + i5 | 0;
+ HEAP32[i6 >> 2] = i5;
+ i4 = i4 + 102408 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = (i6 | 0) > (i5 | 0) ? i6 : i5;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return HEAP32[i1 >> 2] | 0;
+}
+function __ZN12b2BroadPhase13QueryCallbackEi(i5, i1) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i4 = i5 + 56 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == (i1 | 0)) {
+ STACKTOP = i2;
+ return 1;
+ }
+ i3 = i5 + 52 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i8 = i5 + 48 | 0;
+ i5 = i5 + 44 | 0;
+ if ((i6 | 0) == (HEAP32[i8 >> 2] | 0)) {
+ i7 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 << 1;
+ i6 = __Z7b2Alloci(i6 * 24 | 0) | 0;
+ HEAP32[i5 >> 2] = i6;
+ _memcpy(i6 | 0, i7 | 0, (HEAP32[i3 >> 2] | 0) * 12 | 0) | 0;
+ __Z6b2FreePv(i7);
+ i7 = HEAP32[i4 >> 2] | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 + (i6 * 12 | 0) >> 2] = (i7 | 0) > (i1 | 0) ? i1 : i7;
+ i4 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i5 + ((HEAP32[i3 >> 2] | 0) * 12 | 0) + 4 >> 2] = (i4 | 0) < (i1 | 0) ? i1 : i4;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return 1;
+}
+function __ZNK10__cxxabiv120__si_class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi(i5, i4, i3, i1) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i6 = 0;
+ i2 = STACKTOP;
+ if ((i5 | 0) != (HEAP32[i4 + 8 >> 2] | 0)) {
+ i6 = HEAP32[i5 + 8 >> 2] | 0;
+ FUNCTION_TABLE_viiii[HEAP32[(HEAP32[i6 >> 2] | 0) + 28 >> 2] & 15](i6, i4, i3, i1);
+ STACKTOP = i2;
+ return;
+ }
+ i5 = i4 + 16 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i5 >> 2] = i3;
+ HEAP32[i4 + 24 >> 2] = i1;
+ HEAP32[i4 + 36 >> 2] = 1;
+ STACKTOP = i2;
+ return;
+ }
+ if ((i6 | 0) != (i3 | 0)) {
+ i6 = i4 + 36 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
+ HEAP32[i4 + 24 >> 2] = 2;
+ HEAP8[i4 + 54 | 0] = 1;
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i4 + 24 | 0;
+ if ((HEAP32[i3 >> 2] | 0) != 2) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i3 >> 2] = i1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN6b2Body19SynchronizeFixturesEv(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, d6 = 0.0, d7 = 0.0, d8 = 0.0, d9 = 0.0, d10 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ d8 = +HEAPF32[i5 + 52 >> 2];
+ d9 = +Math_sin(+d8);
+ HEAPF32[i3 + 8 >> 2] = d9;
+ d8 = +Math_cos(+d8);
+ HEAPF32[i3 + 12 >> 2] = d8;
+ d10 = +HEAPF32[i5 + 28 >> 2];
+ d6 = +HEAPF32[i5 + 32 >> 2];
+ d7 = +(+HEAPF32[i5 + 36 >> 2] - (d8 * d10 - d9 * d6));
+ d6 = +(+HEAPF32[i5 + 40 >> 2] - (d10 * d9 + d8 * d6));
+ i2 = i3;
+ HEAPF32[i2 >> 2] = d7;
+ HEAPF32[i2 + 4 >> 2] = d6;
+ i2 = (HEAP32[i5 + 88 >> 2] | 0) + 102872 | 0;
+ i4 = HEAP32[i5 + 100 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i5 = i5 + 12 | 0;
+ do {
+ __ZN9b2Fixture11SynchronizeEP12b2BroadPhaseRK11b2TransformS4_(i4, i2, i3, i5);
+ i4 = HEAP32[i4 + 4 >> 2] | 0;
+ } while ((i4 | 0) != 0);
+ STACKTOP = i1;
+ return;
+}
+function __ZN13b2DynamicTreeC2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i4 = STACKTOP;
+ HEAP32[i1 >> 2] = -1;
+ i3 = i1 + 12 | 0;
+ HEAP32[i3 >> 2] = 16;
+ HEAP32[i1 + 8 >> 2] = 0;
+ i6 = __Z7b2Alloci(576) | 0;
+ i2 = i1 + 4 | 0;
+ HEAP32[i2 >> 2] = i6;
+ _memset(i6 | 0, 0, (HEAP32[i3 >> 2] | 0) * 36 | 0) | 0;
+ i6 = (HEAP32[i3 >> 2] | 0) + -1 | 0;
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i6 | 0) > 0) {
+ i6 = 0;
+ while (1) {
+ i5 = i6 + 1 | 0;
+ HEAP32[i2 + (i6 * 36 | 0) + 20 >> 2] = i5;
+ HEAP32[i2 + (i6 * 36 | 0) + 32 >> 2] = -1;
+ i6 = (HEAP32[i3 >> 2] | 0) + -1 | 0;
+ if ((i5 | 0) < (i6 | 0)) {
+ i6 = i5;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP32[i2 + (i6 * 36 | 0) + 20 >> 2] = -1;
+ HEAP32[i2 + (((HEAP32[i3 >> 2] | 0) + -1 | 0) * 36 | 0) + 32 >> 2] = -1;
+ HEAP32[i1 + 16 >> 2] = 0;
+ HEAP32[i1 + 20 >> 2] = 0;
+ HEAP32[i1 + 24 >> 2] = 0;
+ STACKTOP = i4;
+ return;
+}
+function __Z7measurePl(i1, i9) {
+ i1 = i1 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0, i7 = 0, d8 = 0.0, i10 = 0, d11 = 0.0;
+ i2 = STACKTOP;
+ i3 = HEAP32[4] | 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + ((4 * i3 | 0) + 15 & -16) | 0;
+ i7 = (i3 | 0) > 0;
+ if (i7) {
+ i10 = 0;
+ d6 = 0.0;
+ do {
+ d8 = +(HEAP32[i9 + (i10 << 2) >> 2] | 0) / 1.0e6 * 1.0e3;
+ HEAPF32[i4 + (i10 << 2) >> 2] = d8;
+ d6 = d6 + d8;
+ i10 = i10 + 1 | 0;
+ } while ((i10 | 0) < (i3 | 0));
+ d5 = +(i3 | 0);
+ d6 = d6 / d5;
+ HEAPF32[i1 >> 2] = d6;
+ if (i7) {
+ i7 = 0;
+ d8 = 0.0;
+ do {
+ d11 = +HEAPF32[i4 + (i7 << 2) >> 2] - d6;
+ d8 = d8 + d11 * d11;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (i3 | 0));
+ } else {
+ d8 = 0.0;
+ }
+ } else {
+ d5 = +(i3 | 0);
+ HEAPF32[i1 >> 2] = 0.0 / d5;
+ d8 = 0.0;
+ }
+ HEAPF32[i1 + 4 >> 2] = +Math_sqrt(+(d8 / d5));
+ STACKTOP = i2;
+ return;
+}
+function __ZN13b2DynamicTree11CreateProxyERK6b2AABBPv(i1, i3, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i4 = 0, i5 = 0, i6 = 0, d7 = 0.0, d8 = 0.0, i9 = 0;
+ i5 = STACKTOP;
+ i4 = __ZN13b2DynamicTree12AllocateNodeEv(i1) | 0;
+ i6 = i1 + 4 | 0;
+ d7 = +(+HEAPF32[i3 >> 2] + -.10000000149011612);
+ d8 = +(+HEAPF32[i3 + 4 >> 2] + -.10000000149011612);
+ i9 = (HEAP32[i6 >> 2] | 0) + (i4 * 36 | 0) | 0;
+ HEAPF32[i9 >> 2] = d7;
+ HEAPF32[i9 + 4 >> 2] = d8;
+ d8 = +(+HEAPF32[i3 + 8 >> 2] + .10000000149011612);
+ d7 = +(+HEAPF32[i3 + 12 >> 2] + .10000000149011612);
+ i3 = (HEAP32[i6 >> 2] | 0) + (i4 * 36 | 0) + 8 | 0;
+ HEAPF32[i3 >> 2] = d8;
+ HEAPF32[i3 + 4 >> 2] = d7;
+ HEAP32[(HEAP32[i6 >> 2] | 0) + (i4 * 36 | 0) + 16 >> 2] = i2;
+ HEAP32[(HEAP32[i6 >> 2] | 0) + (i4 * 36 | 0) + 32 >> 2] = 0;
+ __ZN13b2DynamicTree10InsertLeafEi(i1, i4);
+ STACKTOP = i5;
+ return i4 | 0;
+}
+function __ZN16b2BlockAllocatorC2Ev(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i4 = i3 + 8 | 0;
+ HEAP32[i4 >> 2] = 128;
+ HEAP32[i3 + 4 >> 2] = 0;
+ i5 = __Z7b2Alloci(1024) | 0;
+ HEAP32[i3 >> 2] = i5;
+ _memset(i5 | 0, 0, HEAP32[i4 >> 2] << 3 | 0) | 0;
+ i4 = i3 + 12 | 0;
+ i3 = i4 + 56 | 0;
+ do {
+ HEAP32[i4 >> 2] = 0;
+ i4 = i4 + 4 | 0;
+ } while ((i4 | 0) < (i3 | 0));
+ if ((HEAP8[1280] | 0) == 0) {
+ i3 = 1;
+ i4 = 0;
+ } else {
+ STACKTOP = i2;
+ return;
+ }
+ do {
+ if ((i4 | 0) >= 14) {
+ i1 = 3;
+ break;
+ }
+ if ((i3 | 0) > (HEAP32[576 + (i4 << 2) >> 2] | 0)) {
+ i4 = i4 + 1 | 0;
+ HEAP8[632 + i3 | 0] = i4;
+ } else {
+ HEAP8[632 + i3 | 0] = i4;
+ }
+ i3 = i3 + 1 | 0;
+ } while ((i3 | 0) < 641);
+ if ((i1 | 0) == 3) {
+ ___assert_fail(1288, 1312, 73, 1352);
+ }
+ HEAP8[1280] = 1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN24b2ChainAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i6 = i5;
+ i7 = HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0;
+ HEAP32[i6 >> 2] = 240;
+ HEAP32[i6 + 4 >> 2] = 1;
+ HEAPF32[i6 + 8 >> 2] = .009999999776482582;
+ i8 = i6 + 28 | 0;
+ HEAP32[i8 + 0 >> 2] = 0;
+ HEAP32[i8 + 4 >> 2] = 0;
+ HEAP32[i8 + 8 >> 2] = 0;
+ HEAP32[i8 + 12 >> 2] = 0;
+ HEAP16[i8 + 16 >> 1] = 0;
+ __ZNK12b2ChainShape12GetChildEdgeEP11b2EdgeShapei(i7, i6, HEAP32[i2 + 56 >> 2] | 0);
+ __Z23b2CollideEdgeAndPolygonP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS6_(i4, i6, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __ZN23b2ChainAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i6 = i5;
+ i7 = HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0;
+ HEAP32[i6 >> 2] = 240;
+ HEAP32[i6 + 4 >> 2] = 1;
+ HEAPF32[i6 + 8 >> 2] = .009999999776482582;
+ i8 = i6 + 28 | 0;
+ HEAP32[i8 + 0 >> 2] = 0;
+ HEAP32[i8 + 4 >> 2] = 0;
+ HEAP32[i8 + 8 >> 2] = 0;
+ HEAP32[i8 + 12 >> 2] = 0;
+ HEAP16[i8 + 16 >> 1] = 0;
+ __ZNK12b2ChainShape12GetChildEdgeEP11b2EdgeShapei(i7, i6, HEAP32[i2 + 56 >> 2] | 0);
+ __Z22b2CollideEdgeAndCircleP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK13b2CircleShapeS6_(i4, i6, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __ZN15b2ContactSolver13StoreImpulsesEv(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i4 + 48 >> 2] | 0;
+ if ((i2 | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = HEAP32[i4 + 40 >> 2] | 0;
+ i4 = HEAP32[i4 + 44 >> 2] | 0;
+ i5 = 0;
+ do {
+ i6 = HEAP32[i4 + (HEAP32[i3 + (i5 * 152 | 0) + 148 >> 2] << 2) >> 2] | 0;
+ i7 = HEAP32[i3 + (i5 * 152 | 0) + 144 >> 2] | 0;
+ if ((i7 | 0) > 0) {
+ i8 = 0;
+ do {
+ HEAPF32[i6 + (i8 * 20 | 0) + 72 >> 2] = +HEAPF32[i3 + (i5 * 152 | 0) + (i8 * 36 | 0) + 16 >> 2];
+ HEAPF32[i6 + (i8 * 20 | 0) + 76 >> 2] = +HEAPF32[i3 + (i5 * 152 | 0) + (i8 * 36 | 0) + 20 >> 2];
+ i8 = i8 + 1 | 0;
+ } while ((i8 | 0) < (i7 | 0));
+ }
+ i5 = i5 + 1 | 0;
+ } while ((i5 | 0) < (i2 | 0));
+ STACKTOP = i1;
+ return;
+}
+function __ZN16b2StackAllocator4FreeEPv(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i2 = i1 + 102796 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if ((i4 | 0) <= 0) {
+ ___assert_fail(3952, 3808, 63, 3976);
+ }
+ i6 = i4 + -1 | 0;
+ if ((HEAP32[i1 + (i6 * 12 | 0) + 102412 >> 2] | 0) != (i5 | 0)) {
+ ___assert_fail(3984, 3808, 65, 3976);
+ }
+ if ((HEAP8[i1 + (i6 * 12 | 0) + 102420 | 0] | 0) == 0) {
+ i5 = i1 + (i6 * 12 | 0) + 102416 | 0;
+ i6 = i1 + 102400 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) - (HEAP32[i5 >> 2] | 0);
+ } else {
+ __Z6b2FreePv(i5);
+ i5 = i1 + (i6 * 12 | 0) + 102416 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ }
+ i6 = i1 + 102404 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) - (HEAP32[i5 >> 2] | 0);
+ HEAP32[i2 >> 2] = i4 + -1;
+ STACKTOP = i3;
+ return;
+}
+function __ZNK10__cxxabiv117__class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi(i5, i4, i3, i2) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i6 = 0;
+ i1 = STACKTOP;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != (i5 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ i5 = i4 + 16 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i5 >> 2] = i3;
+ HEAP32[i4 + 24 >> 2] = i2;
+ HEAP32[i4 + 36 >> 2] = 1;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) != (i3 | 0)) {
+ i6 = i4 + 36 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
+ HEAP32[i4 + 24 >> 2] = 2;
+ HEAP8[i4 + 54 | 0] = 1;
+ STACKTOP = i1;
+ return;
+ }
+ i3 = i4 + 24 | 0;
+ if ((HEAP32[i3 >> 2] | 0) != 2) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i3 >> 2] = i2;
+ STACKTOP = i1;
+ return;
+}
+function __ZN12b2BroadPhase11CreateProxyERK6b2AABBPv(i2, i4, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i3 = __ZN13b2DynamicTree11CreateProxyERK6b2AABBPv(i2, i4, i3) | 0;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 1;
+ i4 = i2 + 40 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ i6 = i2 + 36 | 0;
+ i2 = i2 + 32 | 0;
+ if ((i5 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ i7 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 << 1;
+ i5 = __Z7b2Alloci(i5 << 3) | 0;
+ HEAP32[i2 >> 2] = i5;
+ _memcpy(i5 | 0, i7 | 0, HEAP32[i4 >> 2] << 2 | 0) | 0;
+ __Z6b2FreePv(i7);
+ i5 = HEAP32[i4 >> 2] | 0;
+ }
+ HEAP32[(HEAP32[i2 >> 2] | 0) + (i5 << 2) >> 2] = i3;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 1;
+ STACKTOP = i1;
+ return i3 | 0;
+}
+function __ZN9b2ContactC2EP9b2FixtureiS1_i(i1, i4, i6, i3, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i7 = 0, d8 = 0.0, d9 = 0.0;
+ i2 = STACKTOP;
+ HEAP32[i1 >> 2] = 4440;
+ HEAP32[i1 + 4 >> 2] = 4;
+ HEAP32[i1 + 48 >> 2] = i4;
+ HEAP32[i1 + 52 >> 2] = i3;
+ HEAP32[i1 + 56 >> 2] = i6;
+ HEAP32[i1 + 60 >> 2] = i5;
+ HEAP32[i1 + 124 >> 2] = 0;
+ HEAP32[i1 + 128 >> 2] = 0;
+ i5 = i4 + 16 | 0;
+ i6 = i1 + 8 | 0;
+ i7 = i6 + 40 | 0;
+ do {
+ HEAP32[i6 >> 2] = 0;
+ i6 = i6 + 4 | 0;
+ } while ((i6 | 0) < (i7 | 0));
+ HEAPF32[i1 + 136 >> 2] = +Math_sqrt(+(+HEAPF32[i5 >> 2] * +HEAPF32[i3 + 16 >> 2]));
+ d8 = +HEAPF32[i4 + 20 >> 2];
+ d9 = +HEAPF32[i3 + 20 >> 2];
+ HEAPF32[i1 + 140 >> 2] = d8 > d9 ? d8 : d9;
+ STACKTOP = i2;
+ return;
+}
+function __ZN12b2BroadPhase9MoveProxyEiRK6b2AABBRK6b2Vec2(i3, i1, i5, i4) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ if (!(__ZN13b2DynamicTree9MoveProxyEiRK6b2AABBRK6b2Vec2(i3, i1, i5, i4) | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = i3 + 40 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ i6 = i3 + 36 | 0;
+ i3 = i3 + 32 | 0;
+ if ((i5 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ i7 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 << 1;
+ i5 = __Z7b2Alloci(i5 << 3) | 0;
+ HEAP32[i3 >> 2] = i5;
+ _memcpy(i5 | 0, i7 | 0, HEAP32[i4 >> 2] << 2 | 0) | 0;
+ __Z6b2FreePv(i7);
+ i5 = HEAP32[i4 >> 2] | 0;
+ }
+ HEAP32[(HEAP32[i3 >> 2] | 0) + (i5 << 2) >> 2] = i1;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN24b2ChainAndPolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i3, i4, i5, i6) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i6 = __ZN16b2BlockAllocator8AllocateEi(i6, 144) | 0;
+ if ((i6 | 0) == 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i6, i1, i3, i4, i5);
+ HEAP32[i6 >> 2] = 6032;
+ if ((HEAP32[(HEAP32[(HEAP32[i6 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 3) {
+ ___assert_fail(6048, 6096, 43, 6152);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i6 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 2) {
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ ___assert_fail(6184, 6096, 44, 6152);
+ }
+ return 0;
+}
+function __ZN23b2ChainAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i3, i4, i5, i6) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i6 = __ZN16b2BlockAllocator8AllocateEi(i6, 144) | 0;
+ if ((i6 | 0) == 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i6, i1, i3, i4, i5);
+ HEAP32[i6 >> 2] = 5784;
+ if ((HEAP32[(HEAP32[(HEAP32[i6 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 3) {
+ ___assert_fail(5800, 5848, 43, 5904);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i6 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 0) {
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ ___assert_fail(5928, 5848, 44, 5904);
+ }
+ return 0;
+}
+function __ZN25b2PolygonAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i4, i2, i5, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 144) | 0;
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i4;
+ return i5 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i3, i1, 0, i2, 0);
+ HEAP32[i3 >> 2] = 4984;
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 2) {
+ ___assert_fail(5e3, 5048, 41, 5104);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 0) {
+ i5 = i3;
+ STACKTOP = i4;
+ return i5 | 0;
+ } else {
+ ___assert_fail(5136, 5048, 42, 5104);
+ }
+ return 0;
+}
+function __ZN23b2EdgeAndPolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i4, i2, i5, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 144) | 0;
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i4;
+ return i5 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i3, i1, 0, i2, 0);
+ HEAP32[i3 >> 2] = 4736;
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 1) {
+ ___assert_fail(4752, 4800, 41, 4856);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 2) {
+ i5 = i3;
+ STACKTOP = i4;
+ return i5 | 0;
+ } else {
+ ___assert_fail(4880, 4800, 42, 4856);
+ }
+ return 0;
+}
+function __ZN22b2EdgeAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i4, i2, i5, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 144) | 0;
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i4;
+ return i5 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i3, i1, 0, i2, 0);
+ HEAP32[i3 >> 2] = 4488;
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 1) {
+ ___assert_fail(4504, 4552, 41, 4608);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 0) {
+ i5 = i3;
+ STACKTOP = i4;
+ return i5 | 0;
+ } else {
+ ___assert_fail(4632, 4552, 42, 4608);
+ }
+ return 0;
+}
+function __ZN14b2PolygonShape8SetAsBoxEff(i1, d3, d2) {
+ i1 = i1 | 0;
+ d3 = +d3;
+ d2 = +d2;
+ var d4 = 0.0, d5 = 0.0;
+ HEAP32[i1 + 148 >> 2] = 4;
+ d4 = -d3;
+ d5 = -d2;
+ HEAPF32[i1 + 20 >> 2] = d4;
+ HEAPF32[i1 + 24 >> 2] = d5;
+ HEAPF32[i1 + 28 >> 2] = d3;
+ HEAPF32[i1 + 32 >> 2] = d5;
+ HEAPF32[i1 + 36 >> 2] = d3;
+ HEAPF32[i1 + 40 >> 2] = d2;
+ HEAPF32[i1 + 44 >> 2] = d4;
+ HEAPF32[i1 + 48 >> 2] = d2;
+ HEAPF32[i1 + 84 >> 2] = 0.0;
+ HEAPF32[i1 + 88 >> 2] = -1.0;
+ HEAPF32[i1 + 92 >> 2] = 1.0;
+ HEAPF32[i1 + 96 >> 2] = 0.0;
+ HEAPF32[i1 + 100 >> 2] = 0.0;
+ HEAPF32[i1 + 104 >> 2] = 1.0;
+ HEAPF32[i1 + 108 >> 2] = -1.0;
+ HEAPF32[i1 + 112 >> 2] = 0.0;
+ HEAPF32[i1 + 12 >> 2] = 0.0;
+ HEAPF32[i1 + 16 >> 2] = 0.0;
+ return;
+}
+function __ZN16b2PolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i4, i2, i5, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 144) | 0;
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i4;
+ return i5 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i3, i1, 0, i2, 0);
+ HEAP32[i3 >> 2] = 5240;
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 2) {
+ ___assert_fail(5256, 5304, 44, 5352);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 2) {
+ i5 = i3;
+ STACKTOP = i4;
+ return i5 | 0;
+ } else {
+ ___assert_fail(5376, 5304, 45, 5352);
+ }
+ return 0;
+}
+function __ZN15b2CircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator(i1, i4, i2, i5, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 144) | 0;
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i4;
+ return i5 | 0;
+ }
+ __ZN9b2ContactC2EP9b2FixtureiS1_i(i3, i1, 0, i2, 0);
+ HEAP32[i3 >> 2] = 6288;
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) != 0) {
+ ___assert_fail(6304, 6352, 44, 6400);
+ }
+ if ((HEAP32[(HEAP32[(HEAP32[i3 + 52 >> 2] | 0) + 12 >> 2] | 0) + 4 >> 2] | 0) == 0) {
+ i5 = i3;
+ STACKTOP = i4;
+ return i5 | 0;
+ } else {
+ ___assert_fail(6416, 6352, 45, 6400);
+ }
+ return 0;
+}
+function __ZN7b2World10CreateBodyEPK9b2BodyDef(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i5 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i1 + 102868 >> 2] & 2 | 0) != 0) {
+ ___assert_fail(2160, 2184, 109, 2216);
+ }
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i1, 152) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 0;
+ } else {
+ __ZN6b2BodyC2EPK9b2BodyDefP7b2World(i3, i4, i1);
+ }
+ HEAP32[i3 + 92 >> 2] = 0;
+ i4 = i1 + 102952 | 0;
+ HEAP32[i3 + 96 >> 2] = HEAP32[i4 >> 2];
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ HEAP32[i5 + 92 >> 2] = i3;
+ }
+ HEAP32[i4 >> 2] = i3;
+ i5 = i1 + 102960 | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function __ZNK6b2Body13ShouldCollideEPKS_(i4, i2) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ if ((HEAP32[i4 >> 2] | 0) != 2 ? (HEAP32[i2 >> 2] | 0) != 2 : 0) {
+ i2 = 0;
+ } else {
+ i3 = 3;
+ }
+ L3 : do {
+ if ((i3 | 0) == 3) {
+ i3 = HEAP32[i4 + 108 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ i2 = 1;
+ } else {
+ while (1) {
+ if ((HEAP32[i3 >> 2] | 0) == (i2 | 0) ? (HEAP8[(HEAP32[i3 + 4 >> 2] | 0) + 61 | 0] | 0) == 0 : 0) {
+ i2 = 0;
+ break L3;
+ }
+ i3 = HEAP32[i3 + 12 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ i2 = 1;
+ break;
+ }
+ }
+ }
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function __ZNK14b2PolygonShape5CloneEP16b2BlockAllocator(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i3 = __ZN16b2BlockAllocator8AllocateEi(i3, 152) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 0;
+ } else {
+ HEAP32[i3 >> 2] = 504;
+ HEAP32[i3 + 4 >> 2] = 2;
+ HEAPF32[i3 + 8 >> 2] = .009999999776482582;
+ HEAP32[i3 + 148 >> 2] = 0;
+ HEAPF32[i3 + 12 >> 2] = 0.0;
+ HEAPF32[i3 + 16 >> 2] = 0.0;
+ }
+ i6 = i1 + 4 | 0;
+ i5 = HEAP32[i6 + 4 >> 2] | 0;
+ i4 = i3 + 4 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i4 + 4 >> 2] = i5;
+ _memcpy(i3 + 12 | 0, i1 + 12 | 0, 140) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function __ZN7b2World16SetAllowSleepingEb(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = i2 + 102976 | 0;
+ if ((i4 & 1 | 0) == (HEAPU8[i3] | 0 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP8[i3] = i4 & 1;
+ if (i4) {
+ STACKTOP = i1;
+ return;
+ }
+ i2 = HEAP32[i2 + 102952 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ do {
+ i3 = i2 + 4 | 0;
+ i4 = HEAPU16[i3 >> 1] | 0;
+ if ((i4 & 2 | 0) == 0) {
+ HEAP16[i3 >> 1] = i4 | 2;
+ HEAPF32[i2 + 144 >> 2] = 0.0;
+ }
+ i2 = HEAP32[i2 + 96 >> 2] | 0;
+ } while ((i2 | 0) != 0);
+ STACKTOP = i1;
+ return;
+}
+function __ZN16b2BlockAllocator4FreeEPvi(i3, i1, i4) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i4 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i4 | 0) <= 0) {
+ ___assert_fail(1376, 1312, 164, 1488);
+ }
+ if ((i4 | 0) > 640) {
+ __Z6b2FreePv(i1);
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP8[632 + i4 | 0] | 0;
+ if (!((i4 & 255) < 14)) {
+ ___assert_fail(1408, 1312, 173, 1488);
+ }
+ i4 = i3 + ((i4 & 255) << 2) + 12 | 0;
+ HEAP32[i1 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i4 >> 2] = i1;
+ STACKTOP = i2;
+ return;
+}
+function __ZN15b2ContactFilter13ShouldCollideEP9b2FixtureS1_(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ i3 = STACKTOP;
+ i4 = HEAP16[i2 + 36 >> 1] | 0;
+ if (!(i4 << 16 >> 16 != (HEAP16[i1 + 36 >> 1] | 0) | i4 << 16 >> 16 == 0)) {
+ i4 = i4 << 16 >> 16 > 0;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ if ((HEAP16[i1 + 32 >> 1] & HEAP16[i2 + 34 >> 1]) << 16 >> 16 == 0) {
+ i4 = 0;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ i4 = (HEAP16[i1 + 34 >> 1] & HEAP16[i2 + 32 >> 1]) << 16 >> 16 != 0;
+ STACKTOP = i3;
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function __ZN6b2Body13CreateFixtureEPK7b2Shapef(i1, i3, d2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ d2 = +d2;
+ var i4 = 0, i5 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i5 = i4;
+ HEAP16[i5 + 22 >> 1] = 1;
+ HEAP16[i5 + 24 >> 1] = -1;
+ HEAP16[i5 + 26 >> 1] = 0;
+ HEAP32[i5 + 4 >> 2] = 0;
+ HEAPF32[i5 + 8 >> 2] = .20000000298023224;
+ HEAPF32[i5 + 12 >> 2] = 0.0;
+ HEAP8[i5 + 20 | 0] = 0;
+ HEAP32[i5 >> 2] = i3;
+ HEAPF32[i5 + 16 >> 2] = d2;
+ i3 = __ZN6b2Body13CreateFixtureEPK12b2FixtureDef(i1, i5) | 0;
+ STACKTOP = i4;
+ return i3 | 0;
+}
+function __Znwj(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i2 = (i2 | 0) == 0 ? 1 : i2;
+ while (1) {
+ i3 = _malloc(i2) | 0;
+ if ((i3 | 0) != 0) {
+ i2 = 6;
+ break;
+ }
+ i3 = HEAP32[1914] | 0;
+ HEAP32[1914] = i3 + 0;
+ if ((i3 | 0) == 0) {
+ i2 = 5;
+ break;
+ }
+ FUNCTION_TABLE_v[i3 & 3]();
+ }
+ if ((i2 | 0) == 5) {
+ i3 = ___cxa_allocate_exception(4) | 0;
+ HEAP32[i3 >> 2] = 7672;
+ ___cxa_throw(i3 | 0, 7720, 30);
+ } else if ((i2 | 0) == 6) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ return 0;
+}
+function __ZN8b2IslandD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i1 >> 2] | 0, HEAP32[i1 + 20 >> 2] | 0);
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i1 >> 2] | 0, HEAP32[i1 + 24 >> 2] | 0);
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i1 >> 2] | 0, HEAP32[i1 + 16 >> 2] | 0);
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i1 >> 2] | 0, HEAP32[i1 + 12 >> 2] | 0);
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i1 >> 2] | 0, HEAP32[i1 + 8 >> 2] | 0);
+ STACKTOP = i2;
+ return;
+}
+function __ZN16b2BlockAllocatorD2Ev(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i3 = i2 + 4 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if ((HEAP32[i3 >> 2] | 0) > 0) {
+ i5 = 0;
+ } else {
+ i5 = i4;
+ __Z6b2FreePv(i5);
+ STACKTOP = i1;
+ return;
+ }
+ do {
+ __Z6b2FreePv(HEAP32[i4 + (i5 << 3) + 4 >> 2] | 0);
+ i5 = i5 + 1 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ } while ((i5 | 0) < (HEAP32[i3 >> 2] | 0));
+ __Z6b2FreePv(i4);
+ STACKTOP = i1;
+ return;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function __ZNK11b2EdgeShape11ComputeMassEP10b2MassDataf(i2, i1, d3) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ d3 = +d3;
+ var i4 = 0, d5 = 0.0;
+ i4 = STACKTOP;
+ HEAPF32[i1 >> 2] = 0.0;
+ d5 = +((+HEAPF32[i2 + 12 >> 2] + +HEAPF32[i2 + 20 >> 2]) * .5);
+ d3 = +((+HEAPF32[i2 + 16 >> 2] + +HEAPF32[i2 + 24 >> 2]) * .5);
+ i2 = i1 + 4 | 0;
+ HEAPF32[i2 >> 2] = d5;
+ HEAPF32[i2 + 4 >> 2] = d3;
+ HEAPF32[i1 + 12 >> 2] = 0.0;
+ STACKTOP = i4;
+ return;
+}
+function __ZN11b2EdgeShape3SetERK6b2Vec2S2_(i1, i3, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i4 = 0, i5 = 0;
+ i5 = i3;
+ i3 = HEAP32[i5 + 4 >> 2] | 0;
+ i4 = i1 + 12 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i4 + 4 >> 2] = i3;
+ i4 = i2;
+ i2 = HEAP32[i4 + 4 >> 2] | 0;
+ i3 = i1 + 20 | 0;
+ HEAP32[i3 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i3 + 4 >> 2] = i2;
+ HEAP8[i1 + 44 | 0] = 0;
+ HEAP8[i1 + 45 | 0] = 0;
+ return;
+}
+function __ZN25b2PolygonAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ __Z25b2CollidePolygonAndCircleP10b2ManifoldPK14b2PolygonShapeRK11b2TransformPK13b2CircleShapeS6_(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ __Z23b2CollideEdgeAndPolygonP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS6_(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __ZN22b2EdgeAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ __Z22b2CollideEdgeAndCircleP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK13b2CircleShapeS6_(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __Z23b2CollideEdgeAndPolygonP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS6_(i5, i4, i3, i2, i1) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i6 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 256 | 0;
+ __ZN12b2EPCollider7CollideEP10b2ManifoldPK11b2EdgeShapeRK11b2TransformPK14b2PolygonShapeS7_(i6, i5, i4, i3, i2, i1);
+ STACKTOP = i6;
+ return;
+}
+function __ZN16b2PolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ __Z17b2CollidePolygonsP10b2ManifoldPK14b2PolygonShapeRK11b2TransformS3_S6_(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __ZN15b2CircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_(i2, i4, i3, i1) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ __Z16b2CollideCirclesP10b2ManifoldPK13b2CircleShapeRK11b2TransformS3_S6_(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 12 >> 2] | 0, i3, HEAP32[(HEAP32[i2 + 52 >> 2] | 0) + 12 >> 2] | 0, i1);
+ STACKTOP = i5;
+ return;
+}
+function __Z14b2PairLessThanRK6b2PairS1_(i2, i5) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i2 >> 2] | 0;
+ i3 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) >= (i3 | 0)) {
+ if ((i4 | 0) == (i3 | 0)) {
+ i2 = (HEAP32[i2 + 4 >> 2] | 0) < (HEAP32[i5 + 4 >> 2] | 0);
+ } else {
+ i2 = 0;
+ }
+ } else {
+ i2 = 1;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function __ZN9b2FixtureC2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ HEAP16[i1 + 32 >> 1] = 1;
+ HEAP16[i1 + 34 >> 1] = -1;
+ HEAP16[i1 + 36 >> 1] = 0;
+ HEAP32[i1 + 40 >> 2] = 0;
+ HEAP32[i1 + 24 >> 2] = 0;
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i1 + 0 >> 2] = 0;
+ HEAP32[i1 + 4 >> 2] = 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i1 + 12 >> 2] = 0;
+ STACKTOP = i2;
+ return;
+}
+function __ZN12b2BroadPhaseC2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZN13b2DynamicTreeC2Ev(i1);
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i1 + 48 >> 2] = 16;
+ HEAP32[i1 + 52 >> 2] = 0;
+ HEAP32[i1 + 44 >> 2] = __Z7b2Alloci(192) | 0;
+ HEAP32[i1 + 36 >> 2] = 16;
+ HEAP32[i1 + 40 >> 2] = 0;
+ HEAP32[i1 + 32 >> 2] = __Z7b2Alloci(64) | 0;
+ STACKTOP = i2;
+ return;
+}
+function __ZN16b2StackAllocatorD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i1 + 102400 >> 2] | 0) != 0) {
+ ___assert_fail(3792, 3808, 32, 3848);
+ }
+ if ((HEAP32[i1 + 102796 >> 2] | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ } else {
+ ___assert_fail(3872, 3808, 33, 3848);
+ }
+}
+function __ZN15b2ContactSolverD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = i1 + 32 | 0;
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i3 >> 2] | 0, HEAP32[i1 + 40 >> 2] | 0);
+ __ZN16b2StackAllocator4FreeEPv(HEAP32[i3 >> 2] | 0, HEAP32[i1 + 36 >> 2] | 0);
+ STACKTOP = i2;
+ return;
+}
+function __ZN25b2PolygonAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN24b2ChainAndPolygonContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN23b2EdgeAndPolygonContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN23b2ChainAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN22b2EdgeAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN16b2ContactManagerC2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZN12b2BroadPhaseC2Ev(i1);
+ HEAP32[i1 + 60 >> 2] = 0;
+ HEAP32[i1 + 64 >> 2] = 0;
+ HEAP32[i1 + 68 >> 2] = 1888;
+ HEAP32[i1 + 72 >> 2] = 1896;
+ HEAP32[i1 + 76 >> 2] = 0;
+ STACKTOP = i2;
+ return;
+}
+function __ZN16b2PolygonContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function __ZN15b2CircleContact7DestroyEP9b2ContactP16b2BlockAllocator(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ FUNCTION_TABLE_vi[HEAP32[(HEAP32[i1 >> 2] | 0) + 4 >> 2] & 31](i1);
+ __ZN16b2BlockAllocator4FreeEPvi(i2, i1, 144);
+ STACKTOP = i3;
+ return;
+}
+function dynCall_viiiiii(i7, i6, i5, i4, i3, i2, i1) {
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_viiiiii[i7 & 3](i6 | 0, i5 | 0, i4 | 0, i3 | 0, i2 | 0, i1 | 0);
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function dynCall_iiiiii(i6, i5, i4, i3, i2, i1) {
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iiiiii[i6 & 15](i5 | 0, i4 | 0, i3 | 0, i2 | 0, i1 | 0) | 0;
+}
+function dynCall_viiiii(i6, i5, i4, i3, i2, i1) {
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_viiiii[i6 & 3](i5 | 0, i4 | 0, i3 | 0, i2 | 0, i1 | 0);
+}
+function __ZN16b2ContactManager15FindNewContactsEv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZN12b2BroadPhase11UpdatePairsI16b2ContactManagerEEvPT_(i1, i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN16b2StackAllocatorC2Ev(i1) {
+ i1 = i1 | 0;
+ HEAP32[i1 + 102400 >> 2] = 0;
+ HEAP32[i1 + 102404 >> 2] = 0;
+ HEAP32[i1 + 102408 >> 2] = 0;
+ HEAP32[i1 + 102796 >> 2] = 0;
+ return;
+}
+function dynCall_viiii(i5, i4, i3, i2, i1) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_viiii[i5 & 15](i4 | 0, i3 | 0, i2 | 0, i1 | 0);
+}
+function dynCall_iiii(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iiii[i4 & 7](i3 | 0, i2 | 0, i1 | 0) | 0;
+}
+function dynCall_viii(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_viii[i4 & 3](i3 | 0, i2 | 0, i1 | 0);
+}
+function __ZNSt9bad_allocD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZNSt9exceptionD2Ev(i1 | 0);
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function __ZN13b2DynamicTreeD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __Z6b2FreePv(HEAP32[i1 + 4 >> 2] | 0);
+ STACKTOP = i2;
+ return;
+}
+function dynCall_viid(i4, i3, i2, d1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ d1 = +d1;
+ FUNCTION_TABLE_viid[i4 & 3](i3 | 0, i2 | 0, +d1);
+}
+function __ZN17b2ContactListener9PostSolveEP9b2ContactPK16b2ContactImpulse(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ return;
+}
+function __ZN10__cxxabiv120__si_class_type_infoD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN10__cxxabiv117__class_type_infoD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZNSt9bad_allocD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZNSt9exceptionD2Ev(i1 | 0);
+ STACKTOP = i2;
+ return;
+}
+function dynCall_iii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iii[i3 & 3](i2 | 0, i1 | 0) | 0;
+}
+function b8(i1, i2, i3, i4, i5, i6) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ abort(8);
+}
+function __ZN25b2PolygonAndCircleContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN17b2ContactListener8PreSolveEP9b2ContactPK10b2Manifold(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ return;
+}
+function __ZN24b2ChainAndPolygonContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN23b2EdgeAndPolygonContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN23b2ChainAndCircleContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZNK11b2EdgeShape9TestPointERK11b2TransformRK6b2Vec2(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ return 0;
+}
+function __ZN22b2EdgeAndCircleContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZdlPv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i1 | 0) != 0) {
+ _free(i1);
+ }
+ STACKTOP = i2;
+ return;
+}
+function b10(i1, i2, i3, i4, i5) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ abort(10);
+ return 0;
+}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function __Z7b2Alloci(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _malloc(i1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function __ZN17b2ContactListenerD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN16b2PolygonContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function dynCall_vii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vii[i3 & 15](i2 | 0, i1 | 0);
+}
+function __ZN15b2ContactFilterD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN15b2CircleContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN14b2PolygonShapeD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __Znaj(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = __Znwj(i1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function __ZN11b2EdgeShapeD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function __ZN9b2ContactD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function b1(i1, i2, i3, i4, i5) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ abort(1);
+}
+function __Z6b2FreePv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _free(i1);
+ STACKTOP = i2;
+ return;
+}
+function ___clang_call_terminate(i1) {
+ i1 = i1 | 0;
+ ___cxa_begin_catch(i1 | 0) | 0;
+ __ZSt9terminatev();
+}
+function __ZN17b2ContactListener12BeginContactEP9b2Contact(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ return;
+}
+function dynCall_ii(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_ii[i2 & 3](i1 | 0) | 0;
+}
+function __ZN17b2ContactListener10EndContactEP9b2Contact(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ return;
+}
+function b11(i1, i2, i3, i4) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ abort(11);
+}
+function dynCall_vi(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vi[i2 & 31](i1 | 0);
+}
+function b0(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ abort(0);
+ return 0;
+}
+function __ZNK10__cxxabiv116__shim_type_info5noop2Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZNK10__cxxabiv116__shim_type_info5noop1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function b5(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ abort(5);
+}
+function __ZNK14b2PolygonShape13GetChildCountEv(i1) {
+ i1 = i1 | 0;
+ return 1;
+}
+function __ZN10__cxxabiv116__shim_type_infoD2Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function b7(i1, i2, d3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ d3 = +d3;
+ abort(7);
+}
+function __ZNK11b2EdgeShape13GetChildCountEv(i1) {
+ i1 = i1 | 0;
+ return 1;
+}
+function __ZNK7b2Timer15GetMillisecondsEv(i1) {
+ i1 = i1 | 0;
+ return 0.0;
+}
+function __ZN25b2PolygonAndCircleContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN24b2ChainAndPolygonContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function b9(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(9);
+ return 0;
+}
+function __ZN23b2EdgeAndPolygonContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN23b2ChainAndCircleContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN22b2EdgeAndCircleContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function dynCall_v(i1) {
+ i1 = i1 | 0;
+ FUNCTION_TABLE_v[i1 & 3]();
+}
+function __ZNKSt9bad_alloc4whatEv(i1) {
+ i1 = i1 | 0;
+ return 7688;
+}
+function ___cxa_pure_virtual__wrapper() {
+ ___cxa_pure_virtual();
+}
+function __ZN17b2ContactListenerD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN16b2PolygonContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN15b2ContactFilterD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN15b2CircleContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN14b2PolygonShapeD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function b3(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(3);
+}
+function runPostSets() {
+ HEAP32[1932] = __ZTISt9exception;
+}
+function __ZN11b2EdgeShapeD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZNSt9type_infoD2Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN7b2Timer5ResetEv(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function __ZN9b2ContactD1Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function __ZN7b2TimerC2Ev(i1) {
+ i1 = i1 | 0;
+ return;
+}
+function b4(i1) {
+ i1 = i1 | 0;
+ abort(4);
+ return 0;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+function b2(i1) {
+ i1 = i1 | 0;
+ abort(2);
+}
+function b6() {
+ abort(6);
+}
+
+// EMSCRIPTEN_END_FUNCS
+ var FUNCTION_TABLE_iiii = [b0,__ZNK11b2EdgeShape9TestPointERK11b2TransformRK6b2Vec2,__ZNK14b2PolygonShape9TestPointERK11b2TransformRK6b2Vec2,__ZN15b2ContactFilter13ShouldCollideEP9b2FixtureS1_,__ZNK10__cxxabiv117__class_type_info9can_catchEPKNS_16__shim_type_infoERPv,b0,b0,b0];
+ var FUNCTION_TABLE_viiiii = [b1,__ZNK10__cxxabiv117__class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib,__ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib,b1];
+ var FUNCTION_TABLE_vi = [b2,__ZN11b2EdgeShapeD1Ev,__ZN11b2EdgeShapeD0Ev,__ZN14b2PolygonShapeD1Ev,__ZN14b2PolygonShapeD0Ev,__ZN17b2ContactListenerD1Ev,__ZN17b2ContactListenerD0Ev,__ZN15b2ContactFilterD1Ev,__ZN15b2ContactFilterD0Ev,__ZN9b2ContactD1Ev,__ZN9b2ContactD0Ev,__ZN22b2EdgeAndCircleContactD1Ev,__ZN22b2EdgeAndCircleContactD0Ev,__ZN23b2EdgeAndPolygonContactD1Ev,__ZN23b2EdgeAndPolygonContactD0Ev,__ZN25b2PolygonAndCircleContactD1Ev,__ZN25b2PolygonAndCircleContactD0Ev,__ZN16b2PolygonContactD1Ev,__ZN16b2PolygonContactD0Ev,__ZN23b2ChainAndCircleContactD1Ev,__ZN23b2ChainAndCircleContactD0Ev,__ZN24b2ChainAndPolygonContactD1Ev,__ZN24b2ChainAndPolygonContactD0Ev,__ZN15b2CircleContactD1Ev,__ZN15b2CircleContactD0Ev,__ZN10__cxxabiv116__shim_type_infoD2Ev,__ZN10__cxxabiv117__class_type_infoD0Ev,__ZNK10__cxxabiv116__shim_type_info5noop1Ev,__ZNK10__cxxabiv116__shim_type_info5noop2Ev
+ ,__ZN10__cxxabiv120__si_class_type_infoD0Ev,__ZNSt9bad_allocD2Ev,__ZNSt9bad_allocD0Ev];
+ var FUNCTION_TABLE_vii = [b3,__ZN17b2ContactListener12BeginContactEP9b2Contact,__ZN17b2ContactListener10EndContactEP9b2Contact,__ZN15b2CircleContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN25b2PolygonAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN16b2PolygonContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN22b2EdgeAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN23b2EdgeAndPolygonContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN23b2ChainAndCircleContact7DestroyEP9b2ContactP16b2BlockAllocator,__ZN24b2ChainAndPolygonContact7DestroyEP9b2ContactP16b2BlockAllocator,b3,b3,b3,b3,b3,b3];
+ var FUNCTION_TABLE_ii = [b4,__ZNK11b2EdgeShape13GetChildCountEv,__ZNK14b2PolygonShape13GetChildCountEv,__ZNKSt9bad_alloc4whatEv];
+ var FUNCTION_TABLE_viii = [b5,__ZN17b2ContactListener8PreSolveEP9b2ContactPK10b2Manifold,__ZN17b2ContactListener9PostSolveEP9b2ContactPK16b2ContactImpulse,b5];
+ var FUNCTION_TABLE_v = [b6,___cxa_pure_virtual__wrapper,__Z4iterv,b6];
+ var FUNCTION_TABLE_viid = [b7,__ZNK11b2EdgeShape11ComputeMassEP10b2MassDataf,__ZNK14b2PolygonShape11ComputeMassEP10b2MassDataf,b7];
+ var FUNCTION_TABLE_viiiiii = [b8,__ZNK10__cxxabiv117__class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib,__ZNK10__cxxabiv120__si_class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib,b8];
+ var FUNCTION_TABLE_iii = [b9,__ZNK11b2EdgeShape5CloneEP16b2BlockAllocator,__ZNK14b2PolygonShape5CloneEP16b2BlockAllocator,__Z14b2PairLessThanRK6b2PairS1_];
+ var FUNCTION_TABLE_iiiiii = [b10,__ZNK11b2EdgeShape7RayCastEP15b2RayCastOutputRK14b2RayCastInputRK11b2Transformi,__ZNK14b2PolygonShape7RayCastEP15b2RayCastOutputRK14b2RayCastInputRK11b2Transformi,__ZN15b2CircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN25b2PolygonAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN16b2PolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN22b2EdgeAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN23b2EdgeAndPolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN23b2ChainAndCircleContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,__ZN24b2ChainAndPolygonContact6CreateEP9b2FixtureiS1_iP16b2BlockAllocator,b10,b10,b10,b10,b10,b10];
+ var FUNCTION_TABLE_viiii = [b11,__ZNK11b2EdgeShape11ComputeAABBEP6b2AABBRK11b2Transformi,__ZNK14b2PolygonShape11ComputeAABBEP6b2AABBRK11b2Transformi,__ZN22b2EdgeAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN23b2EdgeAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN25b2PolygonAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN16b2PolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN23b2ChainAndCircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN24b2ChainAndPolygonContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZN15b2CircleContact8EvaluateEP10b2ManifoldRK11b2TransformS4_,__ZNK10__cxxabiv117__class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi,__ZNK10__cxxabiv120__si_class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi,b11,b11,b11,b11];
+
+ return { _strlen: _strlen, _free: _free, _main: _main, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9, dynCall_iiii: dynCall_iiii, dynCall_viiiii: dynCall_viiiii, dynCall_vi: dynCall_vi, dynCall_vii: dynCall_vii, dynCall_ii: dynCall_ii, dynCall_viii: dynCall_viii, dynCall_v: dynCall_v, dynCall_viid: dynCall_viid, dynCall_viiiiii: dynCall_viiiiii, dynCall_iii: dynCall_iii, dynCall_iiiiii: dynCall_iiiiii, dynCall_viiii: dynCall_viiii };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "invoke_iiii": invoke_iiii, "invoke_viiiii": invoke_viiiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_ii": invoke_ii, "invoke_viii": invoke_viii, "invoke_v": invoke_v, "invoke_viid": invoke_viid, "invoke_viiiiii": invoke_viiiiii, "invoke_iii": invoke_iii, "invoke_iiiiii": invoke_iiiiii, "invoke_viiii": invoke_viiii, "___cxa_throw": ___cxa_throw, "_emscripten_run_script": _emscripten_run_script, "_cosf": _cosf, "_send": _send, "__ZSt9terminatev": __ZSt9terminatev, "__reallyNegative": __reallyNegative, "___cxa_is_number_type": ___cxa_is_number_type, "___assert_fail": ___assert_fail, "___cxa_allocate_exception": ___cxa_allocate_exception, "___cxa_find_matching_catch": ___cxa_find_matching_catch, "_fflush": _fflush, "_pwrite": _pwrite, "___setErrNo": ___setErrNo, "_sbrk": _sbrk, "___cxa_begin_catch": ___cxa_begin_catch, "_sinf": _sinf, "_fileno": _fileno, "___resumeException": ___resumeException, "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, "_sysconf": _sysconf, "_clock": _clock, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_puts": _puts, "_mkport": _mkport, "_floorf": _floorf, "_sqrtf": _sqrtf, "_write": _write, "_emscripten_set_main_loop": _emscripten_set_main_loop, "___errno_location": ___errno_location, "__ZNSt9exceptionD2Ev": __ZNSt9exceptionD2Ev, "_printf": _printf, "___cxa_does_inherit": ___cxa_does_inherit, "__exit": __exit, "_fputc": _fputc, "_abort": _abort, "_fwrite": _fwrite, "_time": _time, "_fprintf": _fprintf, "_emscripten_cancel_main_loop": _emscripten_cancel_main_loop, "__formatString": __formatString, "_fputs": _fputs, "_exit": _exit, "___cxa_pure_virtual": ___cxa_pure_virtual, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity, "__ZTISt9exception": __ZTISt9exception }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
+var dynCall_viiiii = Module["dynCall_viiiii"] = asm["dynCall_viiiii"];
+var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
+var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
+var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
+var dynCall_viii = Module["dynCall_viii"] = asm["dynCall_viii"];
+var dynCall_v = Module["dynCall_v"] = asm["dynCall_v"];
+var dynCall_viid = Module["dynCall_viid"] = asm["dynCall_viid"];
+var dynCall_viiiiii = Module["dynCall_viiiiii"] = asm["dynCall_viiiiii"];
+var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
+var dynCall_iiiiii = Module["dynCall_iiiiii"] = asm["dynCall_iiiiii"];
+var dynCall_viiii = Module["dynCall_viiii"] = asm["dynCall_viiii"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT = 'sum:8930\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(27);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([101,114,114,111,114,58,32,37,100,92,110,0,0,0,0,0,115,117,109,58,37,100,10,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+
+
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+ Module["_memset"] = _memset;
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+ function _free() {
+ }
+ Module["_free"] = _free;
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var _free=env._free;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _printf=env._printf;
+ var _send=env._send;
+ var _pwrite=env._pwrite;
+ var __reallyNegative=env.__reallyNegative;
+ var _fwrite=env._fwrite;
+ var _malloc=env._malloc;
+ var _mkport=env._mkport;
+ var _fprintf=env._fprintf;
+ var ___setErrNo=env.___setErrNo;
+ var __formatString=env.__formatString;
+ var _fileno=env._fileno;
+ var _fflush=env._fflush;
+ var _write=env._write;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _main(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i3 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i3 | 0) {
+ case 50:
+ {
+ i3 = 625;
+ break L1;
+ }
+ case 51:
+ {
+ i4 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 6250;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 12500;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 75;
+ break L1;
+ }
+ case 48:
+ {
+ i12 = 0;
+ STACKTOP = i1;
+ return i12 | 0;
+ }
+ default:
+ {
+ HEAP32[i2 >> 2] = i3 + -48;
+ _printf(8, i2 | 0) | 0;
+ i12 = -1;
+ STACKTOP = i1;
+ return i12 | 0;
+ }
+ }
+ } else {
+ i4 = 4;
+ }
+ } while (0);
+ if ((i4 | 0) == 4) {
+ i3 = 1250;
+ }
+ i4 = 0;
+ i12 = 0;
+ do {
+ i9 = (i4 | 0) % 10 | 0;
+ i5 = i9 + i4 | 0;
+ i6 = (i4 | 0) % 255 | 0;
+ i8 = (i4 | 0) % 15 | 0;
+ i10 = ((i4 | 0) % 120 | 0 | 0) % 1024 | 0;
+ i11 = ((i4 | 0) % 1024 | 0) + i4 | 0;
+ i5 = ((i5 | 0) % 1024 | 0) + i5 | 0;
+ i8 = ((i8 | 0) % 1024 | 0) + i8 | 0;
+ i6 = (((i6 | 0) % 1024 | 0) + i6 + i10 | 0) % 1024 | 0;
+ i7 = 0;
+ do {
+ i17 = i7 << 1;
+ i14 = (i7 | 0) % 120 | 0;
+ i18 = (i17 | 0) % 1024 | 0;
+ i19 = (i9 + i7 | 0) % 1024 | 0;
+ i16 = ((i7 | 0) % 255 | 0 | 0) % 1024 | 0;
+ i15 = (i7 | 0) % 1024 | 0;
+ i13 = ((i7 | 0) % 15 | 0 | 0) % 1024 | 0;
+ i12 = (((i19 + i18 + i16 + i10 + i15 + i13 + ((i11 + i19 | 0) % 1024 | 0) + ((i5 + i18 | 0) % 1024 | 0) + ((i18 + i17 + i16 | 0) % 1024 | 0) + i6 + ((i8 + i15 | 0) % 1024 | 0) + ((((i14 | 0) % 1024 | 0) + i14 + i13 | 0) % 1024 | 0) | 0) % 100 | 0) + i12 | 0) % 10240 | 0;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != 5e4);
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) < (i3 | 0));
+ HEAP32[i2 >> 2] = i12;
+ _printf(24, i2 | 0) | 0;
+ i19 = 0;
+ STACKTOP = i1;
+ return i19 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function runPostSets() {}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+
+
+ return { _strlen: _strlen, _memcpy: _memcpy, _main: _main, _memset: _memset, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9 };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "_free": _free, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_printf": _printf, "_send": _send, "_pwrite": _pwrite, "__reallyNegative": __reallyNegative, "_fwrite": _fwrite, "_malloc": _malloc, "_mkport": _mkport, "_fprintf": _fprintf, "___setErrNo": ___setErrNo, "__formatString": __formatString, "_fileno": _fileno, "_fflush": _fflush, "_write": _write, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT = 'final: 40006013:58243.\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(35);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([101,114,114,111,114,58,32,37,100,92,110,0,0,0,0,0,102,105,110,97,108,58,32,37,100,58,37,100,46,10,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+
+
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+ Module["_memset"] = _memset;
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+ function _free() {
+ }
+ Module["_free"] = _free;
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var _free=env._free;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _printf=env._printf;
+ var _send=env._send;
+ var _pwrite=env._pwrite;
+ var __reallyNegative=env.__reallyNegative;
+ var _fwrite=env._fwrite;
+ var _malloc=env._malloc;
+ var _mkport=env._mkport;
+ var _fprintf=env._fprintf;
+ var ___setErrNo=env.___setErrNo;
+ var __formatString=env.__formatString;
+ var _fileno=env._fileno;
+ var _fflush=env._fflush;
+ var _write=env._write;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _main(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i3 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i3 | 0) {
+ case 50:
+ {
+ i3 = 3500;
+ break L1;
+ }
+ case 51:
+ {
+ i4 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 35e3;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 7e4;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 550;
+ break L1;
+ }
+ case 48:
+ {
+ i11 = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ default:
+ {
+ HEAP32[i2 >> 2] = i3 + -48;
+ _printf(8, i2 | 0) | 0;
+ i11 = -1;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ }
+ } else {
+ i4 = 4;
+ }
+ } while (0);
+ if ((i4 | 0) == 4) {
+ i3 = 7e3;
+ }
+ i11 = 0;
+ i8 = 0;
+ i5 = 0;
+ while (1) {
+ i6 = ((i5 | 0) % 5 | 0) + 1 | 0;
+ i4 = ((i5 | 0) % 3 | 0) + 1 | 0;
+ i7 = 0;
+ while (1) {
+ i11 = ((i7 | 0) / (i6 | 0) | 0) + i11 | 0;
+ if (i11 >>> 0 > 1e3) {
+ i11 = (i11 >>> 0) / (i4 >>> 0) | 0;
+ }
+ if ((i7 & 3 | 0) == 0) {
+ i11 = i11 + (Math_imul((i7 & 7 | 0) == 0 ? 1 : -1, i7) | 0) | 0;
+ }
+ i10 = i11 << 16 >> 16;
+ i10 = (Math_imul(i10, i10) | 0) & 255;
+ i9 = i10 + (i8 & 65535) | 0;
+ i7 = i7 + 1 | 0;
+ if ((i7 | 0) == 2e4) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i5 = i5 + 1 | 0;
+ if ((i5 | 0) < (i3 | 0)) {
+ i8 = i9;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i2 >> 2] = i11;
+ HEAP32[i2 + 4 >> 2] = i8 + i10 & 65535;
+ _printf(24, i2 | 0) | 0;
+ i11 = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function runPostSets() {}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+
+
+ return { _strlen: _strlen, _memcpy: _memcpy, _main: _main, _memset: _memset, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9 };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "_free": _free, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_printf": _printf, "_send": _send, "_pwrite": _pwrite, "__reallyNegative": __reallyNegative, "_fwrite": _fwrite, "_malloc": _malloc, "_mkport": _mkport, "_fprintf": _fprintf, "___setErrNo": ___setErrNo, "__formatString": __formatString, "_fileno": _fileno, "_fflush": _fflush, "_write": _write, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT =
+ '123456789\n' +
+ '213456789\n' +
+ '231456789\n' +
+ '321456789\n' +
+ '312456789\n' +
+ '132456789\n' +
+ '234156789\n' +
+ '324156789\n' +
+ '342156789\n' +
+ '432156789\n' +
+ '423156789\n' +
+ '243156789\n' +
+ '341256789\n' +
+ '431256789\n' +
+ '413256789\n' +
+ '143256789\n' +
+ '134256789\n' +
+ '314256789\n' +
+ '412356789\n' +
+ '142356789\n' +
+ '124356789\n' +
+ '214356789\n' +
+ '241356789\n' +
+ '421356789\n' +
+ '234516789\n' +
+ '324516789\n' +
+ '342516789\n' +
+ '432516789\n' +
+ '423516789\n' +
+ '243516789\n' +
+ 'Pfannkuchen(9) = 30.\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(547);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([101,114,114,111,114,58,32,37,100,10,0,0,0,0,0,0,80,102,97,110,110,107,117,99,104,101,110,40,37,100,41,32,61,32,37,100,46,10,0,0,37,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+ function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret)|0)]=chr;
+ var fd = _fileno(stream);
+ var ret = _write(fd, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+ }function _putchar(c) {
+ // int putchar(int c);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/putchar.html
+ return _fputc(c, HEAP32[((_stdout)>>2)]);
+ }
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+ function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+
+ Module["_memset"] = _memset;
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+ function _abort() {
+ Module['abort']();
+ }
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var _fflush=env._fflush;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _putchar=env._putchar;
+ var _fputc=env._fputc;
+ var _send=env._send;
+ var _pwrite=env._pwrite;
+ var _abort=env._abort;
+ var __reallyNegative=env.__reallyNegative;
+ var _fwrite=env._fwrite;
+ var _sbrk=env._sbrk;
+ var _mkport=env._mkport;
+ var _fprintf=env._fprintf;
+ var ___setErrNo=env.___setErrNo;
+ var __formatString=env.__formatString;
+ var _fileno=env._fileno;
+ var _printf=env._printf;
+ var _time=env._time;
+ var _sysconf=env._sysconf;
+ var _write=env._write;
+ var ___errno_location=env.___errno_location;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[14] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 96 + (i5 << 2) | 0;
+ i5 = 96 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[14] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[64 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 96 + (i7 << 2) | 0;
+ i7 = 96 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[14] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[64 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[76 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 96 + (i9 << 2) | 0;
+ i7 = HEAP32[14] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 96 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[14] = i7 | i8;
+ i28 = 96 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[64 >> 2] = i4;
+ HEAP32[76 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[60 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[360 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[72 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 360 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[60 >> 2] = HEAP32[60 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[64 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[76 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 96 + (i9 << 2) | 0;
+ i7 = HEAP32[14] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 96 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[14] = i7 | i8;
+ i25 = 96 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[64 >> 2] = i2;
+ HEAP32[76 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[60 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[360 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[360 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[64 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[72 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 360 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[60 >> 2] = HEAP32[60 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 96 + (i6 << 2) | 0;
+ i5 = HEAP32[14] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 96 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[14] = i5 | i4;
+ i21 = 96 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 360 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[60 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[60 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[72 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[64 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[76 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[76 >> 2] = i2 + i12;
+ HEAP32[64 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[64 >> 2] = 0;
+ HEAP32[76 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[68 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[68 >> 2] = i31;
+ i32 = HEAP32[80 >> 2] | 0;
+ HEAP32[80 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[132] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[536 >> 2] = i18;
+ HEAP32[532 >> 2] = i18;
+ HEAP32[540 >> 2] = -1;
+ HEAP32[544 >> 2] = -1;
+ HEAP32[548 >> 2] = 0;
+ HEAP32[500 >> 2] = 0;
+ HEAP32[132] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[536 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[496 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[488 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[500 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[80 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 504 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[68 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[532 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[488 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[496 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[536 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[500 >> 2] = HEAP32[500 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[488 >> 2] | 0) + i14 | 0;
+ HEAP32[488 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[492 >> 2] | 0) >>> 0) {
+ HEAP32[492 >> 2] = i15;
+ }
+ i15 = HEAP32[80 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 504 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[68 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[80 >> 2] = i15 + i3;
+ HEAP32[68 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[84 >> 2] = HEAP32[544 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ HEAP32[72 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 504 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[80 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[76 >> 2] | 0)) {
+ i32 = (HEAP32[64 >> 2] | 0) + i10 | 0;
+ HEAP32[64 >> 2] = i32;
+ HEAP32[76 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 360 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[60 >> 2] = HEAP32[60 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 96 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[14] = HEAP32[14] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 96 + (i10 << 2) | 0;
+ i9 = HEAP32[14] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 96 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[14] = i9 | i5;
+ i3 = 96 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 360 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[60 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[60 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L444 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L444;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[72 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[68 >> 2] | 0) + i10 | 0;
+ HEAP32[68 >> 2] = i32;
+ HEAP32[80 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 504 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[80 >> 2] = i17 + i4;
+ HEAP32[68 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[84 >> 2] = HEAP32[544 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[504 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[508 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[512 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[516 >> 2];
+ HEAP32[504 >> 2] = i17;
+ HEAP32[508 >> 2] = i14;
+ HEAP32[516 >> 2] = 0;
+ HEAP32[512 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 96 + (i4 << 2) | 0;
+ i5 = HEAP32[14] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 96 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[14] = i5 | i3;
+ i7 = 96 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 360 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[60 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[60 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[72 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[72 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[72 >> 2] = i17;
+ }
+ HEAP32[504 >> 2] = i17;
+ HEAP32[508 >> 2] = i14;
+ HEAP32[516 >> 2] = 0;
+ HEAP32[92 >> 2] = HEAP32[132];
+ HEAP32[88 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 96 + (i32 << 2) | 0;
+ HEAP32[96 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[96 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[80 >> 2] = i17 + i2;
+ HEAP32[68 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[84 >> 2] = HEAP32[544 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[68 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[68 >> 2] = i31;
+ i32 = HEAP32[80 >> 2] | 0;
+ HEAP32[80 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[72 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[76 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[64 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 96 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[14] = HEAP32[14] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 360 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[60 >> 2] = HEAP32[60 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[80 >> 2] | 0)) {
+ i21 = (HEAP32[68 >> 2] | 0) + i11 | 0;
+ HEAP32[68 >> 2] = i21;
+ HEAP32[80 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[76 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[76 >> 2] = 0;
+ HEAP32[64 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[76 >> 2] | 0)) {
+ i21 = (HEAP32[64 >> 2] | 0) + i11 | 0;
+ HEAP32[64 >> 2] = i21;
+ HEAP32[76 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 360 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[60 >> 2] = HEAP32[60 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 96 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[14] = HEAP32[14] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[76 >> 2] | 0)) {
+ HEAP32[64 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 96 + (i7 << 2) | 0;
+ i8 = HEAP32[14] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 96 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[14] = i8 | i6;
+ i4 = 96 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 360 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[60 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L205 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L205;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[72 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[72 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[60 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[88 >> 2] | 0) + -1 | 0;
+ HEAP32[88 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 512 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[88 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function __Z15fannkuch_workerPv(i9) {
+ i9 = i9 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
+ i3 = STACKTOP;
+ i7 = HEAP32[i9 + 4 >> 2] | 0;
+ i6 = i7 << 2;
+ i5 = _malloc(i6) | 0;
+ i2 = _malloc(i6) | 0;
+ i6 = _malloc(i6) | 0;
+ i10 = (i7 | 0) > 0;
+ if (i10) {
+ i8 = 0;
+ do {
+ HEAP32[i5 + (i8 << 2) >> 2] = i8;
+ i8 = i8 + 1 | 0;
+ } while ((i8 | 0) != (i7 | 0));
+ i8 = i7 + -1 | 0;
+ i17 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i5 + (i17 << 2) >> 2] = i8;
+ i9 = i5 + (i8 << 2) | 0;
+ HEAP32[i9 >> 2] = i17;
+ if (i10) {
+ i10 = i7 << 2;
+ i11 = 0;
+ i12 = i7;
+ L7 : while (1) {
+ if ((i12 | 0) > 1) {
+ while (1) {
+ i13 = i12 + -1 | 0;
+ HEAP32[i6 + (i13 << 2) >> 2] = i12;
+ if ((i13 | 0) > 1) {
+ i12 = i13;
+ } else {
+ i12 = 1;
+ break;
+ }
+ }
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ if ((i13 | 0) != 0 ? (HEAP32[i9 >> 2] | 0) != (i8 | 0) : 0) {
+ _memcpy(i2 | 0, i5 | 0, i10 | 0) | 0;
+ i15 = 0;
+ i14 = HEAP32[i2 >> 2] | 0;
+ while (1) {
+ i17 = i14 + -1 | 0;
+ if ((i17 | 0) > 1) {
+ i16 = 1;
+ do {
+ i20 = i2 + (i16 << 2) | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ i18 = i2 + (i17 << 2) | 0;
+ HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i18 >> 2] = i19;
+ i16 = i16 + 1 | 0;
+ i17 = i17 + -1 | 0;
+ } while ((i16 | 0) < (i17 | 0));
+ }
+ i15 = i15 + 1 | 0;
+ i20 = i2 + (i14 << 2) | 0;
+ i16 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i20 >> 2] = i14;
+ if ((i16 | 0) == 0) {
+ break;
+ } else {
+ i14 = i16;
+ }
+ }
+ i11 = (i11 | 0) < (i15 | 0) ? i15 : i11;
+ }
+ if ((i12 | 0) >= (i8 | 0)) {
+ i8 = 34;
+ break;
+ }
+ while (1) {
+ if ((i12 | 0) > 0) {
+ i14 = 0;
+ while (1) {
+ i15 = i14 + 1 | 0;
+ HEAP32[i5 + (i14 << 2) >> 2] = HEAP32[i5 + (i15 << 2) >> 2];
+ if ((i15 | 0) == (i12 | 0)) {
+ i14 = i12;
+ break;
+ } else {
+ i14 = i15;
+ }
+ }
+ } else {
+ i14 = 0;
+ }
+ HEAP32[i5 + (i14 << 2) >> 2] = i13;
+ i14 = i6 + (i12 << 2) | 0;
+ i20 = (HEAP32[i14 >> 2] | 0) + -1 | 0;
+ HEAP32[i14 >> 2] = i20;
+ i14 = i12 + 1 | 0;
+ if ((i20 | 0) > 0) {
+ continue L7;
+ }
+ if ((i14 | 0) >= (i8 | 0)) {
+ i8 = 34;
+ break L7;
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ i12 = i14;
+ }
+ }
+ if ((i8 | 0) == 34) {
+ _free(i5);
+ _free(i2);
+ _free(i6);
+ STACKTOP = i3;
+ return i11 | 0;
+ }
+ } else {
+ i1 = i9;
+ i4 = i8;
+ }
+ } else {
+ i4 = i7 + -1 | 0;
+ i20 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i5 + (i20 << 2) >> 2] = i4;
+ i1 = i5 + (i4 << 2) | 0;
+ HEAP32[i1 >> 2] = i20;
+ }
+ i11 = 0;
+ L36 : while (1) {
+ if ((i7 | 0) > 1) {
+ while (1) {
+ i8 = i7 + -1 | 0;
+ HEAP32[i6 + (i8 << 2) >> 2] = i7;
+ if ((i8 | 0) > 1) {
+ i7 = i8;
+ } else {
+ i7 = 1;
+ break;
+ }
+ }
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) != 0 ? (HEAP32[i1 >> 2] | 0) != (i4 | 0) : 0) {
+ i10 = 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ while (1) {
+ i13 = i9 + -1 | 0;
+ if ((i13 | 0) > 1) {
+ i12 = 1;
+ do {
+ i18 = i2 + (i12 << 2) | 0;
+ i19 = HEAP32[i18 >> 2] | 0;
+ i20 = i2 + (i13 << 2) | 0;
+ HEAP32[i18 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i20 >> 2] = i19;
+ i12 = i12 + 1 | 0;
+ i13 = i13 + -1 | 0;
+ } while ((i12 | 0) < (i13 | 0));
+ }
+ i10 = i10 + 1 | 0;
+ i20 = i2 + (i9 << 2) | 0;
+ i12 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i20 >> 2] = i9;
+ if ((i12 | 0) == 0) {
+ break;
+ } else {
+ i9 = i12;
+ }
+ }
+ i11 = (i11 | 0) < (i10 | 0) ? i10 : i11;
+ }
+ if ((i7 | 0) >= (i4 | 0)) {
+ i8 = 34;
+ break;
+ }
+ while (1) {
+ if ((i7 | 0) > 0) {
+ i9 = 0;
+ while (1) {
+ i10 = i9 + 1 | 0;
+ HEAP32[i5 + (i9 << 2) >> 2] = HEAP32[i5 + (i10 << 2) >> 2];
+ if ((i10 | 0) == (i7 | 0)) {
+ i9 = i7;
+ break;
+ } else {
+ i9 = i10;
+ }
+ }
+ } else {
+ i9 = 0;
+ }
+ HEAP32[i5 + (i9 << 2) >> 2] = i8;
+ i9 = i6 + (i7 << 2) | 0;
+ i20 = (HEAP32[i9 >> 2] | 0) + -1 | 0;
+ HEAP32[i9 >> 2] = i20;
+ i9 = i7 + 1 | 0;
+ if ((i20 | 0) > 0) {
+ continue L36;
+ }
+ if ((i9 | 0) >= (i4 | 0)) {
+ i8 = 34;
+ break L36;
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ i7 = i9;
+ }
+ }
+ if ((i8 | 0) == 34) {
+ _free(i5);
+ _free(i2);
+ _free(i6);
+ STACKTOP = i3;
+ return i11 | 0;
+ }
+ return 0;
+}
+function _main(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i1 = i2;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i3 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i3 | 0) {
+ case 50:
+ {
+ i3 = 10;
+ break L1;
+ }
+ case 51:
+ {
+ i4 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 11;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 12;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 9;
+ break L1;
+ }
+ case 48:
+ {
+ i11 = 0;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ default:
+ {
+ HEAP32[i1 >> 2] = i3 + -48;
+ _printf(8, i1 | 0) | 0;
+ i11 = -1;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ }
+ } else {
+ i4 = 4;
+ }
+ } while (0);
+ if ((i4 | 0) == 4) {
+ i3 = 11;
+ }
+ i5 = i3 + -1 | 0;
+ i6 = 0;
+ i7 = 0;
+ while (1) {
+ i4 = _malloc(12) | 0;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i4 + 4 >> 2] = i3;
+ HEAP32[i4 + 8 >> 2] = i6;
+ i7 = i7 + 1 | 0;
+ if ((i7 | 0) == (i5 | 0)) {
+ break;
+ } else {
+ i6 = i4;
+ }
+ }
+ i5 = i3 << 2;
+ i6 = _malloc(i5) | 0;
+ i5 = _malloc(i5) | 0;
+ i7 = 0;
+ do {
+ HEAP32[i6 + (i7 << 2) >> 2] = i7;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != (i3 | 0));
+ i8 = i3;
+ i7 = 30;
+ L19 : do {
+ i9 = 0;
+ do {
+ HEAP32[i1 >> 2] = (HEAP32[i6 + (i9 << 2) >> 2] | 0) + 1;
+ _printf(48, i1 | 0) | 0;
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) != (i3 | 0));
+ _putchar(10) | 0;
+ i7 = i7 + -1 | 0;
+ if ((i8 | 0) <= 1) {
+ if ((i8 | 0) == (i3 | 0)) {
+ break;
+ }
+ } else {
+ while (1) {
+ i9 = i8 + -1 | 0;
+ HEAP32[i5 + (i9 << 2) >> 2] = i8;
+ if ((i9 | 0) > 1) {
+ i8 = i9;
+ } else {
+ i8 = 1;
+ break;
+ }
+ }
+ }
+ while (1) {
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((i8 | 0) > 0) {
+ i11 = 0;
+ while (1) {
+ i10 = i11 + 1 | 0;
+ HEAP32[i6 + (i11 << 2) >> 2] = HEAP32[i6 + (i10 << 2) >> 2];
+ if ((i10 | 0) == (i8 | 0)) {
+ i10 = i8;
+ break;
+ } else {
+ i11 = i10;
+ }
+ }
+ } else {
+ i10 = 0;
+ }
+ HEAP32[i6 + (i10 << 2) >> 2] = i9;
+ i9 = i5 + (i8 << 2) | 0;
+ i11 = (HEAP32[i9 >> 2] | 0) + -1 | 0;
+ HEAP32[i9 >> 2] = i11;
+ i9 = i8 + 1 | 0;
+ if ((i11 | 0) > 0) {
+ break;
+ }
+ if ((i9 | 0) == (i3 | 0)) {
+ break L19;
+ } else {
+ i8 = i9;
+ }
+ }
+ } while ((i7 | 0) != 0);
+ _free(i6);
+ _free(i5);
+ if ((i4 | 0) == 0) {
+ i5 = 0;
+ } else {
+ i5 = 0;
+ while (1) {
+ i6 = __Z15fannkuch_workerPv(i4) | 0;
+ i5 = (i5 | 0) < (i6 | 0) ? i6 : i5;
+ i6 = HEAP32[i4 + 8 >> 2] | 0;
+ _free(i4);
+ if ((i6 | 0) == 0) {
+ break;
+ } else {
+ i4 = i6;
+ }
+ }
+ }
+ HEAP32[i1 >> 2] = i3;
+ HEAP32[i1 + 4 >> 2] = i5;
+ _printf(24, i1 | 0) | 0;
+ i11 = 0;
+ STACKTOP = i2;
+ return i11 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function runPostSets() {}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+
+
+ return { _strlen: _strlen, _free: _free, _main: _main, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9 };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "_fflush": _fflush, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_putchar": _putchar, "_fputc": _fputc, "_send": _send, "_pwrite": _pwrite, "_abort": _abort, "__reallyNegative": __reallyNegative, "_fwrite": _fwrite, "_sbrk": _sbrk, "_mkport": _mkport, "_fprintf": _fprintf, "___setErrNo": ___setErrNo, "__formatString": __formatString, "_fileno": _fileno, "_printf": _printf, "_time": _time, "_sysconf": _sysconf, "_write": _write, "___errno_location": ___errno_location, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT =
+ 'GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA\n' +
+ 'TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT\n' +
+ 'AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG\n' +
+ 'GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG\n' +
+ 'CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT\n' +
+ 'GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA\n' +
+ 'GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA\n' +
+ 'TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG\n' +
+ 'AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA\n' +
+ 'GCCTGGGCGA\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(1155);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([38,2,0,0,0,0,0,0,42,0,0,0,0,0,0,0,97,0,0,0,113,61,138,62,0,0,0,0,99,0,0,0,143,194,245,61,0,0,0,0,103,0,0,0,143,194,245,61,0,0,0,0,116,0,0,0,113,61,138,62,0,0,0,0,66,0,0,0,10,215,163,60,0,0,0,0,68,0,0,0,10,215,163,60,0,0,0,0,72,0,0,0,10,215,163,60,0,0,0,0,75,0,0,0,10,215,163,60,0,0,0,0,77,0,0,0,10,215,163,60,0,0,0,0,78,0,0,0,10,215,163,60,0,0,0,0,82,0,0,0,10,215,163,60,0,0,0,0,83,0,0,0,10,215,163,60,0,0,0,0,86,0,0,0,10,215,163,60,0,0,0,0,87,0,0,0,10,215,163,60,0,0,0,0,89,0,0,0,10,215,163,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,97,0,0,0,233,28,155,62,0,0,0,0,99,0,0,0,114,189,74,62,0,0,0,0,103,0,0,0,215,73,74,62,0,0,0,0,116,0,0,0,114,95,154,62,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,114,114,111,114,58,32,37,100,10,0,0,0,0,0,0,71,71,67,67,71,71,71,67,71,67,71,71,84,71,71,67,84,67,65,67,71,67,67,84,71,84,65,65,84,67,67,67,65,71,67,65,67,84,84,84,71,71,71,65,71,71,67,67,71,65,71,71,67,71,71,71,67,71,71,65,84,67,65,67,67,84,71,65,71,71,84,67,65,71,71,65,71,84,84,67,71,65,71,65,67,67,65,71,67,67,84,71,71,67,67,65,65,67,65,84,71,71,84,71,65,65,65,67,67,67,67,71,84,67,84,67,84,65,67,84,65,65,65,65,65,84,65,67,65,65,65,65,65,84,84,65,71,67,67,71,71,71,67,71,84,71,71,84,71,71,67,71,67,71,67,71,67,67,84,71,84,65,65,84,67,67,67,65,71,67,84,65,67,84,67,71,71,71,65,71,71,67,84,71,65,71,71,67,65,71,71,65,71,65,65,84,67,71,67,84,84,71,65,65,67,67,67,71,71,71,65,71,71,67,71,71,65,71,71,84,84,71,67,65,71,84,71,65,71,67,67,71,65,71,65,84,67,71,67,71,67,67,65,67,84,71,67,65,67,84,67,67,65,71,67,67,84,71,71,71,67,71,65,67,65,71,65,71,67,71,65,71,65,67,84,67,67,71,84,67,84,67,65,65,65,65,65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,120,4,0,0,1,0,0,0,2,0,0,0,1,0,0,0,0,0,0,0,115,116,100,58,58,98,97,100,95,97,108,108,111,99,0,0,83,116,57,98,97,100,95,97,108,108,111,99,0,0,0,0,8,0,0,0,104,4,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+
+ function __ZSt18uncaught_exceptionv() { // std::uncaught_exception()
+ return !!__ZSt18uncaught_exceptionv.uncaught_exception;
+ }
+
+
+
+ function ___cxa_is_number_type(type) {
+ var isNumber = false;
+ try { if (type == __ZTIi) isNumber = true } catch(e){}
+ try { if (type == __ZTIj) isNumber = true } catch(e){}
+ try { if (type == __ZTIl) isNumber = true } catch(e){}
+ try { if (type == __ZTIm) isNumber = true } catch(e){}
+ try { if (type == __ZTIx) isNumber = true } catch(e){}
+ try { if (type == __ZTIy) isNumber = true } catch(e){}
+ try { if (type == __ZTIf) isNumber = true } catch(e){}
+ try { if (type == __ZTId) isNumber = true } catch(e){}
+ try { if (type == __ZTIe) isNumber = true } catch(e){}
+ try { if (type == __ZTIc) isNumber = true } catch(e){}
+ try { if (type == __ZTIa) isNumber = true } catch(e){}
+ try { if (type == __ZTIh) isNumber = true } catch(e){}
+ try { if (type == __ZTIs) isNumber = true } catch(e){}
+ try { if (type == __ZTIt) isNumber = true } catch(e){}
+ return isNumber;
+ }function ___cxa_does_inherit(definiteType, possibilityType, possibility) {
+ if (possibility == 0) return false;
+ if (possibilityType == 0 || possibilityType == definiteType)
+ return true;
+ var possibility_type_info;
+ if (___cxa_is_number_type(possibilityType)) {
+ possibility_type_info = possibilityType;
+ } else {
+ var possibility_type_infoAddr = HEAP32[((possibilityType)>>2)] - 8;
+ possibility_type_info = HEAP32[((possibility_type_infoAddr)>>2)];
+ }
+ switch (possibility_type_info) {
+ case 0: // possibility is a pointer
+ // See if definite type is a pointer
+ var definite_type_infoAddr = HEAP32[((definiteType)>>2)] - 8;
+ var definite_type_info = HEAP32[((definite_type_infoAddr)>>2)];
+ if (definite_type_info == 0) {
+ // Also a pointer; compare base types of pointers
+ var defPointerBaseAddr = definiteType+8;
+ var defPointerBaseType = HEAP32[((defPointerBaseAddr)>>2)];
+ var possPointerBaseAddr = possibilityType+8;
+ var possPointerBaseType = HEAP32[((possPointerBaseAddr)>>2)];
+ return ___cxa_does_inherit(defPointerBaseType, possPointerBaseType, possibility);
+ } else
+ return false; // one pointer and one non-pointer
+ case 1: // class with no base class
+ return false;
+ case 2: // class with base class
+ var parentTypeAddr = possibilityType + 8;
+ var parentType = HEAP32[((parentTypeAddr)>>2)];
+ return ___cxa_does_inherit(definiteType, parentType, possibility);
+ default:
+ return false; // some unencountered type
+ }
+ }
+
+
+
+ var ___cxa_last_thrown_exception=0;function ___resumeException(ptr) {
+ if (!___cxa_last_thrown_exception) { ___cxa_last_thrown_exception = ptr; }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
+ }
+
+ var ___cxa_exception_header_size=8;function ___cxa_find_matching_catch(thrown, throwntype) {
+ if (thrown == -1) thrown = ___cxa_last_thrown_exception;
+ header = thrown - ___cxa_exception_header_size;
+ if (throwntype == -1) throwntype = HEAP32[((header)>>2)];
+ var typeArray = Array.prototype.slice.call(arguments, 2);
+
+ // If throwntype is a pointer, this means a pointer has been
+ // thrown. When a pointer is thrown, actually what's thrown
+ // is a pointer to the pointer. We'll dereference it.
+ if (throwntype != 0 && !___cxa_is_number_type(throwntype)) {
+ var throwntypeInfoAddr= HEAP32[((throwntype)>>2)] - 8;
+ var throwntypeInfo= HEAP32[((throwntypeInfoAddr)>>2)];
+ if (throwntypeInfo == 0)
+ thrown = HEAP32[((thrown)>>2)];
+ }
+ // The different catch blocks are denoted by different types.
+ // Due to inheritance, those types may not precisely match the
+ // type of the thrown object. Find one which matches, and
+ // return the type of the catch block which should be called.
+ for (var i = 0; i < typeArray.length; i++) {
+ if (___cxa_does_inherit(typeArray[i], throwntype, thrown))
+ return ((asm["setTempRet0"](typeArray[i]),thrown)|0);
+ }
+ // Shouldn't happen unless we have bogus data in typeArray
+ // or encounter a type for which emscripten doesn't have suitable
+ // typeinfo defined. Best-efforts match just in case.
+ return ((asm["setTempRet0"](throwntype),thrown)|0);
+ }function ___cxa_throw(ptr, type, destructor) {
+ if (!___cxa_throw.initialized) {
+ try {
+ HEAP32[((__ZTVN10__cxxabiv119__pointer_type_infoE)>>2)]=0; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ try {
+ HEAP32[((__ZTVN10__cxxabiv117__class_type_infoE)>>2)]=1; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ try {
+ HEAP32[((__ZTVN10__cxxabiv120__si_class_type_infoE)>>2)]=2; // Workaround for libcxxabi integration bug
+ } catch(e){}
+ ___cxa_throw.initialized = true;
+ }
+ var header = ptr - ___cxa_exception_header_size;
+ HEAP32[((header)>>2)]=type;
+ HEAP32[(((header)+(4))>>2)]=destructor;
+ ___cxa_last_thrown_exception = ptr;
+ if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
+ __ZSt18uncaught_exceptionv.uncaught_exception = 1;
+ } else {
+ __ZSt18uncaught_exceptionv.uncaught_exception++;
+ }
+ throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
+ }
+
+
+ Module["_memset"] = _memset;
+
+ function _abort() {
+ Module['abort']();
+ }
+
+
+
+
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+
+ function _fputs(s, stream) {
+ // int fputs(const char *restrict s, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
+ var fd = _fileno(stream);
+ return _write(fd, s, _strlen(s));
+ }
+
+ function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret)|0)]=chr;
+ var fd = _fileno(stream);
+ var ret = _write(fd, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+ }function _puts(s) {
+ // int puts(const char *s);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/puts.html
+ // NOTE: puts() always writes an extra newline.
+ var stdout = HEAP32[((_stdout)>>2)];
+ var ret = _fputs(s, stdout);
+ if (ret < 0) {
+ return ret;
+ } else {
+ var newlineRet = _fputc(10, stdout);
+ return (newlineRet < 0) ? -1 : ret + 1;
+ }
+ }
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+ function __ZNSt9exceptionD2Ev() {}
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;function ___cxa_allocate_exception(size) {
+ var ptr = _malloc(size + ___cxa_exception_header_size);
+ return ptr + ___cxa_exception_header_size;
+ }
+
+ var __ZTISt9exception=allocate([allocate([1,0,0,0,0,0,0], "i8", ALLOC_STATIC)+8, 0], "i32", ALLOC_STATIC);
+
+ function __ZTVN10__cxxabiv120__si_class_type_infoE() {
+ Module['printErr']('missing function: _ZTVN10__cxxabiv120__si_class_type_infoE'); abort(-1);
+ }
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function invoke_ii(index,a1) {
+ try {
+ return Module["dynCall_ii"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vi(index,a1) {
+ try {
+ Module["dynCall_vi"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_v(index) {
+ try {
+ Module["dynCall_v"](index);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+ var __ZTISt9exception=env.__ZTISt9exception|0;
+ var __ZTVN10__cxxabiv120__si_class_type_infoE=env.__ZTVN10__cxxabiv120__si_class_type_infoE|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var invoke_ii=env.invoke_ii;
+ var invoke_vi=env.invoke_vi;
+ var invoke_v=env.invoke_v;
+ var _send=env._send;
+ var ___setErrNo=env.___setErrNo;
+ var ___cxa_is_number_type=env.___cxa_is_number_type;
+ var ___cxa_allocate_exception=env.___cxa_allocate_exception;
+ var ___cxa_find_matching_catch=env.___cxa_find_matching_catch;
+ var _fflush=env._fflush;
+ var _time=env._time;
+ var _pwrite=env._pwrite;
+ var __reallyNegative=env.__reallyNegative;
+ var _sbrk=env._sbrk;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _fileno=env._fileno;
+ var ___resumeException=env.___resumeException;
+ var __ZSt18uncaught_exceptionv=env.__ZSt18uncaught_exceptionv;
+ var _sysconf=env._sysconf;
+ var _puts=env._puts;
+ var _mkport=env._mkport;
+ var _write=env._write;
+ var ___errno_location=env.___errno_location;
+ var __ZNSt9exceptionD2Ev=env.__ZNSt9exceptionD2Ev;
+ var _fputc=env._fputc;
+ var ___cxa_throw=env.___cxa_throw;
+ var _abort=env._abort;
+ var _fwrite=env._fwrite;
+ var ___cxa_does_inherit=env.___cxa_does_inherit;
+ var _fprintf=env._fprintf;
+ var __formatString=env.__formatString;
+ var _fputs=env._fputs;
+ var _printf=env._printf;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[146] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 624 + (i5 << 2) | 0;
+ i5 = 624 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[146] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[592 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 624 + (i7 << 2) | 0;
+ i7 = 624 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[146] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[592 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[604 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 624 + (i9 << 2) | 0;
+ i7 = HEAP32[146] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 624 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[146] = i7 | i8;
+ i28 = 624 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[592 >> 2] = i4;
+ HEAP32[604 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[588 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[888 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[600 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 888 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[588 >> 2] = HEAP32[588 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[592 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[604 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 624 + (i9 << 2) | 0;
+ i7 = HEAP32[146] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 624 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[146] = i7 | i8;
+ i25 = 624 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[592 >> 2] = i2;
+ HEAP32[604 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[588 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[888 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[888 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[592 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[600 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 888 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[588 >> 2] = HEAP32[588 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 624 + (i6 << 2) | 0;
+ i5 = HEAP32[146] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 624 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[146] = i5 | i4;
+ i21 = 624 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 888 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[588 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[588 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[600 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[592 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[604 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[604 >> 2] = i2 + i12;
+ HEAP32[592 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[592 >> 2] = 0;
+ HEAP32[604 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[596 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[596 >> 2] = i31;
+ i32 = HEAP32[608 >> 2] | 0;
+ HEAP32[608 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[264] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[1064 >> 2] = i18;
+ HEAP32[1060 >> 2] = i18;
+ HEAP32[1068 >> 2] = -1;
+ HEAP32[1072 >> 2] = -1;
+ HEAP32[1076 >> 2] = 0;
+ HEAP32[1028 >> 2] = 0;
+ HEAP32[264] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[1064 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[1024 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[1016 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[1028 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[608 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 1032 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[596 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[1060 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[1016 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[1024 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[1064 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[1028 >> 2] = HEAP32[1028 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[1016 >> 2] | 0) + i14 | 0;
+ HEAP32[1016 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[1020 >> 2] | 0) >>> 0) {
+ HEAP32[1020 >> 2] = i15;
+ }
+ i15 = HEAP32[608 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 1032 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[596 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[608 >> 2] = i15 + i3;
+ HEAP32[596 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[612 >> 2] = HEAP32[1072 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ HEAP32[600 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 1032 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[608 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[604 >> 2] | 0)) {
+ i32 = (HEAP32[592 >> 2] | 0) + i10 | 0;
+ HEAP32[592 >> 2] = i32;
+ HEAP32[604 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 888 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[588 >> 2] = HEAP32[588 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 624 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[146] = HEAP32[146] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 624 + (i10 << 2) | 0;
+ i9 = HEAP32[146] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 624 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[146] = i9 | i5;
+ i3 = 624 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 888 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[588 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[588 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L444 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L444;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[600 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[596 >> 2] | 0) + i10 | 0;
+ HEAP32[596 >> 2] = i32;
+ HEAP32[608 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 1032 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[608 >> 2] = i17 + i4;
+ HEAP32[596 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[612 >> 2] = HEAP32[1072 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[1032 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[1036 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[1040 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[1044 >> 2];
+ HEAP32[1032 >> 2] = i17;
+ HEAP32[1036 >> 2] = i14;
+ HEAP32[1044 >> 2] = 0;
+ HEAP32[1040 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 624 + (i4 << 2) | 0;
+ i5 = HEAP32[146] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 624 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[146] = i5 | i3;
+ i7 = 624 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 888 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[588 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[588 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[600 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[600 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[600 >> 2] = i17;
+ }
+ HEAP32[1032 >> 2] = i17;
+ HEAP32[1036 >> 2] = i14;
+ HEAP32[1044 >> 2] = 0;
+ HEAP32[620 >> 2] = HEAP32[264];
+ HEAP32[616 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 624 + (i32 << 2) | 0;
+ HEAP32[624 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[624 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[608 >> 2] = i17 + i2;
+ HEAP32[596 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[612 >> 2] = HEAP32[1072 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[596 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[596 >> 2] = i31;
+ i32 = HEAP32[608 >> 2] | 0;
+ HEAP32[608 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[600 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[604 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[592 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 624 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[146] = HEAP32[146] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 888 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[588 >> 2] = HEAP32[588 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[608 >> 2] | 0)) {
+ i21 = (HEAP32[596 >> 2] | 0) + i11 | 0;
+ HEAP32[596 >> 2] = i21;
+ HEAP32[608 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[604 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[604 >> 2] = 0;
+ HEAP32[592 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[604 >> 2] | 0)) {
+ i21 = (HEAP32[592 >> 2] | 0) + i11 | 0;
+ HEAP32[592 >> 2] = i21;
+ HEAP32[604 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 888 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[588 >> 2] = HEAP32[588 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 624 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[146] = HEAP32[146] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[604 >> 2] | 0)) {
+ HEAP32[592 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 624 + (i7 << 2) | 0;
+ i8 = HEAP32[146] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 624 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[146] = i8 | i6;
+ i4 = 624 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 888 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[588 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L204 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L204;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[600 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[600 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[588 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[616 >> 2] | 0) + -1 | 0;
+ HEAP32[616 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 1040 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[616 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function _main(i7, i8) {
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, d9 = 0.0, d10 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 4272 | 0;
+ i3 = i2;
+ i5 = i2 + 4248 | 0;
+ i4 = i2 + 2128 | 0;
+ i1 = i2 + 8 | 0;
+ L1 : do {
+ if ((i7 | 0) > 1) {
+ i7 = HEAP8[HEAP32[i8 + 4 >> 2] | 0] | 0;
+ switch (i7 | 0) {
+ case 50:
+ {
+ i3 = 95e5;
+ break L1;
+ }
+ case 51:
+ {
+ i6 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 95e6;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 19e7;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 95e4;
+ break L1;
+ }
+ case 48:
+ {
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ default:
+ {
+ HEAP32[i3 >> 2] = i7 + -48;
+ _printf(280, i3 | 0) | 0;
+ i8 = -1;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ }
+ } else {
+ i6 = 4;
+ }
+ } while (0);
+ if ((i6 | 0) == 4) {
+ i3 = 19e6;
+ }
+ HEAP32[i5 + 8 >> 2] = 0;
+ HEAP32[i5 + 4 >> 2] = 287;
+ i8 = __Znaj(347) | 0;
+ HEAP32[i5 >> 2] = i8;
+ _memcpy(i8 | 0, 296, 287) | 0;
+ i8 = i8 + 287 | 0;
+ i7 = 296 | 0;
+ i6 = i8 + 60 | 0;
+ do {
+ HEAP8[i8] = HEAP8[i7] | 0;
+ i8 = i8 + 1 | 0;
+ i7 = i7 + 1 | 0;
+ } while ((i8 | 0) < (i6 | 0));
+ i7 = i3 << 1;
+ while (1) {
+ i6 = i7 >>> 0 < 60 ? i7 : 60;
+ __ZN14RotatingString5writeEj(i5, i6);
+ if ((i7 | 0) == (i6 | 0)) {
+ break;
+ } else {
+ i7 = i7 - i6 | 0;
+ }
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ __ZdaPv(i5);
+ }
+ if ((HEAP32[6] | 0) == 0) {
+ i6 = 24;
+ i5 = 0;
+ } else {
+ i5 = 24;
+ d9 = 0.0;
+ while (1) {
+ i6 = i5 + 4 | 0;
+ d9 = d9 + +HEAPF32[i6 >> 2];
+ d10 = d9 < 1.0 ? d9 : 1.0;
+ HEAPF32[i6 >> 2] = d10;
+ HEAP32[i5 + 8 >> 2] = ~~(d10 * 512.0) >>> 0;
+ i5 = i5 + 12 | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 0) {
+ i6 = 24;
+ i5 = 0;
+ break;
+ }
+ }
+ }
+ do {
+ while (1) {
+ i8 = HEAP32[i6 + 8 >> 2] | 0;
+ if (i5 >>> 0 > i8 >>> 0 & (i8 | 0) != 0) {
+ i6 = i6 + 12 | 0;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i4 + (i5 << 2) >> 2] = i6;
+ i5 = i5 + 1 | 0;
+ } while ((i5 | 0) != 513);
+ HEAP32[i4 + 2116 >> 2] = 0;
+ __Z9makeFastaI10RandomizedEvPKcS2_jRT_(0, 0, i3 * 3 | 0, i4);
+ if ((HEAP32[54] | 0) == 0) {
+ i5 = 216;
+ i4 = 0;
+ } else {
+ i5 = 216;
+ d9 = 0.0;
+ while (1) {
+ i4 = i5 + 4 | 0;
+ d9 = d9 + +HEAPF32[i4 >> 2];
+ d10 = d9 < 1.0 ? d9 : 1.0;
+ HEAPF32[i4 >> 2] = d10;
+ HEAP32[i5 + 8 >> 2] = ~~(d10 * 512.0) >>> 0;
+ i5 = i5 + 12 | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 0) {
+ i5 = 216;
+ i4 = 0;
+ break;
+ }
+ }
+ }
+ do {
+ while (1) {
+ i8 = HEAP32[i5 + 8 >> 2] | 0;
+ if (i4 >>> 0 > i8 >>> 0 & (i8 | 0) != 0) {
+ i5 = i5 + 12 | 0;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i1 + (i4 << 2) >> 2] = i5;
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) != 513);
+ HEAP32[i1 + 2116 >> 2] = 0;
+ __Z9makeFastaI10RandomizedEvPKcS2_jRT_(0, 0, i3 * 5 | 0, i1);
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function __Z9makeFastaI10RandomizedEvPKcS2_jRT_(i3, i2, i6, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i4 = 0, i5 = 0, i7 = 0, d8 = 0.0, i9 = 0;
+ i2 = STACKTOP;
+ if ((i6 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = i1 + 2116 | 0;
+ i3 = i1 + 2052 | 0;
+ while (1) {
+ i5 = i6 >>> 0 < 60 ? i6 : 60;
+ if ((i5 | 0) != 0) {
+ i7 = 0;
+ do {
+ i9 = ((((HEAP32[4] | 0) * 3877 | 0) + 29573 | 0) >>> 0) % 139968 | 0;
+ HEAP32[4] = i9;
+ d8 = +(i9 >>> 0) / 139968.0;
+ i9 = HEAP32[i1 + (~~(d8 * 512.0) >>> 0 << 2) >> 2] | 0;
+ while (1) {
+ if (+HEAPF32[i9 + 4 >> 2] < d8) {
+ i9 = i9 + 12 | 0;
+ } else {
+ break;
+ }
+ }
+ HEAP8[i1 + i7 + 2052 | 0] = HEAP32[i9 >> 2];
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != (i5 | 0));
+ }
+ HEAP8[i1 + i5 + 2052 | 0] = 10;
+ i9 = i5 + 1 | 0;
+ HEAP8[i1 + i9 + 2052 | 0] = 0;
+ HEAP32[i4 >> 2] = i9;
+ i9 = _strlen(i3 | 0) | 0;
+ i7 = HEAP32[2] | 0;
+ if ((i9 | 0) > (i7 | 0)) {
+ if ((i7 | 0) > 0) {
+ HEAP8[i1 + i7 + 2052 | 0] = 0;
+ _puts(i3 | 0) | 0;
+ HEAP8[i1 + (HEAP32[2] | 0) + 2052 | 0] = 122;
+ HEAP32[2] = 0;
+ }
+ } else {
+ _puts(i3 | 0) | 0;
+ HEAP32[2] = (HEAP32[2] | 0) - i9;
+ }
+ if ((i6 | 0) == (i5 | 0)) {
+ break;
+ } else {
+ i6 = i6 - i5 | 0;
+ }
+ }
+ STACKTOP = i2;
+ return;
+}
+function __ZN14RotatingString5writeEj(i3, i4) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i5 = __Znaj(i4 + 2 | 0) | 0;
+ i2 = i3 + 8 | 0;
+ _memcpy(i5 | 0, (HEAP32[i3 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0, i4 | 0) | 0;
+ HEAP8[i5 + i4 | 0] = 0;
+ i7 = _strlen(i5 | 0) | 0;
+ i6 = HEAP32[2] | 0;
+ if ((i7 | 0) > (i6 | 0)) {
+ if ((i6 | 0) > 0) {
+ HEAP8[i5 + i6 | 0] = 0;
+ _puts(i5 | 0) | 0;
+ HEAP32[2] = 0;
+ i6 = 6;
+ } else {
+ i6 = 5;
+ }
+ } else {
+ _puts(i5 | 0) | 0;
+ HEAP32[2] = (HEAP32[2] | 0) - i7;
+ i6 = 5;
+ }
+ if ((i6 | 0) == 5 ? (i5 | 0) != 0 : 0) {
+ i6 = 6;
+ }
+ if ((i6 | 0) == 6) {
+ __ZdlPv(i5);
+ }
+ i4 = (HEAP32[i2 >> 2] | 0) + i4 | 0;
+ HEAP32[i2 >> 2] = i4;
+ i3 = HEAP32[i3 + 4 >> 2] | 0;
+ if (!(i4 >>> 0 > i3 >>> 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i2 >> 2] = i4 - i3;
+ STACKTOP = i1;
+ return;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function __Znwj(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i2 = (i2 | 0) == 0 ? 1 : i2;
+ while (1) {
+ i3 = _malloc(i2) | 0;
+ if ((i3 | 0) != 0) {
+ i2 = 6;
+ break;
+ }
+ i3 = HEAP32[270] | 0;
+ HEAP32[270] = i3 + 0;
+ if ((i3 | 0) == 0) {
+ i2 = 5;
+ break;
+ }
+ FUNCTION_TABLE_v[i3 & 0]();
+ }
+ if ((i2 | 0) == 5) {
+ i3 = ___cxa_allocate_exception(4) | 0;
+ HEAP32[i3 >> 2] = 1096;
+ ___cxa_throw(i3 | 0, 1144, 1);
+ } else if ((i2 | 0) == 6) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ return 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function __ZNSt9bad_allocD0Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZNSt9exceptionD2Ev(i1 | 0);
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function __ZNSt9bad_allocD2Ev(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZNSt9exceptionD2Ev(i1 | 0);
+ STACKTOP = i2;
+ return;
+}
+function __ZdlPv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i1 | 0) != 0) {
+ _free(i1);
+ }
+ STACKTOP = i2;
+ return;
+}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function __Znaj(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = __Znwj(i1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function runPostSets() {
+ HEAP32[286] = __ZTVN10__cxxabiv120__si_class_type_infoE;
+ HEAP32[288] = __ZTISt9exception;
+}
+function dynCall_ii(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_ii[i2 & 1](i1 | 0) | 0;
+}
+function __ZdaPv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ __ZdlPv(i1);
+ STACKTOP = i2;
+ return;
+}
+function dynCall_vi(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vi[i2 & 3](i1 | 0);
+}
+function dynCall_v(i1) {
+ i1 = i1 | 0;
+ FUNCTION_TABLE_v[i1 & 0]();
+}
+function __ZNKSt9bad_alloc4whatEv(i1) {
+ i1 = i1 | 0;
+ return 1112;
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function b0(i1) {
+ i1 = i1 | 0;
+ abort(0);
+ return 0;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+function b1(i1) {
+ i1 = i1 | 0;
+ abort(1);
+}
+function b2() {
+ abort(2);
+}
+
+// EMSCRIPTEN_END_FUNCS
+ var FUNCTION_TABLE_ii = [b0,__ZNKSt9bad_alloc4whatEv];
+ var FUNCTION_TABLE_vi = [b1,__ZNSt9bad_allocD2Ev,__ZNSt9bad_allocD0Ev,b1];
+ var FUNCTION_TABLE_v = [b2];
+
+ return { _strlen: _strlen, _free: _free, _main: _main, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9, dynCall_ii: dynCall_ii, dynCall_vi: dynCall_vi, dynCall_v: dynCall_v };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "invoke_ii": invoke_ii, "invoke_vi": invoke_vi, "invoke_v": invoke_v, "_send": _send, "___setErrNo": ___setErrNo, "___cxa_is_number_type": ___cxa_is_number_type, "___cxa_allocate_exception": ___cxa_allocate_exception, "___cxa_find_matching_catch": ___cxa_find_matching_catch, "_fflush": _fflush, "_time": _time, "_pwrite": _pwrite, "__reallyNegative": __reallyNegative, "_sbrk": _sbrk, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_fileno": _fileno, "___resumeException": ___resumeException, "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, "_sysconf": _sysconf, "_puts": _puts, "_mkport": _mkport, "_write": _write, "___errno_location": ___errno_location, "__ZNSt9exceptionD2Ev": __ZNSt9exceptionD2Ev, "_fputc": _fputc, "___cxa_throw": ___cxa_throw, "_abort": _abort, "_fwrite": _fwrite, "___cxa_does_inherit": ___cxa_does_inherit, "_fprintf": _fprintf, "__formatString": __formatString, "_fputs": _fputs, "_printf": _printf, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity, "__ZTISt9exception": __ZTISt9exception, "__ZTVN10__cxxabiv120__si_class_type_infoE": __ZTVN10__cxxabiv120__si_class_type_infoE }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
+var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
+var dynCall_v = Module["dynCall_v"] = asm["dynCall_v"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT =
+ 'stretch tree of depth 10\t check: -1\n' +
+ '1448\t trees of depth 4\t check: -1448\n' +
+ '362\t trees of depth 6\t check: -362\n' +
+ '90\t trees of depth 8\t check: -90\n' +
+ 'long lived tree of depth 9\t check: -1\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+
+var Module;
+if (typeof Module === 'undefined') Module = eval('(function() { try { return Module || {} } catch(e) { return {} } })()');
+if (!Module.expectedDataFileDownloads) {
+ Module.expectedDataFileDownloads = 0;
+ Module.finishedDataFileDownloads = 0;
+}
+Module.expectedDataFileDownloads++;
+(function() {
+
+ function runWithFS() {
+
+function assert(check, msg) {
+ if (!check) throw msg + new Error().stack;
+}
+Module['FS_createDataFile']('/', 'binarytrees.lua', [45, 45, 32, 84, 104, 101, 32, 67, 111, 109, 112, 117, 116, 101, 114, 32, 76, 97, 110, 103, 117, 97, 103, 101, 32, 66, 101, 110, 99, 104, 109, 97, 114, 107, 115, 32, 71, 97, 109, 101, 10, 45, 45, 32, 104, 116, 116, 112, 58, 47, 47, 98, 101, 110, 99, 104, 109, 97, 114, 107, 115, 103, 97, 109, 101, 46, 97, 108, 105, 111, 116, 104, 46, 100, 101, 98, 105, 97, 110, 46, 111, 114, 103, 47, 10, 45, 45, 32, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 100, 32, 98, 121, 32, 77, 105, 107, 101, 32, 80, 97, 108, 108, 10, 10, 108, 111, 99, 97, 108, 32, 102, 117, 110, 99, 116, 105, 111, 110, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 116, 101, 109, 44, 32, 100, 101, 112, 116, 104, 41, 10, 32, 32, 105, 102, 32, 100, 101, 112, 116, 104, 32, 62, 32, 48, 32, 116, 104, 101, 110, 10, 32, 32, 32, 32, 108, 111, 99, 97, 108, 32, 105, 32, 61, 32, 105, 116, 101, 109, 32, 43, 32, 105, 116, 101, 109, 10, 32, 32, 32, 32, 100, 101, 112, 116, 104, 32, 61, 32, 100, 101, 112, 116, 104, 32, 45, 32, 49, 10, 32, 32, 32, 32, 108, 111, 99, 97, 108, 32, 108, 101, 102, 116, 44, 32, 114, 105, 103, 104, 116, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 45, 49, 44, 32, 100, 101, 112, 116, 104, 41, 44, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 105, 44, 32, 100, 101, 112, 116, 104, 41, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 123, 32, 105, 116, 101, 109, 44, 32, 108, 101, 102, 116, 44, 32, 114, 105, 103, 104, 116, 32, 125, 10, 32, 32, 101, 108, 115, 101, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 123, 32, 105, 116, 101, 109, 32, 125, 10, 32, 32, 101, 110, 100, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 102, 117, 110, 99, 116, 105, 111, 110, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 41, 10, 32, 32, 105, 102, 32, 116, 114, 101, 101, 91, 50, 93, 32, 116, 104, 101, 110, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 116, 114, 101, 101, 91, 49, 93, 32, 43, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 91, 50, 93, 41, 32, 45, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 116, 114, 101, 101, 91, 51, 93, 41, 10, 32, 32, 101, 108, 115, 101, 10, 32, 32, 32, 32, 114, 101, 116, 117, 114, 110, 32, 116, 114, 101, 101, 91, 49, 93, 10, 32, 32, 101, 110, 100, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 78, 32, 61, 32, 116, 111, 110, 117, 109, 98, 101, 114, 40, 97, 114, 103, 32, 97, 110, 100, 32, 97, 114, 103, 91, 49, 93, 41, 32, 111, 114, 32, 52, 10, 10, 105, 102, 32, 78, 32, 61, 61, 32, 48, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 48, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 49, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 57, 46, 53, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 50, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 49, 46, 57, 57, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 51, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 50, 46, 56, 53, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 52, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 52, 46, 55, 50, 10, 101, 108, 115, 101, 105, 102, 32, 78, 32, 61, 61, 32, 53, 32, 116, 104, 101, 110, 10, 32, 32, 78, 32, 61, 32, 49, 53, 46, 56, 50, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 109, 105, 110, 100, 101, 112, 116, 104, 32, 61, 32, 52, 10, 108, 111, 99, 97, 108, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 61, 32, 109, 105, 110, 100, 101, 112, 116, 104, 32, 43, 32, 50, 10, 105, 102, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 60, 32, 78, 32, 116, 104, 101, 110, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 61, 32, 78, 32, 101, 110, 100, 10, 10, 100, 111, 10, 32, 32, 108, 111, 99, 97, 108, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 32, 61, 32, 109, 97, 120, 100, 101, 112, 116, 104, 32, 43, 32, 49, 10, 32, 32, 108, 111, 99, 97, 108, 32, 115, 116, 114, 101, 116, 99, 104, 116, 114, 101, 101, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 48, 44, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 41, 10, 32, 32, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 115, 116, 114, 101, 116, 99, 104, 32, 116, 114, 101, 101, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 32, 32, 115, 116, 114, 101, 116, 99, 104, 100, 101, 112, 116, 104, 44, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 115, 116, 114, 101, 116, 99, 104, 116, 114, 101, 101, 41, 41, 41, 10, 101, 110, 100, 10, 10, 108, 111, 99, 97, 108, 32, 108, 111, 110, 103, 108, 105, 118, 101, 100, 116, 114, 101, 101, 32, 61, 32, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 48, 44, 32, 109, 97, 120, 100, 101, 112, 116, 104, 41, 10, 10, 102, 111, 114, 32, 100, 101, 112, 116, 104, 61, 109, 105, 110, 100, 101, 112, 116, 104, 44, 109, 97, 120, 100, 101, 112, 116, 104, 44, 50, 32, 100, 111, 10, 32, 32, 108, 111, 99, 97, 108, 32, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 32, 61, 32, 50, 32, 94, 32, 40, 109, 97, 120, 100, 101, 112, 116, 104, 32, 45, 32, 100, 101, 112, 116, 104, 32, 43, 32, 109, 105, 110, 100, 101, 112, 116, 104, 41, 10, 32, 32, 108, 111, 99, 97, 108, 32, 99, 104, 101, 99, 107, 32, 61, 32, 48, 10, 32, 32, 102, 111, 114, 32, 105, 61, 49, 44, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 32, 100, 111, 10, 32, 32, 32, 32, 99, 104, 101, 99, 107, 32, 61, 32, 99, 104, 101, 99, 107, 32, 43, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 49, 44, 32, 100, 101, 112, 116, 104, 41, 41, 32, 43, 10, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 66, 111, 116, 116, 111, 109, 85, 112, 84, 114, 101, 101, 40, 45, 49, 44, 32, 100, 101, 112, 116, 104, 41, 41, 10, 32, 32, 101, 110, 100, 10, 32, 32, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 37, 100, 92, 116, 32, 116, 114, 101, 101, 115, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 32, 32, 105, 116, 101, 114, 97, 116, 105, 111, 110, 115, 42, 50, 44, 32, 100, 101, 112, 116, 104, 44, 32, 99, 104, 101, 99, 107, 41, 41, 10, 101, 110, 100, 10, 10, 105, 111, 46, 119, 114, 105, 116, 101, 40, 115, 116, 114, 105, 110, 103, 46, 102, 111, 114, 109, 97, 116, 40, 34, 108, 111, 110, 103, 32, 108, 105, 118, 101, 100, 32, 116, 114, 101, 101, 32, 111, 102, 32, 100, 101, 112, 116, 104, 32, 37, 100, 92, 116, 32, 99, 104, 101, 99, 107, 58, 32, 37, 100, 92, 110, 34, 44, 10, 32, 32, 109, 97, 120, 100, 101, 112, 116, 104, 44, 32, 73, 116, 101, 109, 67, 104, 101, 99, 107, 40, 108, 111, 110, 103, 108, 105, 118, 101, 100, 116, 114, 101, 101, 41, 41, 41, 10], true, true);
+
+ }
+ if (Module['calledRun']) {
+ runWithFS();
+ } else {
+ if (!Module['preRun']) Module['preRun'] = [];
+ Module["preRun"].push(runWithFS); // FS is not initialized yet, wait for it
+ }
+
+})();
+
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(13467);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([99,97,110,110,111,116,32,99,114,101,97,116,101,32,115,116,97,116,101,58,32,110,111,116,32,101,110,111,117,103,104,32,109,101,109,111,114,121,0,0,40,101,114,114,111,114,32,111,98,106,101,99,116,32,105,115,32,110,111,116,32,97,32,115,116,114,105,110,103,41,0,0,88,0,0,0,0,0,0,0,108,117,97,0,0,0,0,0,76,85,65,95,78,79,69,78,86,0,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,112,114,105,110,116,0,0,0,0,0,0,0,112,114,105,110,116,0,0,0,101,114,114,111,114,32,99,97,108,108,105,110,103,32,39,112,114,105,110,116,39,32,40,37,115,41,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,105,110,116,101,114,114,117,112,116,101,100,33,0,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,40,110,111,32,101,114,114,111,114,32,109,101,115,115,97,103,101,41,0,0,0,0,0,0,61,115,116,100,105,110,0,0,60,101,111,102,62,0,0,0,114,101,116,117,114,110,32,37,115,0,0,0,0,0,0,0,95,80,82,79,77,80,84,0,95,80,82,79,77,80,84,50,0,0,0,0,0,0,0,0,62,32,0,0,0,0,0,0,62,62,32,0,0,0,0,0,97,114,103,0,0,0,0,0,45,0,0,0,0,0,0,0,45,45,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,32,116,111,32,115,99,114,105,112,116,0,0,0,0,61,40,99,111,109,109,97,110,100,32,108,105,110,101,41,0,114,101,113,117,105,114,101,0,61,76,85,65,95,73,78,73,84,95,53,95,50,0,0,0,61,76,85,65,95,73,78,73,84,0,0,0,0,0,0,0,76,117,97,32,53,46,50,46,50,32,32,67,111,112,121,114,105,103,104,116,32,40,67,41,32,49,57,57,52,45,50,48,49,51,32,76,117,97,46,111,114,103,44,32,80,85,67,45,82,105,111,0,0,0,0,0,37,115,58,32,0,0,0,0,39,37,115,39,32,110,101,101,100,115,32,97,114,103,117,109,101,110,116,10,0,0,0,0,117,110,114,101,99,111,103,110,105,122,101,100,32,111,112,116,105,111,110,32,39,37,115,39,10,0,0,0,0,0,0,0,117,115,97,103,101,58,32,37,115,32,91,111,112,116,105,111,110,115,93,32,91,115,99,114,105,112,116,32,91,97,114,103,115,93,93,10,65,118,97,105,108,97,98,108,101,32,111,112,116,105,111,110,115,32,97,114,101,58,10,32,32,45,101,32,115,116,97,116,32,32,101,120,101,99,117,116,101,32,115,116,114,105,110,103,32,39,115,116,97,116,39,10,32,32,45,105,32,32,32,32,32,32,32,101,110,116,101,114,32,105,110,116,101,114,97,99,116,105,118,101,32,109,111,100,101,32,97,102,116,101,114,32,101,120,101,99,117,116,105,110,103,32,39,115,99,114,105,112,116,39,10,32,32,45,108,32,110,97,109,101,32,32,114,101,113,117,105,114,101,32,108,105,98,114,97,114,121,32,39,110,97,109,101,39,10,32,32,45,118,32,32,32,32,32,32,32,115,104,111,119,32,118,101,114,115,105,111,110,32,105,110,102,111,114,109,97,116,105,111,110,10,32,32,45,69,32,32,32,32,32,32,32,105,103,110,111,114,101,32,101,110,118,105,114,111,110,109,101,110,116,32,118,97,114,105,97,98,108,101,115,10,32,32,45,45,32,32,32,32,32,32,32,115,116,111,112,32,104,97,110,100,108,105,110,103,32,111,112,116,105,111,110,115,10,32,32,45,32,32,32,32,32,32,32,32,115,116,111,112,32,104,97,110,100,108,105,110,103,32,111,112,116,105,111,110,115,32,97,110,100,32,101,120,101,99,117,116,101,32,115,116,100,105,110,10,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,0,0,0,0,0,96,127,64,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,115,116,97,99,107,32,116,114,97,99,101,98,97,99,107,58,0,0,0,0,0,0,0,0,10,9,46,46,46,0,0,0,83,108,110,116,0,0,0,0,10,9,37,115,58,0,0,0,37,100,58,0,0,0,0,0,32,105,110,32,0,0,0,0,10,9,40,46,46,46,116,97,105,108,32,99,97,108,108,115,46,46,46,41,0,0,0,0,98,97,100,32,97,114,103,117,109,101,110,116,32,35,37,100,32,40,37,115,41,0,0,0,110,0,0,0,0,0,0,0,109,101,116,104,111,100,0,0,99,97,108,108,105,110,103,32,39,37,115,39,32,111,110,32,98,97,100,32,115,101,108,102,32,40,37,115,41,0,0,0,63,0,0,0,0,0,0,0,98,97,100,32,97,114,103,117,109,101,110,116,32,35,37,100,32,116,111,32,39,37,115,39,32,40,37,115,41,0,0,0,83,108,0,0,0,0,0,0,37,115,58,37,100,58,32,0,0,0,0,0,0,0,0,0,37,115,58,32,37,115,0,0,101,120,105,116,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,115,39,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,32,40,37,115,41,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,118,97,108,117,101,32,101,120,112,101,99,116,101,100,0,0,98,117,102,102,101,114,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,0,0,61,115,116,100,105,110,0,0,64,37,115,0,0,0,0,0,114,0,0,0,0,0,0,0,111,112,101,110,0,0,0,0,114,98,0,0,0,0,0,0,114,101,111,112,101,110,0,0,114,101,97,100,0,0,0,0,111,98,106,101,99,116,32,108,101,110,103,116,104,32,105,115,32,110,111,116,32,97,32,110,117,109,98,101,114,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,116,114,117,101,0,0,0,0,102,97,108,115,101,0,0,0,110,105,108,0,0,0,0,0,37,115,58,32,37,112,0,0,95,76,79,65,68,69,68,0,110,97,109,101,32,99,111,110,102,108,105,99,116,32,102,111,114,32,109,111,100,117,108,101,32,39,37,115,39,0,0,0,116,111,111,32,109,97,110,121,32,117,112,118,97,108,117,101,115,0,0,0,0,0,0,0,109,117,108,116,105,112,108,101,32,76,117,97,32,86,77,115,32,100,101,116,101,99,116,101,100,0,0,0,0,0,0,0,118,101,114,115,105,111,110,32,109,105,115,109,97,116,99,104,58,32,97,112,112,46,32,110,101,101,100,115,32,37,102,44,32,76,117,97,32,99,111,114,101,32,112,114,111,118,105,100,101,115,32,37,102,0,0,0,98,97,100,32,99,111,110,118,101,114,115,105,111,110,32,110,117,109,98,101,114,45,62,105,110,116,59,32,109,117,115,116,32,114,101,99,111,109,112,105,108,101,32,76,117,97,32,119,105,116,104,32,112,114,111,112,101,114,32,115,101,116,116,105,110,103,115,0,0,0,0,0,80,65,78,73,67,58,32,117,110,112,114,111,116,101,99,116,101,100,32,101,114,114,111,114,32,105,110,32,99,97,108,108,32,116,111,32,76,117,97,32,65,80,73,32,40,37,115,41,10,0,0,0,0,0,0,0,239,187,191,0,0,0,0,0,99,97,110,110,111,116,32,37,115,32,37,115,58,32,37,115,0,0,0,0,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,44,32,103,111,116,32,37,115,0,0,0,0,0,102,0,0,0,0,0,0,0,46,0,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,39,37,115,39,0,0,0,109,97,105,110,32,99,104,117,110,107,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,60,37,115,58,37,100,62,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,37,115,32,37,115,32,39,37,115,39,32,40,97,32,37,115,32,118,97,108,117,101,41,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,37,115,32,97,32,37,115,32,118,97,108,117,101,0,0,0,0,0,0,0,0,99,111,110,99,97,116,101,110,97,116,101,0,0,0,0,0,112,101,114,102,111,114,109,32,97,114,105,116,104,109,101,116,105,99,32,111,110,0,0,0,97,116,116,101,109,112,116,32,116,111,32,99,111,109,112,97,114,101,32,116,119,111,32,37,115,32,118,97,108,117,101,115,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,99,111,109,112,97,114,101,32,37,115,32,119,105,116,104,32,37,115,0,0,0,37,115,58,37,100,58,32,37,115,0,0,0,0,0,0,0,108,111,99,97,108,0,0,0,95,69,78,86,0,0,0,0,103,108,111,98,97,108,0,0,102,105,101,108,100,0,0,0,117,112,118,97,108,117,101,0,99,111,110,115,116,97,110,116,0,0,0,0,0,0,0,0,109,101,116,104,111,100,0,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,111,114,32,105,116,101,114,97,116,111,114,0,0,0,0,109,101,116,97,109,101,116,104,111,100,0,0,0,0,0,0,61,91,67,93,0,0,0,0,67,0,0,0,0,0,0,0,61,63,0,0,0,0,0,0,109,97,105,110,0,0,0,0,76,117,97,0,0,0,0,0,40,42,116,101,109,112,111,114,97,114,121,41,0,0,0,0,40,42,118,97,114,97,114,103,41,0,0,0,0,0,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,67,32,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,121,105,101,108,100,32,97,99,114,111,115,115,32,97,32,67,45,99,97,108,108,32,98,111,117,110,100,97,114,121,0,0,0,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,121,105,101,108,100,32,102,114,111,109,32,111,117,116,115,105,100,101,32,97,32,99,111,114,111,117,116,105,110,101,0,0,0,0,0,0,0,98,105,110,97,114,121,0,0,116,101,120,116,0,0,0,0,97,116,116,101,109,112,116,32,116,111,32,108,111,97,100,32,97,32,37,115,32,99,104,117,110,107,32,40,109,111,100,101,32,105,115,32,39,37,115,39,41,0,0,0,0,0,0,0,101,114,114,111,114,32,105,110,32,101,114,114,111,114,32,104,97,110,100,108,105,110,103,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,110,111,110,45,115,117,115,112,101,110,100,101,100,32,99,111,114,111,117,116,105,110,101,0,0,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,100,101,97,100,32,99,111,114,111,117,116,105,110,101,0,0,0,0,99,97,108,108,0,0,0,0,110,111,32,109,101,115,115,97,103,101,0,0,0,0,0,0,101,114,114,111,114,32,105,110,32,95,95,103,99,32,109,101,116,97,109,101,116,104,111,100,32,40,37,115,41,0,0,0,95,80,82,69,76,79,65,68,0,0,0,0,0,0,0,0,95,71,0,0,0,0,0,0,112,97,99,107,97,103,101,0,99,111,114,111,117,116,105,110,101,0,0,0,0,0,0,0,116,97,98,108,101,0,0,0,105,111,0,0,0,0,0,0,111,115,0,0,0,0,0,0,115,116,114,105,110,103,0,0,98,105,116,51,50,0,0,0,109,97,116,104,0,0,0,0,100,101,98,117,103,0,0,0,144,11,0,0,1,0,0,0,152,11,0,0,2,0,0,0,48,13,0,0,3,0,0,0,160,11,0,0,4,0,0,0,56,13,0,0,5,0,0,0,64,13,0,0,6,0,0,0,72,13,0,0,7,0,0,0,168,11,0,0,8,0,0,0,80,13,0,0,9,0,0,0,88,13,0,0,10,0,0,0,192,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,95,73,79,95,105,110,112,117,116,0,0,0,0,0,0,0,115,116,100,105,110,0,0,0,95,73,79,95,111,117,116,112,117,116,0,0,0,0,0,0,115,116,100,111,117,116,0,0,115,116,100,101,114,114,0,0,70,73,76,69,42,0,0,0,99,97,110,110,111,116,32,99,108,111,115,101,32,115,116,97,110,100,97,114,100,32,102,105,108,101,0,0,0,0,0,0,95,95,105,110,100,101,120,0,144,11,0,0,1,0,0,0,152,11,0,0,12,0,0,0,160,11,0,0,13,0,0,0,168,11,0,0,14,0,0,0,176,11,0,0,15,0,0,0,184,11,0,0,16,0,0,0,192,11,0,0,17,0,0,0,200,11,0,0,18,0,0,0,208,11,0,0,19,0,0,0,0,0,0,0,0,0,0,0,99,108,111,115,101,0,0,0,102,108,117,115,104,0,0,0,108,105,110,101,115,0,0,0,114,101,97,100,0,0,0,0,115,101,101,107,0,0,0,0,115,101,116,118,98,117,102,0,119,114,105,116,101,0,0,0,95,95,103,99,0,0,0,0,95,95,116,111,115,116,114,105,110,103,0,0,0,0,0,0,102,105,108,101,32,40,99,108,111,115,101,100,41,0,0,0,102,105,108,101,32,40,37,112,41,0,0,0,0,0,0,0,37,46,49,52,103,0,0,0,97,116,116,101,109,112,116,32,116,111,32,117,115,101,32,97,32,99,108,111,115,101,100,32,102,105,108,101,0,0,0,0,2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,72,12,0,0,80,12,0,0,88,12,0,0,0,0,0,0,110,111,0,0,0,0,0,0,102,117,108,108,0,0,0,0,108,105,110,101,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,128,12,0,0,136,12,0,0,144,12,0,0,0,0,0,0,115,101,116,0,0,0,0,0,99,117,114,0,0,0,0,0,101,110,100,0,0,0,0,0,110,111,116,32,97,110,32,105,110,116,101,103,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,0,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,0,0,37,108,102,0,0,0,0,0,116,111,111,32,109,97,110,121,32,111,112,116,105,111,110,115,0,0,0,0,0,0,0,0,102,105,108,101,32,105,115,32,97,108,114,101,97,100,121,32,99,108,111,115,101,100,0,0,37,115,0,0,0,0,0,0,105,110,112,117,116,0,0,0,111,112,101,110,0,0,0,0,111,117,116,112,117,116,0,0,112,111,112,101,110,0,0,0,116,109,112,102,105,108,101,0,116,121,112,101,0,0,0,0,115,116,97,110,100,97,114,100,32,37,115,32,102,105,108,101,32,105,115,32,99,108,111,115,101,100,0,0,0,0,0,0,99,108,111,115,101,100,32,102,105,108,101,0,0,0,0,0,102,105,108,101,0,0,0,0,114,0,0,0,0,0,0,0,39,112,111,112,101,110,39,32,110,111,116,32,115,117,112,112,111,114,116,101,100,0,0,0,119,0,0,0,0,0,0,0,99,97,110,110,111,116,32,111,112,101,110,32,102,105,108,101,32,39,37,115,39,32,40,37,115,41,0,0,0,0,0,0,114,119,97,0,0,0,0,0,105,110,118,97,108,105,100,32,109,111,100,101,0,0,0,0,240,14,0,0,20,0,0,0,248,14,0,0,21,0,0,0,0,15,0,0,22,0,0,0,8,15,0,0,23,0,0,0,16,15,0,0,24,0,0,0,24,15,0,0,25,0,0,0,32,15,0,0,26,0,0,0,40,15,0,0,27,0,0,0,48,15,0,0,28,0,0,0,56,15,0,0,29,0,0,0,64,15,0,0,30,0,0,0,72,15,0,0,31,0,0,0,80,15,0,0,32,0,0,0,88,15,0,0,33,0,0,0,96,15,0,0,34,0,0,0,104,15,0,0,35,0,0,0,112,15,0,0,36,0,0,0,120,15,0,0,37,0,0,0,128,15,0,0,38,0,0,0,136,15,0,0,39,0,0,0,144,15,0,0,40,0,0,0,152,15,0,0,41,0,0,0,160,15,0,0,42,0,0,0,176,15,0,0,43,0,0,0,184,15,0,0,44,0,0,0,192,15,0,0,45,0,0,0,200,15,0,0,46,0,0,0,208,15,0,0,47,0,0,0,0,0,0,0,0,0,0,0,112,105,0,0,0,0,0,0,104,117,103,101,0,0,0,0,97,98,115,0,0,0,0,0,97,99,111,115,0,0,0,0,97,115,105,110,0,0,0,0,97,116,97,110,50,0,0,0,97,116,97,110,0,0,0,0,99,101,105,108,0,0,0,0,99,111,115,104,0,0,0,0,99,111,115,0,0,0,0,0,100,101,103,0,0,0,0,0,101,120,112,0,0,0,0,0,102,108,111,111,114,0,0,0,102,109,111,100,0,0,0,0,102,114,101,120,112,0,0,0,108,100,101,120,112,0,0,0,108,111,103,49,48,0,0,0,108,111,103,0,0,0,0,0,109,97,120,0,0,0,0,0,109,105,110,0,0,0,0,0,109,111,100,102,0,0,0,0,112,111,119,0,0,0,0,0,114,97,100,0,0,0,0,0,114,97,110,100,111,109,0,0,114,97,110,100,111,109,115,101,101,100,0,0,0,0,0,0,115,105,110,104,0,0,0,0,115,105,110,0,0,0,0,0,115,113,114,116,0,0,0,0,116,97,110,104,0,0,0,0,116,97,110,0,0,0,0,0,105,110,116,101,114,118,97,108,32,105,115,32,101,109,112,116,121,0,0,0,0,0,0,0,119,114,111,110,103,32,110,117,109,98,101,114,32,111,102,32,97,114,103,117,109,101,110,116,115,0,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,37,115,32,40,108,105,109,105,116,32,105,115,32,37,100,41,0,0,0,0,0,0,0,109,101,109,111,114,121,32,97,108,108,111,99,97,116,105,111,110,32,101,114,114,111,114,58,32,98,108,111,99,107,32,116,111,111,32,98,105,103,0,0,95,67,76,73,66,83,0,0,95,95,103,99,0,0,0,0,16,20,0,0,48,0,0,0,24,20,0,0,49,0,0,0,40,20,0,0,50,0,0,0,0,0,0,0,0,0,0,0,108,111,97,100,101,114,115,0,115,101,97,114,99,104,101,114,115,0,0,0,0,0,0,0,112,97,116,104,0,0,0,0,76,85,65,95,80,65,84,72,95,53,95,50,0,0,0,0,76,85,65,95,80,65,84,72,0,0,0,0,0,0,0,0,47,117,115,114,47,108,111,99,97,108,47,115,104,97,114,101,47,108,117,97,47,53,46,50,47,63,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,115,104,97,114,101,47,108,117,97,47,53,46,50,47,63,47,105,110,105,116,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,46,108,117,97,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,47,105,110,105,116,46,108,117,97,59,46,47,63,46,108,117,97,0,0,0,0,0,0,0,99,112,97,116,104,0,0,0,76,85,65,95,67,80,65,84,72,95,53,95,50,0,0,0,76,85,65,95,67,80,65,84,72,0,0,0,0,0,0,0,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,63,46,115,111,59,47,117,115,114,47,108,111,99,97,108,47,108,105,98,47,108,117,97,47,53,46,50,47,108,111,97,100,97,108,108,46,115,111,59,46,47,63,46,115,111,0,0,0,0,47,10,59,10,63,10,33,10,45,10,0,0,0,0,0,0,99,111,110,102,105,103,0,0,95,76,79,65,68,69,68,0,108,111,97,100,101,100,0,0,95,80,82,69,76,79,65,68,0,0,0,0,0,0,0,0,112,114,101,108,111,97,100,0,32,18,0,0,51,0,0,0,40,18,0,0,52,0,0,0,0,0,0,0,0,0,0,0,109,111,100,117,108,101,0,0,114,101,113,117,105,114,101,0,39,112,97,99,107,97,103,101,46,115,101,97,114,99,104,101,114,115,39,32,109,117,115,116,32,98,101,32,97,32,116,97,98,108,101,0,0,0,0,0,109,111,100,117,108,101,32,39,37,115,39,32,110,111,116,32,102,111,117,110,100,58,37,115,0,0,0,0,0,0,0,0,95,78,65,77,69,0,0,0,102,0,0,0,0,0,0,0,39,109,111,100,117,108,101,39,32,110,111,116,32,99,97,108,108,101,100,32,102,114,111,109,32,97,32,76,117,97,32,102,117,110,99,116,105,111,110,0,95,77,0,0,0,0,0,0,95,80,65,67,75,65,71,69,0,0,0,0,0,0,0,0,59,59,0,0,0,0,0,0,59,1,59,0,0,0,0,0,1,0,0,0,0,0,0,0,76,85,65,95,78,79,69,78,86,0,0,0,0,0,0,0,47,0,0,0,0,0,0,0,10,9,110,111,32,109,111,100,117,108,101,32,39,37,115,39,32,105,110,32,102,105,108,101,32,39,37,115,39,0,0,0,101,114,114,111,114,32,108,111,97,100,105,110,103,32,109,111,100,117,108,101,32,39,37,115,39,32,102,114,111,109,32,102,105,108,101,32,39,37,115,39,58,10,9,37,115,0,0,0,46,0,0,0,0,0,0,0,95,0,0,0,0,0,0,0,108,117,97,111,112,101,110,95,37,115,0,0,0,0,0,0,100,121,110,97,109,105,99,32,108,105,98,114,97,114,105,101,115,32,110,111,116,32,101,110,97,98,108,101,100,59,32,99,104,101,99,107,32,121,111,117,114,32,76,117,97,32,105,110,115,116,97,108,108,97,116,105,111,110,0,0,0,0,0,0,39,112,97,99,107,97,103,101,46,37,115,39,32,109,117,115,116,32,98,101,32,97,32,115,116,114,105,110,103,0,0,0,63,0,0,0,0,0,0,0,10,9,110,111,32,102,105,108,101,32,39,37,115,39,0,0,114,0,0,0,0,0,0,0,10,9,110,111,32,102,105,101,108,100,32,112,97,99,107,97,103,101,46,112,114,101,108,111,97,100,91,39,37,115,39,93,0,0,0,0,0,0,0,0,108,111,97,100,108,105,98,0,115,101,97,114,99,104,112,97,116,104,0,0,0,0,0,0,115,101,101,97,108,108,0,0,95,95,105,110,100,101,120,0,97,98,115,101,110,116,0,0,105,110,105,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,110,78,0,0,0,0,0,0,120,88,0,0,0,0,0,0,40,110,117,108,108,41,0,0,37,112,0,0,0,0,0,0,37,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,37,37,99,39,32,116,111,32,39,108,117,97,95,112,117,115,104,102,115,116,114,105,110,103,39,0,0,0,0,0,0,46,46,46,0,0,0,0,0,91,115,116,114,105,110,103,32,34,0,0,0,0,0,0,0,34,93,0,0,0,0,0,0,96,113,65,84,80,80,92,108,60,16,60,84,108,124,124,124,124,124,124,96,96,96,104,34,188,188,188,132,228,84,84,16,98,98,4,98,20,81,80,23,88,22,0,0,53,0,0,0,96,22,0,0,54,0,0,0,104,22,0,0,55,0,0,0,120,22,0,0,56,0,0,0,128,22,0,0,57,0,0,0,136,22,0,0,58,0,0,0,144,22,0,0,59,0,0,0,152,22,0,0,60,0,0,0,160,22,0,0,61,0,0,0,176,22,0,0,62,0,0,0,184,22,0,0,63,0,0,0,0,0,0,0,0,0,0,0,99,108,111,99,107,0,0,0,100,97,116,101,0,0,0,0,100,105,102,102,116,105,109,101,0,0,0,0,0,0,0,0,101,120,101,99,117,116,101,0,101,120,105,116,0,0,0,0,103,101,116,101,110,118,0,0,114,101,109,111,118,101,0,0,114,101,110,97,109,101,0,0,115,101,116,108,111,99,97,108,101,0,0,0,0,0,0,0,116,105,109,101,0,0,0,0,116,109,112,110,97,109,101,0,117,110,97,98,108,101,32,116,111,32,103,101,110,101,114,97,116,101,32,97,32,117,110,105,113,117,101,32,102,105,108,101,110,97,109,101,0,0,0,0,115,101,99,0,0,0,0,0,109,105,110,0,0,0,0,0,104,111,117,114,0,0,0,0,100,97,121,0,0,0,0,0,109,111,110,116,104,0,0,0,121,101,97,114,0,0,0,0,105,115,100,115,116,0,0,0,102,105,101,108,100,32,39,37,115,39,32,109,105,115,115,105,110,103,32,105,110,32,100,97,116,101,32,116,97,98,108,101,0,0,0,0,0,0,0,0,6,0,0,0,3,0,0,0,0,0,0,0,4,0,0,0,1,0,0,0,2,0,0,0,128,23,0,0,136,23,0,0,144,23,0,0,152,23,0,0,168,23,0,0,176,22,0,0,0,0,0,0,0,0,0,0,97,108,108,0,0,0,0,0,99,111,108,108,97,116,101,0,99,116,121,112,101,0,0,0,109,111,110,101,116,97,114,121,0,0,0,0,0,0,0,0,110,117,109,101,114,105,99,0,37,99,0,0,0,0,0,0,42,116,0,0,0,0,0,0,119,100,97,121,0,0,0,0,121,100,97,121,0,0,0,0,97,65,98,66,99,100,72,73,106,109,77,112,83,85,119,87,120,88,121,89,122,37,0,0,105,110,118,97,108,105,100,32,99,111,110,118,101,114,115,105,111,110,32,115,112,101,99,105,102,105,101,114,32,39,37,37,37,115,39,0,0,0,0,0,60,37,115,62,32,97,116,32,108,105,110,101,32,37,100,32,110,111,116,32,105,110,115,105,100,101,32,97,32,108,111,111,112,0,0,0,0,0,0,0,110,111,32,118,105,115,105,98,108,101,32,108,97,98,101,108,32,39,37,115,39,32,102,111,114,32,60,103,111,116,111,62,32,97,116,32,108,105,110,101,32,37,100,0,0,0,0,0,60,103,111,116,111,32,37,115,62,32,97,116,32,108,105,110,101,32,37,100,32,106,117,109,112,115,32,105,110,116,111,32,116,104,101,32,115,99,111,112,101,32,111,102,32,108,111,99,97,108,32,39,37,115,39,0,98,114,101,97,107,0,0,0,108,97,98,101,108,115,47,103,111,116,111,115,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,0,0,0,0,0,115,121,110,116,97,120,32,101,114,114,111,114,0,0,0,0,67,32,108,101,118,101,108,115,0,0,0,0,0,0,0,0,6,6,6,6,7,7,7,7,7,7,10,9,5,4,3,3,3,3,3,3,3,3,3,3,3,3,2,2,1,1,0,0,99,97,110,110,111,116,32,117,115,101,32,39,46,46,46,39,32,111,117,116,115,105,100,101,32,97,32,118,97,114,97,114,103,32,102,117,110,99,116,105,111,110,0,0,0,0,0,0,115,101,108,102,0,0,0,0,60,110,97,109,101,62,32,111,114,32,39,46,46,46,39,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,0,0,108,111,99,97,108,32,118,97,114,105,97,98,108,101,115,0,102,117,110,99,116,105,111,110,115,0,0,0,0,0,0,0,105,116,101,109,115,32,105,110,32,97,32,99,111,110,115,116,114,117,99,116,111,114,0,0,109,97,105,110,32,102,117,110,99,116,105,111,110,0,0,0,102,117,110,99,116,105,111,110,32,97,116,32,108,105,110,101,32,37,100,0,0,0,0,0,116,111,111,32,109,97,110,121,32,37,115,32,40,108,105,109,105,116,32,105,115,32,37,100,41,32,105,110,32,37,115,0,102,117,110,99,116,105,111,110,32,97,114,103,117,109,101,110,116,115,32,101,120,112,101,99,116,101,100,0,0,0,0,0,117,110,101,120,112,101,99,116,101,100,32,115,121,109,98,111,108,0,0,0,0,0,0,0,108,97,98,101,108,32,39,37,115,39,32,97,108,114,101,97,100,121,32,100,101,102,105,110,101,100,32,111,110,32,108,105,110,101,32,37,100,0,0,0,39,61,39,32,111,114,32,39,105,110,39,32,101,120,112,101,99,116,101,100,0,0,0,0,40,102,111,114,32,103,101,110,101,114,97,116,111,114,41,0,40,102,111,114,32,115,116,97,116,101,41,0,0,0,0,0,40,102,111,114,32,99,111,110,116,114,111,108,41,0,0,0,40,102,111,114,32,105,110,100,101,120,41,0,0,0,0,0,40,102,111,114,32,108,105,109,105,116,41,0,0,0,0,0,40,102,111,114,32,115,116,101,112,41,0,0,0,0,0,0,37,115,32,101,120,112,101,99,116,101,100,32,40,116,111,32,99,108,111,115,101,32,37,115,32,97,116,32,108,105,110,101,32,37,100,41,0,0,0,0,117,112,118,97,108,117,101,115,0,0,0,0,0,0,0,0,110,111,116,32,101,110,111,117,103,104,32,109,101,109,111,114,121,0,0,0,0,0,0,0,144,27,0,0,64,0,0,0,152,27,0,0,65,0,0,0,160,27,0,0,66,0,0,0,168,27,0,0,67,0,0,0,176,27,0,0,68,0,0,0,184,27,0,0,69,0,0,0,192,27,0,0,70,0,0,0,200,27,0,0,71,0,0,0,208,27,0,0,72,0,0,0,216,27,0,0,73,0,0,0,224,27,0,0,74,0,0,0,232,27,0,0,75,0,0,0,240,27,0,0,76,0,0,0,248,27,0,0,77,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,95,95,105,110,100,101,120,0,98,121,116,101,0,0,0,0,99,104,97,114,0,0,0,0,100,117,109,112,0,0,0,0,102,105,110,100,0,0,0,0,102,111,114,109,97,116,0,0,103,109,97,116,99,104,0,0,103,115,117,98,0,0,0,0,108,101,110,0,0,0,0,0,108,111,119,101,114,0,0,0,109,97,116,99,104,0,0,0,114,101,112,0,0,0,0,0,114,101,118,101,114,115,101,0,115,117,98,0,0,0,0,0,117,112,112,101,114,0,0,0,114,101,115,117,108,116,105,110,103,32,115,116,114,105,110,103,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,116,111,111,32,109,97,110,121,32,99,97,112,116,117,114,101,115,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,99,97,112,116,117,114,101,32,105,110,100,101,120,0,0,0,117,110,102,105,110,105,115,104,101,100,32,99,97,112,116,117,114,101,0,0,0,0,0,0,112,97,116,116,101,114,110,32,116,111,111,32,99,111,109,112,108,101,120,0,0,0,0,0,109,105,115,115,105,110,103,32,39,91,39,32,97,102,116,101,114,32,39,37,37,102,39,32,105,110,32,112,97,116,116,101,114,110,0,0,0,0,0,0,105,110,118,97,108,105,100,32,99,97,112,116,117,114,101,32,105,110,100,101,120,32,37,37,37,100,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,101,110,100,115,32,119,105,116,104,32,39,37,37,39,41,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,109,105,115,115,105,110,103,32,39,93,39,41,0,109,97,108,102,111,114,109,101,100,32,112,97,116,116,101,114,110,32,40,109,105,115,115,105,110,103,32,97,114,103,117,109,101,110,116,115,32,116,111,32,39,37,37,98,39,41,0,0,105,110,118,97,108,105,100,32,112,97,116,116,101,114,110,32,99,97,112,116,117,114,101,0,94,36,42,43,63,46,40,91,37,45,0,0,0,0,0,0,115,116,114,105,110,103,47,102,117,110,99,116,105,111,110,47,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,105,110,118,97,108,105,100,32,114,101,112,108,97,99,101,109,101,110,116,32,118,97,108,117,101,32,40,97,32,37,115,41,0,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,117,115,101,32,111,102,32,39,37,99,39,32,105,110,32,114,101,112,108,97,99,101,109,101,110,116,32,115,116,114,105,110,103,0,0,0,0,0,0,0,110,111,32,118,97,108,117,101,0,0,0,0,0,0,0,0,110,111,116,32,97,32,110,117,109,98,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,0,0,110,111,116,32,97,32,110,111,110,45,110,101,103,97,116,105,118,101,32,110,117,109,98,101,114,32,105,110,32,112,114,111,112,101,114,32,114,97,110,103,101,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,32,39,37,37,37,99,39,32,116,111,32,39,102,111,114,109,97,116,39,0,0,0,0,0,0,0,92,37,100,0,0,0,0,0,92,37,48,51,100,0,0,0,45,43,32,35,48,0,0,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,32,40,114,101,112,101,97,116,101,100,32,102,108,97,103,115,41,0,105,110,118,97,108,105,100,32,102,111,114,109,97,116,32,40,119,105,100,116,104,32,111,114,32,112,114,101,99,105,115,105,111,110,32,116,111,111,32,108,111,110,103,41,0,0,0,0,117,110,97,98,108,101,32,116,111,32,100,117,109,112,32,103,105,118,101,110,32,102,117,110,99,116,105,111,110,0,0,0,118,97,108,117,101,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,115,116,114,105,110,103,32,115,108,105,99,101,32,116,111,111,32,108,111,110,103,0,0,0,116,97,98,108,101,32,105,110,100,101,120,32,105,115,32,110,105,108,0,0,0,0,0,0,116,97,98,108,101,32,105,110,100,101,120,32,105,115,32,78,97,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,116,97,98,108,101,32,111,118,101,114,102,108,111,119,0,0,105,110,118,97,108,105,100,32,107,101,121,32,116,111,32,39,110,101,120,116,39,0,0,0,224,31,0,0,78,0,0,0,232,31,0,0,79,0,0,0,240,31,0,0,80,0,0,0,248,31,0,0,81,0,0,0,216,31,0,0,82,0,0,0,0,32,0,0,83,0,0,0,8,32,0,0,84,0,0,0,0,0,0,0,0,0,0,0,117,110,112,97,99,107,0,0,99,111,110,99,97,116,0,0,109,97,120,110,0,0,0,0,105,110,115,101,114,116,0,0,112,97,99,107,0,0,0,0,114,101,109,111,118,101,0,0,115,111,114,116,0,0,0,0,0,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,114,100,101,114,32,102,117,110,99,116,105,111,110,32,102,111,114,32,115,111,114,116,105,110,103,0,0,0,0,0,0,112,111,115,105,116,105,111,110,32,111,117,116,32,111,102,32,98,111,117,110,100,115,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,117,110,112,97,99,107,0,0,0,0,0,0,110,0,0,0,0,0,0,0,119,114,111,110,103,32,110,117,109,98,101,114,32,111,102,32,97,114,103,117,109,101,110,116,115,32,116,111,32,39,105,110,115,101,114,116,39,0,0,0,105,110,118,97,108,105,100,32,118,97,108,117,101,32,40,37,115,41,32,97,116,32,105,110,100,101,120,32,37,100,32,105,110,32,116,97,98,108,101,32,102,111,114,32,39,99,111,110,99,97,116,39,0,0,0,0,110,111,32,118,97,108,117,101,0,0,0,0,0,0,0,0,110,105,108,0,0,0,0,0,98,111,111,108,101,97,110,0,117,115,101,114,100,97,116,97,0,0,0,0,0,0,0,0,110,117,109,98,101,114,0,0,115,116,114,105,110,103,0,0,116,97,98,108,101,0,0,0,102,117,110,99,116,105,111,110,0,0,0,0,0,0,0,0,116,104,114,101,97,100,0,0,112,114,111,116,111,0,0,0,117,112,118,97,108,0,0,0,224,32,0,0,240,32,0,0,248,32,0,0,0,33,0,0,16,33,0,0,24,33,0,0,32,33,0,0,40,33,0,0,0,33,0,0,56,33,0,0,64,33,0,0,72,33,0,0,200,33,0,0,208,33,0,0,224,33,0,0,232,33,0,0,240,33,0,0,248,33,0,0,0,34,0,0,8,34,0,0,16,34,0,0,24,34,0,0,32,34,0,0,40,34,0,0,48,34,0,0,56,34,0,0,64,34,0,0,72,34,0,0,88,34,0,0,0,0,0,0,95,95,105,110,100,101,120,0,95,95,110,101,119,105,110,100,101,120,0,0,0,0,0,0,95,95,103,99,0,0,0,0,95,95,109,111,100,101,0,0,95,95,108,101,110,0,0,0,95,95,101,113,0,0,0,0,95,95,97,100,100,0,0,0,95,95,115,117,98,0,0,0,95,95,109,117,108,0,0,0,95,95,100,105,118,0,0,0,95,95,109,111,100,0,0,0,95,95,112,111,119,0,0,0,95,95,117,110,109,0,0,0,95,95,108,116,0,0,0,0,95,95,108,101,0,0,0,0,95,95,99,111,110,99,97,116,0,0,0,0,0,0,0,0,95,95,99,97,108,108,0,0,98,105,110,97,114,121,32,115,116,114,105,110,103,0,0,0,25,147,13,10,26,10,0,0,116,114,117,110,99,97,116,101,100,0,0,0,0,0,0,0,37,115,58,32,37,115,32,112,114,101,99,111,109,112,105,108,101,100,32,99,104,117,110,107,0,0,0,0,0,0,0,0,99,111,114,114,117,112,116,101,100,0,0,0,0,0,0,0,110,111,116,32,97,0,0,0,118,101,114,115,105,111,110,32,109,105,115,109,97,116,99,104,32,105,110,0,0,0,0,0,105,110,99,111,109,112,97,116,105,98,108,101,0,0,0,0,37,46,49,52,103,0,0,0,105,110,100,101,120,0,0,0,108,111,111,112,32,105,110,32,103,101,116,116,97,98,108,101,0,0,0,0,0,0,0,0,108,111,111,112,32,105,110,32,115,101,116,116,97,98,108,101,0,0,0,0,0,0,0,0,115,116,114,105,110,103,32,108,101,110,103,116,104,32,111,118,101,114,102,108,111,119,0,0,103,101,116,32,108,101,110,103,116,104,32,111,102,0,0,0,39,102,111,114,39,32,105,110,105,116,105,97,108,32,118,97,108,117,101,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,39,102,111,114,39,32,108,105,109,105,116,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,39,102,111,114,39,32,115,116,101,112,32,109,117,115,116,32,98,101,32,97,32,110,117,109,98,101,114,0,0,0,0,0,95,71,0,0,0,0,0,0,152,36,0,0,85,0,0,0,160,36,0,0,86,0,0,0,176,36,0,0,87,0,0,0,184,36,0,0,88,0,0,0,192,36,0,0,89,0,0,0,208,36,0,0,90,0,0,0,216,36,0,0,91,0,0,0,232,36,0,0,92,0,0,0,240,36,0,0,92,0,0,0,0,37,0,0,93,0,0,0,8,37,0,0,94,0,0,0,16,37,0,0,95,0,0,0,24,37,0,0,96,0,0,0,32,37,0,0,97,0,0,0,48,37,0,0,98,0,0,0,56,37,0,0,99,0,0,0,64,37,0,0,100,0,0,0,72,37,0,0,101,0,0,0,80,37,0,0,102,0,0,0,96,37,0,0,103,0,0,0,112,37,0,0,104,0,0,0,128,37,0,0,105,0,0,0,136,37,0,0,106,0,0,0,0,0,0,0,0,0,0,0,76,117,97,32,53,46,50,0,95,86,69,82,83,73,79,78,0,0,0,0,0,0,0,0,97,115,115,101,114,116,0,0,99,111,108,108,101,99,116,103,97,114,98,97,103,101,0,0,100,111,102,105,108,101,0,0,101,114,114,111,114,0,0,0,103,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,105,112,97,105,114,115,0,0,108,111,97,100,102,105,108,101,0,0,0,0,0,0,0,0,108,111,97,100,0,0,0,0,108,111,97,100,115,116,114,105,110,103,0,0,0,0,0,0,110,101,120,116,0,0,0,0,112,97,105,114,115,0,0,0,112,99,97,108,108,0,0,0,112,114,105,110,116,0,0,0,114,97,119,101,113,117,97,108,0,0,0,0,0,0,0,0,114,97,119,108,101,110,0,0,114,97,119,103,101,116,0,0,114,97,119,115,101,116,0,0,115,101,108,101,99,116,0,0,115,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,116,111,110,117,109,98,101,114,0,0,0,0,0,0,0,0,116,111,115,116,114,105,110,103,0,0,0,0,0,0,0,0,116,121,112,101,0,0,0,0,120,112,99,97,108,108,0,0,118,97,108,117,101,32,101,120,112,101,99,116,101,100,0,0,115,116,97,99,107,32,111,118,101,114,102,108,111,119,0,0,98,97,115,101,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,0,32,12,10,13,9,11,0,0,110,105,108,32,111,114,32,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,0,95,95,109,101,116,97,116,97,98,108,101,0,0,0,0,0,99,97,110,110,111,116,32,99,104,97,110,103,101,32,97,32,112,114,111,116,101,99,116,101,100,32,109,101,116,97,116,97,98,108,101,0,0,0,0,0,105,110,100,101,120,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,116,97,98,108,101,32,111,114,32,115,116,114,105,110,103,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,0,0,39,116,111,115,116,114,105,110,103,39,32,109,117,115,116,32,114,101,116,117,114,110,32,97,32,115,116,114,105,110,103,32,116,111,32,39,112,114,105,110,116,39,0,0,0,0,0,0,95,95,112,97,105,114,115,0,98,116,0,0,0,0,0,0,61,40,108,111,97,100,41,0,116,111,111,32,109,97,110,121,32,110,101,115,116,101,100,32,102,117,110,99,116,105,111,110,115,0,0,0,0,0,0,0,114,101,97,100,101,114,32,102,117,110,99,116,105,111,110,32,109,117,115,116,32,114,101,116,117,114,110,32,97,32,115,116,114,105,110,103,0,0,0,0,95,95,105,112,97,105,114,115,0,0,0,0,0,0,0,0,40,39,0,0,48,39,0,0,56,39,0,0,64,39,0,0,72,39,0,0,80,39,0,0,96,39,0,0,112,39,0,0,128,39,0,0,144,39,0,0,160,39,0,0,0,0,0,0,115,116,111,112,0,0,0,0,114,101,115,116,97,114,116,0,99,111,108,108,101,99,116,0,99,111,117,110,116,0,0,0,115,116,101,112,0,0,0,0,115,101,116,112,97,117,115,101,0,0,0,0,0,0,0,0,115,101,116,115,116,101,112,109,117,108,0,0,0,0,0,0,115,101,116,109,97,106,111,114,105,110,99,0,0,0,0,0,105,115,114,117,110,110,105,110,103,0,0,0,0,0,0,0,103,101,110,101,114,97,116,105,111,110,97,108,0,0,0,0,105,110,99,114,101,109,101,110,116,97,108,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,3,0,0,0,5,0,0,0,6,0,0,0,7,0,0,0,8,0,0,0,9,0,0,0,10,0,0,0,11,0,0,0,0,0,0,0,37,115,0,0,0,0,0,0,97,115,115,101,114,116,105,111,110,32,102,97,105,108,101,100,33,0,0,0,0,0,0,0,104,40,0,0,107], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+/* memory initializer */ allocate([112,40,0,0,108,0,0,0,120,40,0,0,109,0,0,0,128,40,0,0,110,0,0,0,136,40,0,0,111,0,0,0,144,40,0,0,112,0,0,0,152,40,0,0,113,0,0,0,160,40,0,0,114,0,0,0,168,40,0,0,115,0,0,0,176,40,0,0,116,0,0,0,184,40,0,0,117,0,0,0,192,40,0,0,118,0,0,0,0,0,0,0,0,0,0,0,97,114,115,104,105,102,116,0,98,97,110,100,0,0,0,0,98,110,111,116,0,0,0,0,98,111,114,0,0,0,0,0,98,120,111,114,0,0,0,0,98,116,101,115,116,0,0,0,101,120,116,114,97,99,116,0,108,114,111,116,97,116,101,0,108,115,104,105,102,116,0,0,114,101,112,108,97,99,101,0,114,114,111,116,97,116,101,0,114,115,104,105,102,116,0,0,102,105,101,108,100,32,99,97,110,110,111,116,32,98,101,32,110,101,103,97,116,105,118,101,0,0,0,0,0,0,0,0,119,105,100,116,104,32,109,117,115,116,32,98,101,32,112,111,115,105,116,105,118,101,0,0,116,114,121,105,110,103,32,116,111,32,97,99,99,101,115,115,32,110,111,110,45,101,120,105,115,116,101,110,116,32,98,105,116,115,0,0,0,0,0,0,102,117,110,99,116,105,111,110,32,111,114,32,101,120,112,114,101,115,115,105,111,110,32,116,111,111,32,99,111,109,112,108,101,120,0,0,0,0,0,0,99,111,110,115,116,114,117,99,116,111,114,32,116,111,111,32,108,111,110,103,0,0,0,0,99,111,110,115,116,97,110,116,115,0,0,0,0,0,0,0,111,112,99,111,100,101,115,0,99,111,110,116,114,111,108,32,115,116,114,117,99,116,117,114,101,32,116,111,111,32,108,111,110,103,0,0,0,0,0,0,216,41,0,0,119,0,0,0,224,41,0,0,120,0,0,0,232,41,0,0,121,0,0,0,240,41,0,0,122,0,0,0,248,41,0,0,123,0,0,0,0,42,0,0,124,0,0,0,0,0,0,0,0,0,0,0,99,114,101,97,116,101,0,0,114,101,115,117,109,101,0,0,114,117,110,110,105,110,103,0,115,116,97,116,117,115,0,0,119,114,97,112,0,0,0,0,121,105,101,108,100,0,0,0,116,111,111,32,109,97,110,121,32,97,114,103,117,109,101,110,116,115,32,116,111,32,114,101,115,117,109,101,0,0,0,0,99,97,110,110,111,116,32,114,101,115,117,109,101,32,100,101,97,100,32,99,111,114,111,117,116,105,110,101,0,0,0,0,116,111,111,32,109,97,110,121,32,114,101,115,117,108,116,115,32,116,111,32,114,101,115,117,109,101,0,0,0,0,0,0,99,111,114,111,117,116,105,110,101,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,115,117,115,112,101,110,100,101,100,0,0,0,0,0,0,0,110,111,114,109,97,108,0,0,100,101,97,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,8,8,8,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,22,22,22,22,22,22,22,22,22,22,4,4,4,4,4,4,4,21,21,21,21,21,21,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4,4,4,4,5,4,21,21,21,21,21,21,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,44,0,0,125,0,0,0,56,44,0,0,126,0,0,0,72,44,0,0,127,0,0,0,80,44,0,0,128,0,0,0,88,44,0,0,129,0,0,0,104,44,0,0,130,0,0,0,120,44,0,0,131,0,0,0,136,44,0,0,132,0,0,0,152,44,0,0,133,0,0,0,168,44,0,0,134,0,0,0,184,44,0,0,135,0,0,0,200,44,0,0,136,0,0,0,208,44,0,0,137,0,0,0,224,44,0,0,138,0,0,0,240,44,0,0,139,0,0,0,0,45,0,0,140,0,0,0,0,0,0,0,0,0,0,0,100,101,98,117,103,0,0,0,103,101,116,117,115,101,114,118,97,108,117,101,0,0,0,0,103,101,116,104,111,111,107,0,103,101,116,105,110,102,111,0,103,101,116,108,111,99,97,108,0,0,0,0,0,0,0,0,103,101,116,114,101,103,105,115,116,114,121,0,0,0,0,0,103,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,103,101,116,117,112,118,97,108,117,101,0,0,0,0,0,0,117,112,118,97,108,117,101,106,111,105,110,0,0,0,0,0,117,112,118,97,108,117,101,105,100,0,0,0,0,0,0,0,115,101,116,117,115,101,114,118,97,108,117,101,0,0,0,0,115,101,116,104,111,111,107,0,115,101,116,108,111,99,97,108,0,0,0,0,0,0,0,0,115,101,116,109,101,116,97,116,97,98,108,101,0,0,0,0,115,101,116,117,112,118,97,108,117,101,0,0,0,0,0,0,116,114,97,99,101,98,97,99,107,0,0,0,0,0,0,0,110,105,108,32,111,114,32,116,97,98,108,101,32,101,120,112,101,99,116,101,100,0,0,0,108,101,118,101,108,32,111,117,116,32,111,102,32,114,97,110,103,101,0,0,0,0,0,0,95,72,75,69,89,0,0,0,107,0,0,0,0,0,0,0,95,95,109,111,100,101,0,0,112,45,0,0,120,45,0,0,128,45,0,0,136,45,0,0,144,45,0,0,0,0,0,0,99,97,108,108,0,0,0,0,114,101,116,117,114,110,0,0,108,105,110,101,0,0,0,0,99,111,117,110,116,0,0,0,116,97,105,108,32,99,97,108,108,0,0,0,0,0,0,0,102,117,108,108,32,117,115,101,114,100,97,116,97,32,101,120,112,101,99,116,101,100,44,32,103,111,116,32,108,105,103,104,116,32,117,115,101,114,100,97,116,97,0,0,0,0,0,0,62,117,0,0,0,0,0,0,105,110,118,97,108,105,100,32,117,112,118,97,108,117,101,32,105,110,100,101,120,0,0,0,76,117,97,32,102,117,110,99,116,105,111,110,32,101,120,112,101,99,116,101,100,0,0,0,102,108,110,83,116,117,0,0,62,37,115,0,0,0,0,0,102,117,110,99,116,105,111,110,32,111,114,32,108,101,118,101,108,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,105,110,118,97,108,105,100,32,111,112,116,105,111,110,0,0,115,111,117,114,99,101,0,0,115,104,111,114,116,95,115,114,99,0,0,0,0,0,0,0,108,105,110,101,100,101,102,105,110,101,100,0,0,0,0,0,108,97,115,116,108,105,110,101,100,101,102,105,110,101,100,0,119,104,97,116,0,0,0,0,99,117,114,114,101,110,116,108,105,110,101,0,0,0,0,0,110,117,112,115,0,0,0,0,110,112,97,114,97,109,115,0,105,115,118,97,114,97,114,103,0,0,0,0,0,0,0,0,110,97,109,101,0,0,0,0,110,97,109,101,119,104,97,116,0,0,0,0,0,0,0,0,105,115,116,97,105,108,99,97,108,108,0,0,0,0,0,0,97,99,116,105,118,101,108,105,110,101,115,0,0,0,0,0,102,117,110,99,0,0,0,0,101,120,116,101,114,110,97,108,32,104,111,111,107,0,0,0,108,117,97,95,100,101,98,117,103,62,32,0,0,0,0,0,99,111,110,116,10,0,0,0,61,40,100,101,98,117,103,32,99,111,109,109,97,110,100,41,0,0,0,0,0,0,0,0,37,115,10,0,0,0,0,0,80,49,0,0,88,49,0,0,96,49,0,0,104,49,0,0,112,49,0,0,120,49,0,0,128,49,0,0,136,49,0,0,144,49,0,0,160,49,0,0,168,49,0,0,176,49,0,0,184,49,0,0,192,49,0,0,200,49,0,0,208,49,0,0,216,49,0,0,224,49,0,0,232,49,0,0,240,49,0,0,248,49,0,0,0,50,0,0,8,50,0,0,16,50,0,0,24,50,0,0,32,50,0,0,40,50,0,0,48,50,0,0,56,50,0,0,64,50,0,0,72,50,0,0,88,50,0,0,96,50,0,0,0,0,0,0,39,37,99,39,0,0,0,0,99,104,97,114,40,37,100,41,0,0,0,0,0,0,0,0,39,37,115,39,0,0,0,0,95,69,78,86,0,0,0,0,105,110,118,97,108,105,100,32,108,111,110,103,32,115,116,114,105,110,103,32,100,101,108,105,109,105,116,101,114,0,0,0,46,0,0,0,0,0,0,0,69,101,0,0,0,0,0,0,88,120,0,0,0,0,0,0,80,112,0,0,0,0,0,0,43,45,0,0,0,0,0,0,109,97,108,102,111,114,109,101,100,32,110,117,109,98,101,114,0,0,0,0,0,0,0,0,108,101,120,105,99,97,108,32,101,108,101,109,101,110,116,32,116,111,111,32,108,111,110,103,0,0,0,0,0,0,0,0,117,110,102,105,110,105,115,104,101,100,32,115,116,114,105,110,103,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,101,115,99,97,112,101,32,115,101,113,117,101,110,99,101,0,100,101,99,105,109,97,108,32,101,115,99,97,112,101,32,116,111,111,32,108,97,114,103,101,0,0,0,0,0,0,0,0,104,101,120,97,100,101,99,105,109,97,108,32,100,105,103,105,116,32,101,120,112,101,99,116,101,100,0,0,0,0,0,0,117,110,102,105,110,105,115,104,101,100,32,108,111,110,103,32,115,116,114,105,110,103,0,0,117,110,102,105,110,105,115,104,101,100,32,108,111,110,103,32,99,111,109,109,101,110,116,0,99,104,117,110,107,32,104,97,115,32,116,111,111,32,109,97,110,121,32,108,105,110,101,115,0,0,0,0,0,0,0,0,37,115,58,37,100,58,32,37,115,0,0,0,0,0,0,0,37,115,32,110,101,97,114,32,37,115,0,0,0,0,0,0,97,110,100,0,0,0,0,0,98,114,101,97,107,0,0,0,100,111,0,0,0,0,0,0,101,108,115,101,0,0,0,0,101,108,115,101,105,102,0,0,101,110,100,0,0,0,0,0,102,97,108,115,101,0,0,0,102,111,114,0,0,0,0,0,102,117,110,99,116,105,111,110,0,0,0,0,0,0,0,0,103,111,116,111,0,0,0,0,105,102,0,0,0,0,0,0,105,110,0,0,0,0,0,0,108,111,99,97,108,0,0,0,110,105,108,0,0,0,0,0,110,111,116,0,0,0,0,0,111,114,0,0,0,0,0,0,114,101,112,101,97,116,0,0,114,101,116,117,114,110,0,0,116,104,101,110,0,0,0,0,116,114,117,101,0,0,0,0,117,110,116,105,108,0,0,0,119,104,105,108,101,0,0,0,46,46,0,0,0,0,0,0,46,46,46,0,0,0,0,0,61,61,0,0,0,0,0,0,62,61,0,0,0,0,0,0,60,61,0,0,0,0,0,0,126,61,0,0,0,0,0,0,58,58,0,0,0,0,0,0,60,101,111,102,62,0,0,0,60,110,117,109,98,101,114,62,0,0,0,0,0,0,0,0,60,110,97,109,101,62,0,0,60,115,116,114,105,110,103,62,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,105,110,102,105,110,105,116,121,0,0,0,0,0,0,0,0,110,97,110,0,0,0,0,0,95,112,137,0,255,9,47,15,10,0,0,0,100,0,0,0,232,3,0,0,16,39,0,0,160,134,1,0,64,66,15,0,128,150,152,0,0,225,245,5], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE+10240);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+
+
+ Module["_rand_r"] = _rand_r;
+
+ var ___rand_seed=allocate([0x0273459b, 0, 0, 0], "i32", ALLOC_STATIC);
+ Module["_rand"] = _rand;
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+ function _lseek(fildes, offset, whence) {
+ // off_t lseek(int fildes, off_t offset, int whence);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/lseek.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ return FS.llseek(stream, offset, whence);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fseek(stream, offset, whence) {
+ // int fseek(FILE *stream, long offset, int whence);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fseek.html
+ var fd = _fileno(stream);
+ var ret = _lseek(fd, offset, whence);
+ if (ret == -1) {
+ return -1;
+ }
+ stream = FS.getStreamFromPtr(stream);
+ stream.eof = false;
+ return 0;
+ }
+
+
+ Module["_i64Subtract"] = _i64Subtract;
+
+
+ Module["_i64Add"] = _i64Add;
+
+ function _setlocale(category, locale) {
+ if (!_setlocale.ret) _setlocale.ret = allocate([0], 'i8', ALLOC_NORMAL);
+ return _setlocale.ret;
+ }
+
+
+ function _close(fildes) {
+ // int close(int fildes);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/close.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ FS.close(stream);
+ return 0;
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fsync(fildes) {
+ // int fsync(int fildes);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fsync.html
+ var stream = FS.getStream(fildes);
+ if (stream) {
+ // We write directly to the file system, so there's nothing to do here.
+ return 0;
+ } else {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ }function _fclose(stream) {
+ // int fclose(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fclose.html
+ var fd = _fileno(stream);
+ _fsync(fd);
+ return _close(fd);
+ }
+
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _recv(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _read(fd, buf, len);
+ }
+
+ function _pread(fildes, buf, nbyte, offset) {
+ // ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.read(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _read(fildes, buf, nbyte) {
+ // ssize_t read(int fildes, void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/read.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.read(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _fread(ptr, size, nitems, stream) {
+ // size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html
+ var bytesToRead = nitems * size;
+ if (bytesToRead == 0) {
+ return 0;
+ }
+ var bytesRead = 0;
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (!streamObj) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return 0;
+ }
+ while (streamObj.ungotten.length && bytesToRead > 0) {
+ HEAP8[((ptr++)|0)]=streamObj.ungotten.pop();
+ bytesToRead--;
+ bytesRead++;
+ }
+ var err = _read(streamObj.fd, ptr, bytesToRead);
+ if (err == -1) {
+ if (streamObj) streamObj.error = true;
+ return 0;
+ }
+ bytesRead += err;
+ if (bytesRead < bytesToRead) streamObj.eof = true;
+ return Math.floor(bytesRead / size);
+ }
+
+ function _toupper(chr) {
+ if (chr >= 97 && chr <= 122) {
+ return chr - 97 + 65;
+ } else {
+ return chr;
+ }
+ }
+
+
+
+ function _open(path, oflag, varargs) {
+ // int open(const char *path, int oflag, ...);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/open.html
+ var mode = HEAP32[((varargs)>>2)];
+ path = Pointer_stringify(path);
+ try {
+ var stream = FS.open(path, oflag, mode);
+ return stream.fd;
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _fopen(filename, mode) {
+ // FILE *fopen(const char *restrict filename, const char *restrict mode);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fopen.html
+ var flags;
+ mode = Pointer_stringify(mode);
+ if (mode[0] == 'r') {
+ if (mode.indexOf('+') != -1) {
+ flags = 2;
+ } else {
+ flags = 0;
+ }
+ } else if (mode[0] == 'w') {
+ if (mode.indexOf('+') != -1) {
+ flags = 2;
+ } else {
+ flags = 1;
+ }
+ flags |= 64;
+ flags |= 512;
+ } else if (mode[0] == 'a') {
+ if (mode.indexOf('+') != -1) {
+ flags = 2;
+ } else {
+ flags = 1;
+ }
+ flags |= 64;
+ flags |= 1024;
+ } else {
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return 0;
+ }
+ var fd = _open(filename, flags, allocate([0x1FF, 0, 0, 0], 'i32', ALLOC_STACK)); // All creation permissions.
+ return fd === -1 ? 0 : FS.getPtrForStream(FS.getStream(fd));
+ }
+
+ var _emscripten_check_longjmp=true;
+
+
+
+ function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret)|0)]=chr;
+ var fd = _fileno(stream);
+ var ret = _write(fd, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+ }
+
+ var _log=Math_log;
+
+ var _emscripten_postinvoke=true;
+
+
+ function _putchar(c) {
+ // int putchar(int c);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/putchar.html
+ return _fputc(c, HEAP32[((_stdout)>>2)]);
+ }
+ Module["_saveSetjmp"] = _saveSetjmp;
+
+ function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+ function _system(command) {
+ // int system(const char *command);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/system.html
+ // Can't call external programs.
+ ___setErrNo(ERRNO_CODES.EAGAIN);
+ return -1;
+ }
+
+ function _frexp(x, exp_addr) {
+ var sig = 0, exp_ = 0;
+ if (x !== 0) {
+ var sign = 1;
+ if (x < 0) {
+ x = -x;
+ sign = -1;
+ }
+ var raw_exp = Math.log(x)/Math.log(2);
+ exp_ = Math.ceil(raw_exp);
+ if (exp_ === raw_exp) exp_ += 1;
+ sig = sign*x/Math.pow(2, exp_);
+ }
+ HEAP32[((exp_addr)>>2)]=exp_;
+ return sig;
+ }
+
+
+
+ var _tzname=allocate(8, "i32*", ALLOC_STATIC);
+
+ var _daylight=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _timezone=allocate(1, "i32*", ALLOC_STATIC);function _tzset() {
+ // TODO: Use (malleable) environment variables instead of system settings.
+ if (_tzset.called) return;
+ _tzset.called = true;
+
+ HEAP32[((_timezone)>>2)]=-(new Date()).getTimezoneOffset() * 60;
+
+ var winter = new Date(2000, 0, 1);
+ var summer = new Date(2000, 6, 1);
+ HEAP32[((_daylight)>>2)]=Number(winter.getTimezoneOffset() != summer.getTimezoneOffset());
+
+ var winterName = 'GMT'; // XXX do not rely on browser timezone info, it is very unpredictable | winter.toString().match(/\(([A-Z]+)\)/)[1];
+ var summerName = 'GMT'; // XXX do not rely on browser timezone info, it is very unpredictable | summer.toString().match(/\(([A-Z]+)\)/)[1];
+ var winterNamePtr = allocate(intArrayFromString(winterName), 'i8', ALLOC_NORMAL);
+ var summerNamePtr = allocate(intArrayFromString(summerName), 'i8', ALLOC_NORMAL);
+ HEAP32[((_tzname)>>2)]=winterNamePtr;
+ HEAP32[(((_tzname)+(4))>>2)]=summerNamePtr;
+ }function _mktime(tmPtr) {
+ _tzset();
+ var year = HEAP32[(((tmPtr)+(20))>>2)];
+ var timestamp = new Date(year >= 1900 ? year : year + 1900,
+ HEAP32[(((tmPtr)+(16))>>2)],
+ HEAP32[(((tmPtr)+(12))>>2)],
+ HEAP32[(((tmPtr)+(8))>>2)],
+ HEAP32[(((tmPtr)+(4))>>2)],
+ HEAP32[((tmPtr)>>2)],
+ 0).getTime() / 1000;
+ HEAP32[(((tmPtr)+(24))>>2)]=new Date(timestamp).getDay();
+ var yday = Math.round((timestamp - (new Date(year, 0, 1)).getTime()) / (1000 * 60 * 60 * 24));
+ HEAP32[(((tmPtr)+(28))>>2)]=yday;
+ return timestamp;
+ }
+
+ function _isalpha(chr) {
+ return (chr >= 97 && chr <= 122) ||
+ (chr >= 65 && chr <= 90);
+ }
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;function _tmpnam(s, dir, prefix) {
+ // char *tmpnam(char *s);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/tmpnam.html
+ // NOTE: The dir and prefix arguments are for internal use only.
+ var folder = FS.findObject(dir || '/tmp');
+ if (!folder || !folder.isFolder) {
+ dir = '/tmp';
+ folder = FS.findObject(dir);
+ if (!folder || !folder.isFolder) return 0;
+ }
+ var name = prefix || 'file';
+ do {
+ name += String.fromCharCode(65 + Math.floor(Math.random() * 25));
+ } while (name in folder.contents);
+ var result = dir + '/' + name;
+ if (!_tmpnam.buffer) _tmpnam.buffer = _malloc(256);
+ if (!s) s = _tmpnam.buffer;
+ writeAsciiToMemory(result, s);
+ return s;
+ }
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _log10(x) {
+ return Math.log(x) / Math.LN10;
+ }
+
+ function _isspace(chr) {
+ return (chr == 32) || (chr >= 9 && chr <= 13);
+ }
+
+
+ var ___tm_current=allocate(44, "i8", ALLOC_STATIC);
+
+
+ var ___tm_timezone=allocate(intArrayFromString("GMT"), "i8", ALLOC_STATIC);function _localtime_r(time, tmPtr) {
+ _tzset();
+ var date = new Date(HEAP32[((time)>>2)]*1000);
+ HEAP32[((tmPtr)>>2)]=date.getSeconds();
+ HEAP32[(((tmPtr)+(4))>>2)]=date.getMinutes();
+ HEAP32[(((tmPtr)+(8))>>2)]=date.getHours();
+ HEAP32[(((tmPtr)+(12))>>2)]=date.getDate();
+ HEAP32[(((tmPtr)+(16))>>2)]=date.getMonth();
+ HEAP32[(((tmPtr)+(20))>>2)]=date.getFullYear()-1900;
+ HEAP32[(((tmPtr)+(24))>>2)]=date.getDay();
+
+ var start = new Date(date.getFullYear(), 0, 1);
+ var yday = Math.floor((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
+ HEAP32[(((tmPtr)+(28))>>2)]=yday;
+ HEAP32[(((tmPtr)+(36))>>2)]=start.getTimezoneOffset() * 60;
+
+ var dst = Number(start.getTimezoneOffset() != date.getTimezoneOffset());
+ HEAP32[(((tmPtr)+(32))>>2)]=dst;
+
+ HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
+
+ return tmPtr;
+ }function _localtime(time) {
+ return _localtime_r(time, ___tm_current);
+ }
+
+ function _srand(seed) {
+ HEAP32[((___rand_seed)>>2)]=seed
+ }
+
+ var _emscripten_prep_setjmp=true;
+
+
+
+
+ Module["_testSetjmp"] = _testSetjmp;function _longjmp(env, value) {
+ asm['setThrew'](env, value || 1);
+ throw 'longjmp';
+ }function _emscripten_longjmp(env, value) {
+ _longjmp(env, value);
+ }
+
+ var _ceil=Math_ceil;
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+ var _llvm_pow_f64=Math_pow;
+
+
+
+ Module["_strlen"] = _strlen;function _fputs(s, stream) {
+ // int fputs(const char *restrict s, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
+ var fd = _fileno(stream);
+ return _write(fd, s, _strlen(s));
+ }
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+
+ function _sinh(x) {
+ var p = Math.pow(Math.E, x);
+ return (p - (1 / p)) / 2;
+ }
+
+ function _cosh(x) {
+ var p = Math.pow(Math.E, x);
+ return (p + (1 / p)) / 2;
+ }function _tanh(x) {
+ return _sinh(x) / _cosh(x);
+ }
+
+ function _signal(sig, func) {
+ // TODO
+ return 0;
+ }
+
+
+
+ function __getFloat(text) {
+ return /^[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?/.exec(text);
+ }function __scanString(format, get, unget, varargs) {
+ if (!__scanString.whiteSpace) {
+ __scanString.whiteSpace = {};
+ __scanString.whiteSpace[32] = 1;
+ __scanString.whiteSpace[9] = 1;
+ __scanString.whiteSpace[10] = 1;
+ __scanString.whiteSpace[11] = 1;
+ __scanString.whiteSpace[12] = 1;
+ __scanString.whiteSpace[13] = 1;
+ }
+ // Supports %x, %4x, %d.%d, %lld, %s, %f, %lf.
+ // TODO: Support all format specifiers.
+ format = Pointer_stringify(format);
+ var soFar = 0;
+ if (format.indexOf('%n') >= 0) {
+ // need to track soFar
+ var _get = get;
+ get = function get() {
+ soFar++;
+ return _get();
+ }
+ var _unget = unget;
+ unget = function unget() {
+ soFar--;
+ return _unget();
+ }
+ }
+ var formatIndex = 0;
+ var argsi = 0;
+ var fields = 0;
+ var argIndex = 0;
+ var next;
+
+ mainLoop:
+ for (var formatIndex = 0; formatIndex < format.length;) {
+ if (format[formatIndex] === '%' && format[formatIndex+1] == 'n') {
+ var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
+ argIndex += Runtime.getAlignSize('void*', null, true);
+ HEAP32[((argPtr)>>2)]=soFar;
+ formatIndex += 2;
+ continue;
+ }
+
+ if (format[formatIndex] === '%') {
+ var nextC = format.indexOf('c', formatIndex+1);
+ if (nextC > 0) {
+ var maxx = 1;
+ if (nextC > formatIndex+1) {
+ var sub = format.substring(formatIndex+1, nextC);
+ maxx = parseInt(sub);
+ if (maxx != sub) maxx = 0;
+ }
+ if (maxx) {
+ var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
+ argIndex += Runtime.getAlignSize('void*', null, true);
+ fields++;
+ for (var i = 0; i < maxx; i++) {
+ next = get();
+ HEAP8[((argPtr++)|0)]=next;
+ if (next === 0) return i > 0 ? fields : fields-1; // we failed to read the full length of this field
+ }
+ formatIndex += nextC - formatIndex + 1;
+ continue;
+ }
+ }
+ }
+
+ // handle %[...]
+ if (format[formatIndex] === '%' && format.indexOf('[', formatIndex+1) > 0) {
+ var match = /\%([0-9]*)\[(\^)?(\]?[^\]]*)\]/.exec(format.substring(formatIndex));
+ if (match) {
+ var maxNumCharacters = parseInt(match[1]) || Infinity;
+ var negateScanList = (match[2] === '^');
+ var scanList = match[3];
+
+ // expand "middle" dashs into character sets
+ var middleDashMatch;
+ while ((middleDashMatch = /([^\-])\-([^\-])/.exec(scanList))) {
+ var rangeStartCharCode = middleDashMatch[1].charCodeAt(0);
+ var rangeEndCharCode = middleDashMatch[2].charCodeAt(0);
+ for (var expanded = ''; rangeStartCharCode <= rangeEndCharCode; expanded += String.fromCharCode(rangeStartCharCode++));
+ scanList = scanList.replace(middleDashMatch[1] + '-' + middleDashMatch[2], expanded);
+ }
+
+ var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
+ argIndex += Runtime.getAlignSize('void*', null, true);
+ fields++;
+
+ for (var i = 0; i < maxNumCharacters; i++) {
+ next = get();
+ if (negateScanList) {
+ if (scanList.indexOf(String.fromCharCode(next)) < 0) {
+ HEAP8[((argPtr++)|0)]=next;
+ } else {
+ unget();
+ break;
+ }
+ } else {
+ if (scanList.indexOf(String.fromCharCode(next)) >= 0) {
+ HEAP8[((argPtr++)|0)]=next;
+ } else {
+ unget();
+ break;
+ }
+ }
+ }
+
+ // write out null-terminating character
+ HEAP8[((argPtr++)|0)]=0;
+ formatIndex += match[0].length;
+
+ continue;
+ }
+ }
+ // remove whitespace
+ while (1) {
+ next = get();
+ if (next == 0) return fields;
+ if (!(next in __scanString.whiteSpace)) break;
+ }
+ unget();
+
+ if (format[formatIndex] === '%') {
+ formatIndex++;
+ var suppressAssignment = false;
+ if (format[formatIndex] == '*') {
+ suppressAssignment = true;
+ formatIndex++;
+ }
+ var maxSpecifierStart = formatIndex;
+ while (format[formatIndex].charCodeAt(0) >= 48 &&
+ format[formatIndex].charCodeAt(0) <= 57) {
+ formatIndex++;
+ }
+ var max_;
+ if (formatIndex != maxSpecifierStart) {
+ max_ = parseInt(format.slice(maxSpecifierStart, formatIndex), 10);
+ }
+ var long_ = false;
+ var half = false;
+ var longLong = false;
+ if (format[formatIndex] == 'l') {
+ long_ = true;
+ formatIndex++;
+ if (format[formatIndex] == 'l') {
+ longLong = true;
+ formatIndex++;
+ }
+ } else if (format[formatIndex] == 'h') {
+ half = true;
+ formatIndex++;
+ }
+ var type = format[formatIndex];
+ formatIndex++;
+ var curr = 0;
+ var buffer = [];
+ // Read characters according to the format. floats are trickier, they may be in an unfloat state in the middle, then be a valid float later
+ if (type == 'f' || type == 'e' || type == 'g' ||
+ type == 'F' || type == 'E' || type == 'G') {
+ next = get();
+ while (next > 0 && (!(next in __scanString.whiteSpace))) {
+ buffer.push(String.fromCharCode(next));
+ next = get();
+ }
+ var m = __getFloat(buffer.join(''));
+ var last = m ? m[0].length : 0;
+ for (var i = 0; i < buffer.length - last + 1; i++) {
+ unget();
+ }
+ buffer.length = last;
+ } else {
+ next = get();
+ var first = true;
+
+ // Strip the optional 0x prefix for %x.
+ if ((type == 'x' || type == 'X') && (next == 48)) {
+ var peek = get();
+ if (peek == 120 || peek == 88) {
+ next = get();
+ } else {
+ unget();
+ }
+ }
+
+ while ((curr < max_ || isNaN(max_)) && next > 0) {
+ if (!(next in __scanString.whiteSpace) && // stop on whitespace
+ (type == 's' ||
+ ((type === 'd' || type == 'u' || type == 'i') && ((next >= 48 && next <= 57) ||
+ (first && next == 45))) ||
+ ((type === 'x' || type === 'X') && (next >= 48 && next <= 57 ||
+ next >= 97 && next <= 102 ||
+ next >= 65 && next <= 70))) &&
+ (formatIndex >= format.length || next !== format[formatIndex].charCodeAt(0))) { // Stop when we read something that is coming up
+ buffer.push(String.fromCharCode(next));
+ next = get();
+ curr++;
+ first = false;
+ } else {
+ break;
+ }
+ }
+ unget();
+ }
+ if (buffer.length === 0) return 0; // Failure.
+ if (suppressAssignment) continue;
+
+ var text = buffer.join('');
+ var argPtr = HEAP32[(((varargs)+(argIndex))>>2)];
+ argIndex += Runtime.getAlignSize('void*', null, true);
+ switch (type) {
+ case 'd': case 'u': case 'i':
+ if (half) {
+ HEAP16[((argPtr)>>1)]=parseInt(text, 10);
+ } else if (longLong) {
+ (tempI64 = [parseInt(text, 10)>>>0,(tempDouble=parseInt(text, 10),(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((argPtr)>>2)]=tempI64[0],HEAP32[(((argPtr)+(4))>>2)]=tempI64[1]);
+ } else {
+ HEAP32[((argPtr)>>2)]=parseInt(text, 10);
+ }
+ break;
+ case 'X':
+ case 'x':
+ HEAP32[((argPtr)>>2)]=parseInt(text, 16);
+ break;
+ case 'F':
+ case 'f':
+ case 'E':
+ case 'e':
+ case 'G':
+ case 'g':
+ case 'E':
+ // fallthrough intended
+ if (long_) {
+ HEAPF64[((argPtr)>>3)]=parseFloat(text);
+ } else {
+ HEAPF32[((argPtr)>>2)]=parseFloat(text);
+ }
+ break;
+ case 's':
+ var array = intArrayFromString(text);
+ for (var j = 0; j < array.length; j++) {
+ HEAP8[(((argPtr)+(j))|0)]=array[j];
+ }
+ break;
+ }
+ fields++;
+ } else if (format[formatIndex].charCodeAt(0) in __scanString.whiteSpace) {
+ next = get();
+ while (next in __scanString.whiteSpace) {
+ if (next <= 0) break mainLoop; // End of input.
+ next = get();
+ }
+ unget(next);
+ formatIndex++;
+ } else {
+ // Not a specifier.
+ next = get();
+ if (format[formatIndex].charCodeAt(0) !== next) {
+ unget(next);
+ break mainLoop;
+ }
+ formatIndex++;
+ }
+ }
+ return fields;
+ }
+
+ function _fgetc(stream) {
+ // int fgetc(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fgetc.html
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (!streamObj) return -1;
+ if (streamObj.eof || streamObj.error) return -1;
+ var ret = _fread(_fgetc.ret, 1, 1, stream);
+ if (ret == 0) {
+ return -1;
+ } else if (ret == -1) {
+ streamObj.error = true;
+ return -1;
+ } else {
+ return HEAPU8[((_fgetc.ret)|0)];
+ }
+ }
+
+ function _ungetc(c, stream) {
+ // int ungetc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/ungetc.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) {
+ return -1;
+ }
+ if (c === -1) {
+ // do nothing for EOF character
+ return c;
+ }
+ c = unSign(c & 0xFF);
+ stream.ungotten.push(c);
+ stream.eof = false;
+ return c;
+ }function _fscanf(stream, format, varargs) {
+ // int fscanf(FILE *restrict stream, const char *restrict format, ... );
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/scanf.html
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (!streamObj) {
+ return -1;
+ }
+ var buffer = [];
+ function get() {
+ var c = _fgetc(stream);
+ buffer.push(c);
+ return c;
+ };
+ function unget() {
+ _ungetc(buffer.pop(), stream);
+ };
+ return __scanString(format, get, unget, varargs);
+ }
+
+ var _emscripten_preinvoke=true;
+
+ function _localeconv() {
+ // %struct.timeval = type { char* decimal point, other stuff... }
+ // var indexes = Runtime.calculateStructAlignment({ fields: ['i32', 'i32'] });
+ var me = _localeconv;
+ if (!me.ret) {
+ // These are defaults from the "C" locale
+ me.ret = allocate([
+ allocate(intArrayFromString('.'), 'i8', ALLOC_NORMAL),0,0,0, // decimal_point
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // thousands_sep
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // grouping
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // int_curr_symbol
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // currency_symbol
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_decimal_point
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_thousands_sep
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // mon_grouping
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0, // positive_sign
+ allocate(intArrayFromString(''), 'i8', ALLOC_NORMAL),0,0,0 // negative_sign
+ ], 'i8*', ALLOC_NORMAL); // Allocate strings in lconv, still don't allocate chars
+ }
+ return me.ret;
+ }
+
+
+ function _unlink(path) {
+ // int unlink(const char *path);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/unlink.html
+ path = Pointer_stringify(path);
+ try {
+ FS.unlink(path);
+ return 0;
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _rmdir(path) {
+ // int rmdir(const char *path);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/rmdir.html
+ path = Pointer_stringify(path);
+ try {
+ FS.rmdir(path);
+ return 0;
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _remove(path) {
+ // int remove(const char *path);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/remove.html
+ var ret = _unlink(path);
+ if (ret == -1) ret = _rmdir(path);
+ return ret;
+ }
+
+ function _freopen(filename, mode, stream) {
+ // FILE *freopen(const char *restrict filename, const char *restrict mode, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/freopen.html
+ if (!filename) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (!streamObj) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return 0;
+ }
+ if (_freopen.buffer) _free(_freopen.buffer);
+ filename = intArrayFromString(streamObj.path);
+ filename = allocate(filename, 'i8', ALLOC_NORMAL);
+ }
+ _fclose(stream);
+ return _fopen(filename, mode);
+ }
+
+
+ function _rename(old_path, new_path) {
+ // int rename(const char *old, const char *new);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/rename.html
+ old_path = Pointer_stringify(old_path);
+ new_path = Pointer_stringify(new_path);
+ try {
+ FS.rename(old_path, new_path);
+ return 0;
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _tmpfile() {
+ // FILE *tmpfile(void);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/tmpfile.html
+ // TODO: Delete the created file on closing.
+ if (_tmpfile.mode) {
+ _tmpfile.mode = allocate(intArrayFromString('w+'), 'i8', ALLOC_NORMAL);
+ }
+ return _fopen(_tmpnam(0), _tmpfile.mode);
+ }
+
+ function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+
+ Module["_memset"] = _memset;
+
+
+
+ Module["_bitshift64Shl"] = _bitshift64Shl;
+
+ function _abort() {
+ Module['abort']();
+ }
+
+
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var origArg = currArg;
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], null); else
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (argSize == 8 && i64Math) {
+ if (origArg[1]) {
+ argText = (origArg[1]>>>0).toString(16);
+ var lower = (origArg[0]>>>0).toString(16);
+ while (lower.length < 8) lower = '0' + lower;
+ argText += lower;
+ } else {
+ argText = (origArg[0]>>>0).toString(16);
+ }
+ } else
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }
+
+ function _fgets(s, n, stream) {
+ // char *fgets(char *restrict s, int n, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fgets.html
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (!streamObj) return 0;
+ if (streamObj.error || streamObj.eof) return 0;
+ var byte_;
+ for (var i = 0; i < n - 1 && byte_ != 10; i++) {
+ byte_ = _fgetc(stream);
+ if (byte_ == -1) {
+ if (streamObj.error || (streamObj.eof && i == 0)) return 0;
+ else if (streamObj.eof) break;
+ }
+ HEAP8[(((s)+(i))|0)]=byte_;
+ }
+ HEAP8[(((s)+(i))|0)]=0;
+ return s;
+ }
+
+ var _tan=Math_tan;
+
+ function _ispunct(chr) {
+ return (chr >= 33 && chr <= 47) ||
+ (chr >= 58 && chr <= 64) ||
+ (chr >= 91 && chr <= 96) ||
+ (chr >= 123 && chr <= 126);
+ }
+
+ function _feof(stream) {
+ // int feof(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/feof.html
+ stream = FS.getStreamFromPtr(stream);
+ return Number(stream && stream.eof);
+ }
+
+
+ Module["_tolower"] = _tolower;
+
+ var _asin=Math_asin;
+
+ function _clearerr(stream) {
+ // void clearerr(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/clearerr.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) {
+ return;
+ }
+ stream.eof = false;
+ stream.error = false;
+ }
+
+ var _fabs=Math_abs;
+
+ function _clock() {
+ if (_clock.start === undefined) _clock.start = Date.now();
+ return Math.floor((Date.now() - _clock.start) * (1000000/1000));
+ }
+
+
+ var _getc=_fgetc;
+
+ function _modf(x, intpart) {
+ HEAPF64[((intpart)>>3)]=Math.floor(x);
+ return x - HEAPF64[((intpart)>>3)];
+ }
+
+ var _sqrt=Math_sqrt;
+
+ function _isxdigit(chr) {
+ return (chr >= 48 && chr <= 57) ||
+ (chr >= 97 && chr <= 102) ||
+ (chr >= 65 && chr <= 70);
+ }
+
+ function _ftell(stream) {
+ // long ftell(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/ftell.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ if (FS.isChrdev(stream.node.mode)) {
+ ___setErrNo(ERRNO_CODES.ESPIPE);
+ return -1;
+ } else {
+ return stream.position;
+ }
+ }
+
+
+ function __exit(status) {
+ // void _exit(int status);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
+ Module['exit'](status);
+ }function _exit(status) {
+ __exit(status);
+ }
+
+
+ function _snprintf(s, n, format, varargs) {
+ // int snprintf(char *restrict s, size_t n, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var limit = (n === undefined) ? result.length
+ : Math.min(result.length, Math.max(n - 1, 0));
+ if (s < 0) {
+ s = -s;
+ var buf = _malloc(limit+1);
+ HEAP32[((s)>>2)]=buf;
+ s = buf;
+ }
+ for (var i = 0; i < limit; i++) {
+ HEAP8[(((s)+(i))|0)]=result[i];
+ }
+ if (limit < n || (n === undefined)) HEAP8[(((s)+(i))|0)]=0;
+ return result.length;
+ }function _sprintf(s, format, varargs) {
+ // int sprintf(char *restrict s, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ return _snprintf(s, undefined, format, varargs);
+ }
+
+ var _emscripten_get_longjmp_result=true;
+
+ var _sin=Math_sin;
+
+
+ function _fmod(x, y) {
+ return x % y;
+ }var _fmodl=_fmod;
+
+
+
+ var _atan=Math_atan;
+
+ function _ferror(stream) {
+ // int ferror(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/ferror.html
+ stream = FS.getStreamFromPtr(stream);
+ return Number(stream && stream.error);
+ }
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+ function _copysign(a, b) {
+ return __reallyNegative(a) === __reallyNegative(b) ? a : -a;
+ }
+
+
+ function _gmtime_r(time, tmPtr) {
+ var date = new Date(HEAP32[((time)>>2)]*1000);
+ HEAP32[((tmPtr)>>2)]=date.getUTCSeconds();
+ HEAP32[(((tmPtr)+(4))>>2)]=date.getUTCMinutes();
+ HEAP32[(((tmPtr)+(8))>>2)]=date.getUTCHours();
+ HEAP32[(((tmPtr)+(12))>>2)]=date.getUTCDate();
+ HEAP32[(((tmPtr)+(16))>>2)]=date.getUTCMonth();
+ HEAP32[(((tmPtr)+(20))>>2)]=date.getUTCFullYear()-1900;
+ HEAP32[(((tmPtr)+(24))>>2)]=date.getUTCDay();
+ HEAP32[(((tmPtr)+(36))>>2)]=0;
+ HEAP32[(((tmPtr)+(32))>>2)]=0;
+ var start = new Date(date); // define date using UTC, start from Jan 01 00:00:00 UTC
+ start.setUTCDate(1);
+ start.setUTCMonth(0);
+ start.setUTCHours(0);
+ start.setUTCMinutes(0);
+ start.setUTCSeconds(0);
+ start.setUTCMilliseconds(0);
+ var yday = Math.floor((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
+ HEAP32[(((tmPtr)+(28))>>2)]=yday;
+ HEAP32[(((tmPtr)+(40))>>2)]=___tm_timezone;
+
+ return tmPtr;
+ }function _gmtime(time) {
+ return _gmtime_r(time, ___tm_current);
+ }
+
+ function _isgraph(chr) {
+ return 0x20 < chr && chr < 0x7F;
+ }
+
+
+
+ function _strerror_r(errnum, strerrbuf, buflen) {
+ if (errnum in ERRNO_MESSAGES) {
+ if (ERRNO_MESSAGES[errnum].length > buflen - 1) {
+ return ___setErrNo(ERRNO_CODES.ERANGE);
+ } else {
+ var msg = ERRNO_MESSAGES[errnum];
+ writeAsciiToMemory(msg, strerrbuf);
+ return 0;
+ }
+ } else {
+ return ___setErrNo(ERRNO_CODES.EINVAL);
+ }
+ }function _strerror(errnum) {
+ if (!_strerror.buffer) _strerror.buffer = _malloc(256);
+ _strerror_r(errnum, _strerror.buffer, 256);
+ return _strerror.buffer;
+ }
+
+
+
+
+
+ var _environ=allocate(1, "i32*", ALLOC_STATIC);var ___environ=_environ;function ___buildEnvironment(env) {
+ // WARNING: Arbitrary limit!
+ var MAX_ENV_VALUES = 64;
+ var TOTAL_ENV_SIZE = 1024;
+
+ // Statically allocate memory for the environment.
+ var poolPtr;
+ var envPtr;
+ if (!___buildEnvironment.called) {
+ ___buildEnvironment.called = true;
+ // Set default values. Use string keys for Closure Compiler compatibility.
+ ENV['USER'] = 'root';
+ ENV['PATH'] = '/';
+ ENV['PWD'] = '/';
+ ENV['HOME'] = '/home/emscripten';
+ ENV['LANG'] = 'en_US.UTF-8';
+ ENV['_'] = './this.program';
+ // Allocate memory.
+ poolPtr = allocate(TOTAL_ENV_SIZE, 'i8', ALLOC_STATIC);
+ envPtr = allocate(MAX_ENV_VALUES * 4,
+ 'i8*', ALLOC_STATIC);
+ HEAP32[((envPtr)>>2)]=poolPtr;
+ HEAP32[((_environ)>>2)]=envPtr;
+ } else {
+ envPtr = HEAP32[((_environ)>>2)];
+ poolPtr = HEAP32[((envPtr)>>2)];
+ }
+
+ // Collect key=value lines.
+ var strings = [];
+ var totalSize = 0;
+ for (var key in env) {
+ if (typeof env[key] === 'string') {
+ var line = key + '=' + env[key];
+ strings.push(line);
+ totalSize += line.length;
+ }
+ }
+ if (totalSize > TOTAL_ENV_SIZE) {
+ throw new Error('Environment size exceeded TOTAL_ENV_SIZE!');
+ }
+
+ // Make new.
+ var ptrSize = 4;
+ for (var i = 0; i < strings.length; i++) {
+ var line = strings[i];
+ writeAsciiToMemory(line, poolPtr);
+ HEAP32[(((envPtr)+(i * ptrSize))>>2)]=poolPtr;
+ poolPtr += line.length + 1;
+ }
+ HEAP32[(((envPtr)+(strings.length * ptrSize))>>2)]=0;
+ }var ENV={};function _getenv(name) {
+ // char *getenv(const char *name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/getenv.html
+ if (name === 0) return 0;
+ name = Pointer_stringify(name);
+ if (!ENV.hasOwnProperty(name)) return 0;
+
+ if (_getenv.ret) _free(_getenv.ret);
+ _getenv.ret = allocate(intArrayFromString(ENV[name]), 'i8', ALLOC_NORMAL);
+ return _getenv.ret;
+ }
+
+ var _emscripten_setjmp=true;
+
+ var _cos=Math_cos;
+
+ function _isalnum(chr) {
+ return (chr >= 48 && chr <= 57) ||
+ (chr >= 97 && chr <= 122) ||
+ (chr >= 65 && chr <= 90);
+ }
+
+ var _BItoD=true;
+
+ function _difftime(time1, time0) {
+ return time1 - time0;
+ }
+
+ var _floor=Math_floor;
+
+ function _iscntrl(chr) {
+ return (0 <= chr && chr <= 0x1F) || chr === 0x7F;
+ }
+
+ var _atan2=Math_atan2;
+
+ function _setvbuf(stream, buf, type, size) {
+ // int setvbuf(FILE *restrict stream, char *restrict buf, int type, size_t size);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/setvbuf.html
+ // TODO: Implement custom buffering.
+ return 0;
+ }
+
+ var _exp=Math_exp;
+
+ var _copysignl=_copysign;
+
+ function _islower(chr) {
+ return chr >= 97 && chr <= 122;
+ }
+
+ var _acos=Math_acos;
+
+ function _isupper(chr) {
+ return chr >= 65 && chr <= 90;
+ }
+
+
+ function __isLeapYear(year) {
+ return year%4 === 0 && (year%100 !== 0 || year%400 === 0);
+ }
+
+ function __arraySum(array, index) {
+ var sum = 0;
+ for (var i = 0; i <= index; sum += array[i++]);
+ return sum;
+ }
+
+
+ var __MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];
+
+ var __MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];function __addDays(date, days) {
+ var newDate = new Date(date.getTime());
+ while(days > 0) {
+ var leap = __isLeapYear(newDate.getFullYear());
+ var currentMonth = newDate.getMonth();
+ var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
+
+ if (days > daysInCurrentMonth-newDate.getDate()) {
+ // we spill over to next month
+ days -= (daysInCurrentMonth-newDate.getDate()+1);
+ newDate.setDate(1);
+ if (currentMonth < 11) {
+ newDate.setMonth(currentMonth+1)
+ } else {
+ newDate.setMonth(0);
+ newDate.setFullYear(newDate.getFullYear()+1);
+ }
+ } else {
+ // we stay in current month
+ newDate.setDate(newDate.getDate()+days);
+ return newDate;
+ }
+ }
+
+ return newDate;
+ }function _strftime(s, maxsize, format, tm) {
+ // size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/strftime.html
+
+ var date = {
+ tm_sec: HEAP32[((tm)>>2)],
+ tm_min: HEAP32[(((tm)+(4))>>2)],
+ tm_hour: HEAP32[(((tm)+(8))>>2)],
+ tm_mday: HEAP32[(((tm)+(12))>>2)],
+ tm_mon: HEAP32[(((tm)+(16))>>2)],
+ tm_year: HEAP32[(((tm)+(20))>>2)],
+ tm_wday: HEAP32[(((tm)+(24))>>2)],
+ tm_yday: HEAP32[(((tm)+(28))>>2)],
+ tm_isdst: HEAP32[(((tm)+(32))>>2)]
+ };
+
+ var pattern = Pointer_stringify(format);
+
+ // expand format
+ var EXPANSION_RULES_1 = {
+ '%c': '%a %b %d %H:%M:%S %Y', // Replaced by the locale's appropriate date and time representation - e.g., Mon Aug 3 14:02:01 2013
+ '%D': '%m/%d/%y', // Equivalent to %m / %d / %y
+ '%F': '%Y-%m-%d', // Equivalent to %Y - %m - %d
+ '%h': '%b', // Equivalent to %b
+ '%r': '%I:%M:%S %p', // Replaced by the time in a.m. and p.m. notation
+ '%R': '%H:%M', // Replaced by the time in 24-hour notation
+ '%T': '%H:%M:%S', // Replaced by the time
+ '%x': '%m/%d/%y', // Replaced by the locale's appropriate date representation
+ '%X': '%H:%M:%S', // Replaced by the locale's appropriate date representation
+ };
+ for (var rule in EXPANSION_RULES_1) {
+ pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_1[rule]);
+ }
+
+ var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+ var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+
+ function leadingSomething(value, digits, character) {
+ var str = typeof value === 'number' ? value.toString() : (value || '');
+ while (str.length < digits) {
+ str = character[0]+str;
+ }
+ return str;
+ };
+
+ function leadingNulls(value, digits) {
+ return leadingSomething(value, digits, '0');
+ };
+
+ function compareByDay(date1, date2) {
+ function sgn(value) {
+ return value < 0 ? -1 : (value > 0 ? 1 : 0);
+ };
+
+ var compare;
+ if ((compare = sgn(date1.getFullYear()-date2.getFullYear())) === 0) {
+ if ((compare = sgn(date1.getMonth()-date2.getMonth())) === 0) {
+ compare = sgn(date1.getDate()-date2.getDate());
+ }
+ }
+ return compare;
+ };
+
+ function getFirstWeekStartDate(janFourth) {
+ switch (janFourth.getDay()) {
+ case 0: // Sunday
+ return new Date(janFourth.getFullYear()-1, 11, 29);
+ case 1: // Monday
+ return janFourth;
+ case 2: // Tuesday
+ return new Date(janFourth.getFullYear(), 0, 3);
+ case 3: // Wednesday
+ return new Date(janFourth.getFullYear(), 0, 2);
+ case 4: // Thursday
+ return new Date(janFourth.getFullYear(), 0, 1);
+ case 5: // Friday
+ return new Date(janFourth.getFullYear()-1, 11, 31);
+ case 6: // Saturday
+ return new Date(janFourth.getFullYear()-1, 11, 30);
+ }
+ };
+
+ function getWeekBasedYear(date) {
+ var thisDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
+
+ var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+ var janFourthNextYear = new Date(thisDate.getFullYear()+1, 0, 4);
+
+ var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+ var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+
+ if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+ // this date is after the start of the first week of this year
+ if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+ return thisDate.getFullYear()+1;
+ } else {
+ return thisDate.getFullYear();
+ }
+ } else {
+ return thisDate.getFullYear()-1;
+ }
+ };
+
+ var EXPANSION_RULES_2 = {
+ '%a': function(date) {
+ return WEEKDAYS[date.tm_wday].substring(0,3);
+ },
+ '%A': function(date) {
+ return WEEKDAYS[date.tm_wday];
+ },
+ '%b': function(date) {
+ return MONTHS[date.tm_mon].substring(0,3);
+ },
+ '%B': function(date) {
+ return MONTHS[date.tm_mon];
+ },
+ '%C': function(date) {
+ var year = date.tm_year+1900;
+ return leadingNulls(Math.floor(year/100),2);
+ },
+ '%d': function(date) {
+ return leadingNulls(date.tm_mday, 2);
+ },
+ '%e': function(date) {
+ return leadingSomething(date.tm_mday, 2, ' ');
+ },
+ '%g': function(date) {
+ // %g, %G, and %V give values according to the ISO 8601:2000 standard week-based year.
+ // In this system, weeks begin on a Monday and week 1 of the year is the week that includes
+ // January 4th, which is also the week that includes the first Thursday of the year, and
+ // is also the first week that contains at least four days in the year.
+ // If the first Monday of January is the 2nd, 3rd, or 4th, the preceding days are part of
+ // the last week of the preceding year; thus, for Saturday 2nd January 1999,
+ // %G is replaced by 1998 and %V is replaced by 53. If December 29th, 30th,
+ // or 31st is a Monday, it and any following days are part of week 1 of the following year.
+ // Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and %V is replaced by 01.
+
+ return getWeekBasedYear(date).toString().substring(2);
+ },
+ '%G': function(date) {
+ return getWeekBasedYear(date);
+ },
+ '%H': function(date) {
+ return leadingNulls(date.tm_hour, 2);
+ },
+ '%I': function(date) {
+ return leadingNulls(date.tm_hour < 13 ? date.tm_hour : date.tm_hour-12, 2);
+ },
+ '%j': function(date) {
+ // Day of the year (001-366)
+ return leadingNulls(date.tm_mday+__arraySum(__isLeapYear(date.tm_year+1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon-1), 3);
+ },
+ '%m': function(date) {
+ return leadingNulls(date.tm_mon+1, 2);
+ },
+ '%M': function(date) {
+ return leadingNulls(date.tm_min, 2);
+ },
+ '%n': function() {
+ return '\n';
+ },
+ '%p': function(date) {
+ if (date.tm_hour > 0 && date.tm_hour < 13) {
+ return 'AM';
+ } else {
+ return 'PM';
+ }
+ },
+ '%S': function(date) {
+ return leadingNulls(date.tm_sec, 2);
+ },
+ '%t': function() {
+ return '\t';
+ },
+ '%u': function(date) {
+ var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
+ return day.getDay() || 7;
+ },
+ '%U': function(date) {
+ // Replaced by the week number of the year as a decimal number [00,53].
+ // The first Sunday of January is the first day of week 1;
+ // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
+ var janFirst = new Date(date.tm_year+1900, 0, 1);
+ var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7-janFirst.getDay());
+ var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
+
+ // is target date after the first Sunday?
+ if (compareByDay(firstSunday, endDate) < 0) {
+ // calculate difference in days between first Sunday and endDate
+ var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
+ var firstSundayUntilEndJanuary = 31-firstSunday.getDate();
+ var days = firstSundayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
+ return leadingNulls(Math.ceil(days/7), 2);
+ }
+
+ return compareByDay(firstSunday, janFirst) === 0 ? '01': '00';
+ },
+ '%V': function(date) {
+ // Replaced by the week number of the year (Monday as the first day of the week)
+ // as a decimal number [01,53]. If the week containing 1 January has four
+ // or more days in the new year, then it is considered week 1.
+ // Otherwise, it is the last week of the previous year, and the next week is week 1.
+ // Both January 4th and the first Thursday of January are always in week 1. [ tm_year, tm_wday, tm_yday]
+ var janFourthThisYear = new Date(date.tm_year+1900, 0, 4);
+ var janFourthNextYear = new Date(date.tm_year+1901, 0, 4);
+
+ var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+ var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+
+ var endDate = __addDays(new Date(date.tm_year+1900, 0, 1), date.tm_yday);
+
+ if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
+ // if given date is before this years first week, then it belongs to the 53rd week of last year
+ return '53';
+ }
+
+ if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
+ // if given date is after next years first week, then it belongs to the 01th week of next year
+ return '01';
+ }
+
+ // given date is in between CW 01..53 of this calendar year
+ var daysDifference;
+ if (firstWeekStartThisYear.getFullYear() < date.tm_year+1900) {
+ // first CW of this year starts last year
+ daysDifference = date.tm_yday+32-firstWeekStartThisYear.getDate()
+ } else {
+ // first CW of this year starts this year
+ daysDifference = date.tm_yday+1-firstWeekStartThisYear.getDate();
+ }
+ return leadingNulls(Math.ceil(daysDifference/7), 2);
+ },
+ '%w': function(date) {
+ var day = new Date(date.tm_year+1900, date.tm_mon+1, date.tm_mday, 0, 0, 0, 0);
+ return day.getDay();
+ },
+ '%W': function(date) {
+ // Replaced by the week number of the year as a decimal number [00,53].
+ // The first Monday of January is the first day of week 1;
+ // days in the new year before this are in week 0. [ tm_year, tm_wday, tm_yday]
+ var janFirst = new Date(date.tm_year, 0, 1);
+ var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7-janFirst.getDay()+1);
+ var endDate = new Date(date.tm_year+1900, date.tm_mon, date.tm_mday);
+
+ // is target date after the first Monday?
+ if (compareByDay(firstMonday, endDate) < 0) {
+ var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth()-1)-31;
+ var firstMondayUntilEndJanuary = 31-firstMonday.getDate();
+ var days = firstMondayUntilEndJanuary+februaryFirstUntilEndMonth+endDate.getDate();
+ return leadingNulls(Math.ceil(days/7), 2);
+ }
+ return compareByDay(firstMonday, janFirst) === 0 ? '01': '00';
+ },
+ '%y': function(date) {
+ // Replaced by the last two digits of the year as a decimal number [00,99]. [ tm_year]
+ return (date.tm_year+1900).toString().substring(2);
+ },
+ '%Y': function(date) {
+ // Replaced by the year as a decimal number (for example, 1997). [ tm_year]
+ return date.tm_year+1900;
+ },
+ '%z': function(date) {
+ // Replaced by the offset from UTC in the ISO 8601:2000 standard format ( +hhmm or -hhmm ),
+ // or by no characters if no timezone is determinable.
+ // For example, "-0430" means 4 hours 30 minutes behind UTC (west of Greenwich).
+ // If tm_isdst is zero, the standard time offset is used.
+ // If tm_isdst is greater than zero, the daylight savings time offset is used.
+ // If tm_isdst is negative, no characters are returned.
+ // FIXME: we cannot determine time zone (or can we?)
+ return '';
+ },
+ '%Z': function(date) {
+ // Replaced by the timezone name or abbreviation, or by no bytes if no timezone information exists. [ tm_isdst]
+ // FIXME: we cannot determine time zone (or can we?)
+ return '';
+ },
+ '%%': function() {
+ return '%';
+ }
+ };
+ for (var rule in EXPANSION_RULES_2) {
+ if (pattern.indexOf(rule) >= 0) {
+ pattern = pattern.replace(new RegExp(rule, 'g'), EXPANSION_RULES_2[rule](date));
+ }
+ }
+
+ var bytes = intArrayFromString(pattern, false);
+ if (bytes.length > maxsize) {
+ return 0;
+ }
+
+ writeArrayToMemory(bytes, s);
+ return bytes.length-1;
+ }
+
+
+
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+_fgetc.ret = allocate([0], "i8", ALLOC_STATIC);
+___buildEnvironment(ENV);
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+ var ctlz_i8 = allocate([8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_DYNAMIC);
+ var cttz_i8 = allocate([8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0], "i8", ALLOC_DYNAMIC);
+
+var Math_min = Math.min;
+function invoke_iiii(index,a1,a2,a3) {
+ try {
+ return Module["dynCall_iiii"](index,a1,a2,a3);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vi(index,a1) {
+ try {
+ Module["dynCall_vi"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vii(index,a1,a2) {
+ try {
+ Module["dynCall_vii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_ii(index,a1) {
+ try {
+ return Module["dynCall_ii"](index,a1);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iiiii(index,a1,a2,a3,a4) {
+ try {
+ return Module["dynCall_iiiii"](index,a1,a2,a3,a4);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iii(index,a1,a2) {
+ try {
+ return Module["dynCall_iii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+ var cttz_i8=env.cttz_i8|0;
+ var ctlz_i8=env.ctlz_i8|0;
+ var ___rand_seed=env.___rand_seed|0;
+ var _stderr=env._stderr|0;
+ var _stdin=env._stdin|0;
+ var _stdout=env._stdout|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var invoke_iiii=env.invoke_iiii;
+ var invoke_vi=env.invoke_vi;
+ var invoke_vii=env.invoke_vii;
+ var invoke_ii=env.invoke_ii;
+ var invoke_iiiii=env.invoke_iiiii;
+ var invoke_iii=env.invoke_iii;
+ var _isalnum=env._isalnum;
+ var _fabs=env._fabs;
+ var _frexp=env._frexp;
+ var _exp=env._exp;
+ var _fread=env._fread;
+ var __reallyNegative=env.__reallyNegative;
+ var _longjmp=env._longjmp;
+ var __addDays=env.__addDays;
+ var _fsync=env._fsync;
+ var _signal=env._signal;
+ var _rename=env._rename;
+ var _sbrk=env._sbrk;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _sinh=env._sinh;
+ var _sysconf=env._sysconf;
+ var _close=env._close;
+ var _ferror=env._ferror;
+ var _clock=env._clock;
+ var _cos=env._cos;
+ var _tanh=env._tanh;
+ var _unlink=env._unlink;
+ var _write=env._write;
+ var __isLeapYear=env.__isLeapYear;
+ var _ftell=env._ftell;
+ var _isupper=env._isupper;
+ var _gmtime_r=env._gmtime_r;
+ var _islower=env._islower;
+ var _tmpnam=env._tmpnam;
+ var _tmpfile=env._tmpfile;
+ var _send=env._send;
+ var _abort=env._abort;
+ var _setvbuf=env._setvbuf;
+ var _atan2=env._atan2;
+ var _setlocale=env._setlocale;
+ var _isgraph=env._isgraph;
+ var _modf=env._modf;
+ var _strerror_r=env._strerror_r;
+ var _fscanf=env._fscanf;
+ var ___setErrNo=env.___setErrNo;
+ var _isalpha=env._isalpha;
+ var _srand=env._srand;
+ var _mktime=env._mktime;
+ var _putchar=env._putchar;
+ var _gmtime=env._gmtime;
+ var _localeconv=env._localeconv;
+ var _sprintf=env._sprintf;
+ var _localtime=env._localtime;
+ var _read=env._read;
+ var _fwrite=env._fwrite;
+ var _time=env._time;
+ var _fprintf=env._fprintf;
+ var _exit=env._exit;
+ var _freopen=env._freopen;
+ var _llvm_pow_f64=env._llvm_pow_f64;
+ var _fgetc=env._fgetc;
+ var _fmod=env._fmod;
+ var _lseek=env._lseek;
+ var _rmdir=env._rmdir;
+ var _asin=env._asin;
+ var _floor=env._floor;
+ var _pwrite=env._pwrite;
+ var _localtime_r=env._localtime_r;
+ var _tzset=env._tzset;
+ var _open=env._open;
+ var _remove=env._remove;
+ var _snprintf=env._snprintf;
+ var __scanString=env.__scanString;
+ var _strftime=env._strftime;
+ var _fseek=env._fseek;
+ var _iscntrl=env._iscntrl;
+ var _isxdigit=env._isxdigit;
+ var _fclose=env._fclose;
+ var _log=env._log;
+ var _recv=env._recv;
+ var _tan=env._tan;
+ var _copysign=env._copysign;
+ var __getFloat=env.__getFloat;
+ var _fputc=env._fputc;
+ var _ispunct=env._ispunct;
+ var _ceil=env._ceil;
+ var _isspace=env._isspace;
+ var _fopen=env._fopen;
+ var _sin=env._sin;
+ var _acos=env._acos;
+ var _cosh=env._cosh;
+ var ___buildEnvironment=env.___buildEnvironment;
+ var _difftime=env._difftime;
+ var _ungetc=env._ungetc;
+ var _system=env._system;
+ var _fflush=env._fflush;
+ var _log10=env._log10;
+ var _fileno=env._fileno;
+ var __exit=env.__exit;
+ var __arraySum=env.__arraySum;
+ var _fgets=env._fgets;
+ var _atan=env._atan;
+ var _pread=env._pread;
+ var _mkport=env._mkport;
+ var _toupper=env._toupper;
+ var _feof=env._feof;
+ var ___errno_location=env.___errno_location;
+ var _clearerr=env._clearerr;
+ var _getenv=env._getenv;
+ var _strerror=env._strerror;
+ var _emscripten_longjmp=env._emscripten_longjmp;
+ var __formatString=env.__formatString;
+ var _fputs=env._fputs;
+ var _sqrt=env._sqrt;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[3228] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 12952 + (i5 << 2) | 0;
+ i5 = 12952 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[3228] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[12920 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 12952 + (i7 << 2) | 0;
+ i7 = 12952 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[3228] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[12920 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[12932 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 12952 + (i9 << 2) | 0;
+ i7 = HEAP32[3228] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 12952 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[3228] = i7 | i8;
+ i28 = 12952 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[12920 >> 2] = i4;
+ HEAP32[12932 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[12916 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[13216 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[12928 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 13216 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[12920 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[12932 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 12952 + (i9 << 2) | 0;
+ i7 = HEAP32[3228] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 12952 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[3228] = i7 | i8;
+ i25 = 12952 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[12920 >> 2] = i2;
+ HEAP32[12932 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[12916 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[13216 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[13216 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[12920 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[12928 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 13216 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 12952 + (i6 << 2) | 0;
+ i5 = HEAP32[3228] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 12952 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[3228] = i5 | i4;
+ i21 = 12952 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 13216 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[12916 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[12916 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[12928 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[12920 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[12932 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[12932 >> 2] = i2 + i12;
+ HEAP32[12920 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[12920 >> 2] = 0;
+ HEAP32[12932 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[12924 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[12924 >> 2] = i31;
+ i32 = HEAP32[12936 >> 2] | 0;
+ HEAP32[12936 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[3346] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[13392 >> 2] = i18;
+ HEAP32[13388 >> 2] = i18;
+ HEAP32[13396 >> 2] = -1;
+ HEAP32[13400 >> 2] = -1;
+ HEAP32[13404 >> 2] = 0;
+ HEAP32[13356 >> 2] = 0;
+ HEAP32[3346] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[13392 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[13352 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[13344 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[13356 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[12936 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 13360 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[12924 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[13388 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[13344 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[13352 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[13392 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[13356 >> 2] = HEAP32[13356 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[13344 >> 2] | 0) + i14 | 0;
+ HEAP32[13344 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[13348 >> 2] | 0) >>> 0) {
+ HEAP32[13348 >> 2] = i15;
+ }
+ i15 = HEAP32[12936 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 13360 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[12924 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[12936 >> 2] = i15 + i3;
+ HEAP32[12924 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ HEAP32[12928 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 13360 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[12936 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i32 = (HEAP32[12920 >> 2] | 0) + i10 | 0;
+ HEAP32[12920 >> 2] = i32;
+ HEAP32[12932 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 13216 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 12952 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 12952 + (i10 << 2) | 0;
+ i9 = HEAP32[3228] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 12952 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[3228] = i9 | i5;
+ i3 = 12952 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 13216 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[12916 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[12916 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L445 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L445;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[12928 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[12924 >> 2] | 0) + i10 | 0;
+ HEAP32[12924 >> 2] = i32;
+ HEAP32[12936 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 13360 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[12936 >> 2] = i17 + i4;
+ HEAP32[12924 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[13360 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[13364 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[13368 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[13372 >> 2];
+ HEAP32[13360 >> 2] = i17;
+ HEAP32[13364 >> 2] = i14;
+ HEAP32[13372 >> 2] = 0;
+ HEAP32[13368 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 12952 + (i4 << 2) | 0;
+ i5 = HEAP32[3228] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 12952 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[3228] = i5 | i3;
+ i7 = 12952 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 13216 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[12916 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[12916 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[12928 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[12928 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[12928 >> 2] = i17;
+ }
+ HEAP32[13360 >> 2] = i17;
+ HEAP32[13364 >> 2] = i14;
+ HEAP32[13372 >> 2] = 0;
+ HEAP32[12948 >> 2] = HEAP32[3346];
+ HEAP32[12944 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 12952 + (i32 << 2) | 0;
+ HEAP32[12952 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[12952 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[12936 >> 2] = i17 + i2;
+ HEAP32[12924 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[12940 >> 2] = HEAP32[13400 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[12924 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[12924 >> 2] = i31;
+ i32 = HEAP32[12936 >> 2] | 0;
+ HEAP32[12936 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function _llex(i2, i3) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i12 = i1;
+ i4 = i2 + 60 | 0;
+ HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
+ i5 = i2 + 56 | 0;
+ L1 : while (1) {
+ i13 = HEAP32[i2 >> 2] | 0;
+ L3 : while (1) {
+ switch (i13 | 0) {
+ case 11:
+ case 9:
+ case 12:
+ case 32:
+ {
+ break;
+ }
+ case 91:
+ {
+ i9 = 25;
+ break L1;
+ }
+ case 62:
+ {
+ i9 = 45;
+ break L1;
+ }
+ case 46:
+ {
+ i9 = 161;
+ break L1;
+ }
+ case 13:
+ case 10:
+ {
+ i9 = 4;
+ break L3;
+ }
+ case 45:
+ {
+ break L3;
+ }
+ case 61:
+ {
+ i9 = 29;
+ break L1;
+ }
+ case 39:
+ case 34:
+ {
+ i9 = 69;
+ break L1;
+ }
+ case 126:
+ {
+ i9 = 53;
+ break L1;
+ }
+ case 60:
+ {
+ i9 = 37;
+ break L1;
+ }
+ case 58:
+ {
+ i9 = 61;
+ break L1;
+ }
+ case 57:
+ case 56:
+ case 55:
+ case 54:
+ case 53:
+ case 52:
+ case 51:
+ case 50:
+ case 49:
+ case 48:
+ {
+ i20 = i13;
+ break L1;
+ }
+ case -1:
+ {
+ i2 = 286;
+ i9 = 306;
+ break L1;
+ }
+ default:
+ {
+ i9 = 283;
+ break L1;
+ }
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i13 = _luaZ_fill(i13) | 0;
+ } else {
+ i27 = i13 + 4 | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i13 + 1;
+ i13 = HEAPU8[i13] | 0;
+ }
+ HEAP32[i2 >> 2] = i13;
+ }
+ if ((i9 | 0) == 4) {
+ i9 = 0;
+ _inclinenumber(i2);
+ continue;
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i13 = _luaZ_fill(i13) | 0;
+ } else {
+ i27 = i13 + 4 | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i13 + 1;
+ i13 = HEAPU8[i13] | 0;
+ }
+ HEAP32[i2 >> 2] = i13;
+ if ((i13 | 0) != 45) {
+ i2 = 45;
+ i9 = 306;
+ break;
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i13 = _luaZ_fill(i13) | 0;
+ } else {
+ i27 = i13 + 4 | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i13 + 1;
+ i13 = HEAPU8[i13] | 0;
+ }
+ HEAP32[i2 >> 2] = i13;
+ do {
+ if ((i13 | 0) == 91) {
+ i13 = _skip_sep(i2) | 0;
+ HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
+ if ((i13 | 0) > -1) {
+ _read_long_string(i2, 0, i13);
+ HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
+ continue L1;
+ } else {
+ i13 = HEAP32[i2 >> 2] | 0;
+ break;
+ }
+ }
+ } while (0);
+ while (1) {
+ if ((i13 | 0) == -1 | (i13 | 0) == 13 | (i13 | 0) == 10) {
+ continue L1;
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i13 = _luaZ_fill(i13) | 0;
+ } else {
+ i27 = i13 + 4 | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i13 + 1;
+ i13 = HEAPU8[i13] | 0;
+ }
+ HEAP32[i2 >> 2] = i13;
+ }
+ }
+ if ((i9 | 0) == 25) {
+ i9 = _skip_sep(i2) | 0;
+ if ((i9 | 0) > -1) {
+ _read_long_string(i2, i3, i9);
+ i27 = 289;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ if ((i9 | 0) == -1) {
+ i27 = 91;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else {
+ _lexerror(i2, 12272, 289);
+ }
+ } else if ((i9 | 0) == 29) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) != 61) {
+ i27 = 61;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 281;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 37) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) != 61) {
+ i27 = 60;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 283;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 45) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) != 61) {
+ i27 = 62;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 282;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 53) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) != 61) {
+ i27 = 126;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 284;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 61) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) != 58) {
+ i27 = 58;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 285;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 69) {
+ i14 = HEAP32[i4 >> 2] | 0;
+ i7 = i14 + 4 | 0;
+ i15 = HEAP32[i7 >> 2] | 0;
+ i8 = i14 + 8 | 0;
+ i6 = HEAP32[i8 >> 2] | 0;
+ do {
+ if ((i15 + 1 | 0) >>> 0 > i6 >>> 0) {
+ if (i6 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i16 = i6 << 1;
+ i15 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i16 | 0) == -2) {
+ _luaM_toobig(i15);
+ } else {
+ i24 = _luaM_realloc_(i15, HEAP32[i14 >> 2] | 0, i6, i16) | 0;
+ HEAP32[i14 >> 2] = i24;
+ HEAP32[i8 >> 2] = i16;
+ i23 = HEAP32[i7 >> 2] | 0;
+ break;
+ }
+ } else {
+ i23 = i15;
+ i24 = HEAP32[i14 >> 2] | 0;
+ }
+ } while (0);
+ i6 = i13 & 255;
+ HEAP32[i7 >> 2] = i23 + 1;
+ HEAP8[i24 + i23 | 0] = i6;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i14 = _luaZ_fill(i7) | 0;
+ } else {
+ i27 = i7 + 4 | 0;
+ i14 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i14 + 1;
+ i14 = HEAPU8[i14] | 0;
+ }
+ HEAP32[i2 >> 2] = i14;
+ L139 : do {
+ if ((i14 | 0) != (i13 | 0)) {
+ i7 = i2 + 52 | 0;
+ L141 : while (1) {
+ L143 : do {
+ if ((i14 | 0) == 92) {
+ i8 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i8 = _luaZ_fill(i8) | 0;
+ } else {
+ i27 = i8 + 4 | 0;
+ i8 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i8 + 1;
+ i8 = HEAPU8[i8] | 0;
+ }
+ HEAP32[i2 >> 2] = i8;
+ switch (i8 | 0) {
+ case 13:
+ case 10:
+ {
+ _inclinenumber(i2);
+ i8 = 10;
+ break;
+ }
+ case 39:
+ case 34:
+ case 92:
+ {
+ i9 = 124;
+ break;
+ }
+ case 122:
+ {
+ i8 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i14 = _luaZ_fill(i8) | 0;
+ } else {
+ i27 = i8 + 4 | 0;
+ i14 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i14 + 1;
+ i14 = HEAPU8[i14] | 0;
+ }
+ HEAP32[i2 >> 2] = i14;
+ if ((HEAP8[i14 + 10913 | 0] & 8) == 0) {
+ break L143;
+ }
+ while (1) {
+ if ((i14 | 0) == 13 | (i14 | 0) == 10) {
+ _inclinenumber(i2);
+ i14 = HEAP32[i2 >> 2] | 0;
+ } else {
+ i8 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i14 = _luaZ_fill(i8) | 0;
+ } else {
+ i27 = i8 + 4 | 0;
+ i14 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i14 + 1;
+ i14 = HEAPU8[i14] | 0;
+ }
+ HEAP32[i2 >> 2] = i14;
+ }
+ if ((HEAP8[i14 + 10913 | 0] & 8) == 0) {
+ break L143;
+ }
+ }
+ }
+ case 118:
+ {
+ i8 = 11;
+ i9 = 124;
+ break;
+ }
+ case 120:
+ {
+ HEAP32[i12 >> 2] = 120;
+ i14 = 1;
+ i8 = 0;
+ while (1) {
+ i9 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i9 = _luaZ_fill(i9) | 0;
+ } else {
+ i27 = i9 + 4 | 0;
+ i9 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i9 + 1;
+ i9 = HEAPU8[i9] | 0;
+ }
+ HEAP32[i2 >> 2] = i9;
+ HEAP32[i12 + (i14 << 2) >> 2] = i9;
+ if ((HEAP8[i9 + 10913 | 0] & 16) == 0) {
+ i9 = 100;
+ break L141;
+ }
+ i8 = (_luaO_hexavalue(i9) | 0) + (i8 << 4) | 0;
+ i14 = i14 + 1 | 0;
+ if ((i14 | 0) >= 3) {
+ i9 = 124;
+ break;
+ }
+ }
+ break;
+ }
+ case -1:
+ {
+ i14 = -1;
+ break L143;
+ }
+ case 98:
+ {
+ i8 = 8;
+ i9 = 124;
+ break;
+ }
+ case 102:
+ {
+ i8 = 12;
+ i9 = 124;
+ break;
+ }
+ case 110:
+ {
+ i8 = 10;
+ i9 = 124;
+ break;
+ }
+ case 114:
+ {
+ i8 = 13;
+ i9 = 124;
+ break;
+ }
+ case 116:
+ {
+ i8 = 9;
+ i9 = 124;
+ break;
+ }
+ case 97:
+ {
+ i8 = 7;
+ i9 = 124;
+ break;
+ }
+ default:
+ {
+ if ((HEAP8[i8 + 10913 | 0] & 2) == 0) {
+ i9 = 116;
+ break L141;
+ } else {
+ i15 = i8;
+ i14 = 0;
+ i8 = 0;
+ }
+ do {
+ if ((HEAP8[i15 + 10913 | 0] & 2) == 0) {
+ break;
+ }
+ HEAP32[i12 + (i14 << 2) >> 2] = i15;
+ i8 = i15 + -48 + (i8 * 10 | 0) | 0;
+ i15 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i15 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i15 = _luaZ_fill(i15) | 0;
+ } else {
+ i27 = i15 + 4 | 0;
+ i15 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i15 + 1;
+ i15 = HEAPU8[i15] | 0;
+ }
+ HEAP32[i2 >> 2] = i15;
+ i14 = i14 + 1 | 0;
+ } while ((i14 | 0) < 3);
+ if ((i8 | 0) > 255) {
+ i9 = 123;
+ break L141;
+ }
+ }
+ }
+ if ((i9 | 0) == 124) {
+ i9 = 0;
+ i14 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i14 = _luaZ_fill(i14) | 0;
+ } else {
+ i27 = i14 + 4 | 0;
+ i14 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i14 + 1;
+ i14 = HEAPU8[i14] | 0;
+ }
+ HEAP32[i2 >> 2] = i14;
+ }
+ i15 = HEAP32[i4 >> 2] | 0;
+ i14 = i15 + 4 | 0;
+ i18 = HEAP32[i14 >> 2] | 0;
+ i16 = i15 + 8 | 0;
+ i17 = HEAP32[i16 >> 2] | 0;
+ if ((i18 + 1 | 0) >>> 0 > i17 >>> 0) {
+ if (i17 >>> 0 > 2147483645) {
+ i9 = 131;
+ break L141;
+ }
+ i18 = i17 << 1;
+ i19 = HEAP32[i7 >> 2] | 0;
+ if ((i18 | 0) == -2) {
+ i9 = 133;
+ break L141;
+ }
+ i27 = _luaM_realloc_(i19, HEAP32[i15 >> 2] | 0, i17, i18) | 0;
+ HEAP32[i15 >> 2] = i27;
+ HEAP32[i16 >> 2] = i18;
+ i18 = HEAP32[i14 >> 2] | 0;
+ i15 = i27;
+ } else {
+ i15 = HEAP32[i15 >> 2] | 0;
+ }
+ HEAP32[i14 >> 2] = i18 + 1;
+ HEAP8[i15 + i18 | 0] = i8;
+ i14 = HEAP32[i2 >> 2] | 0;
+ } else if ((i14 | 0) == -1) {
+ i9 = 82;
+ break L141;
+ } else if ((i14 | 0) == 13 | (i14 | 0) == 10) {
+ i9 = 83;
+ break L141;
+ } else {
+ i15 = HEAP32[i4 >> 2] | 0;
+ i8 = i15 + 4 | 0;
+ i18 = HEAP32[i8 >> 2] | 0;
+ i17 = i15 + 8 | 0;
+ i16 = HEAP32[i17 >> 2] | 0;
+ if ((i18 + 1 | 0) >>> 0 > i16 >>> 0) {
+ if (i16 >>> 0 > 2147483645) {
+ i9 = 139;
+ break L141;
+ }
+ i19 = i16 << 1;
+ i18 = HEAP32[i7 >> 2] | 0;
+ if ((i19 | 0) == -2) {
+ i9 = 141;
+ break L141;
+ }
+ i27 = _luaM_realloc_(i18, HEAP32[i15 >> 2] | 0, i16, i19) | 0;
+ HEAP32[i15 >> 2] = i27;
+ HEAP32[i17 >> 2] = i19;
+ i18 = HEAP32[i8 >> 2] | 0;
+ i15 = i27;
+ } else {
+ i15 = HEAP32[i15 >> 2] | 0;
+ }
+ HEAP32[i8 >> 2] = i18 + 1;
+ HEAP8[i15 + i18 | 0] = i14;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i14 = _luaZ_fill(i8) | 0;
+ } else {
+ i27 = i8 + 4 | 0;
+ i14 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i14 + 1;
+ i14 = HEAPU8[i14] | 0;
+ }
+ HEAP32[i2 >> 2] = i14;
+ }
+ } while (0);
+ if ((i14 | 0) == (i13 | 0)) {
+ break L139;
+ }
+ }
+ if ((i9 | 0) == 82) {
+ _lexerror(i2, 12400, 286);
+ } else if ((i9 | 0) == 83) {
+ _lexerror(i2, 12400, 289);
+ } else if ((i9 | 0) == 100) {
+ _escerror(i2, i12, i14 + 1 | 0, 12480);
+ } else if ((i9 | 0) == 116) {
+ _escerror(i2, i2, 1, 12424);
+ } else if ((i9 | 0) == 123) {
+ _escerror(i2, i12, i14, 12448);
+ } else if ((i9 | 0) == 131) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 133) {
+ _luaM_toobig(i19);
+ } else if ((i9 | 0) == 139) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 141) {
+ _luaM_toobig(i18);
+ }
+ }
+ } while (0);
+ i7 = HEAP32[i4 >> 2] | 0;
+ i8 = i7 + 4 | 0;
+ i13 = HEAP32[i8 >> 2] | 0;
+ i12 = i7 + 8 | 0;
+ i9 = HEAP32[i12 >> 2] | 0;
+ do {
+ if ((i13 + 1 | 0) >>> 0 > i9 >>> 0) {
+ if (i9 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i14 = i9 << 1;
+ i13 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i14 | 0) == -2) {
+ _luaM_toobig(i13);
+ } else {
+ i11 = _luaM_realloc_(i13, HEAP32[i7 >> 2] | 0, i9, i14) | 0;
+ HEAP32[i7 >> 2] = i11;
+ HEAP32[i12 >> 2] = i14;
+ i10 = HEAP32[i8 >> 2] | 0;
+ break;
+ }
+ } else {
+ i10 = i13;
+ i11 = HEAP32[i7 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i8 >> 2] = i10 + 1;
+ HEAP8[i11 + i10 | 0] = i6;
+ i5 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i5 = _luaZ_fill(i5) | 0;
+ } else {
+ i27 = i5 + 4 | 0;
+ i5 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i5 + 1;
+ i5 = HEAPU8[i5] | 0;
+ }
+ HEAP32[i2 >> 2] = i5;
+ i5 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP32[i2 + 52 >> 2] | 0;
+ i5 = _luaS_newlstr(i4, (HEAP32[i5 >> 2] | 0) + 1 | 0, (HEAP32[i5 + 4 >> 2] | 0) + -2 | 0) | 0;
+ i6 = i4 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i7 + 16;
+ HEAP32[i7 >> 2] = i5;
+ HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 64;
+ i7 = _luaH_set(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i6 >> 2] | 0) + -16 | 0) | 0;
+ i2 = i7 + 8 | 0;
+ if ((HEAP32[i2 >> 2] | 0) == 0 ? (HEAP32[i7 >> 2] = 1, HEAP32[i2 >> 2] = 1, (HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
+ _luaC_step(i4);
+ }
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + -16;
+ HEAP32[i3 >> 2] = i5;
+ i27 = 289;
+ STACKTOP = i1;
+ return i27 | 0;
+ } else if ((i9 | 0) == 161) {
+ i10 = HEAP32[i4 >> 2] | 0;
+ i9 = i10 + 4 | 0;
+ i13 = HEAP32[i9 >> 2] | 0;
+ i12 = i10 + 8 | 0;
+ i11 = HEAP32[i12 >> 2] | 0;
+ do {
+ if ((i13 + 1 | 0) >>> 0 > i11 >>> 0) {
+ if (i11 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i13 = i11 << 1;
+ i20 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i13 | 0) == -2) {
+ _luaM_toobig(i20);
+ } else {
+ i25 = _luaM_realloc_(i20, HEAP32[i10 >> 2] | 0, i11, i13) | 0;
+ HEAP32[i10 >> 2] = i25;
+ HEAP32[i12 >> 2] = i13;
+ i26 = HEAP32[i9 >> 2] | 0;
+ break;
+ }
+ } else {
+ i26 = i13;
+ i25 = HEAP32[i10 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i9 >> 2] = i26 + 1;
+ HEAP8[i25 + i26 | 0] = 46;
+ i9 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i20 = _luaZ_fill(i9) | 0;
+ } else {
+ i27 = i9 + 4 | 0;
+ i20 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i20 + 1;
+ i20 = HEAPU8[i20] | 0;
+ }
+ HEAP32[i2 >> 2] = i20;
+ if ((i20 | 0) != 0 ? (_memchr(12304, i20, 2) | 0) != 0 : 0) {
+ i6 = HEAP32[i4 >> 2] | 0;
+ i3 = i6 + 4 | 0;
+ i9 = HEAP32[i3 >> 2] | 0;
+ i8 = i6 + 8 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ do {
+ if ((i9 + 1 | 0) >>> 0 > i7 >>> 0) {
+ if (i7 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i9 = i7 << 1;
+ i10 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i9 | 0) == -2) {
+ _luaM_toobig(i10);
+ } else {
+ i21 = _luaM_realloc_(i10, HEAP32[i6 >> 2] | 0, i7, i9) | 0;
+ HEAP32[i6 >> 2] = i21;
+ HEAP32[i8 >> 2] = i9;
+ i22 = HEAP32[i3 >> 2] | 0;
+ break;
+ }
+ } else {
+ i22 = i9;
+ i21 = HEAP32[i6 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i3 >> 2] = i22 + 1;
+ HEAP8[i21 + i22 | 0] = i20;
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ if ((i3 | 0) == 0) {
+ i27 = 279;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ if ((_memchr(12304, i3, 2) | 0) == 0) {
+ i27 = 279;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i6 = HEAP32[i4 >> 2] | 0;
+ i7 = i6 + 4 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ i8 = i6 + 8 | 0;
+ i4 = HEAP32[i8 >> 2] | 0;
+ do {
+ if ((i9 + 1 | 0) >>> 0 > i4 >>> 0) {
+ if (i4 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i10 = i4 << 1;
+ i9 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i10 | 0) == -2) {
+ _luaM_toobig(i9);
+ } else {
+ i18 = _luaM_realloc_(i9, HEAP32[i6 >> 2] | 0, i4, i10) | 0;
+ HEAP32[i6 >> 2] = i18;
+ HEAP32[i8 >> 2] = i10;
+ i19 = HEAP32[i7 >> 2] | 0;
+ break;
+ }
+ } else {
+ i19 = i9;
+ i18 = HEAP32[i6 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i7 >> 2] = i19 + 1;
+ HEAP8[i18 + i19 | 0] = i3;
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = 280;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ if ((HEAP8[i20 + 10913 | 0] & 2) == 0) {
+ i27 = 46;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ } else if ((i9 | 0) == 283) {
+ if ((HEAP8[i13 + 10913 | 0] & 1) == 0) {
+ i3 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i27 = i3 + 4 | 0;
+ i3 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i27 = i13;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i10 = i2 + 52 | 0;
+ while (1) {
+ i11 = HEAP32[i4 >> 2] | 0;
+ i9 = i11 + 4 | 0;
+ i12 = HEAP32[i9 >> 2] | 0;
+ i19 = i11 + 8 | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i12 + 1 | 0) >>> 0 > i18 >>> 0) {
+ if (i18 >>> 0 > 2147483645) {
+ i9 = 288;
+ break;
+ }
+ i21 = i18 << 1;
+ i12 = HEAP32[i10 >> 2] | 0;
+ if ((i21 | 0) == -2) {
+ i9 = 290;
+ break;
+ }
+ i27 = _luaM_realloc_(i12, HEAP32[i11 >> 2] | 0, i18, i21) | 0;
+ HEAP32[i11 >> 2] = i27;
+ HEAP32[i19 >> 2] = i21;
+ i12 = HEAP32[i9 >> 2] | 0;
+ i11 = i27;
+ } else {
+ i11 = HEAP32[i11 >> 2] | 0;
+ }
+ HEAP32[i9 >> 2] = i12 + 1;
+ HEAP8[i11 + i12 | 0] = i13;
+ i9 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i13 = _luaZ_fill(i9) | 0;
+ } else {
+ i27 = i9 + 4 | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i13 + 1;
+ i13 = HEAPU8[i13] | 0;
+ }
+ HEAP32[i2 >> 2] = i13;
+ if ((HEAP8[i13 + 10913 | 0] & 3) == 0) {
+ i9 = 296;
+ break;
+ }
+ }
+ if ((i9 | 0) == 288) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 290) {
+ _luaM_toobig(i12);
+ } else if ((i9 | 0) == 296) {
+ i6 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP32[i10 >> 2] | 0;
+ i6 = _luaS_newlstr(i4, HEAP32[i6 >> 2] | 0, HEAP32[i6 + 4 >> 2] | 0) | 0;
+ i7 = i4 + 8 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i8 + 16;
+ HEAP32[i8 >> 2] = i6;
+ i5 = i6 + 4 | 0;
+ HEAP32[i8 + 8 >> 2] = HEAPU8[i5] | 64;
+ i8 = _luaH_set(i4, HEAP32[(HEAP32[i2 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i7 >> 2] | 0) + -16 | 0) | 0;
+ i2 = i8 + 8 | 0;
+ if ((HEAP32[i2 >> 2] | 0) == 0 ? (HEAP32[i8 >> 2] = 1, HEAP32[i2 >> 2] = 1, (HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
+ _luaC_step(i4);
+ }
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
+ HEAP32[i3 >> 2] = i6;
+ if ((HEAP8[i5] | 0) != 4) {
+ i27 = 288;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i2 = HEAP8[i6 + 6 | 0] | 0;
+ if (i2 << 24 >> 24 == 0) {
+ i27 = 288;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i27 = i2 & 255 | 256;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ } else if ((i9 | 0) == 306) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ i9 = HEAP32[i4 >> 2] | 0;
+ i12 = i9 + 4 | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ i11 = i9 + 8 | 0;
+ i10 = HEAP32[i11 >> 2] | 0;
+ do {
+ if ((i13 + 1 | 0) >>> 0 > i10 >>> 0) {
+ if (i10 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i18 = i10 << 1;
+ i13 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i18 | 0) == -2) {
+ _luaM_toobig(i13);
+ } else {
+ i16 = _luaM_realloc_(i13, HEAP32[i9 >> 2] | 0, i10, i18) | 0;
+ HEAP32[i9 >> 2] = i16;
+ HEAP32[i11 >> 2] = i18;
+ i17 = HEAP32[i12 >> 2] | 0;
+ break;
+ }
+ } else {
+ i17 = i13;
+ i16 = HEAP32[i9 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i12 >> 2] = i17 + 1;
+ HEAP8[i16 + i17 | 0] = i20;
+ i9 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i9 = _luaZ_fill(i9) | 0;
+ } else {
+ i27 = i9 + 4 | 0;
+ i9 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i9 + 1;
+ i9 = HEAPU8[i9] | 0;
+ }
+ HEAP32[i2 >> 2] = i9;
+ if ((i20 | 0) == 48) {
+ if ((i9 | 0) != 0) {
+ if ((_memchr(12320, i9, 3) | 0) == 0) {
+ i15 = i9;
+ i9 = 12312;
+ } else {
+ i10 = HEAP32[i4 >> 2] | 0;
+ i13 = i10 + 4 | 0;
+ i16 = HEAP32[i13 >> 2] | 0;
+ i11 = i10 + 8 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ do {
+ if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
+ if (i12 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i17 = i12 << 1;
+ i16 = HEAP32[i2 + 52 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ _luaM_toobig(i16);
+ } else {
+ i15 = _luaM_realloc_(i16, HEAP32[i10 >> 2] | 0, i12, i17) | 0;
+ HEAP32[i10 >> 2] = i15;
+ HEAP32[i11 >> 2] = i17;
+ i14 = HEAP32[i13 >> 2] | 0;
+ break;
+ }
+ } else {
+ i14 = i16;
+ i15 = HEAP32[i10 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i13 >> 2] = i14 + 1;
+ HEAP8[i15 + i14 | 0] = i9;
+ i9 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i15 = _luaZ_fill(i9) | 0;
+ } else {
+ i27 = i9 + 4 | 0;
+ i15 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i15 + 1;
+ i15 = HEAPU8[i15] | 0;
+ }
+ HEAP32[i2 >> 2] = i15;
+ i9 = 12328;
+ }
+ } else {
+ i15 = 0;
+ i9 = 12312;
+ }
+ } else {
+ i15 = i9;
+ i9 = 12312;
+ }
+ i10 = i2 + 52 | 0;
+ while (1) {
+ if ((i15 | 0) != 0) {
+ if ((_memchr(i9, i15, 3) | 0) != 0) {
+ i12 = HEAP32[i4 >> 2] | 0;
+ i11 = i12 + 4 | 0;
+ i16 = HEAP32[i11 >> 2] | 0;
+ i14 = i12 + 8 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ if ((i16 + 1 | 0) >>> 0 > i13 >>> 0) {
+ if (i13 >>> 0 > 2147483645) {
+ i9 = 227;
+ break;
+ }
+ i17 = i13 << 1;
+ i16 = HEAP32[i10 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ i9 = 229;
+ break;
+ }
+ i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
+ HEAP32[i12 >> 2] = i27;
+ HEAP32[i14 >> 2] = i17;
+ i16 = HEAP32[i11 >> 2] | 0;
+ i12 = i27;
+ } else {
+ i12 = HEAP32[i12 >> 2] | 0;
+ }
+ HEAP32[i11 >> 2] = i16 + 1;
+ HEAP8[i12 + i16 | 0] = i15;
+ i11 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i15 = _luaZ_fill(i11) | 0;
+ } else {
+ i27 = i11 + 4 | 0;
+ i15 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i15 + 1;
+ i15 = HEAPU8[i15] | 0;
+ }
+ HEAP32[i2 >> 2] = i15;
+ if ((i15 | 0) != 0) {
+ if ((_memchr(12336, i15, 3) | 0) != 0) {
+ i12 = HEAP32[i4 >> 2] | 0;
+ i11 = i12 + 4 | 0;
+ i16 = HEAP32[i11 >> 2] | 0;
+ i14 = i12 + 8 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ if ((i16 + 1 | 0) >>> 0 > i13 >>> 0) {
+ if (i13 >>> 0 > 2147483645) {
+ i9 = 239;
+ break;
+ }
+ i17 = i13 << 1;
+ i16 = HEAP32[i10 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ i9 = 241;
+ break;
+ }
+ i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
+ HEAP32[i12 >> 2] = i27;
+ HEAP32[i14 >> 2] = i17;
+ i16 = HEAP32[i11 >> 2] | 0;
+ i12 = i27;
+ } else {
+ i12 = HEAP32[i12 >> 2] | 0;
+ }
+ HEAP32[i11 >> 2] = i16 + 1;
+ HEAP8[i12 + i16 | 0] = i15;
+ i11 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i15 = _luaZ_fill(i11) | 0;
+ } else {
+ i27 = i11 + 4 | 0;
+ i15 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i15 + 1;
+ i15 = HEAPU8[i15] | 0;
+ }
+ HEAP32[i2 >> 2] = i15;
+ }
+ } else {
+ i15 = 0;
+ }
+ }
+ } else {
+ i15 = 0;
+ }
+ i12 = HEAP32[i4 >> 2] | 0;
+ i11 = i12 + 4 | 0;
+ i17 = HEAP32[i11 >> 2] | 0;
+ i14 = i12 + 8 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ i16 = (i17 + 1 | 0) >>> 0 > i13 >>> 0;
+ if (!((HEAP8[i15 + 10913 | 0] & 16) != 0 | (i15 | 0) == 46)) {
+ i9 = 259;
+ break;
+ }
+ if (i16) {
+ if (i13 >>> 0 > 2147483645) {
+ i9 = 251;
+ break;
+ }
+ i17 = i13 << 1;
+ i16 = HEAP32[i10 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ i9 = 253;
+ break;
+ }
+ i27 = _luaM_realloc_(i16, HEAP32[i12 >> 2] | 0, i13, i17) | 0;
+ HEAP32[i12 >> 2] = i27;
+ HEAP32[i14 >> 2] = i17;
+ i17 = HEAP32[i11 >> 2] | 0;
+ i12 = i27;
+ } else {
+ i12 = HEAP32[i12 >> 2] | 0;
+ }
+ HEAP32[i11 >> 2] = i17 + 1;
+ HEAP8[i12 + i17 | 0] = i15;
+ i11 = HEAP32[i5 >> 2] | 0;
+ i27 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i27 + -1;
+ if ((i27 | 0) == 0) {
+ i15 = _luaZ_fill(i11) | 0;
+ } else {
+ i27 = i11 + 4 | 0;
+ i15 = HEAP32[i27 >> 2] | 0;
+ HEAP32[i27 >> 2] = i15 + 1;
+ i15 = HEAPU8[i15] | 0;
+ }
+ HEAP32[i2 >> 2] = i15;
+ }
+ if ((i9 | 0) == 227) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 229) {
+ _luaM_toobig(i16);
+ } else if ((i9 | 0) == 239) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 241) {
+ _luaM_toobig(i16);
+ } else if ((i9 | 0) == 251) {
+ _lexerror(i2, 12368, 0);
+ } else if ((i9 | 0) == 253) {
+ _luaM_toobig(i16);
+ } else if ((i9 | 0) == 259) {
+ do {
+ if (i16) {
+ if (i13 >>> 0 > 2147483645) {
+ _lexerror(i2, 12368, 0);
+ }
+ i5 = i13 << 1;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i5 | 0) == -2) {
+ _luaM_toobig(i9);
+ } else {
+ i7 = _luaM_realloc_(i9, HEAP32[i12 >> 2] | 0, i13, i5) | 0;
+ HEAP32[i12 >> 2] = i7;
+ HEAP32[i14 >> 2] = i5;
+ i8 = HEAP32[i11 >> 2] | 0;
+ break;
+ }
+ } else {
+ i8 = i17;
+ i7 = HEAP32[i12 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i11 >> 2] = i8 + 1;
+ HEAP8[i7 + i8 | 0] = 0;
+ i5 = i2 + 76 | 0;
+ i7 = HEAP8[i5] | 0;
+ i10 = HEAP32[i4 >> 2] | 0;
+ i8 = HEAP32[i10 >> 2] | 0;
+ i10 = HEAP32[i10 + 4 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i7 = -1;
+ } else {
+ do {
+ i10 = i10 + -1 | 0;
+ i9 = i8 + i10 | 0;
+ if ((HEAP8[i9] | 0) == 46) {
+ HEAP8[i9] = i7;
+ }
+ } while ((i10 | 0) != 0);
+ i7 = HEAP32[i4 >> 2] | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i7 = (HEAP32[i7 + 4 >> 2] | 0) + -1 | 0;
+ }
+ if ((_luaO_str2d(i8, i7, i3) | 0) != 0) {
+ i27 = 287;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i9 = HEAP8[i5] | 0;
+ i8 = HEAP8[HEAP32[(_localeconv() | 0) >> 2] | 0] | 0;
+ HEAP8[i5] = i8;
+ i10 = HEAP32[i4 >> 2] | 0;
+ i7 = HEAP32[i10 >> 2] | 0;
+ i10 = HEAP32[i10 + 4 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i8 = -1;
+ } else {
+ do {
+ i10 = i10 + -1 | 0;
+ i11 = i7 + i10 | 0;
+ if ((HEAP8[i11] | 0) == i9 << 24 >> 24) {
+ HEAP8[i11] = i8;
+ }
+ } while ((i10 | 0) != 0);
+ i8 = HEAP32[i4 >> 2] | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ i8 = (HEAP32[i8 + 4 >> 2] | 0) + -1 | 0;
+ }
+ if ((_luaO_str2d(i7, i8, i3) | 0) != 0) {
+ i27 = 287;
+ STACKTOP = i1;
+ return i27 | 0;
+ }
+ i1 = HEAP8[i5] | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP32[i4 + 4 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ _lexerror(i2, 12344, 287);
+ } else {
+ i6 = i4;
+ }
+ do {
+ i6 = i6 + -1 | 0;
+ i4 = i3 + i6 | 0;
+ if ((HEAP8[i4] | 0) == i1 << 24 >> 24) {
+ HEAP8[i4] = 46;
+ }
+ } while ((i6 | 0) != 0);
+ _lexerror(i2, 12344, 287);
+ }
+ return 0;
+}
+function _luaV_execute(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, d37 = 0.0, d38 = 0.0, d39 = 0.0;
+ i12 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i13 = i12 + 24 | 0;
+ i10 = i12 + 16 | 0;
+ i9 = i12 + 8 | 0;
+ i8 = i12;
+ i3 = i1 + 16 | 0;
+ i4 = i1 + 40 | 0;
+ i6 = i1 + 12 | 0;
+ i5 = i1 + 8 | 0;
+ i11 = i1 + 24 | 0;
+ i17 = i1 + 48 | 0;
+ i2 = i1 + 20 | 0;
+ i16 = i1 + 6 | 0;
+ i7 = i1 + 44 | 0;
+ i19 = HEAP32[i3 >> 2] | 0;
+ L1 : while (1) {
+ i22 = HEAP32[HEAP32[i19 >> 2] >> 2] | 0;
+ i18 = i22 + 12 | 0;
+ i23 = HEAP32[(HEAP32[i18 >> 2] | 0) + 8 >> 2] | 0;
+ i20 = i19 + 24 | 0;
+ i21 = i19 + 28 | 0;
+ i22 = i22 + 16 | 0;
+ i24 = i19 + 4 | 0;
+ i25 = HEAP32[i20 >> 2] | 0;
+ L3 : while (1) {
+ i28 = HEAP32[i21 >> 2] | 0;
+ HEAP32[i21 >> 2] = i28 + 4;
+ i28 = HEAP32[i28 >> 2] | 0;
+ i27 = HEAP8[i4] | 0;
+ do {
+ if (!((i27 & 12) == 0)) {
+ i26 = (HEAP32[i17 >> 2] | 0) + -1 | 0;
+ HEAP32[i17 >> 2] = i26;
+ i26 = (i26 | 0) == 0;
+ if (!i26 ? (i27 & 4) == 0 : 0) {
+ break;
+ }
+ i25 = HEAP32[i3 >> 2] | 0;
+ i29 = i27 & 255;
+ if ((i29 & 8 | 0) == 0 | i26 ^ 1) {
+ i27 = 0;
+ } else {
+ HEAP32[i17 >> 2] = HEAP32[i7 >> 2];
+ i27 = 1;
+ }
+ i26 = i25 + 18 | 0;
+ i30 = HEAPU8[i26] | 0;
+ if ((i30 & 128 | 0) == 0) {
+ if (i27) {
+ _luaD_hook(i1, 3, -1);
+ }
+ do {
+ if ((i29 & 4 | 0) == 0) {
+ i29 = i25 + 28 | 0;
+ } else {
+ i34 = HEAP32[(HEAP32[HEAP32[i25 >> 2] >> 2] | 0) + 12 >> 2] | 0;
+ i29 = i25 + 28 | 0;
+ i32 = HEAP32[i29 >> 2] | 0;
+ i35 = HEAP32[i34 + 12 >> 2] | 0;
+ i33 = (i32 - i35 >> 2) + -1 | 0;
+ i34 = HEAP32[i34 + 20 >> 2] | 0;
+ i31 = (i34 | 0) == 0;
+ if (i31) {
+ i30 = 0;
+ } else {
+ i30 = HEAP32[i34 + (i33 << 2) >> 2] | 0;
+ }
+ if ((i33 | 0) != 0 ? (i14 = HEAP32[i2 >> 2] | 0, i32 >>> 0 > i14 >>> 0) : 0) {
+ if (i31) {
+ i31 = 0;
+ } else {
+ i31 = HEAP32[i34 + ((i14 - i35 >> 2) + -1 << 2) >> 2] | 0;
+ }
+ if ((i30 | 0) == (i31 | 0)) {
+ break;
+ }
+ }
+ _luaD_hook(i1, 2, i30);
+ }
+ } while (0);
+ HEAP32[i2 >> 2] = HEAP32[i29 >> 2];
+ if ((HEAP8[i16] | 0) == 1) {
+ i15 = 23;
+ break L1;
+ }
+ } else {
+ HEAP8[i26] = i30 & 127;
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ }
+ } while (0);
+ i26 = i28 >>> 6 & 255;
+ i27 = i25 + (i26 << 4) | 0;
+ switch (i28 & 63 | 0) {
+ case 9:
+ {
+ i28 = HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0;
+ i35 = HEAP32[i28 + 8 >> 2] | 0;
+ i33 = i27;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i36 = i35;
+ HEAP32[i36 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i36 + 4 >> 2] = i34;
+ i36 = i25 + (i26 << 4) + 8 | 0;
+ HEAP32[i35 + 8 >> 2] = HEAP32[i36 >> 2];
+ if ((HEAP32[i36 >> 2] & 64 | 0) == 0) {
+ continue L3;
+ }
+ i26 = HEAP32[i27 >> 2] | 0;
+ if ((HEAP8[i26 + 5 | 0] & 3) == 0) {
+ continue L3;
+ }
+ if ((HEAP8[i28 + 5 | 0] & 4) == 0) {
+ continue L3;
+ }
+ _luaC_barrier_(i1, i28, i26);
+ continue L3;
+ }
+ case 10:
+ {
+ i26 = i28 >>> 23;
+ if ((i26 & 256 | 0) == 0) {
+ i26 = i25 + (i26 << 4) | 0;
+ } else {
+ i26 = i23 + ((i26 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i25 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ _luaV_settable(i1, i27, i26, i25);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 17:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ d37 = +HEAPF64[i29 >> 3];
+ d38 = +HEAPF64[i28 >> 3];
+ HEAPF64[i27 >> 3] = d37 - d38 * +Math_floor(+(d37 / d38));
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 10);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 23:
+ {
+ if ((i26 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i26 + -1 << 4) | 0);
+ }
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
+ continue L3;
+ }
+ case 24:
+ {
+ i27 = i28 >>> 23;
+ if ((i27 & 256 | 0) == 0) {
+ i27 = i25 + (i27 << 4) | 0;
+ } else {
+ i27 = i23 + ((i27 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i25 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i27 + 8 >> 2] | 0) == (HEAP32[i25 + 8 >> 2] | 0)) {
+ i27 = (_luaV_equalobj_(i1, i27, i25) | 0) != 0;
+ } else {
+ i27 = 0;
+ }
+ i25 = HEAP32[i21 >> 2] | 0;
+ if ((i27 & 1 | 0) == (i26 | 0)) {
+ i26 = HEAP32[i25 >> 2] | 0;
+ i27 = i26 >>> 6 & 255;
+ if ((i27 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
+ i25 = HEAP32[i21 >> 2] | 0;
+ }
+ i25 = i25 + ((i26 >>> 14) + -131070 << 2) | 0;
+ } else {
+ i25 = i25 + 4 | 0;
+ }
+ HEAP32[i21 >> 2] = i25;
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 18:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ HEAPF64[i27 >> 3] = +Math_pow(+(+HEAPF64[i29 >> 3]), +(+HEAPF64[i28 >> 3]));
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 11);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 1:
+ {
+ i36 = i28 >>> 14;
+ i33 = i23 + (i36 << 4) | 0;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i27;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i23 + (i36 << 4) + 8 >> 2];
+ continue L3;
+ }
+ case 0:
+ {
+ i36 = i28 >>> 23;
+ i33 = i25 + (i36 << 4) | 0;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i27;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
+ continue L3;
+ }
+ case 2:
+ {
+ i36 = HEAP32[i21 >> 2] | 0;
+ HEAP32[i21 >> 2] = i36 + 4;
+ i36 = (HEAP32[i36 >> 2] | 0) >>> 6;
+ i33 = i23 + (i36 << 4) | 0;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i27;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i23 + (i36 << 4) + 8 >> 2];
+ continue L3;
+ }
+ case 5:
+ {
+ i36 = HEAP32[(HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0) + 8 >> 2] | 0;
+ i33 = i36;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i27;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i36 + 8 >> 2];
+ continue L3;
+ }
+ case 3:
+ {
+ HEAP32[i27 >> 2] = i28 >>> 23;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 1;
+ if ((i28 & 8372224 | 0) == 0) {
+ continue L3;
+ }
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
+ continue L3;
+ }
+ case 7:
+ {
+ i26 = i28 >>> 14;
+ if ((i26 & 256 | 0) == 0) {
+ i26 = i25 + ((i26 & 511) << 4) | 0;
+ } else {
+ i26 = i23 + ((i26 & 255) << 4) | 0;
+ }
+ _luaV_gettable(i1, i25 + (i28 >>> 23 << 4) | 0, i26, i27);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 12:
+ {
+ i36 = i28 >>> 23;
+ i29 = i25 + (i36 << 4) | 0;
+ i26 = i26 + 1 | 0;
+ i33 = i29;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i25 + (i26 << 4) | 0;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
+ i26 = i28 >>> 14;
+ if ((i26 & 256 | 0) == 0) {
+ i25 = i25 + ((i26 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i26 & 255) << 4) | 0;
+ }
+ _luaV_gettable(i1, i29, i25, i27);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 13:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] + +HEAPF64[i28 >> 3];
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 6);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 14:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] - +HEAPF64[i28 >> 3];
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 7);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 6:
+ {
+ i26 = i28 >>> 14;
+ if ((i26 & 256 | 0) == 0) {
+ i25 = i25 + ((i26 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i26 & 255) << 4) | 0;
+ }
+ _luaV_gettable(i1, HEAP32[(HEAP32[i22 + (i28 >>> 23 << 2) >> 2] | 0) + 8 >> 2] | 0, i25, i27);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 4:
+ {
+ i26 = i28 >>> 23;
+ while (1) {
+ HEAP32[i27 + 8 >> 2] = 0;
+ if ((i26 | 0) == 0) {
+ continue L3;
+ } else {
+ i26 = i26 + -1 | 0;
+ i27 = i27 + 16 | 0;
+ }
+ }
+ }
+ case 8:
+ {
+ i27 = i28 >>> 23;
+ if ((i27 & 256 | 0) == 0) {
+ i27 = i25 + (i27 << 4) | 0;
+ } else {
+ i27 = i23 + ((i27 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i25 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ _luaV_settable(i1, HEAP32[(HEAP32[i22 + (i26 << 2) >> 2] | 0) + 8 >> 2] | 0, i27, i25);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 11:
+ {
+ i29 = i28 >>> 23;
+ i28 = i28 >>> 14 & 511;
+ i30 = _luaH_new(i1) | 0;
+ HEAP32[i27 >> 2] = i30;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 69;
+ if ((i28 | i29 | 0) != 0) {
+ i36 = _luaO_fb2int(i29) | 0;
+ _luaH_resize(i1, i30, i36, _luaO_fb2int(i28) | 0);
+ }
+ if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ HEAP32[i5 >> 2] = i25 + (i26 + 1 << 4);
+ _luaC_step(i1);
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 19:
+ {
+ i36 = i28 >>> 23;
+ i28 = i25 + (i36 << 4) | 0;
+ if ((HEAP32[i25 + (i36 << 4) + 8 >> 2] | 0) == 3) {
+ HEAPF64[i27 >> 3] = -+HEAPF64[i28 >> 3];
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ } else {
+ _luaV_arith(i1, i27, i28, i28, 12);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ }
+ case 15:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] * +HEAPF64[i28 >> 3];
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 8);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 16:
+ {
+ i29 = i28 >>> 23;
+ if ((i29 & 256 | 0) == 0) {
+ i29 = i25 + (i29 << 4) | 0;
+ } else {
+ i29 = i23 + ((i29 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i28 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i28 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ if ((HEAP32[i29 + 8 >> 2] | 0) == 3 ? (HEAP32[i28 + 8 >> 2] | 0) == 3 : 0) {
+ HEAPF64[i27 >> 3] = +HEAPF64[i29 >> 3] / +HEAPF64[i28 >> 3];
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ _luaV_arith(i1, i27, i29, i28, 9);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 20:
+ {
+ i29 = i28 >>> 23;
+ i28 = HEAP32[i25 + (i29 << 4) + 8 >> 2] | 0;
+ if ((i28 | 0) != 0) {
+ if ((i28 | 0) == 1) {
+ i28 = (HEAP32[i25 + (i29 << 4) >> 2] | 0) == 0;
+ } else {
+ i28 = 0;
+ }
+ } else {
+ i28 = 1;
+ }
+ HEAP32[i27 >> 2] = i28 & 1;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 1;
+ continue L3;
+ }
+ case 21:
+ {
+ _luaV_objlen(i1, i27, i25 + (i28 >>> 23 << 4) | 0);
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 22:
+ {
+ i27 = i28 >>> 23;
+ i28 = i28 >>> 14 & 511;
+ HEAP32[i5 >> 2] = i25 + (i28 + 1 << 4);
+ _luaV_concat(i1, 1 - i27 + i28 | 0);
+ i25 = HEAP32[i20 >> 2] | 0;
+ i28 = i25 + (i27 << 4) | 0;
+ i34 = i28;
+ i35 = HEAP32[i34 + 4 >> 2] | 0;
+ i36 = i25 + (i26 << 4) | 0;
+ HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
+ HEAP32[i36 + 4 >> 2] = i35;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = HEAP32[i25 + (i27 << 4) + 8 >> 2];
+ if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ if (!(i26 >>> 0 < i27 >>> 0)) {
+ i28 = i25 + (i26 + 1 << 4) | 0;
+ }
+ HEAP32[i5 >> 2] = i28;
+ _luaC_step(i1);
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ continue L3;
+ }
+ case 25:
+ {
+ i27 = i28 >>> 23;
+ if ((i27 & 256 | 0) == 0) {
+ i27 = i25 + (i27 << 4) | 0;
+ } else {
+ i27 = i23 + ((i27 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i25 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ i36 = (_luaV_lessthan(i1, i27, i25) | 0) == (i26 | 0);
+ i26 = HEAP32[i21 >> 2] | 0;
+ if (i36) {
+ i25 = HEAP32[i26 >> 2] | 0;
+ i27 = i25 >>> 6 & 255;
+ if ((i27 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
+ i26 = HEAP32[i21 >> 2] | 0;
+ }
+ i25 = i26 + ((i25 >>> 14) + -131070 << 2) | 0;
+ } else {
+ i25 = i26 + 4 | 0;
+ }
+ HEAP32[i21 >> 2] = i25;
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 27:
+ {
+ i29 = HEAP32[i25 + (i26 << 4) + 8 >> 2] | 0;
+ i26 = (i29 | 0) == 0;
+ if ((i28 & 8372224 | 0) == 0) {
+ if (!i26) {
+ if (!((i29 | 0) == 1 ? (HEAP32[i27 >> 2] | 0) == 0 : 0)) {
+ i15 = 192;
+ }
+ }
+ } else {
+ if (!i26) {
+ if ((i29 | 0) == 1 ? (HEAP32[i27 >> 2] | 0) == 0 : 0) {
+ i15 = 192;
+ }
+ } else {
+ i15 = 192;
+ }
+ }
+ if ((i15 | 0) == 192) {
+ i15 = 0;
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
+ continue L3;
+ }
+ i27 = HEAP32[i21 >> 2] | 0;
+ i26 = HEAP32[i27 >> 2] | 0;
+ i28 = i26 >>> 6 & 255;
+ if ((i28 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i28 + -1 << 4) | 0);
+ i27 = HEAP32[i21 >> 2] | 0;
+ }
+ HEAP32[i21 >> 2] = i27 + ((i26 >>> 14) + -131070 << 2);
+ continue L3;
+ }
+ case 26:
+ {
+ i27 = i28 >>> 23;
+ if ((i27 & 256 | 0) == 0) {
+ i27 = i25 + (i27 << 4) | 0;
+ } else {
+ i27 = i23 + ((i27 & 255) << 4) | 0;
+ }
+ i28 = i28 >>> 14;
+ if ((i28 & 256 | 0) == 0) {
+ i25 = i25 + ((i28 & 511) << 4) | 0;
+ } else {
+ i25 = i23 + ((i28 & 255) << 4) | 0;
+ }
+ i36 = (_luaV_lessequal(i1, i27, i25) | 0) == (i26 | 0);
+ i26 = HEAP32[i21 >> 2] | 0;
+ if (i36) {
+ i25 = HEAP32[i26 >> 2] | 0;
+ i27 = i25 >>> 6 & 255;
+ if ((i27 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i27 + -1 << 4) | 0);
+ i26 = HEAP32[i21 >> 2] | 0;
+ }
+ i25 = i26 + ((i25 >>> 14) + -131070 << 2) | 0;
+ } else {
+ i25 = i26 + 4 | 0;
+ }
+ HEAP32[i21 >> 2] = i25;
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 28:
+ {
+ i30 = i28 >>> 23;
+ i29 = i25 + (i30 << 4) | 0;
+ i30 = HEAP32[i25 + (i30 << 4) + 8 >> 2] | 0;
+ i31 = (i30 | 0) == 0;
+ if ((i28 & 8372224 | 0) == 0) {
+ if (!i31) {
+ if (!((i30 | 0) == 1 ? (HEAP32[i29 >> 2] | 0) == 0 : 0)) {
+ i15 = 203;
+ }
+ }
+ } else {
+ if (!i31) {
+ if ((i30 | 0) == 1 ? (HEAP32[i29 >> 2] | 0) == 0 : 0) {
+ i15 = 203;
+ }
+ } else {
+ i15 = 203;
+ }
+ }
+ if ((i15 | 0) == 203) {
+ i15 = 0;
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + 4;
+ continue L3;
+ }
+ i36 = i29;
+ i28 = HEAP32[i36 + 4 >> 2] | 0;
+ HEAP32[i27 >> 2] = HEAP32[i36 >> 2];
+ HEAP32[i27 + 4 >> 2] = i28;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = i30;
+ i27 = HEAP32[i21 >> 2] | 0;
+ i26 = HEAP32[i27 >> 2] | 0;
+ i28 = i26 >>> 6 & 255;
+ if ((i28 | 0) != 0) {
+ _luaF_close(i1, (HEAP32[i20 >> 2] | 0) + (i28 + -1 << 4) | 0);
+ i27 = HEAP32[i21 >> 2] | 0;
+ }
+ HEAP32[i21 >> 2] = i27 + ((i26 >>> 14) + -131070 << 2);
+ continue L3;
+ }
+ case 30:
+ {
+ i28 = i28 >>> 23;
+ if ((i28 | 0) != 0) {
+ HEAP32[i5 >> 2] = i25 + (i26 + i28 << 4);
+ }
+ if ((_luaD_precall(i1, i27, -1) | 0) == 0) {
+ i15 = 218;
+ break L3;
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 29:
+ {
+ i29 = i28 >>> 23;
+ i28 = i28 >>> 14 & 511;
+ if ((i29 | 0) != 0) {
+ HEAP32[i5 >> 2] = i25 + (i26 + i29 << 4);
+ }
+ if ((_luaD_precall(i1, i27, i28 + -1 | 0) | 0) == 0) {
+ i15 = 213;
+ break L3;
+ }
+ if ((i28 | 0) != 0) {
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 32:
+ {
+ d39 = +HEAPF64[i25 + (i26 + 2 << 4) >> 3];
+ d38 = d39 + +HEAPF64[i27 >> 3];
+ d37 = +HEAPF64[i25 + (i26 + 1 << 4) >> 3];
+ if (d39 > 0.0) {
+ if (!(d38 <= d37)) {
+ continue L3;
+ }
+ } else {
+ if (!(d37 <= d38)) {
+ continue L3;
+ }
+ }
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
+ HEAPF64[i27 >> 3] = d38;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 3;
+ i36 = i26 + 3 | 0;
+ HEAPF64[i25 + (i36 << 4) >> 3] = d38;
+ HEAP32[i25 + (i36 << 4) + 8 >> 2] = 3;
+ continue L3;
+ }
+ case 33:
+ {
+ i32 = i26 + 1 | 0;
+ i30 = i25 + (i32 << 4) | 0;
+ i31 = i26 + 2 | 0;
+ i29 = i25 + (i31 << 4) | 0;
+ i26 = i25 + (i26 << 4) + 8 | 0;
+ i33 = HEAP32[i26 >> 2] | 0;
+ if ((i33 | 0) != 3) {
+ if ((i33 & 15 | 0) != 4) {
+ i15 = 239;
+ break L1;
+ }
+ i36 = HEAP32[i27 >> 2] | 0;
+ if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i8) | 0) == 0) {
+ i15 = 239;
+ break L1;
+ }
+ HEAPF64[i27 >> 3] = +HEAPF64[i8 >> 3];
+ HEAP32[i26 >> 2] = 3;
+ if ((i27 | 0) == 0) {
+ i15 = 239;
+ break L1;
+ }
+ }
+ i33 = i25 + (i32 << 4) + 8 | 0;
+ i32 = HEAP32[i33 >> 2] | 0;
+ if ((i32 | 0) != 3) {
+ if ((i32 & 15 | 0) != 4) {
+ i15 = 244;
+ break L1;
+ }
+ i36 = HEAP32[i30 >> 2] | 0;
+ if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i9) | 0) == 0) {
+ i15 = 244;
+ break L1;
+ }
+ HEAPF64[i30 >> 3] = +HEAPF64[i9 >> 3];
+ HEAP32[i33 >> 2] = 3;
+ }
+ i31 = i25 + (i31 << 4) + 8 | 0;
+ i30 = HEAP32[i31 >> 2] | 0;
+ if ((i30 | 0) != 3) {
+ if ((i30 & 15 | 0) != 4) {
+ i15 = 249;
+ break L1;
+ }
+ i36 = HEAP32[i29 >> 2] | 0;
+ if ((_luaO_str2d(i36 + 16 | 0, HEAP32[i36 + 12 >> 2] | 0, i10) | 0) == 0) {
+ i15 = 249;
+ break L1;
+ }
+ HEAPF64[i29 >> 3] = +HEAPF64[i10 >> 3];
+ HEAP32[i31 >> 2] = 3;
+ }
+ HEAPF64[i27 >> 3] = +HEAPF64[i27 >> 3] - +HEAPF64[i29 >> 3];
+ HEAP32[i26 >> 2] = 3;
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
+ continue L3;
+ }
+ case 31:
+ {
+ i15 = 223;
+ break L3;
+ }
+ case 34:
+ {
+ i35 = i26 + 3 | 0;
+ i36 = i25 + (i35 << 4) | 0;
+ i33 = i26 + 2 | 0;
+ i34 = i26 + 5 | 0;
+ i32 = i25 + (i33 << 4) | 0;
+ i31 = HEAP32[i32 + 4 >> 2] | 0;
+ i30 = i25 + (i34 << 4) | 0;
+ HEAP32[i30 >> 2] = HEAP32[i32 >> 2];
+ HEAP32[i30 + 4 >> 2] = i31;
+ HEAP32[i25 + (i34 << 4) + 8 >> 2] = HEAP32[i25 + (i33 << 4) + 8 >> 2];
+ i34 = i26 + 1 | 0;
+ i33 = i26 + 4 | 0;
+ i30 = i25 + (i34 << 4) | 0;
+ i31 = HEAP32[i30 + 4 >> 2] | 0;
+ i32 = i25 + (i33 << 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i30 >> 2];
+ HEAP32[i32 + 4 >> 2] = i31;
+ HEAP32[i25 + (i33 << 4) + 8 >> 2] = HEAP32[i25 + (i34 << 4) + 8 >> 2];
+ i33 = i27;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i27 = i36;
+ HEAP32[i27 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i27 + 4 >> 2] = i34;
+ HEAP32[i25 + (i35 << 4) + 8 >> 2] = HEAP32[i25 + (i26 << 4) + 8 >> 2];
+ HEAP32[i5 >> 2] = i25 + (i26 + 6 << 4);
+ _luaD_call(i1, i36, i28 >>> 14 & 511, 1);
+ i36 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ i27 = HEAP32[i21 >> 2] | 0;
+ HEAP32[i21 >> 2] = i27 + 4;
+ i27 = HEAP32[i27 >> 2] | 0;
+ i25 = i36;
+ i28 = i27;
+ i27 = i36 + ((i27 >>> 6 & 255) << 4) | 0;
+ break;
+ }
+ case 35:
+ {
+ break;
+ }
+ case 36:
+ {
+ i29 = i28 >>> 23;
+ i28 = i28 >>> 14 & 511;
+ if ((i29 | 0) == 0) {
+ i29 = ((HEAP32[i5 >> 2] | 0) - i27 >> 4) + -1 | 0;
+ }
+ if ((i28 | 0) == 0) {
+ i28 = HEAP32[i21 >> 2] | 0;
+ HEAP32[i21 >> 2] = i28 + 4;
+ i28 = (HEAP32[i28 >> 2] | 0) >>> 6;
+ }
+ i27 = HEAP32[i27 >> 2] | 0;
+ i30 = i29 + -50 + (i28 * 50 | 0) | 0;
+ if ((i30 | 0) > (HEAP32[i27 + 28 >> 2] | 0)) {
+ _luaH_resizearray(i1, i27, i30);
+ }
+ if ((i29 | 0) > 0) {
+ i28 = i27 + 5 | 0;
+ while (1) {
+ i36 = i29 + i26 | 0;
+ i32 = i25 + (i36 << 4) | 0;
+ i31 = i30 + -1 | 0;
+ _luaH_setint(i1, i27, i30, i32);
+ if (((HEAP32[i25 + (i36 << 4) + 8 >> 2] & 64 | 0) != 0 ? !((HEAP8[(HEAP32[i32 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) ? !((HEAP8[i28] & 4) == 0) : 0) {
+ _luaC_barrierback_(i1, i27);
+ }
+ i29 = i29 + -1 | 0;
+ if ((i29 | 0) > 0) {
+ i30 = i31;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ continue L3;
+ }
+ case 37:
+ {
+ i29 = HEAP32[(HEAP32[(HEAP32[i18 >> 2] | 0) + 16 >> 2] | 0) + (i28 >>> 14 << 2) >> 2] | 0;
+ i28 = i29 + 32 | 0;
+ i33 = HEAP32[i28 >> 2] | 0;
+ i30 = HEAP32[i29 + 40 >> 2] | 0;
+ i31 = HEAP32[i29 + 28 >> 2] | 0;
+ L323 : do {
+ if ((i33 | 0) == 0) {
+ i15 = 276;
+ } else {
+ if ((i30 | 0) > 0) {
+ i34 = i33 + 16 | 0;
+ i32 = 0;
+ while (1) {
+ i35 = HEAPU8[i31 + (i32 << 3) + 5 | 0] | 0;
+ if ((HEAP8[i31 + (i32 << 3) + 4 | 0] | 0) == 0) {
+ i36 = HEAP32[(HEAP32[i22 + (i35 << 2) >> 2] | 0) + 8 >> 2] | 0;
+ } else {
+ i36 = i25 + (i35 << 4) | 0;
+ }
+ i35 = i32 + 1 | 0;
+ if ((HEAP32[(HEAP32[i34 + (i32 << 2) >> 2] | 0) + 8 >> 2] | 0) != (i36 | 0)) {
+ i15 = 276;
+ break L323;
+ }
+ if ((i35 | 0) < (i30 | 0)) {
+ i32 = i35;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP32[i27 >> 2] = i33;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 70;
+ }
+ } while (0);
+ if ((i15 | 0) == 276) {
+ i15 = 0;
+ i32 = _luaF_newLclosure(i1, i30) | 0;
+ HEAP32[i32 + 12 >> 2] = i29;
+ HEAP32[i27 >> 2] = i32;
+ HEAP32[i25 + (i26 << 4) + 8 >> 2] = 70;
+ if ((i30 | 0) > 0) {
+ i27 = i32 + 16 | 0;
+ i34 = 0;
+ do {
+ i33 = HEAPU8[i31 + (i34 << 3) + 5 | 0] | 0;
+ if ((HEAP8[i31 + (i34 << 3) + 4 | 0] | 0) == 0) {
+ HEAP32[i27 + (i34 << 2) >> 2] = HEAP32[i22 + (i33 << 2) >> 2];
+ } else {
+ HEAP32[i27 + (i34 << 2) >> 2] = _luaF_findupval(i1, i25 + (i33 << 4) | 0) | 0;
+ }
+ i34 = i34 + 1 | 0;
+ } while ((i34 | 0) != (i30 | 0));
+ }
+ if (!((HEAP8[i29 + 5 | 0] & 4) == 0)) {
+ _luaC_barrierproto_(i1, i29, i32);
+ }
+ HEAP32[i28 >> 2] = i32;
+ }
+ if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ HEAP32[i5 >> 2] = i25 + (i26 + 1 << 4);
+ _luaC_step(i1);
+ HEAP32[i5 >> 2] = HEAP32[i24 >> 2];
+ }
+ i25 = HEAP32[i20 >> 2] | 0;
+ continue L3;
+ }
+ case 38:
+ {
+ i36 = i28 >>> 23;
+ i29 = i36 + -1 | 0;
+ i30 = (i25 - (HEAP32[i19 >> 2] | 0) >> 4) - (HEAPU8[(HEAP32[i18 >> 2] | 0) + 76 | 0] | 0) | 0;
+ i28 = i30 + -1 | 0;
+ if ((i36 | 0) == 0) {
+ if (((HEAP32[i11 >> 2] | 0) - (HEAP32[i5 >> 2] | 0) >> 4 | 0) <= (i28 | 0)) {
+ _luaD_growstack(i1, i28);
+ }
+ i27 = HEAP32[i20 >> 2] | 0;
+ HEAP32[i5 >> 2] = i27 + (i28 + i26 << 4);
+ i29 = i28;
+ i25 = i27;
+ i27 = i27 + (i26 << 4) | 0;
+ }
+ if ((i29 | 0) <= 0) {
+ continue L3;
+ }
+ i26 = 1 - i30 | 0;
+ i30 = 0;
+ while (1) {
+ if ((i30 | 0) < (i28 | 0)) {
+ i36 = i30 + i26 | 0;
+ i33 = i25 + (i36 << 4) | 0;
+ i34 = HEAP32[i33 + 4 >> 2] | 0;
+ i35 = i27 + (i30 << 4) | 0;
+ HEAP32[i35 >> 2] = HEAP32[i33 >> 2];
+ HEAP32[i35 + 4 >> 2] = i34;
+ HEAP32[i27 + (i30 << 4) + 8 >> 2] = HEAP32[i25 + (i36 << 4) + 8 >> 2];
+ } else {
+ HEAP32[i27 + (i30 << 4) + 8 >> 2] = 0;
+ }
+ i30 = i30 + 1 | 0;
+ if ((i30 | 0) == (i29 | 0)) {
+ continue L3;
+ }
+ }
+ }
+ default:
+ {
+ continue L3;
+ }
+ }
+ i26 = HEAP32[i27 + 24 >> 2] | 0;
+ if ((i26 | 0) == 0) {
+ continue;
+ }
+ i34 = i27 + 16 | 0;
+ i35 = HEAP32[i34 + 4 >> 2] | 0;
+ i36 = i27;
+ HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
+ HEAP32[i36 + 4 >> 2] = i35;
+ HEAP32[i27 + 8 >> 2] = i26;
+ HEAP32[i21 >> 2] = (HEAP32[i21 >> 2] | 0) + ((i28 >>> 14) + -131071 << 2);
+ }
+ if ((i15 | 0) == 213) {
+ i15 = 0;
+ i19 = HEAP32[i3 >> 2] | 0;
+ i36 = i19 + 18 | 0;
+ HEAP8[i36] = HEAPU8[i36] | 4;
+ continue;
+ } else if ((i15 | 0) == 218) {
+ i15 = 0;
+ i22 = HEAP32[i3 >> 2] | 0;
+ i19 = HEAP32[i22 + 8 >> 2] | 0;
+ i23 = HEAP32[i22 >> 2] | 0;
+ i24 = HEAP32[i19 >> 2] | 0;
+ i20 = i22 + 24 | 0;
+ i21 = (HEAP32[i20 >> 2] | 0) + (HEAPU8[(HEAP32[(HEAP32[i23 >> 2] | 0) + 12 >> 2] | 0) + 76 | 0] << 4) | 0;
+ if ((HEAP32[(HEAP32[i18 >> 2] | 0) + 56 >> 2] | 0) > 0) {
+ _luaF_close(i1, HEAP32[i19 + 24 >> 2] | 0);
+ }
+ if (i23 >>> 0 < i21 >>> 0) {
+ i25 = i23;
+ i18 = 0;
+ do {
+ i34 = i25;
+ i35 = HEAP32[i34 + 4 >> 2] | 0;
+ i36 = i24 + (i18 << 4) | 0;
+ HEAP32[i36 >> 2] = HEAP32[i34 >> 2];
+ HEAP32[i36 + 4 >> 2] = i35;
+ HEAP32[i24 + (i18 << 4) + 8 >> 2] = HEAP32[i23 + (i18 << 4) + 8 >> 2];
+ i18 = i18 + 1 | 0;
+ i25 = i23 + (i18 << 4) | 0;
+ } while (i25 >>> 0 < i21 >>> 0);
+ }
+ i36 = i23;
+ HEAP32[i19 + 24 >> 2] = i24 + ((HEAP32[i20 >> 2] | 0) - i36 >> 4 << 4);
+ i36 = i24 + ((HEAP32[i5 >> 2] | 0) - i36 >> 4 << 4) | 0;
+ HEAP32[i5 >> 2] = i36;
+ HEAP32[i19 + 4 >> 2] = i36;
+ HEAP32[i19 + 28 >> 2] = HEAP32[i22 + 28 >> 2];
+ i36 = i19 + 18 | 0;
+ HEAP8[i36] = HEAPU8[i36] | 64;
+ HEAP32[i3 >> 2] = i19;
+ continue;
+ } else if ((i15 | 0) == 223) {
+ i15 = 0;
+ i20 = i28 >>> 23;
+ if ((i20 | 0) != 0) {
+ HEAP32[i5 >> 2] = i25 + (i20 + -1 + i26 << 4);
+ }
+ if ((HEAP32[(HEAP32[i18 >> 2] | 0) + 56 >> 2] | 0) > 0) {
+ _luaF_close(i1, i25);
+ }
+ i18 = _luaD_poscall(i1, i27) | 0;
+ if ((HEAP8[i19 + 18 | 0] & 4) == 0) {
+ i15 = 228;
+ break;
+ }
+ i19 = HEAP32[i3 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ continue;
+ }
+ HEAP32[i5 >> 2] = HEAP32[i19 + 4 >> 2];
+ continue;
+ }
+ }
+ if ((i15 | 0) == 23) {
+ if (!i27) {
+ i36 = HEAP32[i29 >> 2] | 0;
+ i36 = i36 + -4 | 0;
+ HEAP32[i29 >> 2] = i36;
+ i36 = HEAP8[i26] | 0;
+ i36 = i36 & 255;
+ i36 = i36 | 128;
+ i36 = i36 & 255;
+ HEAP8[i26] = i36;
+ i36 = HEAP32[i5 >> 2] | 0;
+ i36 = i36 + -16 | 0;
+ HEAP32[i25 >> 2] = i36;
+ _luaD_throw(i1, 1);
+ }
+ HEAP32[i17 >> 2] = 1;
+ i36 = HEAP32[i29 >> 2] | 0;
+ i36 = i36 + -4 | 0;
+ HEAP32[i29 >> 2] = i36;
+ i36 = HEAP8[i26] | 0;
+ i36 = i36 & 255;
+ i36 = i36 | 128;
+ i36 = i36 & 255;
+ HEAP8[i26] = i36;
+ i36 = HEAP32[i5 >> 2] | 0;
+ i36 = i36 + -16 | 0;
+ HEAP32[i25 >> 2] = i36;
+ _luaD_throw(i1, 1);
+ } else if ((i15 | 0) == 228) {
+ STACKTOP = i12;
+ return;
+ } else if ((i15 | 0) == 239) {
+ _luaG_runerror(i1, 9040, i13);
+ } else if ((i15 | 0) == 244) {
+ _luaG_runerror(i1, 9080, i13);
+ } else if ((i15 | 0) == 249) {
+ _luaG_runerror(i1, 9112, i13);
+ }
+}
+function ___floatscan(i8, i2, i11) {
+ i8 = i8 | 0;
+ i2 = i2 | 0;
+ i11 = i11 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i12 = 0, i13 = 0, d14 = 0.0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, d28 = 0.0, i29 = 0, d30 = 0.0, d31 = 0.0, d32 = 0.0, d33 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 512 | 0;
+ i5 = i1;
+ if ((i2 | 0) == 1) {
+ i2 = 53;
+ i3 = -1074;
+ } else if ((i2 | 0) == 2) {
+ i2 = 53;
+ i3 = -1074;
+ } else if ((i2 | 0) == 0) {
+ i2 = 24;
+ i3 = -149;
+ } else {
+ d31 = 0.0;
+ STACKTOP = i1;
+ return +d31;
+ }
+ i9 = i8 + 4 | 0;
+ i10 = i8 + 100 | 0;
+ do {
+ i4 = HEAP32[i9 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i4 + 1;
+ i21 = HEAPU8[i4] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ } while ((_isspace(i21 | 0) | 0) != 0);
+ do {
+ if ((i21 | 0) == 43 | (i21 | 0) == 45) {
+ i4 = 1 - (((i21 | 0) == 45) << 1) | 0;
+ i7 = HEAP32[i9 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i7 + 1;
+ i21 = HEAPU8[i7] | 0;
+ break;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ break;
+ }
+ } else {
+ i4 = 1;
+ }
+ } while (0);
+ i7 = 0;
+ do {
+ if ((i21 | 32 | 0) != (HEAP8[13408 + i7 | 0] | 0)) {
+ break;
+ }
+ do {
+ if (i7 >>> 0 < 7) {
+ i12 = HEAP32[i9 >> 2] | 0;
+ if (i12 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i12 + 1;
+ i21 = HEAPU8[i12] | 0;
+ break;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ break;
+ }
+ }
+ } while (0);
+ i7 = i7 + 1 | 0;
+ } while (i7 >>> 0 < 8);
+ do {
+ if ((i7 | 0) == 3) {
+ i13 = 23;
+ } else if ((i7 | 0) != 8) {
+ i12 = (i11 | 0) == 0;
+ if (!(i7 >>> 0 < 4 | i12)) {
+ if ((i7 | 0) == 8) {
+ break;
+ } else {
+ i13 = 23;
+ break;
+ }
+ }
+ L34 : do {
+ if ((i7 | 0) == 0) {
+ i7 = 0;
+ do {
+ if ((i21 | 32 | 0) != (HEAP8[13424 + i7 | 0] | 0)) {
+ break L34;
+ }
+ do {
+ if (i7 >>> 0 < 2) {
+ i15 = HEAP32[i9 >> 2] | 0;
+ if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i15 + 1;
+ i21 = HEAPU8[i15] | 0;
+ break;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ break;
+ }
+ }
+ } while (0);
+ i7 = i7 + 1 | 0;
+ } while (i7 >>> 0 < 3);
+ }
+ } while (0);
+ if ((i7 | 0) == 0) {
+ do {
+ if ((i21 | 0) == 48) {
+ i7 = HEAP32[i9 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i7 + 1;
+ i7 = HEAPU8[i7] | 0;
+ } else {
+ i7 = ___shgetc(i8) | 0;
+ }
+ if ((i7 | 32 | 0) != 120) {
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ i21 = 48;
+ break;
+ }
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i21 = 48;
+ break;
+ }
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i5 + 1;
+ i21 = HEAPU8[i5] | 0;
+ i19 = 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ i19 = 0;
+ }
+ while (1) {
+ if ((i21 | 0) == 46) {
+ i13 = 70;
+ break;
+ } else if ((i21 | 0) != 48) {
+ i5 = 0;
+ i7 = 0;
+ i15 = 0;
+ i16 = 0;
+ i18 = 0;
+ i20 = 0;
+ d28 = 1.0;
+ i17 = 0;
+ d14 = 0.0;
+ break;
+ }
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i5 + 1;
+ i21 = HEAPU8[i5] | 0;
+ i19 = 1;
+ continue;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ i19 = 1;
+ continue;
+ }
+ }
+ L66 : do {
+ if ((i13 | 0) == 70) {
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i5 + 1;
+ i21 = HEAPU8[i5] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ if ((i21 | 0) == 48) {
+ i15 = -1;
+ i16 = -1;
+ while (1) {
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i5 + 1;
+ i21 = HEAPU8[i5] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ if ((i21 | 0) != 48) {
+ i5 = 0;
+ i7 = 0;
+ i19 = 1;
+ i18 = 1;
+ i20 = 0;
+ d28 = 1.0;
+ i17 = 0;
+ d14 = 0.0;
+ break L66;
+ }
+ i29 = _i64Add(i15 | 0, i16 | 0, -1, -1) | 0;
+ i15 = i29;
+ i16 = tempRet0;
+ }
+ } else {
+ i5 = 0;
+ i7 = 0;
+ i15 = 0;
+ i16 = 0;
+ i18 = 1;
+ i20 = 0;
+ d28 = 1.0;
+ i17 = 0;
+ d14 = 0.0;
+ }
+ }
+ } while (0);
+ L79 : while (1) {
+ i24 = i21 + -48 | 0;
+ do {
+ if (!(i24 >>> 0 < 10)) {
+ i23 = i21 | 32;
+ i22 = (i21 | 0) == 46;
+ if (!((i23 + -97 | 0) >>> 0 < 6 | i22)) {
+ break L79;
+ }
+ if (i22) {
+ if ((i18 | 0) == 0) {
+ i15 = i7;
+ i16 = i5;
+ i18 = 1;
+ break;
+ } else {
+ i21 = 46;
+ break L79;
+ }
+ } else {
+ i24 = (i21 | 0) > 57 ? i23 + -87 | 0 : i24;
+ i13 = 84;
+ break;
+ }
+ } else {
+ i13 = 84;
+ }
+ } while (0);
+ if ((i13 | 0) == 84) {
+ i13 = 0;
+ do {
+ if (!((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8)) {
+ if ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 14) {
+ d31 = d28 * .0625;
+ d30 = d31;
+ d14 = d14 + d31 * +(i24 | 0);
+ break;
+ }
+ if ((i24 | 0) != 0 & (i20 | 0) == 0) {
+ i20 = 1;
+ d30 = d28;
+ d14 = d14 + d28 * .5;
+ } else {
+ d30 = d28;
+ }
+ } else {
+ d30 = d28;
+ i17 = i24 + (i17 << 4) | 0;
+ }
+ } while (0);
+ i7 = _i64Add(i7 | 0, i5 | 0, 1, 0) | 0;
+ i5 = tempRet0;
+ i19 = 1;
+ d28 = d30;
+ }
+ i21 = HEAP32[i9 >> 2] | 0;
+ if (i21 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i21 + 1;
+ i21 = HEAPU8[i21] | 0;
+ continue;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ continue;
+ }
+ }
+ if ((i19 | 0) == 0) {
+ i2 = (HEAP32[i10 >> 2] | 0) == 0;
+ if (!i2) {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ }
+ if (!i12) {
+ if (!i2 ? (i6 = HEAP32[i9 >> 2] | 0, HEAP32[i9 >> 2] = i6 + -1, (i18 | 0) != 0) : 0) {
+ HEAP32[i9 >> 2] = i6 + -2;
+ }
+ } else {
+ ___shlim(i8, 0);
+ }
+ d31 = +(i4 | 0) * 0.0;
+ STACKTOP = i1;
+ return +d31;
+ }
+ i13 = (i18 | 0) == 0;
+ i6 = i13 ? i7 : i15;
+ i13 = i13 ? i5 : i16;
+ if ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8) {
+ do {
+ i17 = i17 << 4;
+ i7 = _i64Add(i7 | 0, i5 | 0, 1, 0) | 0;
+ i5 = tempRet0;
+ } while ((i5 | 0) < 0 | (i5 | 0) == 0 & i7 >>> 0 < 8);
+ }
+ do {
+ if ((i21 | 32 | 0) == 112) {
+ i7 = _scanexp(i8, i11) | 0;
+ i5 = tempRet0;
+ if ((i7 | 0) == 0 & (i5 | 0) == -2147483648) {
+ if (i12) {
+ ___shlim(i8, 0);
+ d31 = 0.0;
+ STACKTOP = i1;
+ return +d31;
+ } else {
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ i7 = 0;
+ i5 = 0;
+ break;
+ }
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i7 = 0;
+ i5 = 0;
+ break;
+ }
+ }
+ } else {
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ i7 = 0;
+ i5 = 0;
+ } else {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i7 = 0;
+ i5 = 0;
+ }
+ }
+ } while (0);
+ i6 = _bitshift64Shl(i6 | 0, i13 | 0, 2) | 0;
+ i6 = _i64Add(i6 | 0, tempRet0 | 0, -32, -1) | 0;
+ i5 = _i64Add(i6 | 0, tempRet0 | 0, i7 | 0, i5 | 0) | 0;
+ i6 = tempRet0;
+ if ((i17 | 0) == 0) {
+ d31 = +(i4 | 0) * 0.0;
+ STACKTOP = i1;
+ return +d31;
+ }
+ if ((i6 | 0) > 0 | (i6 | 0) == 0 & i5 >>> 0 > (0 - i3 | 0) >>> 0) {
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ d31 = +(i4 | 0) * 1.7976931348623157e+308 * 1.7976931348623157e+308;
+ STACKTOP = i1;
+ return +d31;
+ }
+ i29 = i3 + -106 | 0;
+ i27 = ((i29 | 0) < 0) << 31 >> 31;
+ if ((i6 | 0) < (i27 | 0) | (i6 | 0) == (i27 | 0) & i5 >>> 0 < i29 >>> 0) {
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ d31 = +(i4 | 0) * 2.2250738585072014e-308 * 2.2250738585072014e-308;
+ STACKTOP = i1;
+ return +d31;
+ }
+ if ((i17 | 0) > -1) {
+ do {
+ i17 = i17 << 1;
+ if (!(d14 >= .5)) {
+ d28 = d14;
+ } else {
+ d28 = d14 + -1.0;
+ i17 = i17 | 1;
+ }
+ d14 = d14 + d28;
+ i5 = _i64Add(i5 | 0, i6 | 0, -1, -1) | 0;
+ i6 = tempRet0;
+ } while ((i17 | 0) > -1);
+ }
+ i3 = _i64Subtract(32, 0, i3 | 0, ((i3 | 0) < 0) << 31 >> 31 | 0) | 0;
+ i3 = _i64Add(i5 | 0, i6 | 0, i3 | 0, tempRet0 | 0) | 0;
+ i29 = tempRet0;
+ if (0 > (i29 | 0) | 0 == (i29 | 0) & i2 >>> 0 > i3 >>> 0) {
+ i2 = (i3 | 0) < 0 ? 0 : i3;
+ }
+ if ((i2 | 0) < 53) {
+ d28 = +(i4 | 0);
+ d30 = +_copysign(+(+_scalbn(1.0, 84 - i2 | 0)), +d28);
+ if ((i2 | 0) < 32 & d14 != 0.0) {
+ i29 = i17 & 1;
+ i17 = (i29 ^ 1) + i17 | 0;
+ d14 = (i29 | 0) == 0 ? 0.0 : d14;
+ }
+ } else {
+ d28 = +(i4 | 0);
+ d30 = 0.0;
+ }
+ d14 = d28 * d14 + (d30 + d28 * +(i17 >>> 0)) - d30;
+ if (!(d14 != 0.0)) {
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ }
+ d31 = +_scalbnl(d14, i5);
+ STACKTOP = i1;
+ return +d31;
+ }
+ } while (0);
+ i7 = i3 + i2 | 0;
+ i6 = 0 - i7 | 0;
+ i20 = 0;
+ while (1) {
+ if ((i21 | 0) == 46) {
+ i13 = 139;
+ break;
+ } else if ((i21 | 0) != 48) {
+ i25 = 0;
+ i22 = 0;
+ i19 = 0;
+ break;
+ }
+ i15 = HEAP32[i9 >> 2] | 0;
+ if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i15 + 1;
+ i21 = HEAPU8[i15] | 0;
+ i20 = 1;
+ continue;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ i20 = 1;
+ continue;
+ }
+ }
+ L168 : do {
+ if ((i13 | 0) == 139) {
+ i15 = HEAP32[i9 >> 2] | 0;
+ if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i15 + 1;
+ i21 = HEAPU8[i15] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ if ((i21 | 0) == 48) {
+ i25 = -1;
+ i22 = -1;
+ while (1) {
+ i15 = HEAP32[i9 >> 2] | 0;
+ if (i15 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i15 + 1;
+ i21 = HEAPU8[i15] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ if ((i21 | 0) != 48) {
+ i20 = 1;
+ i19 = 1;
+ break L168;
+ }
+ i29 = _i64Add(i25 | 0, i22 | 0, -1, -1) | 0;
+ i25 = i29;
+ i22 = tempRet0;
+ }
+ } else {
+ i25 = 0;
+ i22 = 0;
+ i19 = 1;
+ }
+ }
+ } while (0);
+ HEAP32[i5 >> 2] = 0;
+ i26 = i21 + -48 | 0;
+ i27 = (i21 | 0) == 46;
+ L182 : do {
+ if (i26 >>> 0 < 10 | i27) {
+ i15 = i5 + 496 | 0;
+ i24 = 0;
+ i23 = 0;
+ i18 = 0;
+ i17 = 0;
+ i16 = 0;
+ while (1) {
+ do {
+ if (i27) {
+ if ((i19 | 0) == 0) {
+ i25 = i24;
+ i22 = i23;
+ i19 = 1;
+ } else {
+ break L182;
+ }
+ } else {
+ i27 = _i64Add(i24 | 0, i23 | 0, 1, 0) | 0;
+ i23 = tempRet0;
+ i29 = (i21 | 0) != 48;
+ if ((i17 | 0) >= 125) {
+ if (!i29) {
+ i24 = i27;
+ break;
+ }
+ HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
+ i24 = i27;
+ break;
+ }
+ i20 = i5 + (i17 << 2) | 0;
+ if ((i18 | 0) != 0) {
+ i26 = i21 + -48 + ((HEAP32[i20 >> 2] | 0) * 10 | 0) | 0;
+ }
+ HEAP32[i20 >> 2] = i26;
+ i18 = i18 + 1 | 0;
+ i21 = (i18 | 0) == 9;
+ i24 = i27;
+ i20 = 1;
+ i18 = i21 ? 0 : i18;
+ i17 = (i21 & 1) + i17 | 0;
+ i16 = i29 ? i27 : i16;
+ }
+ } while (0);
+ i21 = HEAP32[i9 >> 2] | 0;
+ if (i21 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i21 + 1;
+ i21 = HEAPU8[i21] | 0;
+ } else {
+ i21 = ___shgetc(i8) | 0;
+ }
+ i26 = i21 + -48 | 0;
+ i27 = (i21 | 0) == 46;
+ if (!(i26 >>> 0 < 10 | i27)) {
+ i13 = 162;
+ break;
+ }
+ }
+ } else {
+ i24 = 0;
+ i23 = 0;
+ i18 = 0;
+ i17 = 0;
+ i16 = 0;
+ i13 = 162;
+ }
+ } while (0);
+ if ((i13 | 0) == 162) {
+ i13 = (i19 | 0) == 0;
+ i25 = i13 ? i24 : i25;
+ i22 = i13 ? i23 : i22;
+ }
+ i13 = (i20 | 0) != 0;
+ if (i13 ? (i21 | 32 | 0) == 101 : 0) {
+ i15 = _scanexp(i8, i11) | 0;
+ i11 = tempRet0;
+ do {
+ if ((i15 | 0) == 0 & (i11 | 0) == -2147483648) {
+ if (i12) {
+ ___shlim(i8, 0);
+ d31 = 0.0;
+ STACKTOP = i1;
+ return +d31;
+ } else {
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ i15 = 0;
+ i11 = 0;
+ break;
+ }
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i15 = 0;
+ i11 = 0;
+ break;
+ }
+ }
+ } while (0);
+ i9 = _i64Add(i15 | 0, i11 | 0, i25 | 0, i22 | 0) | 0;
+ i22 = tempRet0;
+ } else {
+ if ((i21 | 0) > -1 ? (HEAP32[i10 >> 2] | 0) != 0 : 0) {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i9 = i25;
+ } else {
+ i9 = i25;
+ }
+ }
+ if (!i13) {
+ HEAP32[(___errno_location() | 0) >> 2] = 22;
+ ___shlim(i8, 0);
+ d31 = 0.0;
+ STACKTOP = i1;
+ return +d31;
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ d31 = +(i4 | 0) * 0.0;
+ STACKTOP = i1;
+ return +d31;
+ }
+ do {
+ if ((i9 | 0) == (i24 | 0) & (i22 | 0) == (i23 | 0) & ((i23 | 0) < 0 | (i23 | 0) == 0 & i24 >>> 0 < 10)) {
+ if (!(i2 >>> 0 > 30) ? (i8 >>> i2 | 0) != 0 : 0) {
+ break;
+ }
+ d31 = +(i4 | 0) * +(i8 >>> 0);
+ STACKTOP = i1;
+ return +d31;
+ }
+ } while (0);
+ i29 = (i3 | 0) / -2 | 0;
+ i27 = ((i29 | 0) < 0) << 31 >> 31;
+ if ((i22 | 0) > (i27 | 0) | (i22 | 0) == (i27 | 0) & i9 >>> 0 > i29 >>> 0) {
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ d31 = +(i4 | 0) * 1.7976931348623157e+308 * 1.7976931348623157e+308;
+ STACKTOP = i1;
+ return +d31;
+ }
+ i29 = i3 + -106 | 0;
+ i27 = ((i29 | 0) < 0) << 31 >> 31;
+ if ((i22 | 0) < (i27 | 0) | (i22 | 0) == (i27 | 0) & i9 >>> 0 < i29 >>> 0) {
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ d31 = +(i4 | 0) * 2.2250738585072014e-308 * 2.2250738585072014e-308;
+ STACKTOP = i1;
+ return +d31;
+ }
+ if ((i18 | 0) != 0) {
+ if ((i18 | 0) < 9) {
+ i8 = i5 + (i17 << 2) | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ do {
+ i10 = i10 * 10 | 0;
+ i18 = i18 + 1 | 0;
+ } while ((i18 | 0) != 9);
+ HEAP32[i8 >> 2] = i10;
+ }
+ i17 = i17 + 1 | 0;
+ }
+ do {
+ if ((i16 | 0) < 9 ? (i16 | 0) <= (i9 | 0) & (i9 | 0) < 18 : 0) {
+ if ((i9 | 0) == 9) {
+ d31 = +(i4 | 0) * +((HEAP32[i5 >> 2] | 0) >>> 0);
+ STACKTOP = i1;
+ return +d31;
+ }
+ if ((i9 | 0) < 9) {
+ d31 = +(i4 | 0) * +((HEAP32[i5 >> 2] | 0) >>> 0) / +(HEAP32[13440 + (8 - i9 << 2) >> 2] | 0);
+ STACKTOP = i1;
+ return +d31;
+ }
+ i10 = i2 + 27 + (Math_imul(i9, -3) | 0) | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i10 | 0) <= 30 ? (i8 >>> i10 | 0) != 0 : 0) {
+ break;
+ }
+ d31 = +(i4 | 0) * +(i8 >>> 0) * +(HEAP32[13440 + (i9 + -10 << 2) >> 2] | 0);
+ STACKTOP = i1;
+ return +d31;
+ }
+ } while (0);
+ i8 = (i9 | 0) % 9 | 0;
+ if ((i8 | 0) == 0) {
+ i8 = 0;
+ i10 = 0;
+ } else {
+ i11 = (i9 | 0) > -1 ? i8 : i8 + 9 | 0;
+ i12 = HEAP32[13440 + (8 - i11 << 2) >> 2] | 0;
+ if ((i17 | 0) != 0) {
+ i10 = 1e9 / (i12 | 0) | 0;
+ i8 = 0;
+ i16 = 0;
+ i15 = 0;
+ while (1) {
+ i27 = i5 + (i15 << 2) | 0;
+ i13 = HEAP32[i27 >> 2] | 0;
+ i29 = ((i13 >>> 0) / (i12 >>> 0) | 0) + i16 | 0;
+ HEAP32[i27 >> 2] = i29;
+ i16 = Math_imul((i13 >>> 0) % (i12 >>> 0) | 0, i10) | 0;
+ i13 = i15 + 1 | 0;
+ if ((i15 | 0) == (i8 | 0) & (i29 | 0) == 0) {
+ i8 = i13 & 127;
+ i9 = i9 + -9 | 0;
+ }
+ if ((i13 | 0) == (i17 | 0)) {
+ break;
+ } else {
+ i15 = i13;
+ }
+ }
+ if ((i16 | 0) != 0) {
+ HEAP32[i5 + (i17 << 2) >> 2] = i16;
+ i17 = i17 + 1 | 0;
+ }
+ } else {
+ i8 = 0;
+ i17 = 0;
+ }
+ i10 = 0;
+ i9 = 9 - i11 + i9 | 0;
+ }
+ L280 : while (1) {
+ i11 = i5 + (i8 << 2) | 0;
+ if ((i9 | 0) < 18) {
+ do {
+ i13 = 0;
+ i11 = i17 + 127 | 0;
+ while (1) {
+ i11 = i11 & 127;
+ i12 = i5 + (i11 << 2) | 0;
+ i15 = _bitshift64Shl(HEAP32[i12 >> 2] | 0, 0, 29) | 0;
+ i15 = _i64Add(i15 | 0, tempRet0 | 0, i13 | 0, 0) | 0;
+ i13 = tempRet0;
+ if (i13 >>> 0 > 0 | (i13 | 0) == 0 & i15 >>> 0 > 1e9) {
+ i29 = ___udivdi3(i15 | 0, i13 | 0, 1e9, 0) | 0;
+ i15 = ___uremdi3(i15 | 0, i13 | 0, 1e9, 0) | 0;
+ i13 = i29;
+ } else {
+ i13 = 0;
+ }
+ HEAP32[i12 >> 2] = i15;
+ i12 = (i11 | 0) == (i8 | 0);
+ if (!((i11 | 0) != (i17 + 127 & 127 | 0) | i12)) {
+ i17 = (i15 | 0) == 0 ? i11 : i17;
+ }
+ if (i12) {
+ break;
+ } else {
+ i11 = i11 + -1 | 0;
+ }
+ }
+ i10 = i10 + -29 | 0;
+ } while ((i13 | 0) == 0);
+ } else {
+ if ((i9 | 0) != 18) {
+ break;
+ }
+ do {
+ if (!((HEAP32[i11 >> 2] | 0) >>> 0 < 9007199)) {
+ i9 = 18;
+ break L280;
+ }
+ i13 = 0;
+ i12 = i17 + 127 | 0;
+ while (1) {
+ i12 = i12 & 127;
+ i15 = i5 + (i12 << 2) | 0;
+ i16 = _bitshift64Shl(HEAP32[i15 >> 2] | 0, 0, 29) | 0;
+ i16 = _i64Add(i16 | 0, tempRet0 | 0, i13 | 0, 0) | 0;
+ i13 = tempRet0;
+ if (i13 >>> 0 > 0 | (i13 | 0) == 0 & i16 >>> 0 > 1e9) {
+ i29 = ___udivdi3(i16 | 0, i13 | 0, 1e9, 0) | 0;
+ i16 = ___uremdi3(i16 | 0, i13 | 0, 1e9, 0) | 0;
+ i13 = i29;
+ } else {
+ i13 = 0;
+ }
+ HEAP32[i15 >> 2] = i16;
+ i15 = (i12 | 0) == (i8 | 0);
+ if (!((i12 | 0) != (i17 + 127 & 127 | 0) | i15)) {
+ i17 = (i16 | 0) == 0 ? i12 : i17;
+ }
+ if (i15) {
+ break;
+ } else {
+ i12 = i12 + -1 | 0;
+ }
+ }
+ i10 = i10 + -29 | 0;
+ } while ((i13 | 0) == 0);
+ }
+ i8 = i8 + 127 & 127;
+ if ((i8 | 0) == (i17 | 0)) {
+ i29 = i17 + 127 & 127;
+ i17 = i5 + ((i17 + 126 & 127) << 2) | 0;
+ HEAP32[i17 >> 2] = HEAP32[i17 >> 2] | HEAP32[i5 + (i29 << 2) >> 2];
+ i17 = i29;
+ }
+ HEAP32[i5 + (i8 << 2) >> 2] = i13;
+ i9 = i9 + 9 | 0;
+ }
+ L311 : while (1) {
+ i11 = i17 + 1 & 127;
+ i12 = i5 + ((i17 + 127 & 127) << 2) | 0;
+ while (1) {
+ i15 = (i9 | 0) == 18;
+ i13 = (i9 | 0) > 27 ? 9 : 1;
+ while (1) {
+ i16 = 0;
+ while (1) {
+ i18 = i16 + i8 & 127;
+ if ((i18 | 0) == (i17 | 0)) {
+ i16 = 2;
+ break;
+ }
+ i18 = HEAP32[i5 + (i18 << 2) >> 2] | 0;
+ i19 = HEAP32[13432 + (i16 << 2) >> 2] | 0;
+ if (i18 >>> 0 < i19 >>> 0) {
+ i16 = 2;
+ break;
+ }
+ i20 = i16 + 1 | 0;
+ if (i18 >>> 0 > i19 >>> 0) {
+ break;
+ }
+ if ((i20 | 0) < 2) {
+ i16 = i20;
+ } else {
+ i16 = i20;
+ break;
+ }
+ }
+ if ((i16 | 0) == 2 & i15) {
+ break L311;
+ }
+ i10 = i13 + i10 | 0;
+ if ((i8 | 0) == (i17 | 0)) {
+ i8 = i17;
+ } else {
+ break;
+ }
+ }
+ i15 = (1 << i13) + -1 | 0;
+ i19 = 1e9 >>> i13;
+ i18 = i8;
+ i16 = 0;
+ do {
+ i27 = i5 + (i8 << 2) | 0;
+ i29 = HEAP32[i27 >> 2] | 0;
+ i20 = (i29 >>> i13) + i16 | 0;
+ HEAP32[i27 >> 2] = i20;
+ i16 = Math_imul(i29 & i15, i19) | 0;
+ i20 = (i8 | 0) == (i18 | 0) & (i20 | 0) == 0;
+ i8 = i8 + 1 & 127;
+ i9 = i20 ? i9 + -9 | 0 : i9;
+ i18 = i20 ? i8 : i18;
+ } while ((i8 | 0) != (i17 | 0));
+ if ((i16 | 0) == 0) {
+ i8 = i18;
+ continue;
+ }
+ if ((i11 | 0) != (i18 | 0)) {
+ break;
+ }
+ HEAP32[i12 >> 2] = HEAP32[i12 >> 2] | 1;
+ i8 = i18;
+ }
+ HEAP32[i5 + (i17 << 2) >> 2] = i16;
+ i8 = i18;
+ i17 = i11;
+ }
+ i9 = i8 & 127;
+ if ((i9 | 0) == (i17 | 0)) {
+ HEAP32[i5 + (i11 + -1 << 2) >> 2] = 0;
+ i17 = i11;
+ }
+ d28 = +((HEAP32[i5 + (i9 << 2) >> 2] | 0) >>> 0);
+ i9 = i8 + 1 & 127;
+ if ((i9 | 0) == (i17 | 0)) {
+ i17 = i17 + 1 & 127;
+ HEAP32[i5 + (i17 + -1 << 2) >> 2] = 0;
+ }
+ d14 = +(i4 | 0);
+ d30 = d14 * (d28 * 1.0e9 + +((HEAP32[i5 + (i9 << 2) >> 2] | 0) >>> 0));
+ i4 = i10 + 53 | 0;
+ i3 = i4 - i3 | 0;
+ if ((i3 | 0) < (i2 | 0)) {
+ i2 = (i3 | 0) < 0 ? 0 : i3;
+ i9 = 1;
+ } else {
+ i9 = 0;
+ }
+ if ((i2 | 0) < 53) {
+ d33 = +_copysign(+(+_scalbn(1.0, 105 - i2 | 0)), +d30);
+ d32 = +_fmod(+d30, +(+_scalbn(1.0, 53 - i2 | 0)));
+ d28 = d33;
+ d31 = d32;
+ d30 = d33 + (d30 - d32);
+ } else {
+ d28 = 0.0;
+ d31 = 0.0;
+ }
+ i11 = i8 + 2 & 127;
+ if ((i11 | 0) != (i17 | 0)) {
+ i5 = HEAP32[i5 + (i11 << 2) >> 2] | 0;
+ do {
+ if (!(i5 >>> 0 < 5e8)) {
+ if (i5 >>> 0 > 5e8) {
+ d31 = d14 * .75 + d31;
+ break;
+ }
+ if ((i8 + 3 & 127 | 0) == (i17 | 0)) {
+ d31 = d14 * .5 + d31;
+ break;
+ } else {
+ d31 = d14 * .75 + d31;
+ break;
+ }
+ } else {
+ if ((i5 | 0) == 0 ? (i8 + 3 & 127 | 0) == (i17 | 0) : 0) {
+ break;
+ }
+ d31 = d14 * .25 + d31;
+ }
+ } while (0);
+ if ((53 - i2 | 0) > 1 ? !(+_fmod(+d31, 1.0) != 0.0) : 0) {
+ d31 = d31 + 1.0;
+ }
+ }
+ d14 = d30 + d31 - d28;
+ do {
+ if ((i4 & 2147483647 | 0) > (-2 - i7 | 0)) {
+ if (+Math_abs(+d14) >= 9007199254740992.0) {
+ i9 = (i9 | 0) != 0 & (i2 | 0) == (i3 | 0) ? 0 : i9;
+ i10 = i10 + 1 | 0;
+ d14 = d14 * .5;
+ }
+ if ((i10 + 50 | 0) <= (i6 | 0) ? !((i9 | 0) != 0 & d31 != 0.0) : 0) {
+ break;
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 34;
+ }
+ } while (0);
+ d33 = +_scalbnl(d14, i10);
+ STACKTOP = i1;
+ return +d33;
+ } else if ((i7 | 0) == 3) {
+ i2 = HEAP32[i9 >> 2] | 0;
+ if (i2 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i2 + 1;
+ i2 = HEAPU8[i2] | 0;
+ } else {
+ i2 = ___shgetc(i8) | 0;
+ }
+ if ((i2 | 0) == 40) {
+ i2 = 1;
+ } else {
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ d33 = nan;
+ STACKTOP = i1;
+ return +d33;
+ }
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ d33 = nan;
+ STACKTOP = i1;
+ return +d33;
+ }
+ while (1) {
+ i3 = HEAP32[i9 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0) {
+ HEAP32[i9 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ } else {
+ i3 = ___shgetc(i8) | 0;
+ }
+ if (!((i3 + -48 | 0) >>> 0 < 10 | (i3 + -65 | 0) >>> 0 < 26) ? !((i3 + -97 | 0) >>> 0 < 26 | (i3 | 0) == 95) : 0) {
+ break;
+ }
+ i2 = i2 + 1 | 0;
+ }
+ if ((i3 | 0) == 41) {
+ d33 = nan;
+ STACKTOP = i1;
+ return +d33;
+ }
+ i3 = (HEAP32[i10 >> 2] | 0) == 0;
+ if (!i3) {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ }
+ if (i12) {
+ HEAP32[(___errno_location() | 0) >> 2] = 22;
+ ___shlim(i8, 0);
+ d33 = 0.0;
+ STACKTOP = i1;
+ return +d33;
+ }
+ if ((i2 | 0) == 0 | i3) {
+ d33 = nan;
+ STACKTOP = i1;
+ return +d33;
+ }
+ while (1) {
+ i2 = i2 + -1 | 0;
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ if ((i2 | 0) == 0) {
+ d14 = nan;
+ break;
+ }
+ }
+ STACKTOP = i1;
+ return +d14;
+ } else {
+ if ((HEAP32[i10 >> 2] | 0) != 0) {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 22;
+ ___shlim(i8, 0);
+ d33 = 0.0;
+ STACKTOP = i1;
+ return +d33;
+ }
+ }
+ } while (0);
+ if ((i13 | 0) == 23) {
+ i2 = (HEAP32[i10 >> 2] | 0) == 0;
+ if (!i2) {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ }
+ if (!(i7 >>> 0 < 4 | (i11 | 0) == 0 | i2)) {
+ do {
+ HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + -1;
+ i7 = i7 + -1 | 0;
+ } while (i7 >>> 0 > 3);
+ }
+ }
+ d33 = +(i4 | 0) * inf;
+ STACKTOP = i1;
+ return +d33;
+}
+function _statement(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 160 | 0;
+ i8 = i2 + 120 | 0;
+ i24 = i2 + 96 | 0;
+ i15 = i2 + 72 | 0;
+ i25 = i2 + 48 | 0;
+ i20 = i2 + 24 | 0;
+ i21 = i2;
+ i19 = i4 + 4 | 0;
+ i6 = HEAP32[i19 >> 2] | 0;
+ i3 = i4 + 48 | 0;
+ i9 = HEAP32[i3 >> 2] | 0;
+ i1 = i4 + 52 | 0;
+ i26 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
+ i27 = (HEAP16[i26 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP16[i26 >> 1] = i27;
+ if ((i27 & 65535) > 200) {
+ i27 = i9 + 12 | 0;
+ i26 = HEAP32[(HEAP32[i27 >> 2] | 0) + 52 >> 2] | 0;
+ i5 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i29 = 6552;
+ HEAP32[i8 >> 2] = 6360;
+ i28 = i8 + 4 | 0;
+ HEAP32[i28 >> 2] = 200;
+ i28 = i8 + 8 | 0;
+ HEAP32[i28 >> 2] = i29;
+ i28 = _luaO_pushfstring(i26, 6592, i8) | 0;
+ i29 = HEAP32[i27 >> 2] | 0;
+ _luaX_syntaxerror(i29, i28);
+ }
+ HEAP32[i8 >> 2] = i5;
+ i28 = _luaO_pushfstring(i26, 6568, i8) | 0;
+ HEAP32[i8 >> 2] = 6360;
+ i29 = i8 + 4 | 0;
+ HEAP32[i29 >> 2] = 200;
+ i29 = i8 + 8 | 0;
+ HEAP32[i29 >> 2] = i28;
+ i29 = _luaO_pushfstring(i26, 6592, i8) | 0;
+ i28 = HEAP32[i27 >> 2] | 0;
+ _luaX_syntaxerror(i28, i29);
+ }
+ i5 = i4 + 16 | 0;
+ L8 : do {
+ switch (HEAP32[i5 >> 2] | 0) {
+ case 59:
+ {
+ _luaX_next(i4);
+ break;
+ }
+ case 267:
+ {
+ HEAP32[i21 >> 2] = -1;
+ _test_then_block(i4, i21);
+ while (1) {
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == 260) {
+ i7 = 10;
+ break;
+ } else if ((i8 | 0) != 261) {
+ break;
+ }
+ _test_then_block(i4, i21);
+ }
+ if ((i7 | 0) == 10) {
+ _luaX_next(i4);
+ i7 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i20 + 10 | 0] = 0;
+ HEAP8[i20 + 8 | 0] = HEAP8[i7 + 46 | 0] | 0;
+ i29 = HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i20 + 9 | 0] = 0;
+ i29 = i7 + 16 | 0;
+ HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i20;
+ L16 : do {
+ i8 = HEAP32[i5 >> 2] | 0;
+ switch (i8 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L16;
+ }
+ default:
+ {}
+ }
+ _statement(i4);
+ } while ((i8 | 0) != 274);
+ _leaveblock(i7);
+ }
+ _check_match(i4, 262, 267, i6);
+ _luaK_patchtohere(i9, HEAP32[i21 >> 2] | 0);
+ break;
+ }
+ case 259:
+ {
+ _luaX_next(i4);
+ i7 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i20 + 10 | 0] = 0;
+ HEAP8[i20 + 8 | 0] = HEAP8[i7 + 46 | 0] | 0;
+ i29 = HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i20 + 9 | 0] = 0;
+ i29 = i7 + 16 | 0;
+ HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i20;
+ L22 : do {
+ i8 = HEAP32[i5 >> 2] | 0;
+ switch (i8 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L22;
+ }
+ default:
+ {}
+ }
+ _statement(i4);
+ } while ((i8 | 0) != 274);
+ _leaveblock(i7);
+ _check_match(i4, 262, 259, i6);
+ break;
+ }
+ case 269:
+ {
+ _luaX_next(i4);
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 265) {
+ _luaX_next(i4);
+ i7 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 288) {
+ i29 = HEAP32[i4 + 24 >> 2] | 0;
+ _luaX_next(i4);
+ _new_localvar(i4, i29);
+ i29 = HEAP32[i3 >> 2] | 0;
+ i27 = i29 + 46 | 0;
+ i28 = (HEAPU8[i27] | 0) + 1 | 0;
+ HEAP8[i27] = i28;
+ HEAP32[(HEAP32[(HEAP32[i29 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i29 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((i28 & 255) + -1 + (HEAP32[i29 + 40 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i29 + 20 >> 2];
+ _body(i4, i25, 0, HEAP32[i19 >> 2] | 0);
+ HEAP32[(HEAP32[(HEAP32[i7 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i7 + 40 >> 2] | 0) + (HEAP32[i25 + 8 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i7 + 20 >> 2];
+ break L8;
+ } else {
+ _error_expected(i4, 288);
+ }
+ }
+ if ((i6 | 0) != 288) {
+ _error_expected(i4, 288);
+ }
+ i7 = i4 + 24 | 0;
+ i6 = 1;
+ while (1) {
+ i8 = HEAP32[i7 >> 2] | 0;
+ _luaX_next(i4);
+ _new_localvar(i4, i8);
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == 61) {
+ i7 = 81;
+ break;
+ } else if ((i8 | 0) != 44) {
+ i7 = 83;
+ break;
+ }
+ _luaX_next(i4);
+ if ((HEAP32[i5 >> 2] | 0) == 288) {
+ i6 = i6 + 1 | 0;
+ } else {
+ i7 = 78;
+ break;
+ }
+ }
+ do {
+ if ((i7 | 0) == 78) {
+ _error_expected(i4, 288);
+ } else if ((i7 | 0) == 81) {
+ _luaX_next(i4);
+ _subexpr(i4, i15, 0) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 44) {
+ i8 = 1;
+ do {
+ _luaX_next(i4);
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i15);
+ _subexpr(i4, i15, 0) | 0;
+ i8 = i8 + 1 | 0;
+ } while ((HEAP32[i5 >> 2] | 0) == 44);
+ } else {
+ i8 = 1;
+ }
+ i5 = HEAP32[i15 >> 2] | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ i8 = i6 - i8 | 0;
+ if ((i5 | 0) == 0) {
+ i17 = i8;
+ i18 = i4;
+ i7 = 88;
+ break;
+ } else if (!((i5 | 0) == 13 | (i5 | 0) == 12)) {
+ _luaK_exp2nextreg(i4, i15);
+ i17 = i8;
+ i18 = i4;
+ i7 = 88;
+ break;
+ }
+ i5 = i8 + 1 | 0;
+ i5 = (i5 | 0) < 0 ? 0 : i5;
+ _luaK_setreturns(i4, i15, i5);
+ if ((i5 | 0) > 1) {
+ _luaK_reserveregs(i4, i5 + -1 | 0);
+ }
+ } else if ((i7 | 0) == 83) {
+ HEAP32[i15 >> 2] = 0;
+ i17 = i6;
+ i18 = HEAP32[i3 >> 2] | 0;
+ i7 = 88;
+ }
+ } while (0);
+ if ((i7 | 0) == 88 ? (i17 | 0) > 0 : 0) {
+ i29 = HEAPU8[i18 + 48 | 0] | 0;
+ _luaK_reserveregs(i18, i17);
+ _luaK_nil(i18, i29, i17);
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ i4 = i5 + 46 | 0;
+ i7 = (HEAPU8[i4] | 0) + i6 | 0;
+ HEAP8[i4] = i7;
+ if ((i6 | 0) != 0 ? (i11 = i5 + 20 | 0, i14 = i5 + 40 | 0, i12 = HEAP32[(HEAP32[i5 >> 2] | 0) + 24 >> 2] | 0, i13 = HEAP32[HEAP32[(HEAP32[i5 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i12 + ((HEAP16[i13 + ((i7 & 255) - i6 + (HEAP32[i14 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i11 >> 2], i16 = i6 + -1 | 0, (i16 | 0) != 0) : 0) {
+ do {
+ HEAP32[i12 + ((HEAP16[i13 + ((HEAPU8[i4] | 0) - i16 + (HEAP32[i14 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i11 >> 2];
+ i16 = i16 + -1 | 0;
+ } while ((i16 | 0) != 0);
+ }
+ break;
+ }
+ case 264:
+ {
+ HEAP8[i24 + 10 | 0] = 1;
+ HEAP8[i24 + 8 | 0] = HEAP8[i9 + 46 | 0] | 0;
+ i29 = HEAP32[(HEAP32[i9 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i24 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i24 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i24 + 9 | 0] = 0;
+ i29 = i9 + 16 | 0;
+ HEAP32[i24 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i24;
+ _luaX_next(i4);
+ if ((HEAP32[i5 >> 2] | 0) != 288) {
+ _error_expected(i4, 288);
+ }
+ i14 = i4 + 24 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ _luaX_next(i4);
+ i11 = HEAP32[i5 >> 2] | 0;
+ if ((i11 | 0) == 268 | (i11 | 0) == 44) {
+ i12 = HEAP32[i3 >> 2] | 0;
+ i11 = HEAPU8[i12 + 48 | 0] | 0;
+ _new_localvar(i4, _luaX_newstring(i4, 6744, 15) | 0);
+ _new_localvar(i4, _luaX_newstring(i4, 6760, 11) | 0);
+ _new_localvar(i4, _luaX_newstring(i4, 6776, 13) | 0);
+ _new_localvar(i4, i13);
+ i13 = HEAP32[i5 >> 2] | 0;
+ do {
+ if ((i13 | 0) == 44) {
+ i15 = 4;
+ while (1) {
+ _luaX_next(i4);
+ if ((HEAP32[i5 >> 2] | 0) != 288) {
+ i7 = 40;
+ break;
+ }
+ i13 = HEAP32[i14 >> 2] | 0;
+ _luaX_next(i4);
+ _new_localvar(i4, i13);
+ i13 = HEAP32[i5 >> 2] | 0;
+ if ((i13 | 0) == 44) {
+ i15 = i15 + 1 | 0;
+ } else {
+ i7 = 42;
+ break;
+ }
+ }
+ if ((i7 | 0) == 40) {
+ _error_expected(i4, 288);
+ } else if ((i7 | 0) == 42) {
+ i22 = i13;
+ i10 = i15 + -2 | 0;
+ break;
+ }
+ } else {
+ i22 = i13;
+ i10 = 1;
+ }
+ } while (0);
+ if ((i22 | 0) != 268) {
+ _error_expected(i4, 268);
+ }
+ _luaX_next(i4);
+ i13 = HEAP32[i19 >> 2] | 0;
+ _subexpr(i4, i8, 0) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 44) {
+ i14 = 1;
+ do {
+ _luaX_next(i4);
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
+ _subexpr(i4, i8, 0) | 0;
+ i14 = i14 + 1 | 0;
+ } while ((HEAP32[i5 >> 2] | 0) == 44);
+ } else {
+ i14 = 1;
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ i14 = 3 - i14 | 0;
+ i15 = HEAP32[i8 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ i7 = 51;
+ } else if ((i15 | 0) == 13 | (i15 | 0) == 12) {
+ i15 = i14 + 1 | 0;
+ i15 = (i15 | 0) < 0 ? 0 : i15;
+ _luaK_setreturns(i5, i8, i15);
+ if ((i15 | 0) > 1) {
+ _luaK_reserveregs(i5, i15 + -1 | 0);
+ }
+ } else {
+ _luaK_exp2nextreg(i5, i8);
+ i7 = 51;
+ }
+ if ((i7 | 0) == 51 ? (i14 | 0) > 0 : 0) {
+ i29 = HEAPU8[i5 + 48 | 0] | 0;
+ _luaK_reserveregs(i5, i14);
+ _luaK_nil(i5, i29, i14);
+ }
+ _luaK_checkstack(i12, 3);
+ _forbody(i4, i11, i13, i10, 0);
+ } else if ((i11 | 0) == 61) {
+ i11 = HEAP32[i3 >> 2] | 0;
+ i7 = i11 + 48 | 0;
+ i10 = HEAPU8[i7] | 0;
+ _new_localvar(i4, _luaX_newstring(i4, 6792, 11) | 0);
+ _new_localvar(i4, _luaX_newstring(i4, 6808, 11) | 0);
+ _new_localvar(i4, _luaX_newstring(i4, 6824, 10) | 0);
+ _new_localvar(i4, i13);
+ if ((HEAP32[i5 >> 2] | 0) != 61) {
+ _error_expected(i4, 61);
+ }
+ _luaX_next(i4);
+ _subexpr(i4, i8, 0) | 0;
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
+ if ((HEAP32[i5 >> 2] | 0) != 44) {
+ _error_expected(i4, 44);
+ }
+ _luaX_next(i4);
+ _subexpr(i4, i8, 0) | 0;
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
+ if ((HEAP32[i5 >> 2] | 0) == 44) {
+ _luaX_next(i4);
+ _subexpr(i4, i8, 0) | 0;
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i8);
+ } else {
+ i29 = HEAPU8[i7] | 0;
+ _luaK_codek(i11, i29, _luaK_numberK(i11, 1.0) | 0) | 0;
+ _luaK_reserveregs(i11, 1);
+ }
+ _forbody(i4, i10, i6, 1, 1);
+ } else {
+ _luaX_syntaxerror(i4, 6720);
+ }
+ _check_match(i4, 262, 264, i6);
+ _leaveblock(i9);
+ break;
+ }
+ case 265:
+ {
+ _luaX_next(i4);
+ if ((HEAP32[i5 >> 2] | 0) != 288) {
+ _error_expected(i4, 288);
+ }
+ i8 = HEAP32[i4 + 24 >> 2] | 0;
+ _luaX_next(i4);
+ i9 = HEAP32[i3 >> 2] | 0;
+ if ((_singlevaraux(i9, i8, i20, 1) | 0) == 0) {
+ _singlevaraux(i9, HEAP32[i4 + 72 >> 2] | 0, i20, 1) | 0;
+ i29 = _luaK_stringK(HEAP32[i3 >> 2] | 0, i8) | 0;
+ HEAP32[i25 + 16 >> 2] = -1;
+ HEAP32[i25 + 20 >> 2] = -1;
+ HEAP32[i25 >> 2] = 4;
+ HEAP32[i25 + 8 >> 2] = i29;
+ _luaK_indexed(i9, i20, i25);
+ }
+ while (1) {
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == 58) {
+ i7 = 70;
+ break;
+ } else if ((i8 | 0) != 46) {
+ i5 = 0;
+ break;
+ }
+ _fieldsel(i4, i20);
+ }
+ if ((i7 | 0) == 70) {
+ _fieldsel(i4, i20);
+ i5 = 1;
+ }
+ _body(i4, i21, i5, i6);
+ _luaK_storevar(HEAP32[i3 >> 2] | 0, i20, i21);
+ _luaK_fixline(HEAP32[i3 >> 2] | 0, i6);
+ break;
+ }
+ case 278:
+ {
+ _luaX_next(i4);
+ i7 = _luaK_getlabel(i9) | 0;
+ _subexpr(i4, i20, 0) | 0;
+ if ((HEAP32[i20 >> 2] | 0) == 1) {
+ HEAP32[i20 >> 2] = 3;
+ }
+ _luaK_goiftrue(HEAP32[i3 >> 2] | 0, i20);
+ i8 = HEAP32[i20 + 20 >> 2] | 0;
+ HEAP8[i21 + 10 | 0] = 1;
+ HEAP8[i21 + 8 | 0] = HEAP8[i9 + 46 | 0] | 0;
+ i29 = HEAP32[(HEAP32[i9 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i21 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i21 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i21 + 9 | 0] = 0;
+ i29 = i9 + 16 | 0;
+ HEAP32[i21 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i21;
+ if ((HEAP32[i5 >> 2] | 0) != 259) {
+ _error_expected(i4, 259);
+ }
+ _luaX_next(i4);
+ i10 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i20 + 10 | 0] = 0;
+ HEAP8[i20 + 8 | 0] = HEAP8[i10 + 46 | 0] | 0;
+ i29 = HEAP32[(HEAP32[i10 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i20 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i20 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i20 + 9 | 0] = 0;
+ i29 = i10 + 16 | 0;
+ HEAP32[i20 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i20;
+ L119 : do {
+ i11 = HEAP32[i5 >> 2] | 0;
+ switch (i11 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L119;
+ }
+ default:
+ {}
+ }
+ _statement(i4);
+ } while ((i11 | 0) != 274);
+ _leaveblock(i10);
+ _luaK_patchlist(i9, _luaK_jump(i9) | 0, i7);
+ _check_match(i4, 262, 278, i6);
+ _leaveblock(i9);
+ _luaK_patchtohere(i9, i8);
+ break;
+ }
+ case 273:
+ {
+ i7 = _luaK_getlabel(i9) | 0;
+ HEAP8[i24 + 10 | 0] = 1;
+ i28 = i9 + 46 | 0;
+ HEAP8[i24 + 8 | 0] = HEAP8[i28] | 0;
+ i11 = i9 + 12 | 0;
+ i29 = HEAP32[(HEAP32[i11 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i24 + 4 >> 1] = HEAP32[i29 + 28 >> 2];
+ HEAP16[i24 + 6 >> 1] = HEAP32[i29 + 16 >> 2];
+ HEAP8[i24 + 9 | 0] = 0;
+ i29 = i9 + 16 | 0;
+ HEAP32[i24 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i24;
+ HEAP8[i15 + 10 | 0] = 0;
+ i10 = i15 + 8 | 0;
+ HEAP8[i10] = HEAP8[i28] | 0;
+ i11 = HEAP32[(HEAP32[i11 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i15 + 4 >> 1] = HEAP32[i11 + 28 >> 2];
+ HEAP16[i15 + 6 >> 1] = HEAP32[i11 + 16 >> 2];
+ i11 = i15 + 9 | 0;
+ HEAP8[i11] = 0;
+ HEAP32[i15 >> 2] = HEAP32[i29 >> 2];
+ HEAP32[i29 >> 2] = i15;
+ _luaX_next(i4);
+ L124 : do {
+ i12 = HEAP32[i5 >> 2] | 0;
+ switch (i12 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L124;
+ }
+ default:
+ {}
+ }
+ _statement(i4);
+ } while ((i12 | 0) != 274);
+ _check_match(i4, 277, 273, i6);
+ _subexpr(i4, i8, 0) | 0;
+ if ((HEAP32[i8 >> 2] | 0) == 1) {
+ HEAP32[i8 >> 2] = 3;
+ }
+ _luaK_goiftrue(HEAP32[i3 >> 2] | 0, i8);
+ i4 = HEAP32[i8 + 20 >> 2] | 0;
+ if ((HEAP8[i11] | 0) != 0) {
+ _luaK_patchclose(i9, i4, HEAPU8[i10] | 0);
+ }
+ _leaveblock(i9);
+ _luaK_patchlist(i9, i4, i7);
+ _leaveblock(i9);
+ break;
+ }
+ case 285:
+ {
+ _luaX_next(i4);
+ if ((HEAP32[i5 >> 2] | 0) != 288) {
+ _error_expected(i4, 288);
+ }
+ i10 = HEAP32[i4 + 24 >> 2] | 0;
+ _luaX_next(i4);
+ i15 = HEAP32[i3 >> 2] | 0;
+ i9 = i4 + 64 | 0;
+ i14 = HEAP32[i9 >> 2] | 0;
+ i12 = i14 + 24 | 0;
+ i11 = i15 + 16 | 0;
+ i16 = HEAP16[(HEAP32[i11 >> 2] | 0) + 4 >> 1] | 0;
+ i13 = i14 + 28 | 0;
+ L138 : do {
+ if ((i16 | 0) < (HEAP32[i13 >> 2] | 0)) {
+ while (1) {
+ i17 = i16 + 1 | 0;
+ if ((_luaS_eqstr(i10, HEAP32[(HEAP32[i12 >> 2] | 0) + (i16 << 4) >> 2] | 0) | 0) != 0) {
+ break;
+ }
+ if ((i17 | 0) < (HEAP32[i13 >> 2] | 0)) {
+ i16 = i17;
+ } else {
+ break L138;
+ }
+ }
+ i28 = i15 + 12 | 0;
+ i29 = HEAP32[(HEAP32[i28 >> 2] | 0) + 52 >> 2] | 0;
+ i27 = HEAP32[(HEAP32[i12 >> 2] | 0) + (i16 << 4) + 8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i10 + 16;
+ HEAP32[i8 + 4 >> 2] = i27;
+ i29 = _luaO_pushfstring(i29, 6680, i8) | 0;
+ _semerror(HEAP32[i28 >> 2] | 0, i29);
+ }
+ } while (0);
+ if ((HEAP32[i5 >> 2] | 0) != 285) {
+ _error_expected(i4, 285);
+ }
+ _luaX_next(i4);
+ i8 = HEAP32[i15 + 20 >> 2] | 0;
+ i15 = HEAP32[i13 >> 2] | 0;
+ i14 = i14 + 32 | 0;
+ if ((i15 | 0) < (HEAP32[i14 >> 2] | 0)) {
+ i14 = HEAP32[i12 >> 2] | 0;
+ } else {
+ i14 = _luaM_growaux_(HEAP32[i1 >> 2] | 0, HEAP32[i12 >> 2] | 0, i14, 16, 32767, 6312) | 0;
+ HEAP32[i12 >> 2] = i14;
+ }
+ HEAP32[i14 + (i15 << 4) >> 2] = i10;
+ i29 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i29 + (i15 << 4) + 8 >> 2] = i6;
+ HEAP8[i29 + (i15 << 4) + 12 | 0] = HEAP8[(HEAP32[i3 >> 2] | 0) + 46 | 0] | 0;
+ HEAP32[(HEAP32[i12 >> 2] | 0) + (i15 << 4) + 4 >> 2] = i8;
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + 1;
+ L152 : while (1) {
+ switch (HEAP32[i5 >> 2] | 0) {
+ case 285:
+ case 59:
+ {
+ break;
+ }
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ i7 = 108;
+ break L152;
+ }
+ default:
+ {
+ break L152;
+ }
+ }
+ _statement(i4);
+ }
+ if ((i7 | 0) == 108) {
+ HEAP8[(HEAP32[i12 >> 2] | 0) + (i15 << 4) + 12 | 0] = HEAP8[(HEAP32[i11 >> 2] | 0) + 8 | 0] | 0;
+ }
+ i5 = (HEAP32[i12 >> 2] | 0) + (i15 << 4) | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ i7 = HEAP16[(HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0) + 6 >> 1] | 0;
+ i6 = i8 + 16 | 0;
+ if ((i7 | 0) < (HEAP32[i6 >> 2] | 0)) {
+ i8 = i8 + 12 | 0;
+ do {
+ while (1) {
+ if ((_luaS_eqstr(HEAP32[(HEAP32[i8 >> 2] | 0) + (i7 << 4) >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0) == 0) {
+ break;
+ }
+ _closegoto(i4, i7, i5);
+ if ((i7 | 0) >= (HEAP32[i6 >> 2] | 0)) {
+ break L8;
+ }
+ }
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (HEAP32[i6 >> 2] | 0));
+ }
+ break;
+ }
+ case 274:
+ {
+ _luaX_next(i4);
+ i6 = HEAP32[i3 >> 2] | 0;
+ L166 : do {
+ switch (HEAP32[i5 >> 2] | 0) {
+ case 59:
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ i8 = 0;
+ i7 = 0;
+ break;
+ }
+ default:
+ {
+ _subexpr(i4, i24, 0) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 44) {
+ i7 = 1;
+ do {
+ _luaX_next(i4);
+ _luaK_exp2nextreg(HEAP32[i3 >> 2] | 0, i24);
+ _subexpr(i4, i24, 0) | 0;
+ i7 = i7 + 1 | 0;
+ } while ((HEAP32[i5 >> 2] | 0) == 44);
+ } else {
+ i7 = 1;
+ }
+ if (!(((HEAP32[i24 >> 2] | 0) + -12 | 0) >>> 0 < 2)) {
+ if ((i7 | 0) == 1) {
+ i8 = _luaK_exp2anyreg(i6, i24) | 0;
+ i7 = 1;
+ break L166;
+ } else {
+ _luaK_exp2nextreg(i6, i24);
+ i8 = HEAPU8[i6 + 46 | 0] | 0;
+ break L166;
+ }
+ } else {
+ _luaK_setreturns(i6, i24, -1);
+ if ((HEAP32[i24 >> 2] | 0) == 12 & (i7 | 0) == 1) {
+ i29 = (HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i24 + 8 >> 2] << 2) | 0;
+ HEAP32[i29 >> 2] = HEAP32[i29 >> 2] & -64 | 30;
+ }
+ i8 = HEAPU8[i6 + 46 | 0] | 0;
+ i7 = -1;
+ break L166;
+ }
+ }
+ }
+ } while (0);
+ _luaK_ret(i6, i8, i7);
+ if ((HEAP32[i5 >> 2] | 0) == 59) {
+ _luaX_next(i4);
+ }
+ break;
+ }
+ case 266:
+ case 258:
+ {
+ i6 = _luaK_jump(i9) | 0;
+ i7 = HEAP32[i19 >> 2] | 0;
+ i29 = (HEAP32[i5 >> 2] | 0) == 266;
+ _luaX_next(i4);
+ do {
+ if (i29) {
+ if ((HEAP32[i5 >> 2] | 0) == 288) {
+ i23 = HEAP32[i4 + 24 >> 2] | 0;
+ _luaX_next(i4);
+ break;
+ } else {
+ _error_expected(i4, 288);
+ }
+ } else {
+ i23 = _luaS_new(HEAP32[i1 >> 2] | 0, 6304) | 0;
+ }
+ } while (0);
+ i10 = HEAP32[i4 + 64 >> 2] | 0;
+ i9 = i10 + 12 | 0;
+ i5 = i10 + 16 | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i10 = i10 + 20 | 0;
+ if ((i8 | 0) < (HEAP32[i10 >> 2] | 0)) {
+ i10 = HEAP32[i9 >> 2] | 0;
+ } else {
+ i10 = _luaM_growaux_(HEAP32[i1 >> 2] | 0, HEAP32[i9 >> 2] | 0, i10, 16, 32767, 6312) | 0;
+ HEAP32[i9 >> 2] = i10;
+ }
+ HEAP32[i10 + (i8 << 4) >> 2] = i23;
+ i29 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i29 + (i8 << 4) + 8 >> 2] = i7;
+ HEAP8[i29 + (i8 << 4) + 12 | 0] = HEAP8[(HEAP32[i3 >> 2] | 0) + 46 | 0] | 0;
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i8 << 4) + 4 >> 2] = i6;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ _findlabel(i4, i8) | 0;
+ break;
+ }
+ default:
+ {
+ i6 = i8 + 8 | 0;
+ _suffixedexp(i4, i6);
+ i29 = HEAP32[i5 >> 2] | 0;
+ if ((i29 | 0) == 44 | (i29 | 0) == 61) {
+ HEAP32[i8 >> 2] = 0;
+ _assignment(i4, i8, 1);
+ break L8;
+ }
+ if ((HEAP32[i6 >> 2] | 0) == 12) {
+ i29 = (HEAP32[(HEAP32[i9 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i8 + 16 >> 2] << 2) | 0;
+ HEAP32[i29 >> 2] = HEAP32[i29 >> 2] & -8372225 | 16384;
+ break L8;
+ } else {
+ _luaX_syntaxerror(i4, 6344);
+ }
+ }
+ }
+ } while (0);
+ i29 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i29 + 48 | 0] = HEAP8[i29 + 46 | 0] | 0;
+ i29 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
+ HEAP16[i29 >> 1] = (HEAP16[i29 >> 1] | 0) + -1 << 16 >> 16;
+ STACKTOP = i2;
+ return;
+}
+function _match(i1, i12, i11) {
+ i1 = i1 | 0;
+ i12 = i12 | 0;
+ i11 = i11 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i8 = i2;
+ i32 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i1 >> 2] = i32 + -1;
+ if ((i32 | 0) == 0) {
+ _luaL_error(HEAP32[i1 + 16 >> 2] | 0, 7272, i8) | 0;
+ }
+ i14 = i1 + 12 | 0;
+ i22 = HEAP32[i14 >> 2] | 0;
+ L4 : do {
+ if ((i22 | 0) != (i11 | 0)) {
+ i3 = i1 + 8 | 0;
+ i9 = i1 + 16 | 0;
+ i16 = i1 + 4 | 0;
+ i10 = i1 + 20 | 0;
+ L6 : while (1) {
+ i19 = i12 + 1 | 0;
+ i20 = i12 + -1 | 0;
+ L8 : while (1) {
+ i23 = HEAP8[i11] | 0;
+ i21 = i23 << 24 >> 24;
+ L10 : do {
+ if ((i21 | 0) == 36) {
+ i7 = i11 + 1 | 0;
+ if ((i7 | 0) == (i22 | 0)) {
+ i7 = 23;
+ break L6;
+ } else {
+ i22 = i7;
+ i21 = i7;
+ i7 = 89;
+ }
+ } else if ((i21 | 0) == 37) {
+ i21 = i11 + 1 | 0;
+ i23 = HEAP8[i21] | 0;
+ switch (i23 << 24 >> 24 | 0) {
+ case 57:
+ case 56:
+ case 55:
+ case 54:
+ case 53:
+ case 52:
+ case 51:
+ case 50:
+ case 49:
+ case 48:
+ {
+ i7 = 69;
+ break L8;
+ }
+ case 98:
+ {
+ i7 = 25;
+ break L8;
+ }
+ case 102:
+ {
+ break;
+ }
+ default:
+ {
+ if ((i21 | 0) == (i22 | 0)) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7368, i8) | 0;
+ }
+ i22 = i11 + 2 | 0;
+ i7 = 89;
+ break L10;
+ }
+ }
+ i22 = i11 + 2 | 0;
+ if ((HEAP8[i22] | 0) == 91) {
+ i21 = 91;
+ } else {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7296, i8) | 0;
+ i21 = HEAP8[i22] | 0;
+ }
+ i23 = i11 + 3 | 0;
+ i21 = i21 << 24 >> 24;
+ if ((i21 | 0) == 91) {
+ i21 = (HEAP8[i23] | 0) == 94 ? i11 + 4 | 0 : i23;
+ while (1) {
+ if ((i21 | 0) == (HEAP32[i14 >> 2] | 0)) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7408, i8) | 0;
+ }
+ i11 = i21 + 1 | 0;
+ if ((HEAP8[i21] | 0) == 37) {
+ i11 = i11 >>> 0 < (HEAP32[i14 >> 2] | 0) >>> 0 ? i21 + 2 | 0 : i11;
+ }
+ if ((HEAP8[i11] | 0) == 93) {
+ break;
+ } else {
+ i21 = i11;
+ }
+ }
+ i11 = i11 + 1 | 0;
+ } else if ((i21 | 0) == 37) {
+ if ((i23 | 0) == (HEAP32[i14 >> 2] | 0)) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7368, i8) | 0;
+ }
+ i11 = i11 + 4 | 0;
+ } else {
+ i11 = i23;
+ }
+ if ((i12 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ i25 = 0;
+ } else {
+ i25 = HEAP8[i20] | 0;
+ }
+ i24 = i25 & 255;
+ i21 = i11 + -1 | 0;
+ i26 = (HEAP8[i23] | 0) == 94;
+ i28 = i26 ? i23 : i22;
+ i27 = i26 & 1;
+ i26 = i27 ^ 1;
+ i30 = i28 + 1 | 0;
+ L41 : do {
+ if (i30 >>> 0 < i21 >>> 0) {
+ while (1) {
+ i32 = HEAP8[i30] | 0;
+ i29 = i28 + 2 | 0;
+ i31 = HEAP8[i29] | 0;
+ do {
+ if (i32 << 24 >> 24 == 37) {
+ if ((_match_class(i24, i31 & 255) | 0) == 0) {
+ i28 = i29;
+ } else {
+ break L41;
+ }
+ } else {
+ if (i31 << 24 >> 24 == 45 ? (i18 = i28 + 3 | 0, i18 >>> 0 < i21 >>> 0) : 0) {
+ if ((i32 & 255) > (i25 & 255)) {
+ i28 = i18;
+ break;
+ }
+ if ((HEAPU8[i18] | 0) < (i25 & 255)) {
+ i28 = i18;
+ break;
+ } else {
+ break L41;
+ }
+ }
+ if (i32 << 24 >> 24 == i25 << 24 >> 24) {
+ break L41;
+ } else {
+ i28 = i30;
+ }
+ }
+ } while (0);
+ i30 = i28 + 1 | 0;
+ if (!(i30 >>> 0 < i21 >>> 0)) {
+ i26 = i27;
+ break;
+ }
+ }
+ } else {
+ i26 = i27;
+ }
+ } while (0);
+ if ((i26 | 0) != 0) {
+ i12 = 0;
+ break L4;
+ }
+ i24 = HEAP8[i12] | 0;
+ i25 = i24 & 255;
+ i27 = (HEAP8[i23] | 0) == 94;
+ i26 = i27 ? i23 : i22;
+ i22 = i27 & 1;
+ i23 = i22 ^ 1;
+ i30 = i26 + 1 | 0;
+ L55 : do {
+ if (i30 >>> 0 < i21 >>> 0) {
+ do {
+ i29 = HEAP8[i30] | 0;
+ i28 = i26 + 2 | 0;
+ i27 = HEAP8[i28] | 0;
+ do {
+ if (i29 << 24 >> 24 == 37) {
+ if ((_match_class(i25, i27 & 255) | 0) == 0) {
+ i26 = i28;
+ } else {
+ i22 = i23;
+ break L55;
+ }
+ } else {
+ if (i27 << 24 >> 24 == 45 ? (i17 = i26 + 3 | 0, i17 >>> 0 < i21 >>> 0) : 0) {
+ if ((i29 & 255) > (i24 & 255)) {
+ i26 = i17;
+ break;
+ }
+ if ((HEAPU8[i17] | 0) < (i24 & 255)) {
+ i26 = i17;
+ break;
+ } else {
+ i22 = i23;
+ break L55;
+ }
+ }
+ if (i29 << 24 >> 24 == i24 << 24 >> 24) {
+ i22 = i23;
+ break L55;
+ } else {
+ i26 = i30;
+ }
+ }
+ } while (0);
+ i30 = i26 + 1 | 0;
+ } while (i30 >>> 0 < i21 >>> 0);
+ }
+ } while (0);
+ if ((i22 | 0) == 0) {
+ i12 = 0;
+ break L4;
+ }
+ } else if ((i21 | 0) == 40) {
+ i7 = 7;
+ break L6;
+ } else if ((i21 | 0) != 41) {
+ i21 = i11 + 1 | 0;
+ if (i23 << 24 >> 24 == 91) {
+ i7 = (HEAP8[i21] | 0) == 94 ? i11 + 2 | 0 : i21;
+ while (1) {
+ if ((i7 | 0) == (i22 | 0)) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7408, i8) | 0;
+ }
+ i22 = i7 + 1 | 0;
+ if ((HEAP8[i7] | 0) == 37) {
+ i7 = i22 >>> 0 < (HEAP32[i14 >> 2] | 0) >>> 0 ? i7 + 2 | 0 : i22;
+ } else {
+ i7 = i22;
+ }
+ if ((HEAP8[i7] | 0) == 93) {
+ break;
+ }
+ i22 = HEAP32[i14 >> 2] | 0;
+ }
+ i22 = i7 + 1 | 0;
+ i7 = 89;
+ } else {
+ i22 = i21;
+ i7 = 89;
+ }
+ } else {
+ i7 = 16;
+ break L6;
+ }
+ } while (0);
+ L80 : do {
+ if ((i7 | 0) == 89) {
+ i7 = 0;
+ do {
+ if ((HEAP32[i3 >> 2] | 0) >>> 0 > i12 >>> 0) {
+ i23 = HEAP8[i12] | 0;
+ i24 = i23 & 255;
+ i26 = HEAP8[i11] | 0;
+ i25 = i26 << 24 >> 24;
+ L85 : do {
+ if ((i25 | 0) == 46) {
+ i23 = HEAP8[i22] | 0;
+ } else if ((i25 | 0) == 37) {
+ i25 = _match_class(i24, HEAPU8[i21] | 0) | 0;
+ i7 = 104;
+ } else if ((i25 | 0) == 91) {
+ i7 = i22 + -1 | 0;
+ i25 = (HEAP8[i21] | 0) == 94;
+ i27 = i25 ? i21 : i11;
+ i26 = i25 & 1;
+ i25 = i26 ^ 1;
+ i30 = i27 + 1 | 0;
+ if (i30 >>> 0 < i7 >>> 0) {
+ while (1) {
+ i31 = HEAP8[i30] | 0;
+ i29 = i27 + 2 | 0;
+ i28 = HEAP8[i29] | 0;
+ do {
+ if (i31 << 24 >> 24 == 37) {
+ if ((_match_class(i24, i28 & 255) | 0) == 0) {
+ i27 = i29;
+ } else {
+ i7 = 104;
+ break L85;
+ }
+ } else {
+ if (i28 << 24 >> 24 == 45 ? (i13 = i27 + 3 | 0, i13 >>> 0 < i7 >>> 0) : 0) {
+ if ((i31 & 255) > (i23 & 255)) {
+ i27 = i13;
+ break;
+ }
+ if ((HEAPU8[i13] | 0) < (i23 & 255)) {
+ i27 = i13;
+ break;
+ } else {
+ i7 = 104;
+ break L85;
+ }
+ }
+ if (i31 << 24 >> 24 == i23 << 24 >> 24) {
+ i7 = 104;
+ break L85;
+ } else {
+ i27 = i30;
+ }
+ }
+ } while (0);
+ i30 = i27 + 1 | 0;
+ if (!(i30 >>> 0 < i7 >>> 0)) {
+ i25 = i26;
+ i7 = 104;
+ break;
+ }
+ }
+ } else {
+ i25 = i26;
+ i7 = 104;
+ }
+ } else {
+ i25 = i26 << 24 >> 24 == i23 << 24 >> 24 | 0;
+ i7 = 104;
+ }
+ } while (0);
+ if ((i7 | 0) == 104) {
+ i7 = 0;
+ i23 = HEAP8[i22] | 0;
+ if ((i25 | 0) == 0) {
+ break;
+ }
+ }
+ i23 = i23 << 24 >> 24;
+ if ((i23 | 0) == 45) {
+ i7 = 109;
+ break L6;
+ } else if ((i23 | 0) == 42) {
+ i7 = 112;
+ break L6;
+ } else if ((i23 | 0) == 43) {
+ break L6;
+ } else if ((i23 | 0) != 63) {
+ i12 = i19;
+ i11 = i22;
+ break L8;
+ }
+ i11 = i22 + 1 | 0;
+ i21 = _match(i1, i19, i11) | 0;
+ if ((i21 | 0) == 0) {
+ break L80;
+ } else {
+ i12 = i21;
+ break L4;
+ }
+ } else {
+ i23 = HEAP8[i22] | 0;
+ }
+ } while (0);
+ if (!(i23 << 24 >> 24 == 45 | i23 << 24 >> 24 == 63 | i23 << 24 >> 24 == 42)) {
+ i12 = 0;
+ break L4;
+ }
+ i11 = i22 + 1 | 0;
+ }
+ } while (0);
+ i22 = HEAP32[i14 >> 2] | 0;
+ if ((i11 | 0) == (i22 | 0)) {
+ break L4;
+ }
+ }
+ if ((i7 | 0) == 25) {
+ i7 = 0;
+ i21 = i11 + 2 | 0;
+ if (!((i22 + -1 | 0) >>> 0 > i21 >>> 0)) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7440, i8) | 0;
+ }
+ i20 = HEAP8[i12] | 0;
+ if (!(i20 << 24 >> 24 == (HEAP8[i21] | 0))) {
+ i12 = 0;
+ break L4;
+ }
+ i21 = HEAP8[i11 + 3 | 0] | 0;
+ i22 = HEAP32[i3 >> 2] | 0;
+ if (i19 >>> 0 < i22 >>> 0) {
+ i24 = 1;
+ } else {
+ i12 = 0;
+ break L4;
+ }
+ while (1) {
+ i23 = HEAP8[i19] | 0;
+ if (i23 << 24 >> 24 == i21 << 24 >> 24) {
+ i24 = i24 + -1 | 0;
+ if ((i24 | 0) == 0) {
+ break;
+ }
+ } else {
+ i24 = (i23 << 24 >> 24 == i20 << 24 >> 24) + i24 | 0;
+ }
+ i12 = i19 + 1 | 0;
+ if (i12 >>> 0 < i22 >>> 0) {
+ i32 = i19;
+ i19 = i12;
+ i12 = i32;
+ } else {
+ i12 = 0;
+ break L4;
+ }
+ }
+ i12 = i12 + 2 | 0;
+ i11 = i11 + 4 | 0;
+ } else if ((i7 | 0) == 69) {
+ i7 = 0;
+ i20 = i23 & 255;
+ i19 = i20 + -49 | 0;
+ if (((i19 | 0) >= 0 ? (i19 | 0) < (HEAP32[i10 >> 2] | 0) : 0) ? (i15 = HEAP32[i1 + (i19 << 3) + 28 >> 2] | 0, !((i15 | 0) == -1)) : 0) {
+ i20 = i15;
+ } else {
+ i19 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i8 >> 2] = i20 + -48;
+ i20 = _luaL_error(i19, 7336, i8) | 0;
+ i19 = i20;
+ i20 = HEAP32[i1 + (i20 << 3) + 28 >> 2] | 0;
+ }
+ if (((HEAP32[i3 >> 2] | 0) - i12 | 0) >>> 0 < i20 >>> 0) {
+ i12 = 0;
+ break L4;
+ }
+ if ((_memcmp(HEAP32[i1 + (i19 << 3) + 24 >> 2] | 0, i12, i20) | 0) != 0) {
+ i12 = 0;
+ break L4;
+ }
+ i12 = i12 + i20 | 0;
+ if ((i12 | 0) == 0) {
+ i12 = 0;
+ break L4;
+ }
+ i11 = i11 + 2 | 0;
+ }
+ i22 = HEAP32[i14 >> 2] | 0;
+ if ((i11 | 0) == (i22 | 0)) {
+ break L4;
+ }
+ }
+ if ((i7 | 0) == 7) {
+ i3 = i11 + 1 | 0;
+ if ((HEAP8[i3] | 0) == 41) {
+ i3 = HEAP32[i10 >> 2] | 0;
+ if ((i3 | 0) > 31) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7200, i8) | 0;
+ }
+ HEAP32[i1 + (i3 << 3) + 24 >> 2] = i12;
+ HEAP32[i1 + (i3 << 3) + 28 >> 2] = -2;
+ HEAP32[i10 >> 2] = i3 + 1;
+ i12 = _match(i1, i12, i11 + 2 | 0) | 0;
+ if ((i12 | 0) != 0) {
+ break;
+ }
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
+ i12 = 0;
+ break;
+ } else {
+ i4 = HEAP32[i10 >> 2] | 0;
+ if ((i4 | 0) > 31) {
+ _luaL_error(HEAP32[i9 >> 2] | 0, 7200, i8) | 0;
+ }
+ HEAP32[i1 + (i4 << 3) + 24 >> 2] = i12;
+ HEAP32[i1 + (i4 << 3) + 28 >> 2] = -1;
+ HEAP32[i10 >> 2] = i4 + 1;
+ i12 = _match(i1, i12, i3) | 0;
+ if ((i12 | 0) != 0) {
+ break;
+ }
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
+ i12 = 0;
+ break;
+ }
+ } else if ((i7 | 0) == 16) {
+ i3 = i11 + 1 | 0;
+ i5 = HEAP32[i10 >> 2] | 0;
+ while (1) {
+ i4 = i5 + -1 | 0;
+ if ((i5 | 0) <= 0) {
+ i7 = 19;
+ break;
+ }
+ if ((HEAP32[i1 + (i4 << 3) + 28 >> 2] | 0) == -1) {
+ break;
+ } else {
+ i5 = i4;
+ }
+ }
+ if ((i7 | 0) == 19) {
+ i4 = _luaL_error(HEAP32[i9 >> 2] | 0, 7488, i8) | 0;
+ }
+ i5 = i1 + (i4 << 3) + 28 | 0;
+ HEAP32[i5 >> 2] = i12 - (HEAP32[i1 + (i4 << 3) + 24 >> 2] | 0);
+ i12 = _match(i1, i12, i3) | 0;
+ if ((i12 | 0) != 0) {
+ break;
+ }
+ HEAP32[i5 >> 2] = -1;
+ i12 = 0;
+ break;
+ } else if ((i7 | 0) == 23) {
+ i12 = (i12 | 0) == (HEAP32[i3 >> 2] | 0) ? i12 : 0;
+ break;
+ } else if ((i7 | 0) == 109) {
+ i4 = i22 + 1 | 0;
+ i8 = _match(i1, i12, i4) | 0;
+ if ((i8 | 0) != 0) {
+ i12 = i8;
+ break;
+ }
+ i8 = i22 + -1 | 0;
+ while (1) {
+ if (!((HEAP32[i3 >> 2] | 0) >>> 0 > i12 >>> 0)) {
+ i12 = 0;
+ break L4;
+ }
+ i9 = HEAP8[i12] | 0;
+ i10 = i9 & 255;
+ i14 = HEAP8[i11] | 0;
+ i13 = i14 << 24 >> 24;
+ L139 : do {
+ if ((i13 | 0) == 91) {
+ i6 = (HEAP8[i21] | 0) == 94;
+ i13 = i6 ? i21 : i11;
+ i6 = i6 & 1;
+ i7 = i6 ^ 1;
+ i14 = i13 + 1 | 0;
+ if (i14 >>> 0 < i8 >>> 0) {
+ while (1) {
+ i17 = HEAP8[i14] | 0;
+ i15 = i13 + 2 | 0;
+ i16 = HEAP8[i15] | 0;
+ do {
+ if (i17 << 24 >> 24 == 37) {
+ if ((_match_class(i10, i16 & 255) | 0) == 0) {
+ i13 = i15;
+ } else {
+ i6 = i7;
+ i7 = 147;
+ break L139;
+ }
+ } else {
+ if (i16 << 24 >> 24 == 45 ? (i5 = i13 + 3 | 0, i5 >>> 0 < i8 >>> 0) : 0) {
+ if ((i17 & 255) > (i9 & 255)) {
+ i13 = i5;
+ break;
+ }
+ if ((HEAPU8[i5] | 0) < (i9 & 255)) {
+ i13 = i5;
+ break;
+ } else {
+ i6 = i7;
+ i7 = 147;
+ break L139;
+ }
+ }
+ if (i17 << 24 >> 24 == i9 << 24 >> 24) {
+ i6 = i7;
+ i7 = 147;
+ break L139;
+ } else {
+ i13 = i14;
+ }
+ }
+ } while (0);
+ i14 = i13 + 1 | 0;
+ if (!(i14 >>> 0 < i8 >>> 0)) {
+ i7 = 147;
+ break;
+ }
+ }
+ } else {
+ i7 = 147;
+ }
+ } else if ((i13 | 0) == 37) {
+ i6 = _match_class(i10, HEAPU8[i21] | 0) | 0;
+ i7 = 147;
+ } else if ((i13 | 0) != 46) {
+ i6 = i14 << 24 >> 24 == i9 << 24 >> 24 | 0;
+ i7 = 147;
+ }
+ } while (0);
+ if ((i7 | 0) == 147 ? (i7 = 0, (i6 | 0) == 0) : 0) {
+ i12 = 0;
+ break L4;
+ }
+ i9 = i12 + 1 | 0;
+ i12 = _match(i1, i9, i4) | 0;
+ if ((i12 | 0) == 0) {
+ i12 = i9;
+ } else {
+ break L4;
+ }
+ }
+ } else if ((i7 | 0) == 112) {
+ i19 = i12;
+ }
+ i10 = HEAP32[i3 >> 2] | 0;
+ if (i10 >>> 0 > i19 >>> 0) {
+ i5 = i22 + -1 | 0;
+ i8 = i19;
+ i6 = 0;
+ do {
+ i8 = HEAP8[i8] | 0;
+ i9 = i8 & 255;
+ i13 = HEAP8[i11] | 0;
+ i12 = i13 << 24 >> 24;
+ L183 : do {
+ if ((i12 | 0) == 37) {
+ i10 = _match_class(i9, HEAPU8[i21] | 0) | 0;
+ i7 = 129;
+ } else if ((i12 | 0) == 91) {
+ i7 = (HEAP8[i21] | 0) == 94;
+ i12 = i7 ? i21 : i11;
+ i10 = i7 & 1;
+ i7 = i10 ^ 1;
+ i13 = i12 + 1 | 0;
+ if (i13 >>> 0 < i5 >>> 0) {
+ while (1) {
+ i14 = HEAP8[i13] | 0;
+ i16 = i12 + 2 | 0;
+ i15 = HEAP8[i16] | 0;
+ do {
+ if (i14 << 24 >> 24 == 37) {
+ if ((_match_class(i9, i15 & 255) | 0) == 0) {
+ i12 = i16;
+ } else {
+ i10 = i7;
+ i7 = 129;
+ break L183;
+ }
+ } else {
+ if (i15 << 24 >> 24 == 45 ? (i4 = i12 + 3 | 0, i4 >>> 0 < i5 >>> 0) : 0) {
+ if ((i14 & 255) > (i8 & 255)) {
+ i12 = i4;
+ break;
+ }
+ if ((HEAPU8[i4] | 0) < (i8 & 255)) {
+ i12 = i4;
+ break;
+ } else {
+ i10 = i7;
+ i7 = 129;
+ break L183;
+ }
+ }
+ if (i14 << 24 >> 24 == i8 << 24 >> 24) {
+ i10 = i7;
+ i7 = 129;
+ break L183;
+ } else {
+ i12 = i13;
+ }
+ }
+ } while (0);
+ i13 = i12 + 1 | 0;
+ if (!(i13 >>> 0 < i5 >>> 0)) {
+ i7 = 129;
+ break;
+ }
+ }
+ } else {
+ i7 = 129;
+ }
+ } else if ((i12 | 0) != 46) {
+ i10 = i13 << 24 >> 24 == i8 << 24 >> 24 | 0;
+ i7 = 129;
+ }
+ } while (0);
+ if ((i7 | 0) == 129) {
+ i7 = 0;
+ if ((i10 | 0) == 0) {
+ break;
+ }
+ i10 = HEAP32[i3 >> 2] | 0;
+ }
+ i6 = i6 + 1 | 0;
+ i8 = i19 + i6 | 0;
+ } while (i10 >>> 0 > i8 >>> 0);
+ if (!((i6 | 0) > -1)) {
+ i12 = 0;
+ break;
+ }
+ } else {
+ i6 = 0;
+ }
+ i3 = i22 + 1 | 0;
+ while (1) {
+ i12 = _match(i1, i19 + i6 | 0, i3) | 0;
+ if ((i12 | 0) != 0) {
+ break L4;
+ }
+ if ((i6 | 0) > 0) {
+ i6 = i6 + -1 | 0;
+ } else {
+ i12 = 0;
+ break;
+ }
+ }
+ }
+ } while (0);
+ HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 1;
+ STACKTOP = i2;
+ return i12 | 0;
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[12928 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[12920 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 12952 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 13216 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[12936 >> 2] | 0)) {
+ i21 = (HEAP32[12924 >> 2] | 0) + i11 | 0;
+ HEAP32[12924 >> 2] = i21;
+ HEAP32[12936 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[12932 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[12932 >> 2] = 0;
+ HEAP32[12920 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i21 = (HEAP32[12920 >> 2] | 0) + i11 | 0;
+ HEAP32[12920 >> 2] = i21;
+ HEAP32[12932 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 13216 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 12952 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ HEAP32[12920 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 12952 + (i7 << 2) | 0;
+ i8 = HEAP32[3228] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 12952 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[3228] = i8 | i6;
+ i4 = 12952 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 13216 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[12916 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L204 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L204;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[12928 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[12916 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[12944 >> 2] | 0) + -1 | 0;
+ HEAP32[12944 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 13368 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[12944 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function _dispose_chunk(i6, i7) {
+ i6 = i6 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
+ i1 = STACKTOP;
+ i5 = i6 + i7 | 0;
+ i10 = HEAP32[i6 + 4 >> 2] | 0;
+ do {
+ if ((i10 & 1 | 0) == 0) {
+ i14 = HEAP32[i6 >> 2] | 0;
+ if ((i10 & 3 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i10 = i6 + (0 - i14) | 0;
+ i11 = i14 + i7 | 0;
+ i15 = HEAP32[12928 >> 2] | 0;
+ if (i10 >>> 0 < i15 >>> 0) {
+ _abort();
+ }
+ if ((i10 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i2 = i6 + (i7 + 4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ HEAP32[12920 >> 2] = i11;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i6 + (4 - i14) >> 2] = i11 | 1;
+ HEAP32[i5 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ i17 = i14 >>> 3;
+ if (i14 >>> 0 < 256) {
+ i2 = HEAP32[i6 + (8 - i14) >> 2] | 0;
+ i12 = HEAP32[i6 + (12 - i14) >> 2] | 0;
+ i13 = 12952 + (i17 << 1 << 2) | 0;
+ if ((i2 | 0) != (i13 | 0)) {
+ if (i2 >>> 0 < i15 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i10 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i2 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i17);
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ if ((i12 | 0) != (i13 | 0)) {
+ if (i12 >>> 0 < i15 >>> 0) {
+ _abort();
+ }
+ i13 = i12 + 8 | 0;
+ if ((HEAP32[i13 >> 2] | 0) == (i10 | 0)) {
+ i16 = i13;
+ } else {
+ _abort();
+ }
+ } else {
+ i16 = i12 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i12;
+ HEAP32[i16 >> 2] = i2;
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ i16 = HEAP32[i6 + (24 - i14) >> 2] | 0;
+ i18 = HEAP32[i6 + (12 - i14) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i10 | 0)) {
+ i19 = 16 - i14 | 0;
+ i18 = i6 + (i19 + 4) | 0;
+ i17 = HEAP32[i18 >> 2] | 0;
+ if ((i17 | 0) == 0) {
+ i18 = i6 + i19 | 0;
+ i17 = HEAP32[i18 >> 2] | 0;
+ if ((i17 | 0) == 0) {
+ i13 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i19 = i17 + 20 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i17 = i20;
+ i18 = i19;
+ continue;
+ }
+ i20 = i17 + 16 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) == 0) {
+ break;
+ } else {
+ i17 = i19;
+ i18 = i20;
+ }
+ }
+ if (i18 >>> 0 < i15 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i13 = i17;
+ break;
+ }
+ } else {
+ i17 = HEAP32[i6 + (8 - i14) >> 2] | 0;
+ if (i17 >>> 0 < i15 >>> 0) {
+ _abort();
+ }
+ i19 = i17 + 12 | 0;
+ if ((HEAP32[i19 >> 2] | 0) != (i10 | 0)) {
+ _abort();
+ }
+ i15 = i18 + 8 | 0;
+ if ((HEAP32[i15 >> 2] | 0) == (i10 | 0)) {
+ HEAP32[i19 >> 2] = i18;
+ HEAP32[i15 >> 2] = i17;
+ i13 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i16 | 0) != 0) {
+ i15 = HEAP32[i6 + (28 - i14) >> 2] | 0;
+ i17 = 13216 + (i15 << 2) | 0;
+ if ((i10 | 0) == (HEAP32[i17 >> 2] | 0)) {
+ HEAP32[i17 >> 2] = i13;
+ if ((i13 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i15);
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ } else {
+ if (i16 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i15 = i16 + 16 | 0;
+ if ((HEAP32[i15 >> 2] | 0) == (i10 | 0)) {
+ HEAP32[i15 >> 2] = i13;
+ } else {
+ HEAP32[i16 + 20 >> 2] = i13;
+ }
+ if ((i13 | 0) == 0) {
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i13 + 24 >> 2] = i16;
+ i14 = 16 - i14 | 0;
+ i15 = HEAP32[i6 + i14 >> 2] | 0;
+ do {
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 + 16 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i13;
+ break;
+ }
+ }
+ } while (0);
+ i14 = HEAP32[i6 + (i14 + 4) >> 2] | 0;
+ if ((i14 | 0) != 0) {
+ if (i14 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 + 20 >> 2] = i14;
+ HEAP32[i14 + 24 >> 2] = i13;
+ i2 = i10;
+ i12 = i11;
+ break;
+ }
+ } else {
+ i2 = i10;
+ i12 = i11;
+ }
+ } else {
+ i2 = i10;
+ i12 = i11;
+ }
+ } else {
+ i2 = i6;
+ i12 = i7;
+ }
+ } while (0);
+ i10 = HEAP32[12928 >> 2] | 0;
+ if (i5 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i11 = i6 + (i7 + 4) | 0;
+ i13 = HEAP32[i11 >> 2] | 0;
+ if ((i13 & 2 | 0) == 0) {
+ if ((i5 | 0) == (HEAP32[12936 >> 2] | 0)) {
+ i20 = (HEAP32[12924 >> 2] | 0) + i12 | 0;
+ HEAP32[12924 >> 2] = i20;
+ HEAP32[12936 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i20 | 1;
+ if ((i2 | 0) != (HEAP32[12932 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[12932 >> 2] = 0;
+ HEAP32[12920 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i5 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i20 = (HEAP32[12920 >> 2] | 0) + i12 | 0;
+ HEAP32[12920 >> 2] = i20;
+ HEAP32[12932 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i20 | 1;
+ HEAP32[i2 + i20 >> 2] = i20;
+ STACKTOP = i1;
+ return;
+ }
+ i12 = (i13 & -8) + i12 | 0;
+ i11 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i9 = HEAP32[i6 + (i7 + 24) >> 2] | 0;
+ i11 = HEAP32[i6 + (i7 + 12) >> 2] | 0;
+ do {
+ if ((i11 | 0) == (i5 | 0)) {
+ i13 = i6 + (i7 + 20) | 0;
+ i11 = HEAP32[i13 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ i13 = i6 + (i7 + 16) | 0;
+ i11 = HEAP32[i13 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ i8 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i15 = i11 + 20 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ if ((i14 | 0) != 0) {
+ i11 = i14;
+ i13 = i15;
+ continue;
+ }
+ i14 = i11 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i11 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < i10 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i8 = i11;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i6 + (i7 + 8) >> 2] | 0;
+ if (i13 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i10 = i13 + 12 | 0;
+ if ((HEAP32[i10 >> 2] | 0) != (i5 | 0)) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i10 >> 2] = i11;
+ HEAP32[i14 >> 2] = i13;
+ i8 = i11;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i10 = HEAP32[i6 + (i7 + 28) >> 2] | 0;
+ i11 = 13216 + (i10 << 2) | 0;
+ if ((i5 | 0) == (HEAP32[i11 >> 2] | 0)) {
+ HEAP32[i11 >> 2] = i8;
+ if ((i8 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i10);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i10 = i9 + 16 | 0;
+ if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i10 >> 2] = i8;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i8;
+ }
+ if ((i8 | 0) == 0) {
+ break;
+ }
+ }
+ if (i8 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i8 + 24 >> 2] = i9;
+ i5 = HEAP32[i6 + (i7 + 16) >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i8;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i6 + (i7 + 20) >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i8;
+ break;
+ }
+ }
+ }
+ } else {
+ i8 = HEAP32[i6 + (i7 + 8) >> 2] | 0;
+ i6 = HEAP32[i6 + (i7 + 12) >> 2] | 0;
+ i7 = 12952 + (i11 << 1 << 2) | 0;
+ if ((i8 | 0) != (i7 | 0)) {
+ if (i8 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i8 + 12 >> 2] | 0) != (i5 | 0)) {
+ _abort();
+ }
+ }
+ if ((i6 | 0) == (i8 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i11);
+ break;
+ }
+ if ((i6 | 0) != (i7 | 0)) {
+ if (i6 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i7 = i6 + 8 | 0;
+ if ((HEAP32[i7 >> 2] | 0) == (i5 | 0)) {
+ i9 = i7;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i6 + 8 | 0;
+ }
+ HEAP32[i8 + 12 >> 2] = i6;
+ HEAP32[i9 >> 2] = i8;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i12 | 1;
+ HEAP32[i2 + i12 >> 2] = i12;
+ if ((i2 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ HEAP32[12920 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i11 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i12 | 1;
+ HEAP32[i2 + i12 >> 2] = i12;
+ }
+ i6 = i12 >>> 3;
+ if (i12 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i5 = 12952 + (i7 << 2) | 0;
+ i8 = HEAP32[3228] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i7 = 12952 + (i7 + 2 << 2) | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ if (i6 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i7;
+ i3 = i6;
+ }
+ } else {
+ HEAP32[3228] = i8 | i6;
+ i4 = 12952 + (i7 + 2 << 2) | 0;
+ i3 = i5;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i3;
+ HEAP32[i2 + 12 >> 2] = i5;
+ STACKTOP = i1;
+ return;
+ }
+ i3 = i12 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i19 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i20 = i3 << i19;
+ i18 = (i20 + 520192 | 0) >>> 16 & 4;
+ i20 = i20 << i18;
+ i3 = (i20 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i18 | i19 | i3) + (i20 << i3 >>> 15) | 0;
+ i3 = i12 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 13216 + (i3 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i3;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i5 = HEAP32[12916 >> 2] | 0;
+ i4 = 1 << i3;
+ if ((i5 & i4 | 0) == 0) {
+ HEAP32[12916 >> 2] = i5 | i4;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i6;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L194 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i12 | 0)) {
+ i3 = i12 << i3;
+ i6 = i4;
+ while (1) {
+ i5 = i6 + (i3 >>> 31 << 2) + 16 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) == (i12 | 0)) {
+ break L194;
+ } else {
+ i3 = i3 << 1;
+ i6 = i4;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i6;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ STACKTOP = i1;
+ return;
+ }
+ } while (0);
+ i3 = i4 + 8 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i5 = HEAP32[12928 >> 2] | 0;
+ if (i4 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i6 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ HEAP32[i6 + 12 >> 2] = i2;
+ HEAP32[i3 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i6;
+ HEAP32[i2 + 12 >> 2] = i4;
+ HEAP32[i2 + 24 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+}
+function _singlestep(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i14 = i1;
+ i3 = i2 + 12 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ i6 = i8 + 61 | 0;
+ switch (HEAPU8[i6] | 0) {
+ case 0:
+ {
+ if ((HEAP32[i8 + 84 >> 2] | 0) != 0) {
+ i21 = i8 + 16 | 0;
+ i22 = HEAP32[i21 >> 2] | 0;
+ _propagatemark(i8);
+ i22 = (HEAP32[i21 >> 2] | 0) - i22 | 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ HEAP8[i6] = 1;
+ i6 = i8 + 20 | 0;
+ HEAP32[i6 >> 2] = HEAP32[i8 + 16 >> 2];
+ i8 = HEAP32[i3 >> 2] | 0;
+ i7 = i8 + 16 | 0;
+ i14 = HEAP32[i7 >> 2] | 0;
+ if ((i2 | 0) != 0 ? !((HEAP8[i2 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i8, i2);
+ }
+ if ((HEAP32[i8 + 48 >> 2] & 64 | 0) != 0 ? (i13 = HEAP32[i8 + 40 >> 2] | 0, !((HEAP8[i13 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i8, i13);
+ }
+ _markmt(i8);
+ i13 = i8 + 112 | 0;
+ i15 = HEAP32[i8 + 132 >> 2] | 0;
+ if ((i15 | 0) != (i13 | 0)) {
+ do {
+ if (((HEAP8[i15 + 5 | 0] & 7) == 0 ? (i12 = HEAP32[i15 + 8 >> 2] | 0, (HEAP32[i12 + 8 >> 2] & 64 | 0) != 0) : 0) ? (i11 = HEAP32[i12 >> 2] | 0, !((HEAP8[i11 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i8, i11);
+ }
+ i15 = HEAP32[i15 + 20 >> 2] | 0;
+ } while ((i15 | 0) != (i13 | 0));
+ }
+ i16 = i8 + 84 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != 0) {
+ do {
+ _propagatemark(i8);
+ } while ((HEAP32[i16 >> 2] | 0) != 0);
+ }
+ i17 = (HEAP32[i7 >> 2] | 0) - i14 | 0;
+ i11 = i8 + 92 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ i21 = i8 + 88 | 0;
+ i22 = HEAP32[i21 >> 2] | 0;
+ i15 = i8 + 96 | 0;
+ i13 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i15 >> 2] = 0;
+ HEAP32[i21 >> 2] = 0;
+ HEAP32[i11 >> 2] = 0;
+ HEAP32[i16 >> 2] = i22;
+ if ((i22 | 0) != 0) {
+ do {
+ _propagatemark(i8);
+ } while ((HEAP32[i16 >> 2] | 0) != 0);
+ }
+ HEAP32[i16 >> 2] = i12;
+ if ((i12 | 0) != 0) {
+ do {
+ _propagatemark(i8);
+ } while ((HEAP32[i16 >> 2] | 0) != 0);
+ }
+ HEAP32[i16 >> 2] = i13;
+ if ((i13 | 0) != 0) {
+ do {
+ _propagatemark(i8);
+ } while ((HEAP32[i16 >> 2] | 0) != 0);
+ }
+ i18 = HEAP32[i7 >> 2] | 0;
+ while (1) {
+ i13 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i15 >> 2] = 0;
+ i12 = 0;
+ L42 : while (1) {
+ i14 = i13;
+ while (1) {
+ if ((i14 | 0) == 0) {
+ break L42;
+ }
+ i13 = HEAP32[i14 + 24 >> 2] | 0;
+ if ((_traverseephemeron(i8, i14) | 0) == 0) {
+ i14 = i13;
+ } else {
+ break;
+ }
+ }
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i12 = 1;
+ continue;
+ }
+ while (1) {
+ _propagatemark(i8);
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i12 = 1;
+ continue L42;
+ }
+ }
+ }
+ if ((i12 | 0) == 0) {
+ break;
+ }
+ }
+ _clearvalues(i8, HEAP32[i11 >> 2] | 0, 0);
+ i14 = i8 + 100 | 0;
+ _clearvalues(i8, HEAP32[i14 >> 2] | 0, 0);
+ i13 = HEAP32[i11 >> 2] | 0;
+ i12 = HEAP32[i14 >> 2] | 0;
+ i21 = HEAP32[i7 >> 2] | 0;
+ i20 = HEAP32[i3 >> 2] | 0;
+ i19 = i20 + 104 | 0;
+ while (1) {
+ i22 = HEAP32[i19 >> 2] | 0;
+ if ((i22 | 0) == 0) {
+ break;
+ } else {
+ i19 = i22;
+ }
+ }
+ i17 = i17 - i18 + i21 | 0;
+ i20 = i20 + 72 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ L55 : do {
+ if ((i21 | 0) != 0) {
+ while (1) {
+ i18 = i21;
+ while (1) {
+ i22 = i18 + 5 | 0;
+ i21 = HEAP8[i22] | 0;
+ if ((i21 & 3) == 0) {
+ break;
+ }
+ HEAP8[i22] = i21 & 255 | 8;
+ HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i18 >> 2] = HEAP32[i19 >> 2];
+ HEAP32[i19 >> 2] = i18;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) == 0) {
+ break L55;
+ } else {
+ i22 = i18;
+ i18 = i19;
+ i19 = i22;
+ }
+ }
+ i21 = HEAP32[i18 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i20 = i18;
+ }
+ }
+ }
+ } while (0);
+ i19 = HEAP32[i8 + 104 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i18 = i8 + 60 | 0;
+ do {
+ i22 = i19 + 5 | 0;
+ HEAP8[i22] = HEAP8[i18] & 3 | HEAP8[i22] & 184;
+ _reallymarkobject(i8, i19);
+ i19 = HEAP32[i19 >> 2] | 0;
+ } while ((i19 | 0) != 0);
+ }
+ if ((HEAP32[i16 >> 2] | 0) != 0) {
+ do {
+ _propagatemark(i8);
+ } while ((HEAP32[i16 >> 2] | 0) != 0);
+ }
+ i18 = HEAP32[i7 >> 2] | 0;
+ while (1) {
+ i20 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i15 >> 2] = 0;
+ i19 = 0;
+ L74 : while (1) {
+ i21 = i20;
+ while (1) {
+ if ((i21 | 0) == 0) {
+ break L74;
+ }
+ i20 = HEAP32[i21 + 24 >> 2] | 0;
+ if ((_traverseephemeron(i8, i21) | 0) == 0) {
+ i21 = i20;
+ } else {
+ break;
+ }
+ }
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i19 = 1;
+ continue;
+ }
+ while (1) {
+ _propagatemark(i8);
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i19 = 1;
+ continue L74;
+ }
+ }
+ }
+ if ((i19 | 0) == 0) {
+ break;
+ }
+ }
+ i16 = i17 - i18 | 0;
+ i15 = HEAP32[i15 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ do {
+ i22 = 1 << HEAPU8[i15 + 7 | 0];
+ i19 = HEAP32[i15 + 16 >> 2] | 0;
+ i17 = i19 + (i22 << 5) | 0;
+ if ((i22 | 0) > 0) {
+ do {
+ i18 = i19 + 8 | 0;
+ do {
+ if ((HEAP32[i18 >> 2] | 0) != 0 ? (i9 = i19 + 24 | 0, i10 = HEAP32[i9 >> 2] | 0, (i10 & 64 | 0) != 0) : 0) {
+ i20 = HEAP32[i19 + 16 >> 2] | 0;
+ if ((i10 & 15 | 0) == 4) {
+ if ((i20 | 0) == 0) {
+ break;
+ }
+ if ((HEAP8[i20 + 5 | 0] & 3) == 0) {
+ break;
+ }
+ _reallymarkobject(i8, i20);
+ break;
+ } else {
+ i20 = i20 + 5 | 0;
+ if ((HEAP8[i20] & 3) == 0) {
+ break;
+ }
+ HEAP32[i18 >> 2] = 0;
+ if ((HEAP8[i20] & 3) == 0) {
+ break;
+ }
+ HEAP32[i9 >> 2] = 11;
+ break;
+ }
+ }
+ } while (0);
+ i19 = i19 + 32 | 0;
+ } while (i19 >>> 0 < i17 >>> 0);
+ }
+ i15 = HEAP32[i15 + 24 >> 2] | 0;
+ } while ((i15 | 0) != 0);
+ }
+ i10 = HEAP32[i14 >> 2] | 0;
+ if ((i10 | 0) != 0) {
+ do {
+ i22 = 1 << HEAPU8[i10 + 7 | 0];
+ i17 = HEAP32[i10 + 16 >> 2] | 0;
+ i9 = i17 + (i22 << 5) | 0;
+ if ((i22 | 0) > 0) {
+ do {
+ i15 = i17 + 8 | 0;
+ do {
+ if ((HEAP32[i15 >> 2] | 0) != 0 ? (i5 = i17 + 24 | 0, i4 = HEAP32[i5 >> 2] | 0, (i4 & 64 | 0) != 0) : 0) {
+ i18 = HEAP32[i17 + 16 >> 2] | 0;
+ if ((i4 & 15 | 0) == 4) {
+ if ((i18 | 0) == 0) {
+ break;
+ }
+ if ((HEAP8[i18 + 5 | 0] & 3) == 0) {
+ break;
+ }
+ _reallymarkobject(i8, i18);
+ break;
+ } else {
+ i18 = i18 + 5 | 0;
+ if ((HEAP8[i18] & 3) == 0) {
+ break;
+ }
+ HEAP32[i15 >> 2] = 0;
+ if ((HEAP8[i18] & 3) == 0) {
+ break;
+ }
+ HEAP32[i5 >> 2] = 11;
+ break;
+ }
+ }
+ } while (0);
+ i17 = i17 + 32 | 0;
+ } while (i17 >>> 0 < i9 >>> 0);
+ }
+ i10 = HEAP32[i10 + 24 >> 2] | 0;
+ } while ((i10 | 0) != 0);
+ }
+ _clearvalues(i8, HEAP32[i11 >> 2] | 0, i13);
+ _clearvalues(i8, HEAP32[i14 >> 2] | 0, i12);
+ i4 = i8 + 60 | 0;
+ HEAP8[i4] = HEAPU8[i4] ^ 3;
+ i4 = i16 + (HEAP32[i7 >> 2] | 0) | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i4;
+ i3 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i3 + 61 | 0] = 2;
+ HEAP32[i3 + 64 >> 2] = 0;
+ i7 = i3 + 72 | 0;
+ i5 = 0;
+ do {
+ i5 = i5 + 1 | 0;
+ i6 = _sweeplist(i2, i7, 1) | 0;
+ } while ((i6 | 0) == (i7 | 0));
+ HEAP32[i3 + 80 >> 2] = i6;
+ i6 = i3 + 68 | 0;
+ i7 = 0;
+ do {
+ i7 = i7 + 1 | 0;
+ i8 = _sweeplist(i2, i6, 1) | 0;
+ } while ((i8 | 0) == (i6 | 0));
+ HEAP32[i3 + 76 >> 2] = i8;
+ i22 = ((i7 + i5 | 0) * 5 | 0) + i4 | 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ case 2:
+ {
+ i3 = i8 + 64 | 0;
+ i4 = i8 + 32 | 0;
+ i8 = i8 + 24 | 0;
+ i5 = 0;
+ while (1) {
+ i10 = HEAP32[i3 >> 2] | 0;
+ i11 = i10 + i5 | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ if ((i11 | 0) >= (i9 | 0)) {
+ i2 = i10;
+ break;
+ }
+ _sweeplist(i2, (HEAP32[i8 >> 2] | 0) + (i11 << 2) | 0, -3) | 0;
+ i5 = i5 + 1 | 0;
+ if ((i5 | 0) >= 80) {
+ i7 = 96;
+ break;
+ }
+ }
+ if ((i7 | 0) == 96) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ }
+ i22 = i2 + i5 | 0;
+ HEAP32[i3 >> 2] = i22;
+ if ((i22 | 0) >= (i9 | 0)) {
+ HEAP8[i6] = 3;
+ }
+ i22 = i5 * 5 | 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ case 5:
+ {
+ i2 = i8 + 16 | 0;
+ HEAP32[i2 >> 2] = HEAP32[i8 + 32 >> 2] << 2;
+ i22 = i8 + 84 | 0;
+ i3 = i8 + 172 | 0;
+ HEAP32[i22 + 0 >> 2] = 0;
+ HEAP32[i22 + 4 >> 2] = 0;
+ HEAP32[i22 + 8 >> 2] = 0;
+ HEAP32[i22 + 12 >> 2] = 0;
+ HEAP32[i22 + 16 >> 2] = 0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i8, i3);
+ }
+ if ((HEAP32[i8 + 48 >> 2] & 64 | 0) != 0 ? (i15 = HEAP32[i8 + 40 >> 2] | 0, !((HEAP8[i15 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i8, i15);
+ }
+ _markmt(i8);
+ i4 = HEAP32[i8 + 104 >> 2] | 0;
+ if ((i4 | 0) != 0) {
+ i3 = i8 + 60 | 0;
+ do {
+ i22 = i4 + 5 | 0;
+ HEAP8[i22] = HEAP8[i3] & 3 | HEAP8[i22] & 184;
+ _reallymarkobject(i8, i4);
+ i4 = HEAP32[i4 >> 2] | 0;
+ } while ((i4 | 0) != 0);
+ }
+ HEAP8[i6] = 0;
+ i22 = HEAP32[i2 >> 2] | 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ case 3:
+ {
+ i3 = i8 + 80 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ HEAP8[i6] = 4;
+ i22 = 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ } else {
+ HEAP32[i3 >> 2] = _sweeplist(i2, i4, 80) | 0;
+ i22 = 400;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ }
+ case 4:
+ {
+ i4 = i8 + 76 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ HEAP32[i4 >> 2] = _sweeplist(i2, i5, 80) | 0;
+ i22 = 400;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ HEAP32[i14 >> 2] = HEAP32[i8 + 172 >> 2];
+ _sweeplist(i2, i14, 1) | 0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP8[i3 + 62 | 0] | 0) != 1) {
+ i4 = (HEAP32[i3 + 32 >> 2] | 0) / 2 | 0;
+ if ((HEAP32[i3 + 28 >> 2] | 0) >>> 0 < i4 >>> 0) {
+ _luaS_resize(i2, i4);
+ }
+ i21 = i3 + 144 | 0;
+ i22 = i3 + 152 | 0;
+ HEAP32[i21 >> 2] = _luaM_realloc_(i2, HEAP32[i21 >> 2] | 0, HEAP32[i22 >> 2] | 0, 0) | 0;
+ HEAP32[i22 >> 2] = 0;
+ }
+ HEAP8[i6] = 5;
+ i22 = 5;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ default:
+ {
+ i22 = 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ }
+ return 0;
+}
+function _pmain(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ i7 = _lua_tointegerx(i3, 1, 0) | 0;
+ i4 = _lua_touserdata(i3, 2) | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) != 0 ? (HEAP8[i5] | 0) != 0 : 0) {
+ HEAP32[20] = i5;
+ }
+ i12 = HEAP32[i4 + 4 >> 2] | 0;
+ do {
+ if ((i12 | 0) == 0) {
+ i5 = 0;
+ i6 = 0;
+ i8 = 0;
+ i9 = 1;
+ i10 = 1;
+ } else {
+ i9 = 0;
+ i8 = 0;
+ i11 = 0;
+ i6 = 0;
+ i5 = 1;
+ L6 : while (1) {
+ if ((HEAP8[i12] | 0) != 45) {
+ i10 = 18;
+ break;
+ }
+ switch (HEAP8[i12 + 1 | 0] | 0) {
+ case 108:
+ {
+ i10 = 12;
+ break;
+ }
+ case 69:
+ {
+ i9 = 1;
+ break;
+ }
+ case 45:
+ {
+ i10 = 7;
+ break L6;
+ }
+ case 105:
+ {
+ if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
+ i11 = 1;
+ i6 = 1;
+ } else {
+ i5 = -1;
+ break L6;
+ }
+ break;
+ }
+ case 101:
+ {
+ i8 = 1;
+ i10 = 12;
+ break;
+ }
+ case 118:
+ {
+ if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
+ i11 = 1;
+ } else {
+ i5 = -1;
+ break L6;
+ }
+ break;
+ }
+ case 0:
+ {
+ i10 = 18;
+ break L6;
+ }
+ default:
+ {
+ i10 = 16;
+ break L6;
+ }
+ }
+ if ((i10 | 0) == 12) {
+ i10 = 0;
+ if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
+ i12 = i5 + 1 | 0;
+ i13 = HEAP32[i4 + (i12 << 2) >> 2] | 0;
+ if ((i13 | 0) == 0) {
+ i10 = 15;
+ break;
+ }
+ if ((HEAP8[i13] | 0) == 45) {
+ i10 = 15;
+ break;
+ } else {
+ i5 = i12;
+ }
+ }
+ }
+ i5 = i5 + 1 | 0;
+ i12 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i5 = 0;
+ i12 = i9;
+ i10 = 23;
+ break;
+ }
+ }
+ if ((i10 | 0) == 7) {
+ if ((HEAP8[i12 + 2 | 0] | 0) == 0) {
+ i5 = i5 + 1 | 0;
+ i5 = (HEAP32[i4 + (i5 << 2) >> 2] | 0) == 0 ? 0 : i5;
+ i10 = 18;
+ } else {
+ i5 = -1;
+ }
+ } else if ((i10 | 0) == 15) {
+ i5 = 0 - i5 | 0;
+ i10 = 18;
+ } else if ((i10 | 0) == 16) {
+ i5 = 0 - i5 | 0;
+ i10 = 18;
+ }
+ if ((i10 | 0) == 18) {
+ if ((i5 | 0) >= 0) {
+ i12 = i9;
+ i10 = 23;
+ }
+ }
+ if ((i10 | 0) == 23) {
+ if ((i11 | 0) == 0) {
+ i9 = 1;
+ } else {
+ i9 = HEAP32[_stdout >> 2] | 0;
+ _fwrite(440, 1, 51, i9 | 0) | 0;
+ _fputc(10, i9 | 0) | 0;
+ _fflush(i9 | 0) | 0;
+ i9 = 0;
+ }
+ if ((i12 | 0) == 0) {
+ i10 = 1;
+ break;
+ }
+ _lua_pushboolean(i3, 1);
+ _lua_setfield(i3, -1001e3, 96);
+ i10 = 0;
+ break;
+ }
+ i3 = HEAP32[i4 + (0 - i5 << 2) >> 2] | 0;
+ i4 = HEAP32[_stderr >> 2] | 0;
+ HEAP32[i2 >> 2] = HEAP32[20];
+ _fprintf(i4 | 0, 496, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ i13 = HEAP8[i3 + 1 | 0] | 0;
+ if (i13 << 24 >> 24 == 108 | i13 << 24 >> 24 == 101) {
+ HEAP32[i2 >> 2] = i3;
+ _fprintf(i4 | 0, 504, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ } else {
+ HEAP32[i2 >> 2] = i3;
+ _fprintf(i4 | 0, 528, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = HEAP32[20];
+ _fprintf(i4 | 0, 560, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ } while (0);
+ _luaL_checkversion_(i3, 502.0);
+ _lua_gc(i3, 0, 0) | 0;
+ _luaL_openlibs(i3);
+ _lua_gc(i3, 1, 0) | 0;
+ do {
+ if (i10) {
+ i10 = _getenv(409 | 0) | 0;
+ if ((i10 | 0) == 0) {
+ i10 = _getenv(425 | 0) | 0;
+ if ((i10 | 0) == 0) {
+ break;
+ } else {
+ i11 = 424;
+ }
+ } else {
+ i11 = 408;
+ }
+ if ((HEAP8[i10] | 0) == 64) {
+ i13 = _luaL_loadfilex(i3, i10 + 1 | 0, 0) | 0;
+ if ((i13 | 0) == 0) {
+ i12 = _lua_gettop(i3) | 0;
+ _lua_pushcclosure(i3, 142, 0);
+ _lua_insert(i3, i12);
+ HEAP32[48] = i3;
+ _signal(2, 1) | 0;
+ i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i3, i12);
+ if ((i13 | 0) == 0) {
+ break;
+ }
+ }
+ if ((_lua_type(i3, -1) | 0) == 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i11 = _lua_tolstring(i3, -1, 0) | 0;
+ i12 = HEAP32[20] | 0;
+ i10 = HEAP32[_stderr >> 2] | 0;
+ if ((i12 | 0) != 0) {
+ HEAP32[i2 >> 2] = i12;
+ _fprintf(i10 | 0, 496, i2 | 0) | 0;
+ _fflush(i10 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i11 | 0) == 0 ? 48 : i11;
+ _fprintf(i10 | 0, 912, i2 | 0) | 0;
+ _fflush(i10 | 0) | 0;
+ _lua_settop(i3, -2);
+ _lua_gc(i3, 2, 0) | 0;
+ } else {
+ i13 = _luaL_loadbufferx(i3, i10, _strlen(i10 | 0) | 0, i11, 0) | 0;
+ if ((i13 | 0) == 0) {
+ i12 = _lua_gettop(i3) | 0;
+ _lua_pushcclosure(i3, 142, 0);
+ _lua_insert(i3, i12);
+ HEAP32[48] = i3;
+ _signal(2, 1) | 0;
+ i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i3, i12);
+ if ((i13 | 0) == 0) {
+ break;
+ }
+ }
+ if ((_lua_type(i3, -1) | 0) == 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i11 = _lua_tolstring(i3, -1, 0) | 0;
+ i10 = HEAP32[20] | 0;
+ i12 = HEAP32[_stderr >> 2] | 0;
+ if ((i10 | 0) != 0) {
+ HEAP32[i2 >> 2] = i10;
+ _fprintf(i12 | 0, 496, i2 | 0) | 0;
+ _fflush(i12 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i11 | 0) == 0 ? 48 : i11;
+ _fprintf(i12 | 0, 912, i2 | 0) | 0;
+ _fflush(i12 | 0) | 0;
+ _lua_settop(i3, -2);
+ _lua_gc(i3, 2, 0) | 0;
+ }
+ if ((i13 | 0) != 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ } while (0);
+ i7 = (i5 | 0) > 0 ? i5 : i7;
+ L67 : do {
+ if ((i7 | 0) > 1) {
+ i10 = 1;
+ while (1) {
+ i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
+ i12 = HEAP8[i11 + 1 | 0] | 0;
+ if ((i12 | 0) == 108) {
+ i11 = i11 + 2 | 0;
+ if ((HEAP8[i11] | 0) == 0) {
+ i10 = i10 + 1 | 0;
+ i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
+ }
+ _lua_getglobal(i3, 400);
+ _lua_pushstring(i3, i11) | 0;
+ i12 = (_lua_gettop(i3) | 0) + -1 | 0;
+ _lua_pushcclosure(i3, 142, 0);
+ _lua_insert(i3, i12);
+ HEAP32[48] = i3;
+ _signal(2, 1) | 0;
+ i13 = _lua_pcallk(i3, 1, 1, i12, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i3, i12);
+ if ((i13 | 0) != 0) {
+ i10 = 58;
+ break;
+ }
+ _lua_setglobal(i3, i11);
+ } else if ((i12 | 0) == 101) {
+ i11 = i11 + 2 | 0;
+ if ((HEAP8[i11] | 0) == 0) {
+ i10 = i10 + 1 | 0;
+ i11 = HEAP32[i4 + (i10 << 2) >> 2] | 0;
+ }
+ if ((_luaL_loadbufferx(i3, i11, _strlen(i11 | 0) | 0, 384, 0) | 0) != 0) {
+ i10 = 50;
+ break;
+ }
+ i12 = _lua_gettop(i3) | 0;
+ _lua_pushcclosure(i3, 142, 0);
+ _lua_insert(i3, i12);
+ HEAP32[48] = i3;
+ _signal(2, 1) | 0;
+ i13 = _lua_pcallk(i3, 0, 0, i12, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i3, i12);
+ if ((i13 | 0) != 0) {
+ i10 = 50;
+ break;
+ }
+ }
+ i10 = i10 + 1 | 0;
+ if ((i10 | 0) >= (i7 | 0)) {
+ break L67;
+ }
+ }
+ if ((i10 | 0) == 50) {
+ if ((_lua_type(i3, -1) | 0) == 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i5 = _lua_tolstring(i3, -1, 0) | 0;
+ i6 = HEAP32[20] | 0;
+ i4 = HEAP32[_stderr >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ HEAP32[i2 >> 2] = i6;
+ _fprintf(i4 | 0, 496, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i5 | 0) == 0 ? 48 : i5;
+ _fprintf(i4 | 0, 912, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ _lua_settop(i3, -2);
+ _lua_gc(i3, 2, 0) | 0;
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else if ((i10 | 0) == 58) {
+ if ((_lua_type(i3, -1) | 0) == 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i5 = _lua_tolstring(i3, -1, 0) | 0;
+ i6 = HEAP32[20] | 0;
+ i4 = HEAP32[_stderr >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ HEAP32[i2 >> 2] = i6;
+ _fprintf(i4 | 0, 496, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i5 | 0) == 0 ? 48 : i5;
+ _fprintf(i4 | 0, 912, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ _lua_settop(i3, -2);
+ _lua_gc(i3, 2, 0) | 0;
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i10 = 0;
+ while (1) {
+ if ((HEAP32[i4 + (i10 << 2) >> 2] | 0) == 0) {
+ break;
+ } else {
+ i10 = i10 + 1 | 0;
+ }
+ }
+ i11 = i5 + 1 | 0;
+ i7 = i10 - i11 | 0;
+ _luaL_checkstack(i3, i7 + 3 | 0, 352);
+ if ((i11 | 0) < (i10 | 0)) {
+ i12 = i11;
+ do {
+ _lua_pushstring(i3, HEAP32[i4 + (i12 << 2) >> 2] | 0) | 0;
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) != (i10 | 0));
+ }
+ _lua_createtable(i3, i7, i11);
+ if ((i10 | 0) > 0) {
+ i11 = 0;
+ do {
+ _lua_pushstring(i3, HEAP32[i4 + (i11 << 2) >> 2] | 0) | 0;
+ _lua_rawseti(i3, -2, i11 - i5 | 0);
+ i11 = i11 + 1 | 0;
+ } while ((i11 | 0) != (i10 | 0));
+ }
+ _lua_setglobal(i3, 328);
+ i10 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
+ if ((_strcmp(i10, 336) | 0) == 0) {
+ i13 = (_strcmp(HEAP32[i4 + (i5 + -1 << 2) >> 2] | 0, 344) | 0) == 0;
+ i10 = i13 ? i10 : 0;
+ }
+ i10 = _luaL_loadfilex(i3, i10, 0) | 0;
+ i4 = ~i7;
+ _lua_insert(i3, i4);
+ if ((i10 | 0) == 0) {
+ i13 = (_lua_gettop(i3) | 0) - i7 | 0;
+ _lua_pushcclosure(i3, 142, 0);
+ _lua_insert(i3, i13);
+ HEAP32[48] = i3;
+ _signal(2, 1) | 0;
+ i10 = _lua_pcallk(i3, i7, -1, i13, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i3, i13);
+ if ((i10 | 0) == 0) {
+ break;
+ }
+ } else {
+ _lua_settop(i3, i4);
+ }
+ if ((_lua_type(i3, -1) | 0) != 0) {
+ i7 = _lua_tolstring(i3, -1, 0) | 0;
+ i11 = HEAP32[20] | 0;
+ i4 = HEAP32[_stderr >> 2] | 0;
+ if ((i11 | 0) != 0) {
+ HEAP32[i2 >> 2] = i11;
+ _fprintf(i4 | 0, 496, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i7 | 0) == 0 ? 48 : i7;
+ _fprintf(i4 | 0, 912, i2 | 0) | 0;
+ _fflush(i4 | 0) | 0;
+ _lua_settop(i3, -2);
+ _lua_gc(i3, 2, 0) | 0;
+ }
+ if ((i10 | 0) != 0) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ } while (0);
+ if ((i6 | 0) == 0) {
+ if (!((i8 | i5 | 0) != 0 | i9 ^ 1)) {
+ i13 = HEAP32[_stdout >> 2] | 0;
+ _fwrite(440, 1, 51, i13 | 0) | 0;
+ _fputc(10, i13 | 0) | 0;
+ _fflush(i13 | 0) | 0;
+ _dotty(i3);
+ }
+ } else {
+ _dotty(i3);
+ }
+ _lua_pushboolean(i3, 1);
+ i13 = 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _DumpFunction(i6, i2) {
+ i6 = i6 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i17 = i5 + 56 | 0;
+ i19 = i5 + 52 | 0;
+ i20 = i5 + 48 | 0;
+ i18 = i5;
+ i21 = i5 + 60 | 0;
+ i22 = i5 + 44 | 0;
+ i1 = i5 + 40 | 0;
+ i16 = i5 + 36 | 0;
+ i23 = i5 + 32 | 0;
+ i3 = i5 + 28 | 0;
+ i7 = i5 + 24 | 0;
+ i8 = i5 + 20 | 0;
+ i9 = i5 + 16 | 0;
+ i10 = i5 + 12 | 0;
+ i12 = i5 + 8 | 0;
+ HEAP32[i17 >> 2] = HEAP32[i6 + 64 >> 2];
+ i4 = i2 + 16 | 0;
+ i28 = HEAP32[i4 >> 2] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ HEAP32[i17 >> 2] = HEAP32[i6 + 68 >> 2];
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ HEAP8[i17] = HEAP8[i6 + 76 | 0] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ HEAP8[i17] = HEAP8[i6 + 77 | 0] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ HEAP8[i17] = HEAP8[i6 + 78 | 0] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ i25 = HEAP32[i6 + 12 >> 2] | 0;
+ i24 = HEAP32[i6 + 48 >> 2] | 0;
+ HEAP32[i23 >> 2] = i24;
+ if ((i28 | 0) == 0) {
+ i26 = i2 + 4 | 0;
+ i27 = i2 + 8 | 0;
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i26 >> 2] & 3](HEAP32[i2 >> 2] | 0, i23, 4, HEAP32[i27 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i26 >> 2] & 3](HEAP32[i2 >> 2] | 0, i25, i24 << 2, HEAP32[i27 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ i25 = HEAP32[i6 + 44 >> 2] | 0;
+ HEAP32[i22 >> 2] = i25;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i22, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ } else {
+ i11 = 13;
+ }
+ } else {
+ i11 = 13;
+ }
+ if ((i11 | 0) == 13) {
+ i25 = HEAP32[i6 + 44 >> 2] | 0;
+ HEAP32[i22 >> 2] = i25;
+ }
+ if ((i25 | 0) > 0) {
+ i24 = i6 + 8 | 0;
+ i23 = i2 + 4 | 0;
+ i22 = i2 + 8 | 0;
+ i26 = 0;
+ do {
+ i30 = HEAP32[i24 >> 2] | 0;
+ i27 = i30 + (i26 << 4) | 0;
+ i30 = i30 + (i26 << 4) + 8 | 0;
+ i29 = HEAP32[i30 >> 2] | 0;
+ HEAP8[i17] = i29 & 15;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 1, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ i29 = HEAP32[i30 >> 2] | 0;
+ }
+ i29 = i29 & 15;
+ do {
+ if ((i29 | 0) == 3) {
+ HEAPF64[i18 >> 3] = +HEAPF64[i27 >> 3];
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i18, 8, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ } else if ((i29 | 0) == 1) {
+ HEAP8[i21] = HEAP32[i27 >> 2];
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i21, 1, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ } else if ((i29 | 0) == 4) {
+ i27 = HEAP32[i27 >> 2] | 0;
+ if ((i27 | 0) == 0) {
+ HEAP32[i19 >> 2] = 0;
+ if ((i28 | 0) != 0) {
+ break;
+ }
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i19, 4, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ break;
+ }
+ HEAP32[i20 >> 2] = (HEAP32[i27 + 12 >> 2] | 0) + 1;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i20, 4, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i23 >> 2] & 3](HEAP32[i2 >> 2] | 0, i27 + 16 | 0, HEAP32[i20 >> 2] | 0, HEAP32[i22 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ }
+ }
+ } while (0);
+ i26 = i26 + 1 | 0;
+ } while ((i26 | 0) != (i25 | 0));
+ }
+ i18 = HEAP32[i6 + 56 >> 2] | 0;
+ HEAP32[i17 >> 2] = i18;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i17, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ if ((i18 | 0) > 0) {
+ i17 = i6 + 16 | 0;
+ i19 = 0;
+ do {
+ _DumpFunction(HEAP32[(HEAP32[i17 >> 2] | 0) + (i19 << 2) >> 2] | 0, i2);
+ i19 = i19 + 1 | 0;
+ } while ((i19 | 0) != (i18 | 0));
+ i28 = HEAP32[i4 >> 2] | 0;
+ }
+ i17 = i6 + 40 | 0;
+ i18 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i16 >> 2] = i18;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i16, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ if ((i18 | 0) > 0) {
+ i19 = i6 + 28 | 0;
+ i16 = i2 + 4 | 0;
+ i20 = i2 + 8 | 0;
+ i21 = 0;
+ do {
+ i22 = HEAP32[i19 >> 2] | 0;
+ HEAP8[i1] = HEAP8[i22 + (i21 << 3) + 4 | 0] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i16 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 1, HEAP32[i20 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ i22 = HEAP32[i19 >> 2] | 0;
+ }
+ HEAP8[i1] = HEAP8[i22 + (i21 << 3) + 5 | 0] | 0;
+ if ((i28 | 0) == 0) {
+ i28 = FUNCTION_TABLE_iiiii[HEAP32[i16 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 1, HEAP32[i20 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i28;
+ }
+ i21 = i21 + 1 | 0;
+ } while ((i21 | 0) != (i18 | 0));
+ }
+ i16 = i2 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == 0 ? (i13 = HEAP32[i6 + 36 >> 2] | 0, (i13 | 0) != 0) : 0) {
+ HEAP32[i12 >> 2] = (HEAP32[i13 + 12 >> 2] | 0) + 1;
+ if ((i28 | 0) == 0 ? (i14 = i2 + 4 | 0, i15 = i2 + 8 | 0, i30 = FUNCTION_TABLE_iiiii[HEAP32[i14 >> 2] & 3](HEAP32[i2 >> 2] | 0, i12, 4, HEAP32[i15 >> 2] | 0) | 0, HEAP32[i4 >> 2] = i30, (i30 | 0) == 0) : 0) {
+ HEAP32[i4 >> 2] = FUNCTION_TABLE_iiiii[HEAP32[i14 >> 2] & 3](HEAP32[i2 >> 2] | 0, i13 + 16 | 0, HEAP32[i12 >> 2] | 0, HEAP32[i15 >> 2] | 0) | 0;
+ }
+ } else {
+ i12 = i10;
+ i11 = 50;
+ }
+ if ((i11 | 0) == 50) {
+ HEAP32[i10 >> 2] = 0;
+ if ((i28 | 0) == 0) {
+ HEAP32[i4 >> 2] = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i12, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ }
+ }
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i11 = HEAP32[i6 + 52 >> 2] | 0;
+ } else {
+ i11 = 0;
+ }
+ i10 = HEAP32[i6 + 20 >> 2] | 0;
+ HEAP32[i9 >> 2] = i11;
+ i14 = HEAP32[i4 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ i12 = i2 + 4 | 0;
+ i13 = i2 + 8 | 0;
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i12 >> 2] & 3](HEAP32[i2 >> 2] | 0, i9, 4, HEAP32[i13 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i12 >> 2] & 3](HEAP32[i2 >> 2] | 0, i10, i11 << 2, HEAP32[i13 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ }
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i9 = HEAP32[i6 + 60 >> 2] | 0;
+ } else {
+ i9 = 0;
+ }
+ HEAP32[i8 >> 2] = i9;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i8, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ if ((i9 | 0) > 0) {
+ i10 = i6 + 24 | 0;
+ i11 = i2 + 4 | 0;
+ i8 = i2 + 8 | 0;
+ i12 = 0;
+ do {
+ i13 = HEAP32[(HEAP32[i10 >> 2] | 0) + (i12 * 12 | 0) >> 2] | 0;
+ if ((i13 | 0) == 0) {
+ HEAP32[i1 >> 2] = 0;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ } else {
+ HEAP32[i3 >> 2] = (HEAP32[i13 + 12 >> 2] | 0) + 1;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i3, 4, HEAP32[i8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i13 + 16 | 0, HEAP32[i3 >> 2] | 0, HEAP32[i8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ }
+ }
+ i13 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i1 >> 2] = HEAP32[i13 + (i12 * 12 | 0) + 4 >> 2];
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ i13 = HEAP32[i10 >> 2] | 0;
+ }
+ HEAP32[i1 >> 2] = HEAP32[i13 + (i12 * 12 | 0) + 8 >> 2];
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i11 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) != (i9 | 0));
+ }
+ if ((HEAP32[i16 >> 2] | 0) == 0) {
+ i8 = HEAP32[i17 >> 2] | 0;
+ } else {
+ i8 = 0;
+ }
+ HEAP32[i7 >> 2] = i8;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i2 + 4 >> 2] & 3](HEAP32[i2 >> 2] | 0, i7, 4, HEAP32[i2 + 8 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ if ((i8 | 0) <= 0) {
+ STACKTOP = i5;
+ return;
+ }
+ i7 = i6 + 28 | 0;
+ i6 = i2 + 4 | 0;
+ i9 = i2 + 8 | 0;
+ i10 = 0;
+ do {
+ i11 = HEAP32[(HEAP32[i7 >> 2] | 0) + (i10 << 3) >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ HEAP32[i1 >> 2] = 0;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i1, 4, HEAP32[i9 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ } else {
+ HEAP32[i3 >> 2] = (HEAP32[i11 + 12 >> 2] | 0) + 1;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i3, 4, HEAP32[i9 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ i14 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i2 >> 2] | 0, i11 + 16 | 0, HEAP32[i3 >> 2] | 0, HEAP32[i9 >> 2] | 0) | 0;
+ HEAP32[i4 >> 2] = i14;
+ }
+ }
+ }
+ i10 = i10 + 1 | 0;
+ } while ((i10 | 0) != (i8 | 0));
+ STACKTOP = i5;
+ return;
+}
+function _LoadFunction(i2, i6) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ i5 = i1 + 8 | 0;
+ i4 = i2 + 4 | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ HEAP32[i6 + 64 >> 2] = i8;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ HEAP32[i6 + 68 >> 2] = i8;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ HEAP8[i6 + 76 | 0] = HEAP8[i3] | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ HEAP8[i6 + 77 | 0] = HEAP8[i3] | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ HEAP8[i6 + 78 | 0] = HEAP8[i3] | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i9 = HEAP32[i3 >> 2] | 0;
+ if ((i9 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i8 = HEAP32[i2 >> 2] | 0;
+ if ((i9 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i8);
+ }
+ i14 = i9 << 2;
+ i13 = _luaM_realloc_(i8, 0, 0, i14) | 0;
+ HEAP32[i6 + 12 >> 2] = i13;
+ HEAP32[i6 + 48 >> 2] = i9;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i13, i14) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i9 = HEAP32[i2 >> 2] | 0;
+ if ((i8 + 1 | 0) >>> 0 > 268435455) {
+ _luaM_toobig(i9);
+ }
+ i11 = _luaM_realloc_(i9, 0, 0, i8 << 4) | 0;
+ i9 = i6 + 8 | 0;
+ HEAP32[i9 >> 2] = i11;
+ HEAP32[i6 + 44 >> 2] = i8;
+ i12 = (i8 | 0) > 0;
+ L43 : do {
+ if (i12) {
+ i10 = 0;
+ do {
+ HEAP32[i11 + (i10 << 4) + 8 >> 2] = 0;
+ i10 = i10 + 1 | 0;
+ } while ((i10 | 0) != (i8 | 0));
+ if (i12) {
+ i10 = i2 + 8 | 0;
+ i13 = 0;
+ while (1) {
+ i12 = i11 + (i13 << 4) | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ i9 = 34;
+ break;
+ }
+ i14 = HEAP8[i3] | 0;
+ if ((i14 | 0) == 4) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ i9 = 44;
+ break;
+ }
+ i14 = HEAP32[i3 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ i14 = 0;
+ } else {
+ i14 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i10 >> 2] | 0, i14) | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i14, HEAP32[i3 >> 2] | 0) | 0) != 0) {
+ i9 = 47;
+ break;
+ }
+ i14 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i14, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
+ }
+ HEAP32[i12 >> 2] = i14;
+ HEAP32[i11 + (i13 << 4) + 8 >> 2] = HEAPU8[i14 + 4 | 0] | 64;
+ } else if ((i14 | 0) == 1) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ i9 = 38;
+ break;
+ }
+ HEAP32[i12 >> 2] = HEAP8[i3] | 0;
+ HEAP32[i11 + (i13 << 4) + 8 >> 2] = 1;
+ } else if ((i14 | 0) == 3) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 8) | 0) != 0) {
+ i9 = 41;
+ break;
+ }
+ HEAPF64[i12 >> 3] = +HEAPF64[i3 >> 3];
+ HEAP32[i11 + (i13 << 4) + 8 >> 2] = 3;
+ } else if ((i14 | 0) == 0) {
+ HEAP32[i11 + (i13 << 4) + 8 >> 2] = 0;
+ }
+ i13 = i13 + 1 | 0;
+ if ((i13 | 0) >= (i8 | 0)) {
+ break L43;
+ }
+ i11 = HEAP32[i9 >> 2] | 0;
+ }
+ if ((i9 | 0) == 34) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 38) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 41) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 44) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 47) {
+ _error(i2, 8824);
+ }
+ }
+ }
+ } while (0);
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i9 = HEAP32[i2 >> 2] | 0;
+ if ((i8 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i9);
+ }
+ i11 = _luaM_realloc_(i9, 0, 0, i8 << 2) | 0;
+ i9 = i6 + 16 | 0;
+ HEAP32[i9 >> 2] = i11;
+ HEAP32[i6 + 56 >> 2] = i8;
+ i10 = (i8 | 0) > 0;
+ if (i10) {
+ i12 = 0;
+ while (1) {
+ HEAP32[i11 + (i12 << 2) >> 2] = 0;
+ i12 = i12 + 1 | 0;
+ if ((i12 | 0) == (i8 | 0)) {
+ break;
+ }
+ i11 = HEAP32[i9 >> 2] | 0;
+ }
+ if (i10) {
+ i10 = 0;
+ do {
+ i14 = _luaF_newproto(HEAP32[i2 >> 2] | 0) | 0;
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 << 2) >> 2] = i14;
+ _LoadFunction(i2, HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 << 2) >> 2] | 0);
+ i10 = i10 + 1 | 0;
+ } while ((i10 | 0) != (i8 | 0));
+ }
+ }
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i9 = HEAP32[i3 >> 2] | 0;
+ if ((i9 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i8 = HEAP32[i2 >> 2] | 0;
+ if ((i9 + 1 | 0) >>> 0 > 536870911) {
+ _luaM_toobig(i8);
+ }
+ i10 = _luaM_realloc_(i8, 0, 0, i9 << 3) | 0;
+ i8 = i6 + 28 | 0;
+ HEAP32[i8 >> 2] = i10;
+ HEAP32[i6 + 40 >> 2] = i9;
+ L98 : do {
+ if ((i9 | 0) > 0) {
+ HEAP32[i10 >> 2] = 0;
+ if ((i9 | 0) == 1) {
+ i10 = 0;
+ } else {
+ i10 = 1;
+ while (1) {
+ HEAP32[(HEAP32[i8 >> 2] | 0) + (i10 << 3) >> 2] = 0;
+ i10 = i10 + 1 | 0;
+ if ((i10 | 0) == (i9 | 0)) {
+ i10 = 0;
+ break;
+ }
+ }
+ }
+ while (1) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ i9 = 73;
+ break;
+ }
+ HEAP8[(HEAP32[i8 >> 2] | 0) + (i10 << 3) + 4 | 0] = HEAP8[i3] | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 1) | 0) != 0) {
+ i9 = 75;
+ break;
+ }
+ HEAP8[(HEAP32[i8 >> 2] | 0) + (i10 << 3) + 5 | 0] = HEAP8[i3] | 0;
+ i10 = i10 + 1 | 0;
+ if ((i10 | 0) >= (i9 | 0)) {
+ break L98;
+ }
+ }
+ if ((i9 | 0) == 73) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 75) {
+ _error(i2, 8824);
+ }
+ }
+ } while (0);
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i9 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ i9 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i2 + 8 >> 2] | 0, i9) | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i9, HEAP32[i3 >> 2] | 0) | 0) == 0) {
+ i7 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i9, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
+ break;
+ } else {
+ _error(i2, 8824);
+ }
+ } else {
+ i7 = 0;
+ }
+ } while (0);
+ HEAP32[i6 + 36 >> 2] = i7;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i7 = HEAP32[i3 >> 2] | 0;
+ if ((i7 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i9 = HEAP32[i2 >> 2] | 0;
+ if ((i7 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i9);
+ }
+ i14 = i7 << 2;
+ i13 = _luaM_realloc_(i9, 0, 0, i14) | 0;
+ HEAP32[i6 + 20 >> 2] = i13;
+ HEAP32[i6 + 52 >> 2] = i7;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i13, i14) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i7 = HEAP32[i3 >> 2] | 0;
+ if ((i7 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ i9 = HEAP32[i2 >> 2] | 0;
+ if ((i7 + 1 | 0) >>> 0 > 357913941) {
+ _luaM_toobig(i9);
+ }
+ i10 = _luaM_realloc_(i9, 0, 0, i7 * 12 | 0) | 0;
+ i9 = i6 + 24 | 0;
+ HEAP32[i9 >> 2] = i10;
+ HEAP32[i6 + 60 >> 2] = i7;
+ L141 : do {
+ if ((i7 | 0) > 0) {
+ HEAP32[i10 >> 2] = 0;
+ if ((i7 | 0) != 1) {
+ i6 = 1;
+ do {
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i6 * 12 | 0) >> 2] = 0;
+ i6 = i6 + 1 | 0;
+ } while ((i6 | 0) != (i7 | 0));
+ }
+ i6 = i2 + 8 | 0;
+ i10 = 0;
+ while (1) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ i9 = 102;
+ break;
+ }
+ i11 = HEAP32[i3 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ i11 = 0;
+ } else {
+ i11 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i6 >> 2] | 0, i11) | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i11, HEAP32[i3 >> 2] | 0) | 0) != 0) {
+ i9 = 105;
+ break;
+ }
+ i11 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i11, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
+ }
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) >> 2] = i11;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ i9 = 108;
+ break;
+ }
+ i11 = HEAP32[i3 >> 2] | 0;
+ if ((i11 | 0) < 0) {
+ i9 = 110;
+ break;
+ }
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) + 4 >> 2] = i11;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ i9 = 112;
+ break;
+ }
+ i11 = HEAP32[i3 >> 2] | 0;
+ if ((i11 | 0) < 0) {
+ i9 = 114;
+ break;
+ }
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i10 * 12 | 0) + 8 >> 2] = i11;
+ i10 = i10 + 1 | 0;
+ if ((i10 | 0) >= (i7 | 0)) {
+ break L141;
+ }
+ }
+ if ((i9 | 0) == 102) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 105) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 108) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 110) {
+ _error(i2, 8872);
+ } else if ((i9 | 0) == 112) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 114) {
+ _error(i2, 8872);
+ }
+ }
+ } while (0);
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i5, 4) | 0) != 0) {
+ _error(i2, 8824);
+ }
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) < 0) {
+ _error(i2, 8872);
+ }
+ if ((i6 | 0) <= 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i5 = i2 + 8 | 0;
+ i7 = 0;
+ while (1) {
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i3, 4) | 0) != 0) {
+ i9 = 123;
+ break;
+ }
+ i9 = HEAP32[i3 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = 0;
+ } else {
+ i9 = _luaZ_openspace(HEAP32[i2 >> 2] | 0, HEAP32[i5 >> 2] | 0, i9) | 0;
+ if ((_luaZ_read(HEAP32[i4 >> 2] | 0, i9, HEAP32[i3 >> 2] | 0) | 0) != 0) {
+ i9 = 126;
+ break;
+ }
+ i9 = _luaS_newlstr(HEAP32[i2 >> 2] | 0, i9, (HEAP32[i3 >> 2] | 0) + -1 | 0) | 0;
+ }
+ HEAP32[(HEAP32[i8 >> 2] | 0) + (i7 << 3) >> 2] = i9;
+ i7 = i7 + 1 | 0;
+ if ((i7 | 0) >= (i6 | 0)) {
+ i9 = 129;
+ break;
+ }
+ }
+ if ((i9 | 0) == 123) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 126) {
+ _error(i2, 8824);
+ } else if ((i9 | 0) == 129) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _exp2reg(i4, i1, i7) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0;
+ i5 = STACKTOP;
+ _discharge2reg(i4, i1, i7);
+ i6 = i1 + 16 | 0;
+ do {
+ if ((HEAP32[i1 >> 2] | 0) == 10 ? (i10 = HEAP32[i1 + 8 >> 2] | 0, !((i10 | 0) == -1)) : 0) {
+ i22 = HEAP32[i6 >> 2] | 0;
+ if ((i22 | 0) == -1) {
+ HEAP32[i6 >> 2] = i10;
+ break;
+ }
+ i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i19 = i20 + (i22 << 2) | 0;
+ i21 = HEAP32[i19 >> 2] | 0;
+ i23 = (i21 >>> 14) + -131071 | 0;
+ if ((i23 | 0) == -1) {
+ break;
+ }
+ i23 = i22 + 1 + i23 | 0;
+ if ((i23 | 0) == -1) {
+ break;
+ } else {
+ i22 = i23;
+ }
+ }
+ i10 = i10 + ~i22 | 0;
+ if ((((i10 | 0) > -1 ? i10 : 0 - i10 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i19 >> 2] = (i10 << 14) + 2147467264 | i21 & 16383;
+ break;
+ }
+ }
+ } while (0);
+ i21 = HEAP32[i6 >> 2] | 0;
+ i10 = i1 + 20 | 0;
+ i19 = HEAP32[i10 >> 2] | 0;
+ if ((i21 | 0) == (i19 | 0)) {
+ HEAP32[i6 >> 2] = -1;
+ HEAP32[i10 >> 2] = -1;
+ i25 = i1 + 8 | 0;
+ HEAP32[i25 >> 2] = i7;
+ HEAP32[i1 >> 2] = 6;
+ STACKTOP = i5;
+ return;
+ }
+ L18 : do {
+ if ((i21 | 0) == -1) {
+ i18 = 20;
+ } else {
+ i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i23 = i20 + (i21 << 2) | 0;
+ if ((i21 | 0) > 0 ? (i18 = HEAP32[i20 + (i21 + -1 << 2) >> 2] | 0, (HEAP8[5584 + (i18 & 63) | 0] | 0) < 0) : 0) {
+ i22 = i18;
+ } else {
+ i22 = HEAP32[i23 >> 2] | 0;
+ }
+ if ((i22 & 63 | 0) != 28) {
+ i18 = 28;
+ break L18;
+ }
+ i22 = ((HEAP32[i23 >> 2] | 0) >>> 14) + -131071 | 0;
+ if ((i22 | 0) == -1) {
+ i18 = 20;
+ break L18;
+ }
+ i21 = i21 + 1 + i22 | 0;
+ if ((i21 | 0) == -1) {
+ i18 = 20;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L29 : do {
+ if ((i18 | 0) == 20) {
+ if ((i19 | 0) == -1) {
+ i15 = -1;
+ i8 = -1;
+ } else {
+ i20 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i21 = i20 + (i19 << 2) | 0;
+ if ((i19 | 0) > 0 ? (i17 = HEAP32[i20 + (i19 + -1 << 2) >> 2] | 0, (HEAP8[5584 + (i17 & 63) | 0] | 0) < 0) : 0) {
+ i22 = i17;
+ } else {
+ i22 = HEAP32[i21 >> 2] | 0;
+ }
+ if ((i22 & 63 | 0) != 28) {
+ i18 = 28;
+ break L29;
+ }
+ i21 = ((HEAP32[i21 >> 2] | 0) >>> 14) + -131071 | 0;
+ if ((i21 | 0) == -1) {
+ i15 = -1;
+ i8 = -1;
+ break L29;
+ }
+ i19 = i19 + 1 + i21 | 0;
+ if ((i19 | 0) == -1) {
+ i15 = -1;
+ i8 = -1;
+ break;
+ }
+ }
+ }
+ }
+ } while (0);
+ do {
+ if ((i18 | 0) == 28) {
+ i17 = i4 + 28 | 0;
+ do {
+ if ((HEAP32[i1 >> 2] | 0) != 10) {
+ i21 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i17 >> 2] = -1;
+ i18 = _luaK_code(i4, 2147450903) | 0;
+ if (!((i21 | 0) == -1)) {
+ if (!((i18 | 0) == -1)) {
+ i23 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ i22 = i18;
+ while (1) {
+ i20 = i23 + (i22 << 2) | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ i24 = (i19 >>> 14) + -131071 | 0;
+ if ((i24 | 0) == -1) {
+ break;
+ }
+ i24 = i22 + 1 + i24 | 0;
+ if ((i24 | 0) == -1) {
+ break;
+ } else {
+ i22 = i24;
+ }
+ }
+ i21 = i21 + ~i22 | 0;
+ if ((((i21 | 0) > -1 ? i21 : 0 - i21 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i20 >> 2] = (i21 << 14) + 2147467264 | i19 & 16383;
+ i16 = i18;
+ break;
+ }
+ } else {
+ i16 = i21;
+ }
+ } else {
+ i16 = i18;
+ }
+ } else {
+ i16 = -1;
+ }
+ } while (0);
+ i24 = i4 + 20 | 0;
+ i25 = i4 + 24 | 0;
+ HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
+ i19 = i7 << 6;
+ i18 = _luaK_code(i4, i19 | 16387) | 0;
+ HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
+ i19 = _luaK_code(i4, i19 | 8388611) | 0;
+ HEAP32[i25 >> 2] = HEAP32[i24 >> 2];
+ if (!((i16 | 0) == -1)) {
+ i22 = HEAP32[i17 >> 2] | 0;
+ if ((i22 | 0) == -1) {
+ HEAP32[i17 >> 2] = i16;
+ i15 = i18;
+ i8 = i19;
+ break;
+ }
+ i17 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i21 = i17 + (i22 << 2) | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ i23 = (i20 >>> 14) + -131071 | 0;
+ if ((i23 | 0) == -1) {
+ break;
+ }
+ i23 = i22 + 1 + i23 | 0;
+ if ((i23 | 0) == -1) {
+ break;
+ } else {
+ i22 = i23;
+ }
+ }
+ i16 = i16 + ~i22 | 0;
+ if ((((i16 | 0) > -1 ? i16 : 0 - i16 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i21 >> 2] = (i16 << 14) + 2147467264 | i20 & 16383;
+ i15 = i18;
+ i8 = i19;
+ break;
+ }
+ } else {
+ i15 = i18;
+ i8 = i19;
+ }
+ }
+ } while (0);
+ i16 = HEAP32[i4 + 20 >> 2] | 0;
+ HEAP32[i4 + 24 >> 2] = i16;
+ i22 = HEAP32[i10 >> 2] | 0;
+ L67 : do {
+ if (!((i22 | 0) == -1)) {
+ i19 = (i7 | 0) == 255;
+ i17 = i7 << 6 & 16320;
+ i18 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i20 = i18 + (i22 << 2) | 0;
+ i23 = HEAP32[i20 >> 2] | 0;
+ i21 = (i23 >>> 14) + -131071 | 0;
+ if ((i21 | 0) == -1) {
+ i21 = -1;
+ } else {
+ i21 = i22 + 1 + i21 | 0;
+ }
+ if ((i22 | 0) > 0 ? (i14 = i18 + (i22 + -1 << 2) | 0, i13 = HEAP32[i14 >> 2] | 0, (HEAP8[5584 + (i13 & 63) | 0] | 0) < 0) : 0) {
+ i24 = i14;
+ i25 = i13;
+ } else {
+ i24 = i20;
+ i25 = i23;
+ }
+ if ((i25 & 63 | 0) == 28) {
+ i23 = i25 >>> 23;
+ if (i19 | (i23 | 0) == (i7 | 0)) {
+ i23 = i25 & 8372224 | i23 << 6 | 27;
+ } else {
+ i23 = i25 & -16321 | i17;
+ }
+ HEAP32[i24 >> 2] = i23;
+ i22 = i16 + ~i22 | 0;
+ if ((((i22 | 0) > -1 ? i22 : 0 - i22 | 0) | 0) > 131071) {
+ i18 = 58;
+ break;
+ }
+ i22 = HEAP32[i20 >> 2] & 16383 | (i22 << 14) + 2147467264;
+ } else {
+ i22 = i15 + ~i22 | 0;
+ if ((((i22 | 0) > -1 ? i22 : 0 - i22 | 0) | 0) > 131071) {
+ i18 = 61;
+ break;
+ }
+ i22 = i23 & 16383 | (i22 << 14) + 2147467264;
+ }
+ HEAP32[i20 >> 2] = i22;
+ if ((i21 | 0) == -1) {
+ break L67;
+ } else {
+ i22 = i21;
+ }
+ }
+ if ((i18 | 0) == 58) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else if ((i18 | 0) == 61) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ }
+ }
+ } while (0);
+ i20 = HEAP32[i6 >> 2] | 0;
+ if ((i20 | 0) == -1) {
+ HEAP32[i6 >> 2] = -1;
+ HEAP32[i10 >> 2] = -1;
+ i25 = i1 + 8 | 0;
+ HEAP32[i25 >> 2] = i7;
+ HEAP32[i1 >> 2] = 6;
+ STACKTOP = i5;
+ return;
+ }
+ i13 = i7 << 6;
+ i15 = i13 & 16320;
+ i14 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ if ((i7 | 0) == 255) {
+ while (1) {
+ i17 = i14 + (i20 << 2) | 0;
+ i19 = HEAP32[i17 >> 2] | 0;
+ i18 = (i19 >>> 14) + -131071 | 0;
+ if ((i18 | 0) == -1) {
+ i18 = -1;
+ } else {
+ i18 = i20 + 1 + i18 | 0;
+ }
+ if ((i20 | 0) > 0 ? (i12 = i14 + (i20 + -1 << 2) | 0, i11 = HEAP32[i12 >> 2] | 0, (HEAP8[5584 + (i11 & 63) | 0] | 0) < 0) : 0) {
+ i22 = i12;
+ i21 = i11;
+ } else {
+ i22 = i17;
+ i21 = i19;
+ }
+ if ((i21 & 63 | 0) == 28) {
+ HEAP32[i22 >> 2] = i21 & 8372224 | i21 >>> 23 << 6 | 27;
+ i19 = i16 + ~i20 | 0;
+ if ((((i19 | 0) > -1 ? i19 : 0 - i19 | 0) | 0) > 131071) {
+ i18 = 87;
+ break;
+ }
+ i19 = HEAP32[i17 >> 2] & 16383 | (i19 << 14) + 2147467264;
+ } else {
+ i20 = i8 + ~i20 | 0;
+ if ((((i20 | 0) > -1 ? i20 : 0 - i20 | 0) | 0) > 131071) {
+ i18 = 90;
+ break;
+ }
+ i19 = i19 & 16383 | (i20 << 14) + 2147467264;
+ }
+ HEAP32[i17 >> 2] = i19;
+ if ((i18 | 0) == -1) {
+ i18 = 93;
+ break;
+ } else {
+ i20 = i18;
+ }
+ }
+ if ((i18 | 0) == 87) {
+ i25 = i4 + 12 | 0;
+ i25 = HEAP32[i25 >> 2] | 0;
+ _luaX_syntaxerror(i25, 10624);
+ } else if ((i18 | 0) == 90) {
+ i25 = i4 + 12 | 0;
+ i25 = HEAP32[i25 >> 2] | 0;
+ _luaX_syntaxerror(i25, 10624);
+ } else if ((i18 | 0) == 93) {
+ HEAP32[i6 >> 2] = -1;
+ HEAP32[i10 >> 2] = -1;
+ i25 = i1 + 8 | 0;
+ HEAP32[i25 >> 2] = i7;
+ HEAP32[i1 >> 2] = 6;
+ STACKTOP = i5;
+ return;
+ }
+ } else {
+ i9 = i20;
+ }
+ while (1) {
+ i11 = i14 + (i9 << 2) | 0;
+ i17 = HEAP32[i11 >> 2] | 0;
+ i12 = (i17 >>> 14) + -131071 | 0;
+ if ((i12 | 0) == -1) {
+ i12 = -1;
+ } else {
+ i12 = i9 + 1 + i12 | 0;
+ }
+ if ((i9 | 0) > 0 ? (i3 = i14 + (i9 + -1 << 2) | 0, i2 = HEAP32[i3 >> 2] | 0, (HEAP8[5584 + (i2 & 63) | 0] | 0) < 0) : 0) {
+ i18 = i3;
+ i19 = i2;
+ } else {
+ i18 = i11;
+ i19 = i17;
+ }
+ if ((i19 & 63 | 0) == 28) {
+ if ((i19 >>> 23 | 0) == (i7 | 0)) {
+ i17 = i19 & 8372224 | i13 | 27;
+ } else {
+ i17 = i19 & -16321 | i15;
+ }
+ HEAP32[i18 >> 2] = i17;
+ i9 = i16 + ~i9 | 0;
+ if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
+ i18 = 87;
+ break;
+ }
+ i9 = HEAP32[i11 >> 2] & 16383 | (i9 << 14) + 2147467264;
+ } else {
+ i9 = i8 + ~i9 | 0;
+ if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
+ i18 = 90;
+ break;
+ }
+ i9 = i17 & 16383 | (i9 << 14) + 2147467264;
+ }
+ HEAP32[i11 >> 2] = i9;
+ if ((i12 | 0) == -1) {
+ i18 = 93;
+ break;
+ } else {
+ i9 = i12;
+ }
+ }
+ if ((i18 | 0) == 87) {
+ i25 = i4 + 12 | 0;
+ i25 = HEAP32[i25 >> 2] | 0;
+ _luaX_syntaxerror(i25, 10624);
+ } else if ((i18 | 0) == 90) {
+ i25 = i4 + 12 | 0;
+ i25 = HEAP32[i25 >> 2] | 0;
+ _luaX_syntaxerror(i25, 10624);
+ } else if ((i18 | 0) == 93) {
+ HEAP32[i6 >> 2] = -1;
+ HEAP32[i10 >> 2] = -1;
+ i25 = i1 + 8 | 0;
+ HEAP32[i25 >> 2] = i7;
+ HEAP32[i1 >> 2] = 6;
+ STACKTOP = i5;
+ return;
+ }
+}
+function _propagatemark(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i1 = STACKTOP;
+ i15 = i2 + 84 | 0;
+ i3 = HEAP32[i15 >> 2] | 0;
+ i10 = i3 + 5 | 0;
+ HEAP8[i10] = HEAPU8[i10] | 4;
+ switch (HEAPU8[i3 + 4 | 0] | 0) {
+ case 5:
+ {
+ i9 = i3 + 24 | 0;
+ HEAP32[i15 >> 2] = HEAP32[i9 >> 2];
+ i15 = i3 + 8 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ do {
+ if ((i14 | 0) != 0) {
+ if ((HEAP8[i14 + 6 | 0] & 8) == 0) {
+ i11 = _luaT_gettm(i14, 3, HEAP32[i2 + 196 >> 2] | 0) | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ if ((i14 | 0) != 0) {
+ i6 = 5;
+ }
+ } else {
+ i11 = 0;
+ i6 = 5;
+ }
+ if ((i6 | 0) == 5) {
+ if (!((HEAP8[i14 + 5 | 0] & 3) == 0)) {
+ _reallymarkobject(i2, i14);
+ }
+ }
+ if (((i11 | 0) != 0 ? (HEAP32[i11 + 8 >> 2] & 15 | 0) == 4 : 0) ? (i13 = (HEAP32[i11 >> 2] | 0) + 16 | 0, i12 = _strchr(i13, 107) | 0, i12 = (i12 | 0) != 0, i13 = (_strchr(i13, 118) | 0) == 0, !(i13 & (i12 ^ 1))) : 0) {
+ HEAP8[i10] = HEAP8[i10] & 251;
+ if (i12) {
+ if (i13) {
+ _traverseephemeron(i2, i3) | 0;
+ break;
+ } else {
+ i15 = i2 + 100 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i3;
+ break;
+ }
+ }
+ i15 = 1 << HEAPU8[i3 + 7 | 0];
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ i4 = i5 + (i15 << 5) | 0;
+ i8 = (HEAP32[i3 + 28 >> 2] | 0) > 0 | 0;
+ if ((i15 | 0) > 0) {
+ do {
+ i12 = i5 + 8 | 0;
+ i10 = i5 + 24 | 0;
+ i11 = (HEAP32[i10 >> 2] & 64 | 0) == 0;
+ do {
+ if ((HEAP32[i12 >> 2] | 0) == 0) {
+ if (!i11 ? !((HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
+ HEAP32[i10 >> 2] = 11;
+ }
+ } else {
+ if (!i11 ? (i7 = HEAP32[i5 + 16 >> 2] | 0, !((HEAP8[i7 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i7);
+ }
+ if ((i8 | 0) == 0) {
+ i10 = HEAP32[i12 >> 2] | 0;
+ if ((i10 & 64 | 0) != 0) {
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i10 & 15 | 0) != 4) {
+ i8 = (HEAP8[i8 + 5 | 0] & 3) != 0 | 0;
+ break;
+ }
+ if ((i8 | 0) != 0 ? !((HEAP8[i8 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i8);
+ i8 = 0;
+ } else {
+ i8 = 0;
+ }
+ } else {
+ i8 = 0;
+ }
+ }
+ }
+ } while (0);
+ i5 = i5 + 32 | 0;
+ } while (i5 >>> 0 < i4 >>> 0);
+ }
+ if ((i8 | 0) == 0) {
+ i15 = i2 + 88 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i3;
+ break;
+ } else {
+ i15 = i2 + 92 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i3;
+ break;
+ }
+ } else {
+ i6 = 33;
+ }
+ } else {
+ i6 = 33;
+ }
+ } while (0);
+ if ((i6 | 0) == 33) {
+ i7 = i3 + 16 | 0;
+ i10 = HEAP32[i7 >> 2] | 0;
+ i6 = i10 + (1 << HEAPU8[i3 + 7 | 0] << 5) | 0;
+ i9 = i3 + 28 | 0;
+ i13 = HEAP32[i9 >> 2] | 0;
+ if ((i13 | 0) > 0) {
+ i10 = i3 + 12 | 0;
+ i11 = 0;
+ do {
+ i12 = HEAP32[i10 >> 2] | 0;
+ if ((HEAP32[i12 + (i11 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i8 = HEAP32[i12 + (i11 << 4) >> 2] | 0, !((HEAP8[i8 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i8);
+ i13 = HEAP32[i9 >> 2] | 0;
+ }
+ i11 = i11 + 1 | 0;
+ } while ((i11 | 0) < (i13 | 0));
+ i7 = HEAP32[i7 >> 2] | 0;
+ } else {
+ i7 = i10;
+ }
+ if (i7 >>> 0 < i6 >>> 0) {
+ do {
+ i10 = i7 + 8 | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ i9 = i7 + 24 | 0;
+ i8 = (HEAP32[i9 >> 2] & 64 | 0) == 0;
+ if ((i11 | 0) == 0) {
+ if (!i8 ? !((HEAP8[(HEAP32[i7 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
+ HEAP32[i9 >> 2] = 11;
+ }
+ } else {
+ if (!i8 ? (i5 = HEAP32[i7 + 16 >> 2] | 0, !((HEAP8[i5 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i5);
+ i11 = HEAP32[i10 >> 2] | 0;
+ }
+ if ((i11 & 64 | 0) != 0 ? (i4 = HEAP32[i7 >> 2] | 0, !((HEAP8[i4 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i4);
+ }
+ }
+ i7 = i7 + 32 | 0;
+ } while (i7 >>> 0 < i6 >>> 0);
+ }
+ }
+ i3 = (HEAP32[i3 + 28 >> 2] << 4) + 32 + (32 << HEAPU8[i3 + 7 | 0]) | 0;
+ break;
+ }
+ case 8:
+ {
+ i7 = i3 + 60 | 0;
+ HEAP32[i15 >> 2] = HEAP32[i7 >> 2];
+ i4 = i2 + 88 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i4 >> 2] = i3;
+ HEAP8[i10] = HEAP8[i10] & 251;
+ i4 = i3 + 28 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i3 = 1;
+ } else {
+ i5 = i3 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if (i7 >>> 0 < i6 >>> 0) {
+ do {
+ if ((HEAP32[i7 + 8 >> 2] & 64 | 0) != 0 ? (i11 = HEAP32[i7 >> 2] | 0, !((HEAP8[i11 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i11);
+ i6 = HEAP32[i5 >> 2] | 0;
+ }
+ i7 = i7 + 16 | 0;
+ } while (i7 >>> 0 < i6 >>> 0);
+ }
+ if ((HEAP8[i2 + 61 | 0] | 0) == 1) {
+ i3 = i3 + 32 | 0;
+ i4 = (HEAP32[i4 >> 2] | 0) + (HEAP32[i3 >> 2] << 4) | 0;
+ if (i7 >>> 0 < i4 >>> 0) {
+ do {
+ HEAP32[i7 + 8 >> 2] = 0;
+ i7 = i7 + 16 | 0;
+ } while (i7 >>> 0 < i4 >>> 0);
+ }
+ } else {
+ i3 = i3 + 32 | 0;
+ }
+ i3 = (HEAP32[i3 >> 2] << 4) + 112 | 0;
+ }
+ break;
+ }
+ case 9:
+ {
+ HEAP32[i15 >> 2] = HEAP32[i3 + 72 >> 2];
+ i5 = i3 + 32 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
+ HEAP32[i5 >> 2] = 0;
+ }
+ i4 = HEAP32[i3 + 36 >> 2] | 0;
+ if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i4);
+ }
+ i4 = i3 + 44 | 0;
+ i8 = HEAP32[i4 >> 2] | 0;
+ if ((i8 | 0) > 0) {
+ i5 = i3 + 8 | 0;
+ i6 = 0;
+ do {
+ i7 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i7 + (i6 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i9 = HEAP32[i7 + (i6 << 4) >> 2] | 0, !((HEAP8[i9 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i9);
+ i8 = HEAP32[i4 >> 2] | 0;
+ }
+ i6 = i6 + 1 | 0;
+ } while ((i6 | 0) < (i8 | 0));
+ }
+ i5 = i3 + 40 | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) > 0) {
+ i6 = i3 + 28 | 0;
+ i7 = 0;
+ do {
+ i9 = HEAP32[(HEAP32[i6 >> 2] | 0) + (i7 << 3) >> 2] | 0;
+ if ((i9 | 0) != 0 ? !((HEAP8[i9 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i9);
+ i8 = HEAP32[i5 >> 2] | 0;
+ }
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (i8 | 0));
+ }
+ i6 = i3 + 56 | 0;
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i8 | 0) > 0) {
+ i7 = i3 + 16 | 0;
+ i9 = 0;
+ do {
+ i10 = HEAP32[(HEAP32[i7 >> 2] | 0) + (i9 << 2) >> 2] | 0;
+ if ((i10 | 0) != 0 ? !((HEAP8[i10 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i10);
+ i8 = HEAP32[i6 >> 2] | 0;
+ }
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) < (i8 | 0));
+ }
+ i7 = i3 + 60 | 0;
+ i11 = HEAP32[i7 >> 2] | 0;
+ if ((i11 | 0) > 0) {
+ i8 = i3 + 24 | 0;
+ i9 = 0;
+ do {
+ i10 = HEAP32[(HEAP32[i8 >> 2] | 0) + (i9 * 12 | 0) >> 2] | 0;
+ if ((i10 | 0) != 0 ? !((HEAP8[i10 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i10);
+ i11 = HEAP32[i7 >> 2] | 0;
+ }
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) < (i11 | 0));
+ i8 = HEAP32[i6 >> 2] | 0;
+ }
+ i3 = (i11 * 12 | 0) + 80 + (HEAP32[i4 >> 2] << 4) + (HEAP32[i5 >> 2] << 3) + ((HEAP32[i3 + 48 >> 2] | 0) + i8 + (HEAP32[i3 + 52 >> 2] | 0) << 2) | 0;
+ break;
+ }
+ case 38:
+ {
+ HEAP32[i15 >> 2] = HEAP32[i3 + 8 >> 2];
+ i4 = i3 + 6 | 0;
+ i5 = HEAP8[i4] | 0;
+ if (i5 << 24 >> 24 == 0) {
+ i7 = i5 & 255;
+ } else {
+ i6 = 0;
+ do {
+ if ((HEAP32[i3 + (i6 << 4) + 24 >> 2] & 64 | 0) != 0 ? (i14 = HEAP32[i3 + (i6 << 4) + 16 >> 2] | 0, !((HEAP8[i14 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i2, i14);
+ i5 = HEAP8[i4] | 0;
+ }
+ i6 = i6 + 1 | 0;
+ i7 = i5 & 255;
+ } while ((i6 | 0) < (i7 | 0));
+ }
+ i3 = (i7 << 4) + 16 | 0;
+ break;
+ }
+ case 6:
+ {
+ HEAP32[i15 >> 2] = HEAP32[i3 + 8 >> 2];
+ i4 = HEAP32[i3 + 12 >> 2] | 0;
+ if ((i4 | 0) != 0 ? !((HEAP8[i4 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i4);
+ }
+ i4 = i3 + 6 | 0;
+ i6 = HEAP8[i4] | 0;
+ if (i6 << 24 >> 24 == 0) {
+ i7 = i6 & 255;
+ } else {
+ i5 = 0;
+ do {
+ i7 = HEAP32[i3 + (i5 << 2) + 16 >> 2] | 0;
+ if ((i7 | 0) != 0 ? !((HEAP8[i7 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i7);
+ i6 = HEAP8[i4] | 0;
+ }
+ i5 = i5 + 1 | 0;
+ i7 = i6 & 255;
+ } while ((i5 | 0) < (i7 | 0));
+ }
+ i3 = (i7 << 2) + 16 | 0;
+ break;
+ }
+ default:
+ {
+ STACKTOP = i1;
+ return;
+ }
+ }
+ i15 = i2 + 16 | 0;
+ HEAP32[i15 >> 2] = (HEAP32[i15 >> 2] | 0) + i3;
+ STACKTOP = i1;
+ return;
+}
+function _strstr(i8, i4) {
+ i8 = i8 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i6 = i1 + 1024 | 0;
+ i2 = i1;
+ i10 = HEAP8[i4] | 0;
+ if (i10 << 24 >> 24 == 0) {
+ i20 = i8;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i8 = _strchr(i8, i10 << 24 >> 24) | 0;
+ if ((i8 | 0) == 0) {
+ i20 = 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i13 = HEAP8[i4 + 1 | 0] | 0;
+ if (i13 << 24 >> 24 == 0) {
+ i20 = i8;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i11 = i8 + 1 | 0;
+ i9 = HEAP8[i11] | 0;
+ if (i9 << 24 >> 24 == 0) {
+ i20 = 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i15 = HEAP8[i4 + 2 | 0] | 0;
+ if (i15 << 24 >> 24 == 0) {
+ i2 = i13 & 255 | (i10 & 255) << 8;
+ i3 = i9;
+ i4 = HEAPU8[i8] << 8 | i9 & 255;
+ while (1) {
+ i5 = i4 & 65535;
+ if ((i5 | 0) == (i2 | 0)) {
+ break;
+ }
+ i11 = i11 + 1 | 0;
+ i4 = HEAP8[i11] | 0;
+ if (i4 << 24 >> 24 == 0) {
+ i3 = 0;
+ break;
+ } else {
+ i3 = i4;
+ i4 = i4 & 255 | i5 << 8;
+ }
+ }
+ i20 = i3 << 24 >> 24 == 0 ? 0 : i11 + -1 | 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i16 = i8 + 2 | 0;
+ i11 = HEAP8[i16] | 0;
+ if (i11 << 24 >> 24 == 0) {
+ i20 = 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i18 = HEAP8[i4 + 3 | 0] | 0;
+ if (i18 << 24 >> 24 == 0) {
+ i2 = (i13 & 255) << 16 | (i10 & 255) << 24 | (i15 & 255) << 8;
+ i4 = (i11 & 255) << 8 | (i9 & 255) << 16 | HEAPU8[i8] << 24;
+ if ((i4 | 0) == (i2 | 0)) {
+ i3 = 0;
+ } else {
+ do {
+ i16 = i16 + 1 | 0;
+ i3 = HEAP8[i16] | 0;
+ i4 = (i3 & 255 | i4) << 8;
+ i3 = i3 << 24 >> 24 == 0;
+ } while (!(i3 | (i4 | 0) == (i2 | 0)));
+ }
+ i20 = i3 ? 0 : i16 + -2 | 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ i16 = i8 + 3 | 0;
+ i17 = HEAP8[i16] | 0;
+ if (i17 << 24 >> 24 == 0) {
+ i20 = 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ if ((HEAP8[i4 + 4 | 0] | 0) == 0) {
+ i2 = (i13 & 255) << 16 | (i10 & 255) << 24 | (i15 & 255) << 8 | i18 & 255;
+ i3 = (i11 & 255) << 8 | (i9 & 255) << 16 | i17 & 255 | HEAPU8[i8] << 24;
+ if ((i3 | 0) == (i2 | 0)) {
+ i4 = 0;
+ } else {
+ do {
+ i16 = i16 + 1 | 0;
+ i4 = HEAP8[i16] | 0;
+ i3 = i4 & 255 | i3 << 8;
+ i4 = i4 << 24 >> 24 == 0;
+ } while (!(i4 | (i3 | 0) == (i2 | 0)));
+ }
+ i20 = i4 ? 0 : i16 + -3 | 0;
+ STACKTOP = i1;
+ return i20 | 0;
+ }
+ HEAP32[i6 + 0 >> 2] = 0;
+ HEAP32[i6 + 4 >> 2] = 0;
+ HEAP32[i6 + 8 >> 2] = 0;
+ HEAP32[i6 + 12 >> 2] = 0;
+ HEAP32[i6 + 16 >> 2] = 0;
+ HEAP32[i6 + 20 >> 2] = 0;
+ HEAP32[i6 + 24 >> 2] = 0;
+ HEAP32[i6 + 28 >> 2] = 0;
+ i9 = 0;
+ while (1) {
+ if ((HEAP8[i8 + i9 | 0] | 0) == 0) {
+ i14 = 0;
+ i12 = 80;
+ break;
+ }
+ i20 = i10 & 255;
+ i3 = i6 + (i20 >>> 5 << 2) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] | 1 << (i20 & 31);
+ i3 = i9 + 1 | 0;
+ HEAP32[i2 + (i20 << 2) >> 2] = i3;
+ i10 = HEAP8[i4 + i3 | 0] | 0;
+ if (i10 << 24 >> 24 == 0) {
+ break;
+ } else {
+ i9 = i3;
+ }
+ }
+ if ((i12 | 0) == 80) {
+ STACKTOP = i1;
+ return i14 | 0;
+ }
+ L49 : do {
+ if (i3 >>> 0 > 1) {
+ i14 = 1;
+ i11 = -1;
+ i12 = 0;
+ L50 : while (1) {
+ i10 = 1;
+ while (1) {
+ i13 = i14;
+ L54 : while (1) {
+ i14 = 1;
+ while (1) {
+ i15 = HEAP8[i4 + (i14 + i11) | 0] | 0;
+ i16 = HEAP8[i4 + i13 | 0] | 0;
+ if (!(i15 << 24 >> 24 == i16 << 24 >> 24)) {
+ break L54;
+ }
+ i15 = i14 + 1 | 0;
+ if ((i14 | 0) == (i10 | 0)) {
+ break;
+ }
+ i13 = i15 + i12 | 0;
+ if (i13 >>> 0 < i3 >>> 0) {
+ i14 = i15;
+ } else {
+ break L50;
+ }
+ }
+ i12 = i12 + i10 | 0;
+ i13 = i12 + 1 | 0;
+ if (!(i13 >>> 0 < i3 >>> 0)) {
+ break L50;
+ }
+ }
+ i10 = i13 - i11 | 0;
+ if (!((i15 & 255) > (i16 & 255))) {
+ break;
+ }
+ i14 = i13 + 1 | 0;
+ if (i14 >>> 0 < i3 >>> 0) {
+ i12 = i13;
+ } else {
+ break L50;
+ }
+ }
+ i14 = i12 + 2 | 0;
+ if (i14 >>> 0 < i3 >>> 0) {
+ i11 = i12;
+ i12 = i12 + 1 | 0;
+ } else {
+ i11 = i12;
+ i10 = 1;
+ break;
+ }
+ }
+ i16 = 1;
+ i12 = -1;
+ i14 = 0;
+ while (1) {
+ i13 = 1;
+ while (1) {
+ i15 = i16;
+ L69 : while (1) {
+ i18 = 1;
+ while (1) {
+ i17 = HEAP8[i4 + (i18 + i12) | 0] | 0;
+ i16 = HEAP8[i4 + i15 | 0] | 0;
+ if (!(i17 << 24 >> 24 == i16 << 24 >> 24)) {
+ break L69;
+ }
+ i16 = i18 + 1 | 0;
+ if ((i18 | 0) == (i13 | 0)) {
+ break;
+ }
+ i15 = i16 + i14 | 0;
+ if (i15 >>> 0 < i3 >>> 0) {
+ i18 = i16;
+ } else {
+ i14 = i12;
+ break L49;
+ }
+ }
+ i14 = i14 + i13 | 0;
+ i15 = i14 + 1 | 0;
+ if (!(i15 >>> 0 < i3 >>> 0)) {
+ i14 = i12;
+ break L49;
+ }
+ }
+ i13 = i15 - i12 | 0;
+ if (!((i17 & 255) < (i16 & 255))) {
+ break;
+ }
+ i16 = i15 + 1 | 0;
+ if (i16 >>> 0 < i3 >>> 0) {
+ i14 = i15;
+ } else {
+ i14 = i12;
+ break L49;
+ }
+ }
+ i16 = i14 + 2 | 0;
+ if (i16 >>> 0 < i3 >>> 0) {
+ i12 = i14;
+ i14 = i14 + 1 | 0;
+ } else {
+ i13 = 1;
+ break;
+ }
+ }
+ } else {
+ i11 = -1;
+ i14 = -1;
+ i10 = 1;
+ i13 = 1;
+ }
+ } while (0);
+ i15 = (i14 + 1 | 0) >>> 0 > (i11 + 1 | 0) >>> 0;
+ i12 = i15 ? i13 : i10;
+ i11 = i15 ? i14 : i11;
+ i10 = i11 + 1 | 0;
+ if ((_memcmp(i4, i4 + i12 | 0, i10) | 0) == 0) {
+ i15 = i3 - i12 | 0;
+ i16 = i3 | 63;
+ if ((i3 | 0) != (i12 | 0)) {
+ i14 = i8;
+ i13 = 0;
+ i17 = i8;
+ L82 : while (1) {
+ i18 = i14;
+ do {
+ if ((i17 - i18 | 0) >>> 0 < i3 >>> 0) {
+ i19 = _memchr(i17, 0, i16) | 0;
+ if ((i19 | 0) != 0) {
+ if ((i19 - i18 | 0) >>> 0 < i3 >>> 0) {
+ i14 = 0;
+ i12 = 80;
+ break L82;
+ } else {
+ i17 = i19;
+ break;
+ }
+ } else {
+ i17 = i17 + i16 | 0;
+ break;
+ }
+ }
+ } while (0);
+ i18 = HEAPU8[i14 + i9 | 0] | 0;
+ if ((1 << (i18 & 31) & HEAP32[i6 + (i18 >>> 5 << 2) >> 2] | 0) == 0) {
+ i14 = i14 + i3 | 0;
+ i13 = 0;
+ continue;
+ }
+ i20 = HEAP32[i2 + (i18 << 2) >> 2] | 0;
+ i18 = i3 - i20 | 0;
+ if ((i3 | 0) != (i20 | 0)) {
+ i14 = i14 + ((i13 | 0) != 0 & i18 >>> 0 < i12 >>> 0 ? i15 : i18) | 0;
+ i13 = 0;
+ continue;
+ }
+ i20 = i10 >>> 0 > i13 >>> 0 ? i10 : i13;
+ i18 = HEAP8[i4 + i20 | 0] | 0;
+ L96 : do {
+ if (i18 << 24 >> 24 == 0) {
+ i19 = i10;
+ } else {
+ while (1) {
+ i19 = i20 + 1 | 0;
+ if (!(i18 << 24 >> 24 == (HEAP8[i14 + i20 | 0] | 0))) {
+ break;
+ }
+ i18 = HEAP8[i4 + i19 | 0] | 0;
+ if (i18 << 24 >> 24 == 0) {
+ i19 = i10;
+ break L96;
+ } else {
+ i20 = i19;
+ }
+ }
+ i14 = i14 + (i20 - i11) | 0;
+ i13 = 0;
+ continue L82;
+ }
+ } while (0);
+ while (1) {
+ if (!(i19 >>> 0 > i13 >>> 0)) {
+ break;
+ }
+ i18 = i19 + -1 | 0;
+ if ((HEAP8[i4 + i18 | 0] | 0) == (HEAP8[i14 + i18 | 0] | 0)) {
+ i19 = i18;
+ } else {
+ break;
+ }
+ }
+ if ((i19 | 0) == (i13 | 0)) {
+ i12 = 80;
+ break;
+ }
+ i14 = i14 + i12 | 0;
+ i13 = i15;
+ }
+ if ((i12 | 0) == 80) {
+ STACKTOP = i1;
+ return i14 | 0;
+ }
+ } else {
+ i5 = i16;
+ i7 = i3;
+ }
+ } else {
+ i7 = i3 - i11 + -1 | 0;
+ i5 = i3 | 63;
+ i7 = (i11 >>> 0 > i7 >>> 0 ? i11 : i7) + 1 | 0;
+ }
+ i12 = i4 + i10 | 0;
+ i14 = i8;
+ L111 : while (1) {
+ i13 = i14;
+ do {
+ if ((i8 - i13 | 0) >>> 0 < i3 >>> 0) {
+ i15 = _memchr(i8, 0, i5) | 0;
+ if ((i15 | 0) != 0) {
+ if ((i15 - i13 | 0) >>> 0 < i3 >>> 0) {
+ i14 = 0;
+ i12 = 80;
+ break L111;
+ } else {
+ i8 = i15;
+ break;
+ }
+ } else {
+ i8 = i8 + i5 | 0;
+ break;
+ }
+ }
+ } while (0);
+ i13 = HEAPU8[i14 + i9 | 0] | 0;
+ if ((1 << (i13 & 31) & HEAP32[i6 + (i13 >>> 5 << 2) >> 2] | 0) == 0) {
+ i14 = i14 + i3 | 0;
+ continue;
+ }
+ i13 = HEAP32[i2 + (i13 << 2) >> 2] | 0;
+ if ((i3 | 0) != (i13 | 0)) {
+ i14 = i14 + (i3 - i13) | 0;
+ continue;
+ }
+ i15 = HEAP8[i12] | 0;
+ L125 : do {
+ if (i15 << 24 >> 24 == 0) {
+ i13 = i10;
+ } else {
+ i16 = i10;
+ while (1) {
+ i13 = i16 + 1 | 0;
+ if (!(i15 << 24 >> 24 == (HEAP8[i14 + i16 | 0] | 0))) {
+ break;
+ }
+ i15 = HEAP8[i4 + i13 | 0] | 0;
+ if (i15 << 24 >> 24 == 0) {
+ i13 = i10;
+ break L125;
+ } else {
+ i16 = i13;
+ }
+ }
+ i14 = i14 + (i16 - i11) | 0;
+ continue L111;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 0) {
+ i12 = 80;
+ break L111;
+ }
+ i13 = i13 + -1 | 0;
+ } while ((HEAP8[i4 + i13 | 0] | 0) == (HEAP8[i14 + i13 | 0] | 0));
+ i14 = i14 + i7 | 0;
+ }
+ if ((i12 | 0) == 80) {
+ STACKTOP = i1;
+ return i14 | 0;
+ }
+ return 0;
+}
+function _str_format(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0, i22 = 0;
+ i12 = STACKTOP;
+ STACKTOP = STACKTOP + 1104 | 0;
+ i4 = i12;
+ i7 = i12 + 1060 | 0;
+ i9 = i12 + 1082 | 0;
+ i20 = i12 + 1056 | 0;
+ i10 = i12 + 16 | 0;
+ i5 = i12 + 1064 | 0;
+ i6 = i12 + 8 | 0;
+ i8 = _lua_gettop(i2) | 0;
+ i16 = _luaL_checklstring(i2, 1, i20) | 0;
+ i20 = HEAP32[i20 >> 2] | 0;
+ i3 = i16 + i20 | 0;
+ _luaL_buffinit(i2, i10);
+ L1 : do {
+ if ((i20 | 0) > 0) {
+ i1 = i10 + 8 | 0;
+ i13 = i10 + 4 | 0;
+ i14 = i5 + 1 | 0;
+ i19 = 1;
+ L3 : while (1) {
+ while (1) {
+ i15 = HEAP8[i16] | 0;
+ if (i15 << 24 >> 24 == 37) {
+ i18 = i16 + 1 | 0;
+ if ((HEAP8[i18] | 0) != 37) {
+ break;
+ }
+ i15 = HEAP32[i1 >> 2] | 0;
+ if (i15 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0) {
+ i17 = 37;
+ } else {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i15 = HEAP32[i1 >> 2] | 0;
+ i17 = HEAP8[i18] | 0;
+ }
+ HEAP32[i1 >> 2] = i15 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i15 | 0] = i17;
+ i16 = i16 + 2 | 0;
+ } else {
+ i17 = HEAP32[i1 >> 2] | 0;
+ if (!(i17 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i17 = HEAP32[i1 >> 2] | 0;
+ i15 = HEAP8[i16] | 0;
+ }
+ HEAP32[i1 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i17 | 0] = i15;
+ i16 = i16 + 1 | 0;
+ }
+ if (!(i16 >>> 0 < i3 >>> 0)) {
+ break L1;
+ }
+ }
+ i17 = _luaL_prepbuffsize(i10, 512) | 0;
+ i15 = i19 + 1 | 0;
+ if ((i19 | 0) >= (i8 | 0)) {
+ _luaL_argerror(i2, i15, 7648) | 0;
+ }
+ i19 = HEAP8[i18] | 0;
+ L22 : do {
+ if (i19 << 24 >> 24 == 0) {
+ i19 = 0;
+ i20 = i18;
+ } else {
+ i20 = i18;
+ while (1) {
+ i16 = i20 + 1 | 0;
+ if ((_memchr(7800, i19 << 24 >> 24, 6) | 0) == 0) {
+ break L22;
+ }
+ i19 = HEAP8[i16] | 0;
+ if (i19 << 24 >> 24 == 0) {
+ i19 = 0;
+ i20 = i16;
+ break;
+ } else {
+ i20 = i16;
+ }
+ }
+ }
+ } while (0);
+ i16 = i18;
+ if ((i20 - i16 | 0) >>> 0 > 5) {
+ _luaL_error(i2, 7808, i4) | 0;
+ i19 = HEAP8[i20] | 0;
+ }
+ i19 = ((i19 & 255) + -48 | 0) >>> 0 < 10 ? i20 + 1 | 0 : i20;
+ i19 = ((HEAPU8[i19] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 1 | 0 : i19;
+ i20 = HEAP8[i19] | 0;
+ if (i20 << 24 >> 24 == 46) {
+ i20 = i19 + 1 | 0;
+ i19 = ((HEAPU8[i20] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 2 | 0 : i20;
+ i19 = ((HEAPU8[i19] | 0) + -48 | 0) >>> 0 < 10 ? i19 + 1 | 0 : i19;
+ i20 = HEAP8[i19] | 0;
+ }
+ if (((i20 & 255) + -48 | 0) >>> 0 < 10) {
+ _luaL_error(i2, 7840, i4) | 0;
+ }
+ HEAP8[i5] = 37;
+ i16 = i19 - i16 | 0;
+ _memcpy(i14 | 0, i18 | 0, i16 + 1 | 0) | 0;
+ HEAP8[i5 + (i16 + 2) | 0] = 0;
+ i16 = i19 + 1 | 0;
+ i18 = HEAP8[i19] | 0;
+ L36 : do {
+ switch (i18 | 0) {
+ case 115:
+ {
+ i18 = _luaL_tolstring(i2, i15, i6) | 0;
+ if ((_strchr(i5, 46) | 0) == 0 ? (HEAP32[i6 >> 2] | 0) >>> 0 > 99 : 0) {
+ _luaL_addvalue(i10);
+ i17 = 0;
+ break L36;
+ }
+ HEAP32[i4 >> 2] = i18;
+ i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
+ _lua_settop(i2, -2);
+ break;
+ }
+ case 88:
+ case 120:
+ case 117:
+ case 111:
+ {
+ d21 = +_luaL_checknumber(i2, i15);
+ i18 = ~~d21 >>> 0;
+ d21 = d21 - +(i18 >>> 0);
+ if (!(d21 > -1.0 & d21 < 1.0)) {
+ _luaL_argerror(i2, i15, 7696) | 0;
+ }
+ i20 = _strlen(i5 | 0) | 0;
+ i22 = i5 + (i20 + -1) | 0;
+ i19 = HEAP8[i22] | 0;
+ HEAP8[i22] = 108;
+ HEAP8[i22 + 1 | 0] = 0;
+ HEAP8[i5 + i20 | 0] = i19;
+ HEAP8[i5 + (i20 + 1) | 0] = 0;
+ HEAP32[i4 >> 2] = i18;
+ i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
+ break;
+ }
+ case 99:
+ {
+ HEAP32[i4 >> 2] = _luaL_checkinteger(i2, i15) | 0;
+ i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
+ break;
+ }
+ case 113:
+ {
+ i17 = _luaL_checklstring(i2, i15, i7) | 0;
+ i18 = HEAP32[i1 >> 2] | 0;
+ if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i18 = HEAP32[i1 >> 2] | 0;
+ }
+ HEAP32[i1 >> 2] = i18 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = 34;
+ i22 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i22 + -1;
+ if ((i22 | 0) != 0) {
+ while (1) {
+ i18 = HEAP8[i17] | 0;
+ do {
+ if (i18 << 24 >> 24 == 10 | i18 << 24 >> 24 == 92 | i18 << 24 >> 24 == 34) {
+ i18 = HEAP32[i1 >> 2] | 0;
+ if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i18 = HEAP32[i1 >> 2] | 0;
+ }
+ HEAP32[i1 >> 2] = i18 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = 92;
+ i18 = HEAP32[i1 >> 2] | 0;
+ if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i18 = HEAP32[i1 >> 2] | 0;
+ }
+ i22 = HEAP8[i17] | 0;
+ HEAP32[i1 >> 2] = i18 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = i22;
+ } else if (i18 << 24 >> 24 == 0) {
+ i18 = 0;
+ i11 = 44;
+ } else {
+ if ((_iscntrl(i18 & 255 | 0) | 0) != 0) {
+ i18 = HEAP8[i17] | 0;
+ i11 = 44;
+ break;
+ }
+ i18 = HEAP32[i1 >> 2] | 0;
+ if (!(i18 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i18 = HEAP32[i1 >> 2] | 0;
+ }
+ i22 = HEAP8[i17] | 0;
+ HEAP32[i1 >> 2] = i18 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i18 | 0] = i22;
+ }
+ } while (0);
+ if ((i11 | 0) == 44) {
+ i11 = 0;
+ i18 = i18 & 255;
+ if (((HEAPU8[i17 + 1 | 0] | 0) + -48 | 0) >>> 0 < 10) {
+ HEAP32[i4 >> 2] = i18;
+ _sprintf(i9 | 0, 7792, i4 | 0) | 0;
+ } else {
+ HEAP32[i4 >> 2] = i18;
+ _sprintf(i9 | 0, 7784, i4 | 0) | 0;
+ }
+ _luaL_addstring(i10, i9);
+ }
+ i22 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i22 + -1;
+ if ((i22 | 0) == 0) {
+ break;
+ } else {
+ i17 = i17 + 1 | 0;
+ }
+ }
+ }
+ i17 = HEAP32[i1 >> 2] | 0;
+ if (!(i17 >>> 0 < (HEAP32[i13 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i10, 1) | 0;
+ i17 = HEAP32[i1 >> 2] | 0;
+ }
+ HEAP32[i1 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i17 | 0] = 34;
+ i17 = 0;
+ break;
+ }
+ case 71:
+ case 103:
+ case 102:
+ case 69:
+ case 101:
+ {
+ HEAP8[i5 + (_strlen(i5 | 0) | 0) | 0] = 0;
+ d21 = +_luaL_checknumber(i2, i15);
+ HEAPF64[tempDoublePtr >> 3] = d21;
+ HEAP32[i4 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i4 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
+ break;
+ }
+ case 105:
+ case 100:
+ {
+ d21 = +_luaL_checknumber(i2, i15);
+ i18 = ~~d21;
+ d21 = d21 - +(i18 | 0);
+ if (!(d21 > -1.0 & d21 < 1.0)) {
+ _luaL_argerror(i2, i15, 7664) | 0;
+ }
+ i22 = _strlen(i5 | 0) | 0;
+ i19 = i5 + (i22 + -1) | 0;
+ i20 = HEAP8[i19] | 0;
+ HEAP8[i19] = 108;
+ HEAP8[i19 + 1 | 0] = 0;
+ HEAP8[i5 + i22 | 0] = i20;
+ HEAP8[i5 + (i22 + 1) | 0] = 0;
+ HEAP32[i4 >> 2] = i18;
+ i17 = _sprintf(i17 | 0, i5 | 0, i4 | 0) | 0;
+ break;
+ }
+ default:
+ {
+ break L3;
+ }
+ }
+ } while (0);
+ HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + i17;
+ if (i16 >>> 0 < i3 >>> 0) {
+ i19 = i15;
+ } else {
+ break L1;
+ }
+ }
+ HEAP32[i4 >> 2] = i18;
+ i22 = _luaL_error(i2, 7744, i4) | 0;
+ STACKTOP = i12;
+ return i22 | 0;
+ }
+ } while (0);
+ _luaL_pushresult(i10);
+ i22 = 1;
+ STACKTOP = i12;
+ return i22 | 0;
+}
+function _luaD_precall(i3, i17, i4) {
+ i3 = i3 | 0;
+ i17 = i17 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i8 = i1;
+ i6 = i3 + 28 | 0;
+ i2 = i3 + 8 | 0;
+ i13 = i3 + 24 | 0;
+ i14 = i3 + 32 | 0;
+ while (1) {
+ i15 = HEAP32[i6 >> 2] | 0;
+ i16 = i17;
+ i12 = i15;
+ i5 = i16 - i12 | 0;
+ i11 = HEAP32[i17 + 8 >> 2] & 63;
+ if ((i11 | 0) == 38) {
+ i11 = 4;
+ break;
+ } else if ((i11 | 0) == 22) {
+ i11 = 3;
+ break;
+ } else if ((i11 | 0) == 6) {
+ i11 = 31;
+ break;
+ }
+ i11 = _luaT_gettmbyobj(i3, i17, 16) | 0;
+ i15 = i16 - (HEAP32[i6 >> 2] | 0) | 0;
+ i16 = i11 + 8 | 0;
+ if ((HEAP32[i16 >> 2] & 15 | 0) != 6) {
+ i11 = 54;
+ break;
+ }
+ i19 = HEAP32[i2 >> 2] | 0;
+ if (i19 >>> 0 > i17 >>> 0) {
+ while (1) {
+ i18 = i19 + -16 | 0;
+ i22 = i18;
+ i21 = HEAP32[i22 + 4 >> 2] | 0;
+ i20 = i19;
+ HEAP32[i20 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i20 + 4 >> 2] = i21;
+ HEAP32[i19 + 8 >> 2] = HEAP32[i19 + -8 >> 2];
+ if (i18 >>> 0 > i17 >>> 0) {
+ i19 = i18;
+ } else {
+ break;
+ }
+ }
+ i19 = HEAP32[i2 >> 2] | 0;
+ }
+ i17 = i19 + 16 | 0;
+ HEAP32[i2 >> 2] = i17;
+ if (((HEAP32[i13 >> 2] | 0) - i17 | 0) < 16) {
+ i18 = HEAP32[i14 >> 2] | 0;
+ if ((i18 | 0) > 1e6) {
+ i11 = 60;
+ break;
+ }
+ i17 = (i17 - (HEAP32[i6 >> 2] | 0) >> 4) + 5 | 0;
+ i18 = i18 << 1;
+ i18 = (i18 | 0) > 1e6 ? 1e6 : i18;
+ i17 = (i18 | 0) < (i17 | 0) ? i17 : i18;
+ if ((i17 | 0) > 1e6) {
+ i11 = 62;
+ break;
+ }
+ _luaD_reallocstack(i3, i17);
+ }
+ i22 = HEAP32[i6 >> 2] | 0;
+ i17 = i22 + i15 | 0;
+ i19 = i11;
+ i20 = HEAP32[i19 + 4 >> 2] | 0;
+ i21 = i17;
+ HEAP32[i21 >> 2] = HEAP32[i19 >> 2];
+ HEAP32[i21 + 4 >> 2] = i20;
+ HEAP32[i22 + (i15 + 8) >> 2] = HEAP32[i16 >> 2];
+ }
+ if ((i11 | 0) == 3) {
+ i10 = i17;
+ } else if ((i11 | 0) == 4) {
+ i10 = (HEAP32[i17 >> 2] | 0) + 12 | 0;
+ } else if ((i11 | 0) == 31) {
+ i10 = HEAP32[(HEAP32[i17 >> 2] | 0) + 12 >> 2] | 0;
+ i18 = HEAP32[i2 >> 2] | 0;
+ i16 = i18;
+ i11 = i10 + 78 | 0;
+ i17 = HEAPU8[i11] | 0;
+ do {
+ if (((HEAP32[i13 >> 2] | 0) - i16 >> 4 | 0) <= (i17 | 0)) {
+ i13 = HEAP32[i14 >> 2] | 0;
+ if ((i13 | 0) > 1e6) {
+ _luaD_throw(i3, 6);
+ }
+ i12 = i17 + 5 + (i16 - i12 >> 4) | 0;
+ i13 = i13 << 1;
+ i13 = (i13 | 0) > 1e6 ? 1e6 : i13;
+ i12 = (i13 | 0) < (i12 | 0) ? i12 : i13;
+ if ((i12 | 0) > 1e6) {
+ _luaD_reallocstack(i3, 1000200);
+ _luaG_runerror(i3, 2224, i8);
+ } else {
+ _luaD_reallocstack(i3, i12);
+ i7 = HEAP32[i6 >> 2] | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ break;
+ }
+ } else {
+ i7 = i15;
+ i9 = i18;
+ }
+ } while (0);
+ i6 = i7 + i5 | 0;
+ i22 = i9 - i6 >> 4;
+ i12 = i22 + -1 | 0;
+ i8 = i10 + 76 | 0;
+ i13 = HEAP8[i8] | 0;
+ if ((i22 | 0) > (i13 & 255 | 0)) {
+ i8 = i13;
+ } else {
+ i13 = i9;
+ while (1) {
+ i9 = i13 + 16 | 0;
+ HEAP32[i2 >> 2] = i9;
+ HEAP32[i13 + 8 >> 2] = 0;
+ i12 = i12 + 1 | 0;
+ i13 = HEAP8[i8] | 0;
+ if ((i12 | 0) < (i13 & 255 | 0)) {
+ i13 = i9;
+ } else {
+ i8 = i13;
+ break;
+ }
+ }
+ }
+ if ((HEAP8[i10 + 77 | 0] | 0) != 0) {
+ i5 = i8 & 255;
+ if (!(i8 << 24 >> 24 == 0) ? (i22 = 0 - i12 | 0, HEAP32[i2 >> 2] = i9 + 16, i19 = i9 + (i22 << 4) | 0, i20 = HEAP32[i19 + 4 >> 2] | 0, i21 = i9, HEAP32[i21 >> 2] = HEAP32[i19 >> 2], HEAP32[i21 + 4 >> 2] = i20, i22 = i9 + (i22 << 4) + 8 | 0, HEAP32[i9 + 8 >> 2] = HEAP32[i22 >> 2], HEAP32[i22 >> 2] = 0, (i8 & 255) > 1) : 0) {
+ i7 = 1;
+ do {
+ i21 = HEAP32[i2 >> 2] | 0;
+ i22 = i7 - i12 | 0;
+ HEAP32[i2 >> 2] = i21 + 16;
+ i18 = i9 + (i22 << 4) | 0;
+ i19 = HEAP32[i18 + 4 >> 2] | 0;
+ i20 = i21;
+ HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i20 + 4 >> 2] = i19;
+ i22 = i9 + (i22 << 4) + 8 | 0;
+ HEAP32[i21 + 8 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i22 >> 2] = 0;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (i5 | 0));
+ }
+ } else {
+ i9 = i7 + (i5 + 16) | 0;
+ }
+ i7 = i3 + 16 | 0;
+ i5 = HEAP32[(HEAP32[i7 >> 2] | 0) + 12 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = _luaE_extendCI(i3) | 0;
+ }
+ HEAP32[i7 >> 2] = i5;
+ HEAP16[i5 + 16 >> 1] = i4;
+ HEAP32[i5 >> 2] = i6;
+ HEAP32[i5 + 24 >> 2] = i9;
+ i22 = i9 + (HEAPU8[i11] << 4) | 0;
+ HEAP32[i5 + 4 >> 2] = i22;
+ i4 = i5 + 28 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i10 + 12 >> 2];
+ i6 = i5 + 18 | 0;
+ HEAP8[i6] = 1;
+ HEAP32[i2 >> 2] = i22;
+ if ((HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i3);
+ }
+ if ((HEAP8[i3 + 40 | 0] & 1) == 0) {
+ i22 = 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ }
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 4;
+ i2 = HEAP32[i5 + 8 >> 2] | 0;
+ if (!((HEAP8[i2 + 18 | 0] & 1) == 0) ? (HEAP32[(HEAP32[i2 + 28 >> 2] | 0) + -4 >> 2] & 63 | 0) == 30 : 0) {
+ HEAP8[i6] = HEAPU8[i6] | 64;
+ i2 = 4;
+ } else {
+ i2 = 0;
+ }
+ _luaD_hook(i3, i2, -1);
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -4;
+ i22 = 0;
+ STACKTOP = i1;
+ return i22 | 0;
+ } else if ((i11 | 0) == 54) {
+ _luaG_typeerror(i3, i17, 2520);
+ } else if ((i11 | 0) == 60) {
+ _luaD_throw(i3, 6);
+ } else if ((i11 | 0) == 62) {
+ _luaD_reallocstack(i3, 1000200);
+ _luaG_runerror(i3, 2224, i8);
+ }
+ i7 = HEAP32[i10 >> 2] | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ do {
+ if (((HEAP32[i13 >> 2] | 0) - i9 | 0) < 336) {
+ i10 = HEAP32[i14 >> 2] | 0;
+ if ((i10 | 0) > 1e6) {
+ _luaD_throw(i3, 6);
+ }
+ i9 = (i9 - i12 >> 4) + 25 | 0;
+ i10 = i10 << 1;
+ i10 = (i10 | 0) > 1e6 ? 1e6 : i10;
+ i9 = (i10 | 0) < (i9 | 0) ? i9 : i10;
+ if ((i9 | 0) > 1e6) {
+ _luaD_reallocstack(i3, 1000200);
+ _luaG_runerror(i3, 2224, i8);
+ } else {
+ _luaD_reallocstack(i3, i9);
+ break;
+ }
+ }
+ } while (0);
+ i8 = i3 + 16 | 0;
+ i9 = HEAP32[(HEAP32[i8 >> 2] | 0) + 12 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = _luaE_extendCI(i3) | 0;
+ }
+ HEAP32[i8 >> 2] = i9;
+ HEAP16[i9 + 16 >> 1] = i4;
+ HEAP32[i9 >> 2] = (HEAP32[i6 >> 2] | 0) + i5;
+ HEAP32[i9 + 4 >> 2] = (HEAP32[i2 >> 2] | 0) + 320;
+ HEAP8[i9 + 18 | 0] = 0;
+ if ((HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i3);
+ }
+ i5 = i3 + 40 | 0;
+ if (!((HEAP8[i5] & 1) == 0)) {
+ _luaD_hook(i3, 0, -1);
+ }
+ i7 = FUNCTION_TABLE_ii[i7 & 255](i3) | 0;
+ i7 = (HEAP32[i2 >> 2] | 0) + (0 - i7 << 4) | 0;
+ i4 = HEAP32[i8 >> 2] | 0;
+ i5 = HEAPU8[i5] | 0;
+ if ((i5 & 6 | 0) == 0) {
+ i5 = i7;
+ i6 = i4 + 8 | 0;
+ } else {
+ if ((i5 & 2 | 0) == 0) {
+ i5 = i7;
+ } else {
+ i5 = i7 - (HEAP32[i6 >> 2] | 0) | 0;
+ _luaD_hook(i3, 1, -1);
+ i5 = (HEAP32[i6 >> 2] | 0) + i5 | 0;
+ }
+ i6 = i4 + 8 | 0;
+ HEAP32[i3 + 20 >> 2] = HEAP32[(HEAP32[i6 >> 2] | 0) + 28 >> 2];
+ }
+ i3 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP16[i4 + 16 >> 1] | 0;
+ HEAP32[i8 >> 2] = HEAP32[i6 >> 2];
+ L82 : do {
+ if (!(i4 << 16 >> 16 == 0)) {
+ i4 = i4 << 16 >> 16;
+ while (1) {
+ if (!(i5 >>> 0 < (HEAP32[i2 >> 2] | 0) >>> 0)) {
+ break;
+ }
+ i6 = i3 + 16 | 0;
+ i20 = i5;
+ i21 = HEAP32[i20 + 4 >> 2] | 0;
+ i22 = i3;
+ HEAP32[i22 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i22 + 4 >> 2] = i21;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ i4 = i4 + -1 | 0;
+ if ((i4 | 0) == 0) {
+ i3 = i6;
+ break L82;
+ }
+ i5 = i5 + 16 | 0;
+ i3 = i6;
+ }
+ if ((i4 | 0) > 0) {
+ i5 = i4;
+ i6 = i3;
+ while (1) {
+ i5 = i5 + -1 | 0;
+ HEAP32[i6 + 8 >> 2] = 0;
+ if ((i5 | 0) <= 0) {
+ break;
+ } else {
+ i6 = i6 + 16 | 0;
+ }
+ }
+ i3 = i3 + (i4 << 4) | 0;
+ }
+ }
+ } while (0);
+ HEAP32[i2 >> 2] = i3;
+ i22 = 1;
+ STACKTOP = i1;
+ return i22 | 0;
+}
+function _lua_getinfo(i1, i6, i29) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i29 = i29 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i3;
+ if ((HEAP8[i6] | 0) == 62) {
+ i10 = i1 + 8 | 0;
+ i7 = (HEAP32[i10 >> 2] | 0) + -16 | 0;
+ HEAP32[i10 >> 2] = i7;
+ i6 = i6 + 1 | 0;
+ i10 = 0;
+ } else {
+ i7 = HEAP32[i29 + 96 >> 2] | 0;
+ i10 = i7;
+ i7 = HEAP32[i7 >> 2] | 0;
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] & 31 | 0) == 6) {
+ i9 = HEAP32[i7 >> 2] | 0;
+ } else {
+ i9 = 0;
+ }
+ i34 = HEAP8[i6] | 0;
+ L8 : do {
+ if (i34 << 24 >> 24 == 0) {
+ i33 = 1;
+ } else {
+ i12 = (i9 | 0) == 0;
+ i27 = i29 + 16 | 0;
+ i28 = i29 + 24 | 0;
+ i21 = i29 + 28 | 0;
+ i25 = i29 + 12 | 0;
+ i26 = i29 + 36 | 0;
+ i19 = i9 + 4 | 0;
+ i24 = i9 + 12 | 0;
+ i18 = (i10 | 0) == 0;
+ i23 = i29 + 20 | 0;
+ i17 = i10 + 18 | 0;
+ i22 = i10 + 28 | 0;
+ i15 = i29 + 32 | 0;
+ i14 = i29 + 34 | 0;
+ i13 = i29 + 33 | 0;
+ i11 = i9 + 6 | 0;
+ i16 = i29 + 35 | 0;
+ i20 = i29 + 8 | 0;
+ i30 = i29 + 4 | 0;
+ i29 = i10 + 8 | 0;
+ i31 = i1 + 12 | 0;
+ i32 = i6;
+ i33 = 1;
+ while (1) {
+ L12 : do {
+ switch (i34 << 24 >> 24 | 0) {
+ case 116:
+ {
+ if (i18) {
+ i34 = 0;
+ } else {
+ i34 = HEAPU8[i17] & 64;
+ }
+ HEAP8[i16] = i34;
+ break;
+ }
+ case 110:
+ {
+ L18 : do {
+ if ((!i18 ? (HEAP8[i17] & 64) == 0 : 0) ? (i5 = HEAP32[i29 >> 2] | 0, !((HEAP8[i5 + 18 | 0] & 1) == 0)) : 0) {
+ i36 = HEAP32[(HEAP32[HEAP32[i5 >> 2] >> 2] | 0) + 12 >> 2] | 0;
+ i35 = HEAP32[i36 + 12 >> 2] | 0;
+ i34 = ((HEAP32[i5 + 28 >> 2] | 0) - i35 >> 2) + -1 | 0;
+ i35 = HEAP32[i35 + (i34 << 2) >> 2] | 0;
+ switch (i35 & 63 | 0) {
+ case 10:
+ case 8:
+ {
+ i34 = 1;
+ i4 = 46;
+ break;
+ }
+ case 24:
+ {
+ i34 = 5;
+ i4 = 46;
+ break;
+ }
+ case 13:
+ {
+ i34 = 6;
+ i4 = 46;
+ break;
+ }
+ case 14:
+ {
+ i34 = 7;
+ i4 = 46;
+ break;
+ }
+ case 15:
+ {
+ i34 = 8;
+ i4 = 46;
+ break;
+ }
+ case 16:
+ {
+ i34 = 9;
+ i4 = 46;
+ break;
+ }
+ case 17:
+ {
+ i34 = 10;
+ i4 = 46;
+ break;
+ }
+ case 18:
+ {
+ i34 = 11;
+ i4 = 46;
+ break;
+ }
+ case 19:
+ {
+ i34 = 12;
+ i4 = 46;
+ break;
+ }
+ case 21:
+ {
+ i34 = 4;
+ i4 = 46;
+ break;
+ }
+ case 25:
+ {
+ i34 = 13;
+ i4 = 46;
+ break;
+ }
+ case 26:
+ {
+ i34 = 14;
+ i4 = 46;
+ break;
+ }
+ case 22:
+ {
+ i34 = 15;
+ i4 = 46;
+ break;
+ }
+ case 7:
+ case 6:
+ case 12:
+ {
+ i34 = 0;
+ i4 = 46;
+ break;
+ }
+ case 34:
+ {
+ i34 = 2120;
+ i35 = 2120;
+ break;
+ }
+ case 30:
+ case 29:
+ {
+ i36 = _getobjname(i36, i34, i35 >>> 6 & 255, i30) | 0;
+ HEAP32[i20 >> 2] = i36;
+ if ((i36 | 0) == 0) {
+ break L18;
+ } else {
+ break L12;
+ }
+ }
+ default:
+ {
+ i4 = 47;
+ break L18;
+ }
+ }
+ if ((i4 | 0) == 46) {
+ i4 = 0;
+ i34 = (HEAP32[(HEAP32[i31 >> 2] | 0) + (i34 << 2) + 184 >> 2] | 0) + 16 | 0;
+ i35 = 2136;
+ }
+ HEAP32[i30 >> 2] = i34;
+ HEAP32[i20 >> 2] = i35;
+ break L12;
+ } else {
+ i4 = 47;
+ }
+ } while (0);
+ if ((i4 | 0) == 47) {
+ i4 = 0;
+ HEAP32[i20 >> 2] = 0;
+ }
+ HEAP32[i20 >> 2] = 2112;
+ HEAP32[i30 >> 2] = 0;
+ break;
+ }
+ case 108:
+ {
+ if (!i18 ? !((HEAP8[i17] & 1) == 0) : 0) {
+ i35 = HEAP32[(HEAP32[HEAP32[i10 >> 2] >> 2] | 0) + 12 >> 2] | 0;
+ i34 = HEAP32[i35 + 20 >> 2] | 0;
+ if ((i34 | 0) == 0) {
+ i34 = 0;
+ } else {
+ i34 = HEAP32[i34 + (((HEAP32[i22 >> 2] | 0) - (HEAP32[i35 + 12 >> 2] | 0) >> 2) + -1 << 2) >> 2] | 0;
+ }
+ } else {
+ i34 = -1;
+ }
+ HEAP32[i23 >> 2] = i34;
+ break;
+ }
+ case 83:
+ {
+ if (!i12 ? (HEAP8[i19] | 0) != 38 : 0) {
+ i34 = HEAP32[i24 >> 2] | 0;
+ i35 = HEAP32[i34 + 36 >> 2] | 0;
+ if ((i35 | 0) == 0) {
+ i35 = 2168;
+ } else {
+ i35 = i35 + 16 | 0;
+ }
+ HEAP32[i27 >> 2] = i35;
+ i36 = HEAP32[i34 + 64 >> 2] | 0;
+ HEAP32[i28 >> 2] = i36;
+ HEAP32[i21 >> 2] = HEAP32[i34 + 68 >> 2];
+ i34 = (i36 | 0) == 0 ? 2176 : 2184;
+ } else {
+ HEAP32[i27 >> 2] = 2152;
+ HEAP32[i28 >> 2] = -1;
+ HEAP32[i21 >> 2] = -1;
+ i35 = 2152;
+ i34 = 2160;
+ }
+ HEAP32[i25 >> 2] = i34;
+ _luaO_chunkid(i26, i35, 60);
+ break;
+ }
+ case 117:
+ {
+ if (!i12) {
+ HEAP8[i15] = HEAP8[i11] | 0;
+ if ((HEAP8[i19] | 0) != 38) {
+ HEAP8[i14] = HEAP8[(HEAP32[i24 >> 2] | 0) + 77 | 0] | 0;
+ HEAP8[i13] = HEAP8[(HEAP32[i24 >> 2] | 0) + 76 | 0] | 0;
+ break L12;
+ }
+ } else {
+ HEAP8[i15] = 0;
+ }
+ HEAP8[i14] = 1;
+ HEAP8[i13] = 0;
+ break;
+ }
+ case 102:
+ case 76:
+ {
+ break;
+ }
+ default:
+ {
+ i33 = 0;
+ }
+ }
+ } while (0);
+ i32 = i32 + 1 | 0;
+ i34 = HEAP8[i32] | 0;
+ if (i34 << 24 >> 24 == 0) {
+ break L8;
+ }
+ }
+ }
+ } while (0);
+ if ((_strchr(i6, 102) | 0) != 0) {
+ i36 = i1 + 8 | 0;
+ i35 = HEAP32[i36 >> 2] | 0;
+ i31 = i7;
+ i32 = HEAP32[i31 + 4 >> 2] | 0;
+ i34 = i35;
+ HEAP32[i34 >> 2] = HEAP32[i31 >> 2];
+ HEAP32[i34 + 4 >> 2] = i32;
+ HEAP32[i35 + 8 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i36 >> 2] = (HEAP32[i36 >> 2] | 0) + 16;
+ }
+ if ((_strchr(i6, 76) | 0) == 0) {
+ STACKTOP = i3;
+ return i33 | 0;
+ }
+ if ((i9 | 0) != 0 ? (HEAP8[i9 + 4 | 0] | 0) != 38 : 0) {
+ i6 = i9 + 12 | 0;
+ i5 = HEAP32[(HEAP32[i6 >> 2] | 0) + 20 >> 2] | 0;
+ i4 = _luaH_new(i1) | 0;
+ i36 = i1 + 8 | 0;
+ i35 = HEAP32[i36 >> 2] | 0;
+ HEAP32[i35 >> 2] = i4;
+ HEAP32[i35 + 8 >> 2] = 69;
+ HEAP32[i36 >> 2] = (HEAP32[i36 >> 2] | 0) + 16;
+ HEAP32[i2 >> 2] = 1;
+ HEAP32[i2 + 8 >> 2] = 1;
+ if ((HEAP32[(HEAP32[i6 >> 2] | 0) + 52 >> 2] | 0) > 0) {
+ i7 = 0;
+ } else {
+ STACKTOP = i3;
+ return i33 | 0;
+ }
+ do {
+ _luaH_setint(i1, i4, HEAP32[i5 + (i7 << 2) >> 2] | 0, i2);
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (HEAP32[(HEAP32[i6 >> 2] | 0) + 52 >> 2] | 0));
+ STACKTOP = i3;
+ return i33 | 0;
+ }
+ i36 = i1 + 8 | 0;
+ i35 = HEAP32[i36 >> 2] | 0;
+ HEAP32[i35 + 8 >> 2] = 0;
+ HEAP32[i36 >> 2] = i35 + 16;
+ STACKTOP = i3;
+ return i33 | 0;
+}
+function _read_long_string(i3, i1, i5) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
+ i2 = STACKTOP;
+ i14 = HEAP32[i3 >> 2] | 0;
+ i4 = i3 + 60 | 0;
+ i13 = HEAP32[i4 >> 2] | 0;
+ i15 = i13 + 4 | 0;
+ i16 = HEAP32[i15 >> 2] | 0;
+ i10 = i13 + 8 | 0;
+ i12 = HEAP32[i10 >> 2] | 0;
+ do {
+ if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
+ if (i12 >>> 0 > 2147483645) {
+ _lexerror(i3, 12368, 0);
+ }
+ i16 = i12 << 1;
+ i17 = HEAP32[i3 + 52 >> 2] | 0;
+ if ((i16 | 0) == -2) {
+ _luaM_toobig(i17);
+ } else {
+ i8 = _luaM_realloc_(i17, HEAP32[i13 >> 2] | 0, i12, i16) | 0;
+ HEAP32[i13 >> 2] = i8;
+ HEAP32[i10 >> 2] = i16;
+ i9 = HEAP32[i15 >> 2] | 0;
+ break;
+ }
+ } else {
+ i9 = i16;
+ i8 = HEAP32[i13 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i15 >> 2] = i9 + 1;
+ HEAP8[i8 + i9 | 0] = i14;
+ i9 = i3 + 56 | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ i18 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i18 + -1;
+ if ((i18 | 0) == 0) {
+ i12 = _luaZ_fill(i8) | 0;
+ } else {
+ i18 = i8 + 4 | 0;
+ i12 = HEAP32[i18 >> 2] | 0;
+ HEAP32[i18 >> 2] = i12 + 1;
+ i12 = HEAPU8[i12] | 0;
+ }
+ HEAP32[i3 >> 2] = i12;
+ if ((i12 | 0) == 13 | (i12 | 0) == 10) {
+ _inclinenumber(i3);
+ i11 = 13;
+ }
+ L17 : while (1) {
+ if ((i11 | 0) == 13) {
+ i11 = 0;
+ i12 = HEAP32[i3 >> 2] | 0;
+ }
+ i8 = (i1 | 0) == 0;
+ i10 = i3 + 52 | 0;
+ L21 : do {
+ if (i8) {
+ while (1) {
+ if ((i12 | 0) == 13 | (i12 | 0) == 10) {
+ break L21;
+ } else if ((i12 | 0) == 93) {
+ i11 = 22;
+ break L21;
+ } else if ((i12 | 0) == -1) {
+ i11 = 21;
+ break L17;
+ }
+ i12 = HEAP32[i9 >> 2] | 0;
+ i18 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i18 + -1;
+ if ((i18 | 0) == 0) {
+ i12 = _luaZ_fill(i12) | 0;
+ } else {
+ i18 = i12 + 4 | 0;
+ i12 = HEAP32[i18 >> 2] | 0;
+ HEAP32[i18 >> 2] = i12 + 1;
+ i12 = HEAPU8[i12] | 0;
+ }
+ HEAP32[i3 >> 2] = i12;
+ }
+ } else {
+ while (1) {
+ if ((i12 | 0) == 13 | (i12 | 0) == 10) {
+ break L21;
+ } else if ((i12 | 0) == 93) {
+ i11 = 22;
+ break L21;
+ } else if ((i12 | 0) == -1) {
+ i11 = 21;
+ break L17;
+ }
+ i14 = HEAP32[i4 >> 2] | 0;
+ i13 = i14 + 4 | 0;
+ i17 = HEAP32[i13 >> 2] | 0;
+ i16 = i14 + 8 | 0;
+ i15 = HEAP32[i16 >> 2] | 0;
+ if ((i17 + 1 | 0) >>> 0 > i15 >>> 0) {
+ if (i15 >>> 0 > 2147483645) {
+ i11 = 46;
+ break L17;
+ }
+ i17 = i15 << 1;
+ i18 = HEAP32[i10 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ i11 = 48;
+ break L17;
+ }
+ i18 = _luaM_realloc_(i18, HEAP32[i14 >> 2] | 0, i15, i17) | 0;
+ HEAP32[i14 >> 2] = i18;
+ HEAP32[i16 >> 2] = i17;
+ i17 = HEAP32[i13 >> 2] | 0;
+ i14 = i18;
+ } else {
+ i14 = HEAP32[i14 >> 2] | 0;
+ }
+ HEAP32[i13 >> 2] = i17 + 1;
+ HEAP8[i14 + i17 | 0] = i12;
+ i12 = HEAP32[i9 >> 2] | 0;
+ i18 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i18 + -1;
+ if ((i18 | 0) == 0) {
+ i12 = _luaZ_fill(i12) | 0;
+ } else {
+ i18 = i12 + 4 | 0;
+ i12 = HEAP32[i18 >> 2] | 0;
+ HEAP32[i18 >> 2] = i12 + 1;
+ i12 = HEAPU8[i12] | 0;
+ }
+ HEAP32[i3 >> 2] = i12;
+ }
+ }
+ } while (0);
+ if ((i11 | 0) == 22) {
+ if ((_skip_sep(i3) | 0) == (i5 | 0)) {
+ i11 = 23;
+ break;
+ } else {
+ i11 = 13;
+ continue;
+ }
+ }
+ i12 = HEAP32[i4 >> 2] | 0;
+ i11 = i12 + 4 | 0;
+ i15 = HEAP32[i11 >> 2] | 0;
+ i14 = i12 + 8 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ if ((i15 + 1 | 0) >>> 0 > i13 >>> 0) {
+ if (i13 >>> 0 > 2147483645) {
+ i11 = 37;
+ break;
+ }
+ i15 = i13 << 1;
+ i10 = HEAP32[i10 >> 2] | 0;
+ if ((i15 | 0) == -2) {
+ i11 = 39;
+ break;
+ }
+ i10 = _luaM_realloc_(i10, HEAP32[i12 >> 2] | 0, i13, i15) | 0;
+ HEAP32[i12 >> 2] = i10;
+ HEAP32[i14 >> 2] = i15;
+ i15 = HEAP32[i11 >> 2] | 0;
+ } else {
+ i10 = HEAP32[i12 >> 2] | 0;
+ }
+ HEAP32[i11 >> 2] = i15 + 1;
+ HEAP8[i10 + i15 | 0] = 10;
+ _inclinenumber(i3);
+ if (!i8) {
+ i11 = 13;
+ continue;
+ }
+ HEAP32[(HEAP32[i4 >> 2] | 0) + 4 >> 2] = 0;
+ i11 = 13;
+ }
+ if ((i11 | 0) == 21) {
+ _lexerror(i3, (i1 | 0) != 0 ? 12512 : 12536, 286);
+ } else if ((i11 | 0) == 23) {
+ i15 = HEAP32[i3 >> 2] | 0;
+ i13 = HEAP32[i4 >> 2] | 0;
+ i14 = i13 + 4 | 0;
+ i16 = HEAP32[i14 >> 2] | 0;
+ i11 = i13 + 8 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ do {
+ if ((i16 + 1 | 0) >>> 0 > i12 >>> 0) {
+ if (i12 >>> 0 > 2147483645) {
+ _lexerror(i3, 12368, 0);
+ }
+ i17 = i12 << 1;
+ i16 = HEAP32[i10 >> 2] | 0;
+ if ((i17 | 0) == -2) {
+ _luaM_toobig(i16);
+ } else {
+ i6 = _luaM_realloc_(i16, HEAP32[i13 >> 2] | 0, i12, i17) | 0;
+ HEAP32[i13 >> 2] = i6;
+ HEAP32[i11 >> 2] = i17;
+ i7 = HEAP32[i14 >> 2] | 0;
+ break;
+ }
+ } else {
+ i7 = i16;
+ i6 = HEAP32[i13 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i14 >> 2] = i7 + 1;
+ HEAP8[i6 + i7 | 0] = i15;
+ i6 = HEAP32[i9 >> 2] | 0;
+ i18 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i18 + -1;
+ if ((i18 | 0) == 0) {
+ i6 = _luaZ_fill(i6) | 0;
+ } else {
+ i18 = i6 + 4 | 0;
+ i6 = HEAP32[i18 >> 2] | 0;
+ HEAP32[i18 >> 2] = i6 + 1;
+ i6 = HEAPU8[i6] | 0;
+ }
+ HEAP32[i3 >> 2] = i6;
+ if (i8) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ i5 = i5 + 2 | 0;
+ i6 = HEAP32[i10 >> 2] | 0;
+ i5 = _luaS_newlstr(i6, (HEAP32[i4 >> 2] | 0) + i5 | 0, (HEAP32[i4 + 4 >> 2] | 0) - (i5 << 1) | 0) | 0;
+ i4 = i6 + 8 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i7 + 16;
+ HEAP32[i7 >> 2] = i5;
+ HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
+ i7 = _luaH_set(i6, HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i4 >> 2] | 0) + -16 | 0) | 0;
+ i3 = i7 + 8 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 0 ? (HEAP32[i7 >> 2] = 1, HEAP32[i3 >> 2] = 1, (HEAP32[(HEAP32[i6 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
+ _luaC_step(i6);
+ }
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
+ HEAP32[i1 >> 2] = i5;
+ STACKTOP = i2;
+ return;
+ } else if ((i11 | 0) == 37) {
+ _lexerror(i3, 12368, 0);
+ } else if ((i11 | 0) == 39) {
+ _luaM_toobig(i10);
+ } else if ((i11 | 0) == 46) {
+ _lexerror(i3, 12368, 0);
+ } else if ((i11 | 0) == 48) {
+ _luaM_toobig(i18);
+ }
+}
+function _try_realloc_chunk(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i2 = STACKTOP;
+ i4 = i1 + 4 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ i8 = i6 & -8;
+ i5 = i1 + i8 | 0;
+ i10 = HEAP32[12928 >> 2] | 0;
+ if (i1 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i12 = i6 & 3;
+ if (!((i12 | 0) != 1 & i1 >>> 0 < i5 >>> 0)) {
+ _abort();
+ }
+ i7 = i1 + (i8 | 4) | 0;
+ i13 = HEAP32[i7 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i12 | 0) == 0) {
+ if (i3 >>> 0 < 256) {
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ if (!(i8 >>> 0 < (i3 + 4 | 0) >>> 0) ? !((i8 - i3 | 0) >>> 0 > HEAP32[13392 >> 2] << 1 >>> 0) : 0) {
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ if (!(i8 >>> 0 < i3 >>> 0)) {
+ i5 = i8 - i3 | 0;
+ if (!(i5 >>> 0 > 15)) {
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
+ HEAP32[i1 + (i3 + 4) >> 2] = i5 | 3;
+ HEAP32[i7 >> 2] = HEAP32[i7 >> 2] | 1;
+ _dispose_chunk(i1 + i3 | 0, i5);
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ if ((i5 | 0) == (HEAP32[12936 >> 2] | 0)) {
+ i5 = (HEAP32[12924 >> 2] | 0) + i8 | 0;
+ if (!(i5 >>> 0 > i3 >>> 0)) {
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ i15 = i5 - i3 | 0;
+ HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
+ HEAP32[i1 + (i3 + 4) >> 2] = i15 | 1;
+ HEAP32[12936 >> 2] = i1 + i3;
+ HEAP32[12924 >> 2] = i15;
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ if ((i5 | 0) == (HEAP32[12932 >> 2] | 0)) {
+ i7 = (HEAP32[12920 >> 2] | 0) + i8 | 0;
+ if (i7 >>> 0 < i3 >>> 0) {
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ i5 = i7 - i3 | 0;
+ if (i5 >>> 0 > 15) {
+ HEAP32[i4 >> 2] = i6 & 1 | i3 | 2;
+ HEAP32[i1 + (i3 + 4) >> 2] = i5 | 1;
+ HEAP32[i1 + i7 >> 2] = i5;
+ i15 = i1 + (i7 + 4) | 0;
+ HEAP32[i15 >> 2] = HEAP32[i15 >> 2] & -2;
+ i3 = i1 + i3 | 0;
+ } else {
+ HEAP32[i4 >> 2] = i6 & 1 | i7 | 2;
+ i3 = i1 + (i7 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] | 1;
+ i3 = 0;
+ i5 = 0;
+ }
+ HEAP32[12920 >> 2] = i5;
+ HEAP32[12932 >> 2] = i3;
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ if ((i13 & 2 | 0) != 0) {
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ i7 = (i13 & -8) + i8 | 0;
+ if (i7 >>> 0 < i3 >>> 0) {
+ i15 = 0;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ i6 = i7 - i3 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i11 = HEAP32[i1 + (i8 + 24) >> 2] | 0;
+ i13 = HEAP32[i1 + (i8 + 12) >> 2] | 0;
+ do {
+ if ((i13 | 0) == (i5 | 0)) {
+ i13 = i1 + (i8 + 20) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i1 + (i8 + 16) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i15 = i12 + 20 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ if ((i14 | 0) != 0) {
+ i12 = i14;
+ i13 = i15;
+ continue;
+ }
+ i15 = i12 + 16 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ break;
+ } else {
+ i12 = i14;
+ i13 = i15;
+ }
+ }
+ if (i13 >>> 0 < i10 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i12 = HEAP32[i1 + (i8 + 8) >> 2] | 0;
+ if (i12 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i14 = i12 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i5 | 0)) {
+ _abort();
+ }
+ i10 = i13 + 8 | 0;
+ if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i14 >> 2] = i13;
+ HEAP32[i10 >> 2] = i12;
+ i9 = i13;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i11 | 0) != 0) {
+ i10 = HEAP32[i1 + (i8 + 28) >> 2] | 0;
+ i12 = 13216 + (i10 << 2) | 0;
+ if ((i5 | 0) == (HEAP32[i12 >> 2] | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[12916 >> 2] = HEAP32[12916 >> 2] & ~(1 << i10);
+ break;
+ }
+ } else {
+ if (i11 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i10 = i11 + 16 | 0;
+ if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i10 >> 2] = i9;
+ } else {
+ HEAP32[i11 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i11;
+ i5 = HEAP32[i1 + (i8 + 16) >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i1 + (i8 + 20) >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[12928 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i1 + (i8 + 8) >> 2] | 0;
+ i8 = HEAP32[i1 + (i8 + 12) >> 2] | 0;
+ i13 = 12952 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i13 | 0)) {
+ if (i9 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i5 | 0)) {
+ _abort();
+ }
+ }
+ if ((i8 | 0) == (i9 | 0)) {
+ HEAP32[3228] = HEAP32[3228] & ~(1 << i12);
+ break;
+ }
+ if ((i8 | 0) != (i13 | 0)) {
+ if (i8 >>> 0 < i10 >>> 0) {
+ _abort();
+ }
+ i10 = i8 + 8 | 0;
+ if ((HEAP32[i10 >> 2] | 0) == (i5 | 0)) {
+ i11 = i10;
+ } else {
+ _abort();
+ }
+ } else {
+ i11 = i8 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i8;
+ HEAP32[i11 >> 2] = i9;
+ }
+ } while (0);
+ if (i6 >>> 0 < 16) {
+ HEAP32[i4 >> 2] = i7 | HEAP32[i4 >> 2] & 1 | 2;
+ i15 = i1 + (i7 | 4) | 0;
+ HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ } else {
+ HEAP32[i4 >> 2] = HEAP32[i4 >> 2] & 1 | i3 | 2;
+ HEAP32[i1 + (i3 + 4) >> 2] = i6 | 3;
+ i15 = i1 + (i7 | 4) | 0;
+ HEAP32[i15 >> 2] = HEAP32[i15 >> 2] | 1;
+ _dispose_chunk(i1 + i3 | 0, i6);
+ i15 = i1;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ return 0;
+}
+function _luaK_posfix(i3, i16, i1, i4, i14) {
+ i3 = i3 | 0;
+ i16 = i16 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i14 = i14 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i15 = 0;
+ i2 = STACKTOP;
+ switch (i16 | 0) {
+ case 14:
+ {
+ _luaK_dischargevars(i3, i4);
+ i6 = i4 + 16 | 0;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if (!((i5 | 0) == -1)) {
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((i9 | 0) == -1) {
+ HEAP32[i6 >> 2] = i5;
+ break;
+ }
+ i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i6 = i7 + (i9 << 2) | 0;
+ i8 = HEAP32[i6 >> 2] | 0;
+ i10 = (i8 >>> 14) + -131071 | 0;
+ if ((i10 | 0) == -1) {
+ break;
+ }
+ i10 = i9 + 1 + i10 | 0;
+ if ((i10 | 0) == -1) {
+ break;
+ } else {
+ i9 = i10;
+ }
+ }
+ i5 = i5 + ~i9 | 0;
+ if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i6 >> 2] = (i5 << 14) + 2147467264 | i8 & 16383;
+ break;
+ }
+ }
+ } while (0);
+ HEAP32[i1 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i1 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i1 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i1 + 12 >> 2] = HEAP32[i4 + 12 >> 2];
+ HEAP32[i1 + 16 >> 2] = HEAP32[i4 + 16 >> 2];
+ HEAP32[i1 + 20 >> 2] = HEAP32[i4 + 20 >> 2];
+ STACKTOP = i2;
+ return;
+ }
+ case 13:
+ {
+ _luaK_dischargevars(i3, i4);
+ i6 = i4 + 20 | 0;
+ i5 = HEAP32[i1 + 20 >> 2] | 0;
+ do {
+ if (!((i5 | 0) == -1)) {
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((i9 | 0) == -1) {
+ HEAP32[i6 >> 2] = i5;
+ break;
+ }
+ i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i8 = i7 + (i9 << 2) | 0;
+ i6 = HEAP32[i8 >> 2] | 0;
+ i10 = (i6 >>> 14) + -131071 | 0;
+ if ((i10 | 0) == -1) {
+ break;
+ }
+ i10 = i9 + 1 + i10 | 0;
+ if ((i10 | 0) == -1) {
+ break;
+ } else {
+ i9 = i10;
+ }
+ }
+ i5 = i5 + ~i9 | 0;
+ if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i8 >> 2] = (i5 << 14) + 2147467264 | i6 & 16383;
+ break;
+ }
+ }
+ } while (0);
+ HEAP32[i1 + 0 >> 2] = HEAP32[i4 + 0 >> 2];
+ HEAP32[i1 + 4 >> 2] = HEAP32[i4 + 4 >> 2];
+ HEAP32[i1 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i1 + 12 >> 2] = HEAP32[i4 + 12 >> 2];
+ HEAP32[i1 + 16 >> 2] = HEAP32[i4 + 16 >> 2];
+ HEAP32[i1 + 20 >> 2] = HEAP32[i4 + 20 >> 2];
+ STACKTOP = i2;
+ return;
+ }
+ case 6:
+ {
+ i12 = i4 + 16 | 0;
+ i13 = i4 + 20 | 0;
+ i16 = (HEAP32[i12 >> 2] | 0) == (HEAP32[i13 >> 2] | 0);
+ _luaK_dischargevars(i3, i4);
+ do {
+ if (!i16) {
+ if ((HEAP32[i4 >> 2] | 0) == 6) {
+ i10 = HEAP32[i4 + 8 >> 2] | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (HEAP32[i13 >> 2] | 0)) {
+ break;
+ }
+ if ((i10 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i3, i4, i10);
+ break;
+ }
+ }
+ _luaK_exp2nextreg(i3, i4);
+ }
+ } while (0);
+ if ((HEAP32[i4 >> 2] | 0) == 11 ? (i5 = i4 + 8 | 0, i7 = HEAP32[i5 >> 2] | 0, i8 = (HEAP32[i3 >> 2] | 0) + 12 | 0, i9 = HEAP32[i8 >> 2] | 0, i6 = HEAP32[i9 + (i7 << 2) >> 2] | 0, (i6 & 63 | 0) == 22) : 0) {
+ i4 = i1 + 8 | 0;
+ if (((HEAP32[i1 >> 2] | 0) == 6 ? (i11 = HEAP32[i4 >> 2] | 0, (i11 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i11 | 0) : 0) {
+ i6 = i3 + 48 | 0;
+ HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i16 = HEAP32[i8 >> 2] | 0;
+ i9 = i16;
+ i7 = i6;
+ i6 = HEAP32[i16 + (i6 << 2) >> 2] | 0;
+ }
+ HEAP32[i9 + (i7 << 2) >> 2] = HEAP32[i4 >> 2] << 23 | i6 & 8388607;
+ HEAP32[i1 >> 2] = 11;
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ STACKTOP = i2;
+ return;
+ }
+ _luaK_exp2nextreg(i3, i4);
+ _codearith(i3, 22, i1, i4, i14);
+ STACKTOP = i2;
+ return;
+ }
+ case 9:
+ case 8:
+ case 7:
+ {
+ i7 = i16 + 17 | 0;
+ i6 = _luaK_exp2RK(i3, i1) | 0;
+ i5 = _luaK_exp2RK(i3, i4) | 0;
+ if (((HEAP32[i4 >> 2] | 0) == 6 ? (i15 = HEAP32[i4 + 8 >> 2] | 0, (i15 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i15 | 0) : 0) {
+ i16 = i3 + 48 | 0;
+ HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
+ }
+ i4 = i1 + 8 | 0;
+ if (((HEAP32[i1 >> 2] | 0) == 6 ? (i10 = HEAP32[i4 >> 2] | 0, (i10 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i10 | 0) : 0) {
+ i16 = i3 + 48 | 0;
+ HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
+ }
+ HEAP32[i4 >> 2] = _condjump(i3, i7, 1, i6, i5) | 0;
+ HEAP32[i1 >> 2] = 10;
+ STACKTOP = i2;
+ return;
+ }
+ case 12:
+ case 11:
+ case 10:
+ {
+ i7 = i16 + 14 | 0;
+ i6 = _luaK_exp2RK(i3, i1) | 0;
+ i5 = _luaK_exp2RK(i3, i4) | 0;
+ if (((HEAP32[i4 >> 2] | 0) == 6 ? (i13 = HEAP32[i4 + 8 >> 2] | 0, (i13 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i13 | 0) : 0) {
+ i16 = i3 + 48 | 0;
+ HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
+ }
+ i4 = i1 + 8 | 0;
+ if (((HEAP32[i1 >> 2] | 0) == 6 ? (i12 = HEAP32[i4 >> 2] | 0, (i12 & 256 | 0) == 0) : 0) ? (HEAPU8[i3 + 46 | 0] | 0 | 0) <= (i12 | 0) : 0) {
+ i16 = i3 + 48 | 0;
+ HEAP8[i16] = (HEAP8[i16] | 0) + -1 << 24 >> 24;
+ }
+ i8 = (i7 | 0) == 24;
+ HEAP32[i4 >> 2] = _condjump(i3, i7, i8 & 1 ^ 1, i8 ? i6 : i5, i8 ? i5 : i6) | 0;
+ HEAP32[i1 >> 2] = 10;
+ STACKTOP = i2;
+ return;
+ }
+ case 5:
+ case 4:
+ case 3:
+ case 2:
+ case 1:
+ case 0:
+ {
+ _codearith(i3, i16 + 13 | 0, i1, i4, i14);
+ STACKTOP = i2;
+ return;
+ }
+ default:
+ {
+ STACKTOP = i2;
+ return;
+ }
+ }
+}
+function _body(i1, i4, i13, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i13 = i13 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i3 = i6 + 12 | 0;
+ i14 = i6;
+ i2 = i1 + 48 | 0;
+ i19 = HEAP32[i2 >> 2] | 0;
+ i18 = i1 + 52 | 0;
+ i17 = HEAP32[i18 >> 2] | 0;
+ i16 = HEAP32[i19 >> 2] | 0;
+ i19 = i19 + 36 | 0;
+ i23 = i16 + 56 | 0;
+ i24 = HEAP32[i23 >> 2] | 0;
+ i15 = i16 + 16 | 0;
+ if (((HEAP32[i19 >> 2] | 0) >= (i24 | 0) ? (i21 = _luaM_growaux_(i17, HEAP32[i15 >> 2] | 0, i23, 4, 262143, 6512) | 0, HEAP32[i15 >> 2] = i21, i20 = HEAP32[i23 >> 2] | 0, (i24 | 0) < (i20 | 0)) : 0) ? (i22 = i24 + 1 | 0, HEAP32[i21 + (i24 << 2) >> 2] = 0, (i22 | 0) < (i20 | 0)) : 0) {
+ while (1) {
+ i21 = i22 + 1 | 0;
+ HEAP32[(HEAP32[i15 >> 2] | 0) + (i22 << 2) >> 2] = 0;
+ if ((i21 | 0) == (i20 | 0)) {
+ break;
+ } else {
+ i22 = i21;
+ }
+ }
+ }
+ i20 = _luaF_newproto(i17) | 0;
+ i24 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i24 + 1;
+ HEAP32[(HEAP32[i15 >> 2] | 0) + (i24 << 2) >> 2] = i20;
+ if (!((HEAP8[i20 + 5 | 0] & 3) == 0) ? !((HEAP8[i16 + 5 | 0] & 4) == 0) : 0) {
+ _luaC_barrier_(i17, i16, i20);
+ }
+ HEAP32[i3 >> 2] = i20;
+ HEAP32[i20 + 64 >> 2] = i5;
+ i16 = HEAP32[i18 >> 2] | 0;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i2 >> 2];
+ i17 = i3 + 12 | 0;
+ HEAP32[i17 >> 2] = i1;
+ HEAP32[i2 >> 2] = i3;
+ HEAP32[i3 + 20 >> 2] = 0;
+ HEAP32[i3 + 24 >> 2] = 0;
+ HEAP32[i3 + 28 >> 2] = -1;
+ HEAP32[i3 + 32 >> 2] = 0;
+ HEAP32[i3 + 36 >> 2] = 0;
+ i22 = i3 + 44 | 0;
+ i15 = i1 + 64 | 0;
+ HEAP32[i22 + 0 >> 2] = 0;
+ HEAP8[i22 + 4 | 0] = 0;
+ HEAP32[i3 + 40 >> 2] = HEAP32[(HEAP32[i15 >> 2] | 0) + 4 >> 2];
+ i15 = i3 + 16 | 0;
+ HEAP32[i15 >> 2] = 0;
+ HEAP32[i20 + 36 >> 2] = HEAP32[i1 + 68 >> 2];
+ HEAP8[i20 + 78 | 0] = 2;
+ i22 = _luaH_new(i16) | 0;
+ HEAP32[i3 + 4 >> 2] = i22;
+ i23 = i16 + 8 | 0;
+ i24 = HEAP32[i23 >> 2] | 0;
+ HEAP32[i24 >> 2] = i22;
+ HEAP32[i24 + 8 >> 2] = 69;
+ i24 = (HEAP32[i23 >> 2] | 0) + 16 | 0;
+ HEAP32[i23 >> 2] = i24;
+ if (((HEAP32[i16 + 24 >> 2] | 0) - i24 | 0) < 16) {
+ _luaD_growstack(i16, 0);
+ }
+ HEAP8[i14 + 10 | 0] = 0;
+ HEAP8[i14 + 8 | 0] = HEAP8[i3 + 46 | 0] | 0;
+ i24 = HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i14 + 4 >> 1] = HEAP32[i24 + 28 >> 2];
+ HEAP16[i14 + 6 >> 1] = HEAP32[i24 + 16 >> 2];
+ HEAP8[i14 + 9 | 0] = 0;
+ HEAP32[i14 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i14;
+ i14 = i1 + 16 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != 40) {
+ _error_expected(i1, 40);
+ }
+ _luaX_next(i1);
+ if ((i13 | 0) != 0) {
+ _new_localvar(i1, _luaX_newstring(i1, 6456, 4) | 0);
+ i24 = HEAP32[i2 >> 2] | 0;
+ i22 = i24 + 46 | 0;
+ i23 = (HEAPU8[i22] | 0) + 1 | 0;
+ HEAP8[i22] = i23;
+ HEAP32[(HEAP32[(HEAP32[i24 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i24 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((i23 & 255) + -1 + (HEAP32[i24 + 40 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i24 + 20 >> 2];
+ }
+ i13 = HEAP32[i2 >> 2] | 0;
+ i15 = HEAP32[i13 >> 2] | 0;
+ i16 = i15 + 77 | 0;
+ HEAP8[i16] = 0;
+ i19 = HEAP32[i14 >> 2] | 0;
+ L20 : do {
+ if ((i19 | 0) != 41) {
+ i17 = i1 + 24 | 0;
+ i18 = 0;
+ while (1) {
+ if ((i19 | 0) == 280) {
+ i17 = 18;
+ break;
+ } else if ((i19 | 0) != 288) {
+ i17 = 19;
+ break;
+ }
+ i24 = HEAP32[i17 >> 2] | 0;
+ _luaX_next(i1);
+ _new_localvar(i1, i24);
+ i18 = i18 + 1 | 0;
+ if ((HEAP8[i16] | 0) != 0) {
+ i11 = i18;
+ break L20;
+ }
+ if ((HEAP32[i14 >> 2] | 0) != 44) {
+ i11 = i18;
+ break L20;
+ }
+ _luaX_next(i1);
+ i19 = HEAP32[i14 >> 2] | 0;
+ }
+ if ((i17 | 0) == 18) {
+ _luaX_next(i1);
+ HEAP8[i16] = 1;
+ i11 = i18;
+ break;
+ } else if ((i17 | 0) == 19) {
+ _luaX_syntaxerror(i1, 6464);
+ }
+ } else {
+ i11 = 0;
+ }
+ } while (0);
+ i18 = HEAP32[i2 >> 2] | 0;
+ i16 = i18 + 46 | 0;
+ i17 = (HEAPU8[i16] | 0) + i11 | 0;
+ HEAP8[i16] = i17;
+ if ((i11 | 0) != 0 ? (i8 = i18 + 20 | 0, i9 = i18 + 40 | 0, i7 = HEAP32[(HEAP32[i18 >> 2] | 0) + 24 >> 2] | 0, i10 = HEAP32[HEAP32[(HEAP32[i18 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i7 + ((HEAP16[i10 + ((i17 & 255) - i11 + (HEAP32[i9 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i8 >> 2], i12 = i11 + -1 | 0, (i12 | 0) != 0) : 0) {
+ do {
+ HEAP32[i7 + ((HEAP16[i10 + ((HEAPU8[i16] | 0) - i12 + (HEAP32[i9 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i8 >> 2];
+ i12 = i12 + -1 | 0;
+ } while ((i12 | 0) != 0);
+ }
+ i24 = i13 + 46 | 0;
+ HEAP8[i15 + 76 | 0] = HEAP8[i24] | 0;
+ _luaK_reserveregs(i13, HEAPU8[i24] | 0);
+ if ((HEAP32[i14 >> 2] | 0) != 41) {
+ _error_expected(i1, 41);
+ }
+ _luaX_next(i1);
+ L39 : while (1) {
+ i7 = HEAP32[i14 >> 2] | 0;
+ switch (i7 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ i17 = 30;
+ break L39;
+ }
+ default:
+ {}
+ }
+ _statement(i1);
+ if ((i7 | 0) == 274) {
+ i17 = 30;
+ break;
+ }
+ }
+ if ((i17 | 0) == 30) {
+ HEAP32[(HEAP32[i3 >> 2] | 0) + 68 >> 2] = HEAP32[i1 + 4 >> 2];
+ _check_match(i1, 262, 265, i5);
+ i24 = HEAP32[(HEAP32[i2 >> 2] | 0) + 8 >> 2] | 0;
+ i23 = _luaK_codeABx(i24, 37, 0, (HEAP32[i24 + 36 >> 2] | 0) + -1 | 0) | 0;
+ HEAP32[i4 + 16 >> 2] = -1;
+ HEAP32[i4 + 20 >> 2] = -1;
+ HEAP32[i4 >> 2] = 11;
+ HEAP32[i4 + 8 >> 2] = i23;
+ _luaK_exp2nextreg(i24, i4);
+ _close_func(i1);
+ STACKTOP = i6;
+ return;
+ }
+}
+function _luaH_newkey(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, d21 = 0.0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 144 | 0;
+ i8 = i4 + 8 | 0;
+ i10 = i4;
+ i5 = i4 + 16 | 0;
+ i6 = i1 + 8 | 0;
+ i11 = HEAP32[i6 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ _luaG_runerror(i3, 7968, i8);
+ } else if ((i11 | 0) == 3) {
+ i15 = 3;
+ }
+ if ((i15 | 0) == 3 ? (d21 = +HEAPF64[i1 >> 3], !(d21 == d21 & 0.0 == 0.0)) : 0) {
+ _luaG_runerror(i3, 7992, i8);
+ }
+ i13 = _mainposition(i2, i1) | 0;
+ i14 = i13 + 8 | 0;
+ do {
+ if ((HEAP32[i14 >> 2] | 0) != 0 | (i13 | 0) == 8016) {
+ i18 = i2 + 20 | 0;
+ i11 = i2 + 16 | 0;
+ i17 = HEAP32[i11 >> 2] | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ while (1) {
+ if (!(i16 >>> 0 > i17 >>> 0)) {
+ break;
+ }
+ i12 = i16 + -32 | 0;
+ HEAP32[i18 >> 2] = i12;
+ if ((HEAP32[i16 + -8 >> 2] | 0) == 0) {
+ i15 = 37;
+ break;
+ } else {
+ i16 = i12;
+ }
+ }
+ if ((i15 | 0) == 37) {
+ i5 = _mainposition(i2, i13 + 16 | 0) | 0;
+ if ((i5 | 0) == (i13 | 0)) {
+ i20 = i13 + 28 | 0;
+ HEAP32[i16 + -4 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i20 >> 2] = i12;
+ break;
+ } else {
+ i7 = i5;
+ }
+ do {
+ i5 = i7 + 28 | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ } while ((i7 | 0) != (i13 | 0));
+ HEAP32[i5 >> 2] = i12;
+ HEAP32[i12 + 0 >> 2] = HEAP32[i13 + 0 >> 2];
+ HEAP32[i12 + 4 >> 2] = HEAP32[i13 + 4 >> 2];
+ HEAP32[i12 + 8 >> 2] = HEAP32[i13 + 8 >> 2];
+ HEAP32[i12 + 12 >> 2] = HEAP32[i13 + 12 >> 2];
+ HEAP32[i12 + 16 >> 2] = HEAP32[i13 + 16 >> 2];
+ HEAP32[i12 + 20 >> 2] = HEAP32[i13 + 20 >> 2];
+ HEAP32[i12 + 24 >> 2] = HEAP32[i13 + 24 >> 2];
+ HEAP32[i12 + 28 >> 2] = HEAP32[i13 + 28 >> 2];
+ HEAP32[i13 + 28 >> 2] = 0;
+ HEAP32[i14 >> 2] = 0;
+ i12 = i13;
+ break;
+ }
+ i13 = i5 + 0 | 0;
+ i12 = i13 + 124 | 0;
+ do {
+ HEAP32[i13 >> 2] = 0;
+ i13 = i13 + 4 | 0;
+ } while ((i13 | 0) < (i12 | 0));
+ i15 = i2 + 12 | 0;
+ i13 = HEAP32[i2 + 28 >> 2] | 0;
+ i12 = 0;
+ i20 = 1;
+ i16 = 0;
+ i14 = 1;
+ while (1) {
+ if ((i14 | 0) > (i13 | 0)) {
+ if ((i20 | 0) > (i13 | 0)) {
+ break;
+ } else {
+ i19 = i13;
+ }
+ } else {
+ i19 = i14;
+ }
+ if ((i20 | 0) > (i19 | 0)) {
+ i18 = i20;
+ i17 = 0;
+ } else {
+ i18 = HEAP32[i15 >> 2] | 0;
+ i17 = 0;
+ while (1) {
+ i17 = ((HEAP32[i18 + (i20 + -1 << 4) + 8 >> 2] | 0) != 0) + i17 | 0;
+ if ((i20 | 0) >= (i19 | 0)) {
+ break;
+ } else {
+ i20 = i20 + 1 | 0;
+ }
+ }
+ i18 = i19 + 1 | 0;
+ }
+ i20 = i5 + (i16 << 2) | 0;
+ HEAP32[i20 >> 2] = (HEAP32[i20 >> 2] | 0) + i17;
+ i12 = i17 + i12 | 0;
+ i16 = i16 + 1 | 0;
+ if ((i16 | 0) < 31) {
+ i20 = i18;
+ i14 = i14 << 1;
+ } else {
+ break;
+ }
+ }
+ i14 = 0;
+ i15 = 1 << (HEAPU8[i2 + 7 | 0] | 0);
+ i13 = 0;
+ L32 : while (1) {
+ i16 = i15;
+ while (1) {
+ i15 = i16 + -1 | 0;
+ if ((i16 | 0) == 0) {
+ break L32;
+ }
+ i16 = HEAP32[i11 >> 2] | 0;
+ if ((HEAP32[i16 + (i15 << 5) + 8 >> 2] | 0) == 0) {
+ i16 = i15;
+ } else {
+ break;
+ }
+ }
+ if (((HEAP32[i16 + (i15 << 5) + 24 >> 2] | 0) == 3 ? (d21 = +HEAPF64[i16 + (i15 << 5) + 16 >> 3], HEAPF64[i10 >> 3] = d21 + 6755399441055744.0, i9 = HEAP32[i10 >> 2] | 0, +(i9 | 0) == d21) : 0) ? (i9 + -1 | 0) >>> 0 < 1073741824 : 0) {
+ i16 = i5 + ((_luaO_ceillog2(i9) | 0) << 2) | 0;
+ HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) + 1;
+ i16 = 1;
+ } else {
+ i16 = 0;
+ }
+ i14 = i16 + i14 | 0;
+ i13 = i13 + 1 | 0;
+ }
+ i9 = i14 + i12 | 0;
+ if (((HEAP32[i6 >> 2] | 0) == 3 ? (d21 = +HEAPF64[i1 >> 3], HEAPF64[i8 >> 3] = d21 + 6755399441055744.0, i7 = HEAP32[i8 >> 2] | 0, +(i7 | 0) == d21) : 0) ? (i7 + -1 | 0) >>> 0 < 1073741824 : 0) {
+ i6 = i5 + ((_luaO_ceillog2(i7) | 0) << 2) | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 1;
+ i6 = 1;
+ } else {
+ i6 = 0;
+ }
+ i7 = i9 + i6 | 0;
+ L49 : do {
+ if ((i7 | 0) > 0) {
+ i14 = 0;
+ i10 = 0;
+ i6 = 0;
+ i8 = 0;
+ i11 = 0;
+ i9 = 1;
+ while (1) {
+ i15 = HEAP32[i5 + (i6 << 2) >> 2] | 0;
+ if ((i15 | 0) > 0) {
+ i15 = i15 + i10 | 0;
+ i14 = (i15 | 0) > (i14 | 0);
+ i10 = i15;
+ i8 = i14 ? i9 : i8;
+ i11 = i14 ? i15 : i11;
+ }
+ if ((i10 | 0) == (i7 | 0)) {
+ break L49;
+ }
+ i9 = i9 << 1;
+ i14 = (i9 | 0) / 2 | 0;
+ if ((i14 | 0) < (i7 | 0)) {
+ i6 = i6 + 1 | 0;
+ } else {
+ break;
+ }
+ }
+ } else {
+ i8 = 0;
+ i11 = 0;
+ }
+ } while (0);
+ _luaH_resize(i3, i2, i8, i12 + 1 + i13 - i11 | 0);
+ i5 = _luaH_get(i2, i1) | 0;
+ if ((i5 | 0) != 5192) {
+ i20 = i5;
+ STACKTOP = i4;
+ return i20 | 0;
+ }
+ i20 = _luaH_newkey(i3, i2, i1) | 0;
+ STACKTOP = i4;
+ return i20 | 0;
+ } else {
+ i12 = i13;
+ }
+ } while (0);
+ i18 = i1;
+ i19 = HEAP32[i18 + 4 >> 2] | 0;
+ i20 = i12 + 16 | 0;
+ HEAP32[i20 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i20 + 4 >> 2] = i19;
+ HEAP32[i12 + 24 >> 2] = HEAP32[i6 >> 2];
+ if (((HEAP32[i6 >> 2] & 64 | 0) != 0 ? !((HEAP8[(HEAP32[i1 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) ? !((HEAP8[i2 + 5 | 0] & 4) == 0) : 0) {
+ _luaC_barrierback_(i3, i2);
+ }
+ i20 = i12;
+ STACKTOP = i4;
+ return i20 | 0;
+}
+function _luaV_concat(i7, i10) {
+ i7 = i7 | 0;
+ i10 = i10 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i9 = i5;
+ i8 = i5 + 8 | 0;
+ i6 = i7 + 8 | 0;
+ i2 = i7 + 12 | 0;
+ i3 = i7 + 28 | 0;
+ i4 = i7 + 16 | 0;
+ i11 = HEAP32[i6 >> 2] | 0;
+ L1 : while (1) {
+ i14 = i11 + -32 | 0;
+ i12 = i11 + -24 | 0;
+ i17 = HEAP32[i12 >> 2] | 0;
+ i13 = i11 + -16 | 0;
+ do {
+ if ((i17 & 15 | 0) == 4 | (i17 | 0) == 3) {
+ i15 = i11 + -8 | 0;
+ i16 = HEAP32[i15 >> 2] | 0;
+ if ((i16 & 15 | 0) == 4) {
+ i16 = i13;
+ } else {
+ if ((i16 | 0) != 3) {
+ i1 = 7;
+ break;
+ }
+ HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i13 >> 3];
+ HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i16 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
+ HEAP32[i13 >> 2] = i16;
+ HEAP32[i15 >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
+ i16 = i13;
+ i17 = HEAP32[i12 >> 2] | 0;
+ }
+ i16 = HEAP32[(HEAP32[i16 >> 2] | 0) + 12 >> 2] | 0;
+ i18 = (i17 & 15 | 0) == 4;
+ if ((i16 | 0) == 0) {
+ if (i18) {
+ i12 = 2;
+ break;
+ }
+ if ((i17 | 0) != 3) {
+ i12 = 2;
+ break;
+ }
+ HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i14 >> 3];
+ HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i18 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
+ HEAP32[i14 >> 2] = i18;
+ HEAP32[i12 >> 2] = HEAPU8[i18 + 4 | 0] | 0 | 64;
+ i12 = 2;
+ break;
+ }
+ if (i18 ? (HEAP32[(HEAP32[i14 >> 2] | 0) + 12 >> 2] | 0) == 0 : 0) {
+ i16 = i13;
+ i17 = HEAP32[i16 + 4 >> 2] | 0;
+ i18 = i14;
+ HEAP32[i18 >> 2] = HEAP32[i16 >> 2];
+ HEAP32[i18 + 4 >> 2] = i17;
+ HEAP32[i12 >> 2] = HEAP32[i15 >> 2];
+ i12 = 2;
+ break;
+ }
+ L19 : do {
+ if ((i10 | 0) > 1) {
+ i12 = 1;
+ do {
+ i15 = ~i12;
+ i14 = i11 + (i15 << 4) | 0;
+ i15 = i11 + (i15 << 4) + 8 | 0;
+ i13 = HEAP32[i15 >> 2] | 0;
+ if ((i13 & 15 | 0) != 4) {
+ if ((i13 | 0) != 3) {
+ break L19;
+ }
+ HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i14 >> 3];
+ HEAP32[i9 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i9 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i18 = _luaS_newlstr(i7, i8, _sprintf(i8 | 0, 8936, i9 | 0) | 0) | 0;
+ HEAP32[i14 >> 2] = i18;
+ HEAP32[i15 >> 2] = HEAPU8[i18 + 4 | 0] | 0 | 64;
+ }
+ i13 = HEAP32[(HEAP32[i14 >> 2] | 0) + 12 >> 2] | 0;
+ if (!(i13 >>> 0 < (-3 - i16 | 0) >>> 0)) {
+ i1 = 24;
+ break L1;
+ }
+ i16 = i13 + i16 | 0;
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) < (i10 | 0));
+ } else {
+ i12 = 1;
+ }
+ } while (0);
+ i14 = _luaZ_openspace(i7, (HEAP32[i2 >> 2] | 0) + 144 | 0, i16) | 0;
+ i15 = i12;
+ i13 = 0;
+ do {
+ i17 = HEAP32[i11 + (0 - i15 << 4) >> 2] | 0;
+ i18 = HEAP32[i17 + 12 >> 2] | 0;
+ _memcpy(i14 + i13 | 0, i17 + 16 | 0, i18 | 0) | 0;
+ i13 = i18 + i13 | 0;
+ i15 = i15 + -1 | 0;
+ } while ((i15 | 0) > 0);
+ i18 = 0 - i12 | 0;
+ i17 = _luaS_newlstr(i7, i14, i13) | 0;
+ HEAP32[i11 + (i18 << 4) >> 2] = i17;
+ HEAP32[i11 + (i18 << 4) + 8 >> 2] = HEAPU8[i17 + 4 | 0] | 0 | 64;
+ } else {
+ i1 = 7;
+ }
+ } while (0);
+ if ((i1 | 0) == 7) {
+ i1 = 0;
+ i15 = _luaT_gettmbyobj(i7, i14, 15) | 0;
+ if ((HEAP32[i15 + 8 >> 2] | 0) == 0) {
+ i15 = _luaT_gettmbyobj(i7, i13, 15) | 0;
+ if ((HEAP32[i15 + 8 >> 2] | 0) == 0) {
+ i1 = 10;
+ break;
+ }
+ }
+ i18 = i14 - (HEAP32[i3 >> 2] | 0) | 0;
+ i16 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i16 + 16;
+ i20 = i15;
+ i19 = HEAP32[i20 + 4 >> 2] | 0;
+ i17 = i16;
+ HEAP32[i17 >> 2] = HEAP32[i20 >> 2];
+ HEAP32[i17 + 4 >> 2] = i19;
+ HEAP32[i16 + 8 >> 2] = HEAP32[i15 + 8 >> 2];
+ i15 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i15 + 16;
+ i16 = i14;
+ i17 = HEAP32[i16 + 4 >> 2] | 0;
+ i14 = i15;
+ HEAP32[i14 >> 2] = HEAP32[i16 >> 2];
+ HEAP32[i14 + 4 >> 2] = i17;
+ HEAP32[i15 + 8 >> 2] = HEAP32[i12 >> 2];
+ i12 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i12 + 16;
+ i15 = i13;
+ i14 = HEAP32[i15 + 4 >> 2] | 0;
+ i17 = i12;
+ HEAP32[i17 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i17 + 4 >> 2] = i14;
+ HEAP32[i12 + 8 >> 2] = HEAP32[i11 + -8 >> 2];
+ _luaD_call(i7, (HEAP32[i6 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i4 >> 2] | 0) + 18 | 0] & 1);
+ i12 = HEAP32[i3 >> 2] | 0;
+ i17 = HEAP32[i6 >> 2] | 0;
+ i14 = i17 + -16 | 0;
+ HEAP32[i6 >> 2] = i14;
+ i15 = HEAP32[i14 + 4 >> 2] | 0;
+ i16 = i12 + i18 | 0;
+ HEAP32[i16 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i16 + 4 >> 2] = i15;
+ HEAP32[i12 + (i18 + 8) >> 2] = HEAP32[i17 + -8 >> 2];
+ i12 = 2;
+ }
+ i10 = i10 + 1 - i12 | 0;
+ i11 = (HEAP32[i6 >> 2] | 0) + (1 - i12 << 4) | 0;
+ HEAP32[i6 >> 2] = i11;
+ if ((i10 | 0) <= 1) {
+ i1 = 30;
+ break;
+ }
+ }
+ if ((i1 | 0) == 10) {
+ _luaG_concaterror(i7, i14, i13);
+ } else if ((i1 | 0) == 24) {
+ _luaG_runerror(i7, 9e3, i9);
+ } else if ((i1 | 0) == 30) {
+ STACKTOP = i5;
+ return;
+ }
+}
+function _str_gsub(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 1344 | 0;
+ i4 = i3;
+ i5 = i3 + 1336 | 0;
+ i14 = i3 + 1332 | 0;
+ i10 = i3 + 1328 | 0;
+ i6 = i3 + 1048 | 0;
+ i2 = i3 + 8 | 0;
+ i20 = _luaL_checklstring(i1, 1, i14) | 0;
+ i13 = _luaL_checklstring(i1, 2, i10) | 0;
+ i8 = _lua_type(i1, 3) | 0;
+ i9 = _luaL_optinteger(i1, 4, (HEAP32[i14 >> 2] | 0) + 1 | 0) | 0;
+ i7 = (HEAP8[i13] | 0) == 94;
+ if (!((i8 + -3 | 0) >>> 0 < 2 | (i8 | 0) == 6 | (i8 | 0) == 5)) {
+ _luaL_argerror(i1, 3, 7528) | 0;
+ }
+ _luaL_buffinit(i1, i2);
+ if (i7) {
+ i15 = (HEAP32[i10 >> 2] | 0) + -1 | 0;
+ HEAP32[i10 >> 2] = i15;
+ i13 = i13 + 1 | 0;
+ } else {
+ i15 = HEAP32[i10 >> 2] | 0;
+ }
+ i11 = i6 + 16 | 0;
+ HEAP32[i11 >> 2] = i1;
+ HEAP32[i6 >> 2] = 200;
+ i12 = i6 + 4 | 0;
+ HEAP32[i12 >> 2] = i20;
+ i10 = i6 + 8 | 0;
+ HEAP32[i10 >> 2] = i20 + (HEAP32[i14 >> 2] | 0);
+ HEAP32[i6 + 12 >> 2] = i13 + i15;
+ i14 = i6 + 20 | 0;
+ i15 = i2 + 8 | 0;
+ i18 = i2 + 4 | 0;
+ i16 = i6 + 28 | 0;
+ i17 = i6 + 24 | 0;
+ i22 = 0;
+ while (1) {
+ if (!(i22 >>> 0 < i9 >>> 0)) {
+ i19 = 48;
+ break;
+ }
+ HEAP32[i14 >> 2] = 0;
+ i21 = _match(i6, i20, i13) | 0;
+ if ((i21 | 0) != 0) {
+ i22 = i22 + 1 | 0;
+ i23 = HEAP32[i11 >> 2] | 0;
+ if ((i8 | 0) == 5) {
+ do {
+ if ((HEAP32[i14 >> 2] | 0) > 0) {
+ i24 = HEAP32[i16 >> 2] | 0;
+ if (!((i24 | 0) == -1)) {
+ i25 = HEAP32[i17 >> 2] | 0;
+ if ((i24 | 0) == -2) {
+ _lua_pushinteger(i23, i25 + 1 - (HEAP32[i12 >> 2] | 0) | 0);
+ break;
+ } else {
+ i19 = i23;
+ }
+ } else {
+ _luaL_error(i23, 7248, i4) | 0;
+ i19 = HEAP32[i11 >> 2] | 0;
+ i25 = HEAP32[i17 >> 2] | 0;
+ }
+ _lua_pushlstring(i19, i25, i24) | 0;
+ } else {
+ _lua_pushlstring(i23, i20, i21 - i20 | 0) | 0;
+ }
+ } while (0);
+ _lua_gettable(i23, 3);
+ i19 = 37;
+ } else if ((i8 | 0) != 6) {
+ i24 = _lua_tolstring(i23, 3, i5) | 0;
+ if ((HEAP32[i5 >> 2] | 0) != 0) {
+ i23 = i21 - i20 | 0;
+ i25 = 0;
+ do {
+ i26 = i24 + i25 | 0;
+ i27 = HEAP8[i26] | 0;
+ do {
+ if (i27 << 24 >> 24 == 37) {
+ i25 = i25 + 1 | 0;
+ i26 = i24 + i25 | 0;
+ i28 = HEAP8[i26] | 0;
+ i27 = i28 << 24 >> 24;
+ if (((i28 & 255) + -48 | 0) >>> 0 < 10) {
+ if (i28 << 24 >> 24 == 48) {
+ _luaL_addlstring(i2, i20, i23);
+ break;
+ } else {
+ _push_onecapture(i6, i27 + -49 | 0, i20, i21);
+ _luaL_addvalue(i2);
+ break;
+ }
+ }
+ if (!(i28 << 24 >> 24 == 37)) {
+ i28 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i4 >> 2] = 37;
+ _luaL_error(i28, 7600, i4) | 0;
+ }
+ i27 = HEAP32[i15 >> 2] | 0;
+ if (!(i27 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i2, 1) | 0;
+ i27 = HEAP32[i15 >> 2] | 0;
+ }
+ i28 = HEAP8[i26] | 0;
+ HEAP32[i15 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i2 >> 2] | 0) + i27 | 0] = i28;
+ } else {
+ i28 = HEAP32[i15 >> 2] | 0;
+ if (!(i28 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i2, 1) | 0;
+ i28 = HEAP32[i15 >> 2] | 0;
+ i27 = HEAP8[i26] | 0;
+ }
+ HEAP32[i15 >> 2] = i28 + 1;
+ HEAP8[(HEAP32[i2 >> 2] | 0) + i28 | 0] = i27;
+ }
+ } while (0);
+ i25 = i25 + 1 | 0;
+ } while (i25 >>> 0 < (HEAP32[i5 >> 2] | 0) >>> 0);
+ }
+ } else {
+ _lua_pushvalue(i23, 3);
+ i19 = HEAP32[i14 >> 2] | 0;
+ i19 = (i19 | 0) != 0 | (i20 | 0) == 0 ? i19 : 1;
+ _luaL_checkstack(HEAP32[i11 >> 2] | 0, i19, 7200);
+ if ((i19 | 0) > 0) {
+ i24 = 0;
+ do {
+ _push_onecapture(i6, i24, i20, i21);
+ i24 = i24 + 1 | 0;
+ } while ((i24 | 0) != (i19 | 0));
+ }
+ _lua_callk(i23, i19, 1, 0, 0);
+ i19 = 37;
+ }
+ if ((i19 | 0) == 37) {
+ i19 = 0;
+ if ((_lua_toboolean(i23, -1) | 0) != 0) {
+ if ((_lua_isstring(i23, -1) | 0) == 0) {
+ HEAP32[i4 >> 2] = _lua_typename(i23, _lua_type(i23, -1) | 0) | 0;
+ _luaL_error(i23, 7560, i4) | 0;
+ }
+ } else {
+ _lua_settop(i23, -2);
+ _lua_pushlstring(i23, i20, i21 - i20 | 0) | 0;
+ }
+ _luaL_addvalue(i2);
+ }
+ if (i21 >>> 0 > i20 >>> 0) {
+ i20 = i21;
+ } else {
+ i19 = 43;
+ }
+ } else {
+ i19 = 43;
+ }
+ if ((i19 | 0) == 43) {
+ i19 = 0;
+ if (!(i20 >>> 0 < (HEAP32[i10 >> 2] | 0) >>> 0)) {
+ i19 = 48;
+ break;
+ }
+ i21 = HEAP32[i15 >> 2] | 0;
+ if (!(i21 >>> 0 < (HEAP32[i18 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i2, 1) | 0;
+ i21 = HEAP32[i15 >> 2] | 0;
+ }
+ i28 = HEAP8[i20] | 0;
+ HEAP32[i15 >> 2] = i21 + 1;
+ HEAP8[(HEAP32[i2 >> 2] | 0) + i21 | 0] = i28;
+ i20 = i20 + 1 | 0;
+ }
+ if (i7) {
+ i19 = 48;
+ break;
+ }
+ }
+ if ((i19 | 0) == 48) {
+ _luaL_addlstring(i2, i20, (HEAP32[i10 >> 2] | 0) - i20 | 0);
+ _luaL_pushresult(i2);
+ _lua_pushinteger(i1, i22);
+ STACKTOP = i3;
+ return 2;
+ }
+ return 0;
+}
+function _constructor(i11, i13) {
+ i11 = i11 | 0;
+ i13 = i13 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i10 = i5 + 40 | 0;
+ i8 = i5;
+ i12 = i11 + 48 | 0;
+ i6 = HEAP32[i12 >> 2] | 0;
+ i9 = HEAP32[i11 + 4 >> 2] | 0;
+ i2 = _luaK_codeABC(i6, 11, 0, 0, 0) | 0;
+ i7 = i8 + 36 | 0;
+ HEAP32[i7 >> 2] = 0;
+ i4 = i8 + 28 | 0;
+ HEAP32[i4 >> 2] = 0;
+ i3 = i8 + 32 | 0;
+ HEAP32[i3 >> 2] = 0;
+ i1 = i8 + 24 | 0;
+ HEAP32[i1 >> 2] = i13;
+ HEAP32[i13 + 16 >> 2] = -1;
+ HEAP32[i13 + 20 >> 2] = -1;
+ HEAP32[i13 >> 2] = 11;
+ HEAP32[i13 + 8 >> 2] = i2;
+ HEAP32[i8 + 16 >> 2] = -1;
+ HEAP32[i8 + 20 >> 2] = -1;
+ HEAP32[i8 >> 2] = 0;
+ HEAP32[i8 + 8 >> 2] = 0;
+ _luaK_exp2nextreg(HEAP32[i12 >> 2] | 0, i13);
+ i13 = i11 + 16 | 0;
+ if ((HEAP32[i13 >> 2] | 0) != 123) {
+ _error_expected(i11, 123);
+ }
+ _luaX_next(i11);
+ L4 : do {
+ if ((HEAP32[i13 >> 2] | 0) != 125) {
+ L5 : while (1) {
+ if ((HEAP32[i8 >> 2] | 0) != 0 ? (_luaK_exp2nextreg(i6, i8), HEAP32[i8 >> 2] = 0, (HEAP32[i7 >> 2] | 0) == 50) : 0) {
+ _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, 50);
+ HEAP32[i7 >> 2] = 0;
+ }
+ i14 = HEAP32[i13 >> 2] | 0;
+ do {
+ if ((i14 | 0) == 288) {
+ if ((_luaX_lookahead(i11) | 0) == 61) {
+ _recfield(i11, i8);
+ break;
+ }
+ _subexpr(i11, i8, 0) | 0;
+ i14 = HEAP32[i12 >> 2] | 0;
+ i15 = HEAP32[i3 >> 2] | 0;
+ if ((i15 | 0) > 2147483645) {
+ i12 = 10;
+ break L5;
+ }
+ HEAP32[i3 >> 2] = i15 + 1;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
+ } else if ((i14 | 0) == 91) {
+ _recfield(i11, i8);
+ } else {
+ _subexpr(i11, i8, 0) | 0;
+ i14 = HEAP32[i12 >> 2] | 0;
+ i15 = HEAP32[i3 >> 2] | 0;
+ if ((i15 | 0) > 2147483645) {
+ i12 = 17;
+ break L5;
+ }
+ HEAP32[i3 >> 2] = i15 + 1;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
+ }
+ } while (0);
+ i14 = HEAP32[i13 >> 2] | 0;
+ if ((i14 | 0) == 44) {
+ _luaX_next(i11);
+ } else if ((i14 | 0) == 59) {
+ _luaX_next(i11);
+ } else {
+ break L4;
+ }
+ if ((HEAP32[i13 >> 2] | 0) == 125) {
+ break L4;
+ }
+ }
+ if ((i12 | 0) == 10) {
+ i12 = i14 + 12 | 0;
+ i13 = HEAP32[(HEAP32[i12 >> 2] | 0) + 52 >> 2] | 0;
+ i14 = HEAP32[(HEAP32[i14 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ i16 = 6552;
+ HEAP32[i10 >> 2] = 6528;
+ i15 = i10 + 4 | 0;
+ HEAP32[i15 >> 2] = 2147483645;
+ i15 = i10 + 8 | 0;
+ HEAP32[i15 >> 2] = i16;
+ i15 = _luaO_pushfstring(i13, 6592, i10) | 0;
+ i16 = HEAP32[i12 >> 2] | 0;
+ _luaX_syntaxerror(i16, i15);
+ }
+ HEAP32[i10 >> 2] = i14;
+ i15 = _luaO_pushfstring(i13, 6568, i10) | 0;
+ HEAP32[i10 >> 2] = 6528;
+ i16 = i10 + 4 | 0;
+ HEAP32[i16 >> 2] = 2147483645;
+ i16 = i10 + 8 | 0;
+ HEAP32[i16 >> 2] = i15;
+ i16 = _luaO_pushfstring(i13, 6592, i10) | 0;
+ i15 = HEAP32[i12 >> 2] | 0;
+ _luaX_syntaxerror(i15, i16);
+ } else if ((i12 | 0) == 17) {
+ i13 = i14 + 12 | 0;
+ i12 = HEAP32[(HEAP32[i13 >> 2] | 0) + 52 >> 2] | 0;
+ i14 = HEAP32[(HEAP32[i14 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ i15 = 6552;
+ HEAP32[i10 >> 2] = 6528;
+ i16 = i10 + 4 | 0;
+ HEAP32[i16 >> 2] = 2147483645;
+ i16 = i10 + 8 | 0;
+ HEAP32[i16 >> 2] = i15;
+ i16 = _luaO_pushfstring(i12, 6592, i10) | 0;
+ i15 = HEAP32[i13 >> 2] | 0;
+ _luaX_syntaxerror(i15, i16);
+ }
+ HEAP32[i10 >> 2] = i14;
+ i15 = _luaO_pushfstring(i12, 6568, i10) | 0;
+ HEAP32[i10 >> 2] = 6528;
+ i16 = i10 + 4 | 0;
+ HEAP32[i16 >> 2] = 2147483645;
+ i16 = i10 + 8 | 0;
+ HEAP32[i16 >> 2] = i15;
+ i16 = _luaO_pushfstring(i12, 6592, i10) | 0;
+ i15 = HEAP32[i13 >> 2] | 0;
+ _luaX_syntaxerror(i15, i16);
+ }
+ }
+ } while (0);
+ _check_match(i11, 125, 123, i9);
+ i9 = HEAP32[i7 >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ i10 = HEAP32[i8 >> 2] | 0;
+ if ((i10 | 0) != 0) if ((i10 | 0) == 13 | (i10 | 0) == 12) {
+ _luaK_setreturns(i6, i8, -1);
+ _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, -1);
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + -1;
+ break;
+ } else {
+ _luaK_exp2nextreg(i6, i8);
+ i9 = HEAP32[i7 >> 2] | 0;
+ }
+ _luaK_setlist(i6, HEAP32[(HEAP32[i1 >> 2] | 0) + 8 >> 2] | 0, HEAP32[i3 >> 2] | 0, i9);
+ }
+ } while (0);
+ i16 = HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] & 8388607;
+ i16 = (_luaO_int2fb(HEAP32[i3 >> 2] | 0) | 0) << 23 | i16;
+ HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] = i16;
+ i16 = (_luaO_int2fb(HEAP32[i4 >> 2] | 0) | 0) << 14 & 8372224 | i16 & -8372225;
+ HEAP32[(HEAP32[(HEAP32[i6 >> 2] | 0) + 12 >> 2] | 0) + (i2 << 2) >> 2] = i16;
+ STACKTOP = i5;
+ return;
+}
+function _luaK_prefix(i4, i14, i7, i13) {
+ i4 = i4 | 0;
+ i14 = i14 | 0;
+ i7 = i7 | 0;
+ i13 = i13 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i12 = i1;
+ HEAP32[i12 + 20 >> 2] = -1;
+ HEAP32[i12 + 16 >> 2] = -1;
+ HEAP32[i12 >> 2] = 5;
+ HEAPF64[i12 + 8 >> 3] = 0.0;
+ if ((i14 | 0) == 1) {
+ _luaK_dischargevars(i4, i7);
+ switch (HEAP32[i7 >> 2] | 0) {
+ case 2:
+ case 5:
+ case 4:
+ {
+ HEAP32[i7 >> 2] = 3;
+ break;
+ }
+ case 10:
+ {
+ i13 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ i12 = HEAP32[i7 + 8 >> 2] | 0;
+ i10 = i13 + (i12 << 2) | 0;
+ if (!((i12 | 0) > 0 ? (i11 = i13 + (i12 + -1 << 2) | 0, i9 = HEAP32[i11 >> 2] | 0, (HEAP8[5584 + (i9 & 63) | 0] | 0) < 0) : 0)) {
+ i11 = i10;
+ i9 = HEAP32[i10 >> 2] | 0;
+ }
+ HEAP32[i11 >> 2] = ((i9 & 16320 | 0) == 0) << 6 | i9 & -16321;
+ break;
+ }
+ case 6:
+ {
+ i8 = 25;
+ break;
+ }
+ case 3:
+ case 1:
+ {
+ HEAP32[i7 >> 2] = 2;
+ break;
+ }
+ case 11:
+ {
+ i12 = i4 + 48 | 0;
+ i8 = HEAP8[i12] | 0;
+ i11 = (i8 & 255) + 1 | 0;
+ i9 = (HEAP32[i4 >> 2] | 0) + 78 | 0;
+ do {
+ if (i11 >>> 0 > (HEAPU8[i9] | 0) >>> 0) {
+ if (i11 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i9] = i11;
+ i10 = HEAP8[i12] | 0;
+ break;
+ }
+ } else {
+ i10 = i8;
+ }
+ } while (0);
+ i14 = (i10 & 255) + 1 | 0;
+ HEAP8[i12] = i14;
+ _discharge2reg(i4, i7, (i14 & 255) + -1 | 0);
+ if ((HEAP32[i7 >> 2] | 0) == 6) {
+ i8 = 25;
+ } else {
+ i9 = i7 + 8 | 0;
+ i8 = 28;
+ }
+ break;
+ }
+ default:
+ {}
+ }
+ if ((i8 | 0) == 25) {
+ i8 = i7 + 8 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ if ((i9 & 256 | 0) == 0 ? (HEAPU8[i4 + 46 | 0] | 0) <= (i9 | 0) : 0) {
+ i9 = i4 + 48 | 0;
+ HEAP8[i9] = (HEAP8[i9] | 0) + -1 << 24 >> 24;
+ i9 = i8;
+ i8 = 28;
+ } else {
+ i9 = i8;
+ i8 = 28;
+ }
+ }
+ if ((i8 | 0) == 28) {
+ HEAP32[i9 >> 2] = _luaK_code(i4, HEAP32[i9 >> 2] << 23 | 20) | 0;
+ HEAP32[i7 >> 2] = 11;
+ }
+ i14 = i7 + 20 | 0;
+ i8 = HEAP32[i14 >> 2] | 0;
+ i7 = i7 + 16 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i14 >> 2] = i9;
+ HEAP32[i7 >> 2] = i8;
+ if (!((i9 | 0) == -1)) {
+ i8 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ do {
+ i12 = i8 + (i9 << 2) | 0;
+ if ((i9 | 0) > 0 ? (i5 = i8 + (i9 + -1 << 2) | 0, i6 = HEAP32[i5 >> 2] | 0, (HEAP8[5584 + (i6 & 63) | 0] | 0) < 0) : 0) {
+ i10 = i5;
+ i11 = i6;
+ } else {
+ i10 = i12;
+ i11 = HEAP32[i12 >> 2] | 0;
+ }
+ if ((i11 & 63 | 0) == 28) {
+ HEAP32[i10 >> 2] = i11 & 8372224 | i11 >>> 23 << 6 | 27;
+ }
+ i10 = ((HEAP32[i12 >> 2] | 0) >>> 14) + -131071 | 0;
+ if ((i10 | 0) == -1) {
+ break;
+ }
+ i9 = i9 + 1 + i10 | 0;
+ } while (!((i9 | 0) == -1));
+ i8 = HEAP32[i7 >> 2] | 0;
+ }
+ if ((i8 | 0) == -1) {
+ STACKTOP = i1;
+ return;
+ }
+ i4 = HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i6 = i4 + (i8 << 2) | 0;
+ if ((i8 | 0) > 0 ? (i2 = i4 + (i8 + -1 << 2) | 0, i3 = HEAP32[i2 >> 2] | 0, (HEAP8[5584 + (i3 & 63) | 0] | 0) < 0) : 0) {
+ i7 = i2;
+ i5 = i3;
+ } else {
+ i7 = i6;
+ i5 = HEAP32[i6 >> 2] | 0;
+ }
+ if ((i5 & 63 | 0) == 28) {
+ HEAP32[i7 >> 2] = i5 & 8372224 | i5 >>> 23 << 6 | 27;
+ }
+ i5 = ((HEAP32[i6 >> 2] | 0) >>> 14) + -131071 | 0;
+ if ((i5 | 0) == -1) {
+ i8 = 54;
+ break;
+ }
+ i8 = i8 + 1 + i5 | 0;
+ if ((i8 | 0) == -1) {
+ i8 = 54;
+ break;
+ }
+ }
+ if ((i8 | 0) == 54) {
+ STACKTOP = i1;
+ return;
+ }
+ } else if ((i14 | 0) == 0) {
+ if (((HEAP32[i7 >> 2] | 0) == 5 ? (HEAP32[i7 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i7 + 20 >> 2] | 0) == -1 : 0) {
+ i14 = i7 + 8 | 0;
+ HEAPF64[i14 >> 3] = -+HEAPF64[i14 >> 3];
+ STACKTOP = i1;
+ return;
+ }
+ _luaK_dischargevars(i4, i7);
+ if ((HEAP32[i7 >> 2] | 0) == 6) {
+ i2 = HEAP32[i7 + 8 >> 2] | 0;
+ if ((HEAP32[i7 + 16 >> 2] | 0) != (HEAP32[i7 + 20 >> 2] | 0)) {
+ if ((i2 | 0) < (HEAPU8[i4 + 46 | 0] | 0)) {
+ i8 = 10;
+ } else {
+ _exp2reg(i4, i7, i2);
+ }
+ }
+ } else {
+ i8 = 10;
+ }
+ if ((i8 | 0) == 10) {
+ _luaK_exp2nextreg(i4, i7);
+ }
+ _codearith(i4, 19, i7, i12, i13);
+ STACKTOP = i1;
+ return;
+ } else if ((i14 | 0) == 2) {
+ _luaK_dischargevars(i4, i7);
+ if ((HEAP32[i7 >> 2] | 0) == 6) {
+ i2 = HEAP32[i7 + 8 >> 2] | 0;
+ if ((HEAP32[i7 + 16 >> 2] | 0) != (HEAP32[i7 + 20 >> 2] | 0)) {
+ if ((i2 | 0) < (HEAPU8[i4 + 46 | 0] | 0)) {
+ i8 = 52;
+ } else {
+ _exp2reg(i4, i7, i2);
+ }
+ }
+ } else {
+ i8 = 52;
+ }
+ if ((i8 | 0) == 52) {
+ _luaK_exp2nextreg(i4, i7);
+ }
+ _codearith(i4, 21, i7, i12, i13);
+ STACKTOP = i1;
+ return;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _subexpr(i6, i3, i7) {
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i11 = i2 + 24 | 0;
+ i5 = i2;
+ i4 = i6 + 48 | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ i1 = i6 + 52 | 0;
+ i12 = (HEAP32[i1 >> 2] | 0) + 38 | 0;
+ i13 = (HEAP16[i12 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP16[i12 >> 1] = i13;
+ if ((i13 & 65535) > 200) {
+ i10 = i9 + 12 | 0;
+ i12 = HEAP32[(HEAP32[i10 >> 2] | 0) + 52 >> 2] | 0;
+ i13 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i13 | 0) == 0) {
+ i15 = 6552;
+ HEAP32[i11 >> 2] = 6360;
+ i14 = i11 + 4 | 0;
+ HEAP32[i14 >> 2] = 200;
+ i14 = i11 + 8 | 0;
+ HEAP32[i14 >> 2] = i15;
+ i14 = _luaO_pushfstring(i12, 6592, i11) | 0;
+ i15 = HEAP32[i10 >> 2] | 0;
+ _luaX_syntaxerror(i15, i14);
+ }
+ HEAP32[i11 >> 2] = i13;
+ i14 = _luaO_pushfstring(i12, 6568, i11) | 0;
+ HEAP32[i11 >> 2] = 6360;
+ i15 = i11 + 4 | 0;
+ HEAP32[i15 >> 2] = 200;
+ i15 = i11 + 8 | 0;
+ HEAP32[i15 >> 2] = i14;
+ i15 = _luaO_pushfstring(i12, 6592, i11) | 0;
+ i14 = HEAP32[i10 >> 2] | 0;
+ _luaX_syntaxerror(i14, i15);
+ }
+ i10 = i6 + 16 | 0;
+ L8 : do {
+ switch (HEAP32[i10 >> 2] | 0) {
+ case 287:
+ {
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 5;
+ HEAP32[i3 + 8 >> 2] = 0;
+ HEAPF64[i3 + 8 >> 3] = +HEAPF64[i6 + 24 >> 3];
+ i8 = 20;
+ break;
+ }
+ case 271:
+ {
+ i9 = 1;
+ i8 = 8;
+ break;
+ }
+ case 289:
+ {
+ i8 = _luaK_stringK(i9, HEAP32[i6 + 24 >> 2] | 0) | 0;
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 4;
+ HEAP32[i3 + 8 >> 2] = i8;
+ i8 = 20;
+ break;
+ }
+ case 265:
+ {
+ _luaX_next(i6);
+ _body(i6, i3, 0, HEAP32[i6 + 4 >> 2] | 0);
+ break;
+ }
+ case 276:
+ {
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 2;
+ HEAP32[i3 + 8 >> 2] = 0;
+ i8 = 20;
+ break;
+ }
+ case 45:
+ {
+ i9 = 0;
+ i8 = 8;
+ break;
+ }
+ case 35:
+ {
+ i9 = 2;
+ i8 = 8;
+ break;
+ }
+ case 123:
+ {
+ _constructor(i6, i3);
+ break;
+ }
+ case 263:
+ {
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 3;
+ HEAP32[i3 + 8 >> 2] = 0;
+ i8 = 20;
+ break;
+ }
+ case 280:
+ {
+ if ((HEAP8[(HEAP32[i9 >> 2] | 0) + 77 | 0] | 0) == 0) {
+ _luaX_syntaxerror(i6, 6408);
+ } else {
+ i8 = _luaK_codeABC(i9, 38, 0, 1, 0) | 0;
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 13;
+ HEAP32[i3 + 8 >> 2] = i8;
+ i8 = 20;
+ break L8;
+ }
+ break;
+ }
+ case 270:
+ {
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 1;
+ HEAP32[i3 + 8 >> 2] = 0;
+ i8 = 20;
+ break;
+ }
+ default:
+ {
+ _suffixedexp(i6, i3);
+ }
+ }
+ } while (0);
+ if ((i8 | 0) == 8) {
+ i15 = HEAP32[i6 + 4 >> 2] | 0;
+ _luaX_next(i6);
+ _subexpr(i6, i3, 8) | 0;
+ _luaK_prefix(HEAP32[i4 >> 2] | 0, i9, i3, i15);
+ } else if ((i8 | 0) == 20) {
+ _luaX_next(i6);
+ }
+ switch (HEAP32[i10 >> 2] | 0) {
+ case 257:
+ {
+ i9 = 13;
+ break;
+ }
+ case 272:
+ {
+ i9 = 14;
+ break;
+ }
+ case 47:
+ {
+ i9 = 3;
+ break;
+ }
+ case 37:
+ {
+ i9 = 4;
+ break;
+ }
+ case 43:
+ {
+ i9 = 0;
+ break;
+ }
+ case 284:
+ {
+ i9 = 10;
+ break;
+ }
+ case 281:
+ {
+ i9 = 7;
+ break;
+ }
+ case 62:
+ {
+ i9 = 11;
+ break;
+ }
+ case 282:
+ {
+ i9 = 12;
+ break;
+ }
+ case 45:
+ {
+ i9 = 1;
+ break;
+ }
+ case 42:
+ {
+ i9 = 2;
+ break;
+ }
+ case 60:
+ {
+ i9 = 8;
+ break;
+ }
+ case 283:
+ {
+ i9 = 9;
+ break;
+ }
+ case 94:
+ {
+ i9 = 5;
+ break;
+ }
+ case 279:
+ {
+ i9 = 6;
+ break;
+ }
+ default:
+ {
+ i15 = 15;
+ i14 = HEAP32[i1 >> 2] | 0;
+ i14 = i14 + 38 | 0;
+ i13 = HEAP16[i14 >> 1] | 0;
+ i13 = i13 + -1 << 16 >> 16;
+ HEAP16[i14 >> 1] = i13;
+ STACKTOP = i2;
+ return i15 | 0;
+ }
+ }
+ i8 = i6 + 4 | 0;
+ while (1) {
+ if ((HEAPU8[6376 + (i9 << 1) | 0] | 0) <= (i7 | 0)) {
+ i8 = 39;
+ break;
+ }
+ i15 = HEAP32[i8 >> 2] | 0;
+ _luaX_next(i6);
+ _luaK_infix(HEAP32[i4 >> 2] | 0, i9, i3);
+ i10 = _subexpr(i6, i5, HEAPU8[6377 + (i9 << 1) | 0] | 0) | 0;
+ _luaK_posfix(HEAP32[i4 >> 2] | 0, i9, i3, i5, i15);
+ if ((i10 | 0) == 15) {
+ i9 = 15;
+ i8 = 39;
+ break;
+ } else {
+ i9 = i10;
+ }
+ }
+ if ((i8 | 0) == 39) {
+ i15 = HEAP32[i1 >> 2] | 0;
+ i15 = i15 + 38 | 0;
+ i14 = HEAP16[i15 >> 1] | 0;
+ i14 = i14 + -1 << 16 >> 16;
+ HEAP16[i15 >> 1] = i14;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ return 0;
+}
+function _luaV_lessequal(i5, i3, i2) {
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ i4 = i3 + 8 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == 3) {
+ if ((HEAP32[i2 + 8 >> 2] | 0) == 3) {
+ i9 = +HEAPF64[i3 >> 3] <= +HEAPF64[i2 >> 3] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ } else {
+ if ((i7 & 15 | 0) == 4 ? (HEAP32[i2 + 8 >> 2] & 15 | 0) == 4 : 0) {
+ i3 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ i4 = i3 + 16 | 0;
+ i5 = i6 + 16 | 0;
+ i7 = _strcmp(i4, i5) | 0;
+ L8 : do {
+ if ((i7 | 0) == 0) {
+ i2 = HEAP32[i3 + 12 >> 2] | 0;
+ i3 = HEAP32[i6 + 12 >> 2] | 0;
+ i6 = i5;
+ while (1) {
+ i5 = _strlen(i4 | 0) | 0;
+ i7 = (i5 | 0) == (i2 | 0);
+ if ((i5 | 0) == (i3 | 0)) {
+ break;
+ }
+ if (i7) {
+ i7 = -1;
+ break L8;
+ }
+ i5 = i5 + 1 | 0;
+ i4 = i4 + i5 | 0;
+ i6 = i6 + i5 | 0;
+ i7 = _strcmp(i4, i6) | 0;
+ if ((i7 | 0) == 0) {
+ i2 = i2 - i5 | 0;
+ i3 = i3 - i5 | 0;
+ } else {
+ break L8;
+ }
+ }
+ i7 = i7 & 1 ^ 1;
+ }
+ } while (0);
+ i9 = (i7 | 0) < 1 | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ }
+ i7 = i5 + 8 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i9 = _luaT_gettmbyobj(i5, i3, 14) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ i9 = _luaT_gettmbyobj(i5, i2, 14) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ i8 = HEAP32[i7 >> 2] | 0;
+ i9 = _luaT_gettmbyobj(i5, i2, 13) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ i9 = _luaT_gettmbyobj(i5, i3, 13) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ _luaG_ordererror(i5, i3, i2);
+ } else {
+ i6 = i9;
+ }
+ } else {
+ i6 = i9;
+ }
+ i10 = i5 + 28 | 0;
+ i9 = i8 - (HEAP32[i10 >> 2] | 0) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i8 + 16;
+ i13 = i6;
+ i11 = HEAP32[i13 + 4 >> 2] | 0;
+ i12 = i8;
+ HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAP32[i8 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i8 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i8 + 16;
+ i12 = i2;
+ i11 = HEAP32[i12 + 4 >> 2] | 0;
+ i6 = i8;
+ HEAP32[i6 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i6 + 4 >> 2] = i11;
+ HEAP32[i8 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ i2 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i2 + 16;
+ i8 = i3;
+ i6 = HEAP32[i8 + 4 >> 2] | 0;
+ i3 = i2;
+ HEAP32[i3 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i3 + 4 >> 2] = i6;
+ HEAP32[i2 + 8 >> 2] = HEAP32[i4 >> 2];
+ _luaD_call(i5, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i3 = HEAP32[i10 >> 2] | 0;
+ i2 = HEAP32[i7 >> 2] | 0;
+ i5 = i2 + -16 | 0;
+ HEAP32[i7 >> 2] = i5;
+ i6 = HEAP32[i5 + 4 >> 2] | 0;
+ i8 = i3 + i9 | 0;
+ HEAP32[i8 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i8 + 4 >> 2] = i6;
+ HEAP32[i3 + (i9 + 8) >> 2] = HEAP32[i2 + -8 >> 2];
+ i3 = HEAP32[i7 >> 2] | 0;
+ i2 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i2 | 0) != 0) {
+ if ((i2 | 0) == 1) {
+ i2 = (HEAP32[i3 >> 2] | 0) != 0;
+ } else {
+ i2 = 1;
+ }
+ } else {
+ i2 = 0;
+ }
+ i13 = i2 & 1 ^ 1;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ i10 = i5 + 28 | 0;
+ i13 = i8 - (HEAP32[i10 >> 2] | 0) | 0;
+ i11 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i11 + 16;
+ i6 = i9;
+ i8 = HEAP32[i6 + 4 >> 2] | 0;
+ i12 = i11;
+ HEAP32[i12 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i12 + 4 >> 2] = i8;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ i9 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i9 + 16;
+ i11 = i3;
+ i12 = HEAP32[i11 + 4 >> 2] | 0;
+ i3 = i9;
+ HEAP32[i3 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i3 + 4 >> 2] = i12;
+ HEAP32[i9 + 8 >> 2] = HEAP32[i4 >> 2];
+ i3 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i3 + 16;
+ i9 = i2;
+ i12 = HEAP32[i9 + 4 >> 2] | 0;
+ i11 = i3;
+ HEAP32[i11 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i11 + 4 >> 2] = i12;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ _luaD_call(i5, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i2 = HEAP32[i10 >> 2] | 0;
+ i3 = HEAP32[i7 >> 2] | 0;
+ i10 = i3 + -16 | 0;
+ HEAP32[i7 >> 2] = i10;
+ i11 = HEAP32[i10 + 4 >> 2] | 0;
+ i12 = i2 + i13 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAP32[i2 + (i13 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
+ i2 = HEAP32[i7 >> 2] | 0;
+ i3 = HEAP32[i2 + 8 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if ((i3 | 0) == 1) {
+ i2 = (HEAP32[i2 >> 2] | 0) != 0;
+ } else {
+ i2 = 1;
+ }
+ } else {
+ i2 = 0;
+ }
+ i13 = i2 & 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function ___udivmoddi4(i6, i8, i2, i4, i1) {
+ i6 = i6 | 0;
+ i8 = i8 | 0;
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i5 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i5 = i6;
+ i9 = i8;
+ i7 = i9;
+ i10 = i2;
+ i3 = i4;
+ i11 = i3;
+ if ((i7 | 0) == 0) {
+ i2 = (i1 | 0) != 0;
+ if ((i11 | 0) == 0) {
+ if (i2) {
+ HEAP32[i1 >> 2] = (i5 >>> 0) % (i10 >>> 0);
+ HEAP32[i1 + 4 >> 2] = 0;
+ }
+ i11 = 0;
+ i12 = (i5 >>> 0) / (i10 >>> 0) >>> 0;
+ return (tempRet0 = i11, i12) | 0;
+ } else {
+ if (!i2) {
+ i11 = 0;
+ i12 = 0;
+ return (tempRet0 = i11, i12) | 0;
+ }
+ HEAP32[i1 >> 2] = i6 | 0;
+ HEAP32[i1 + 4 >> 2] = i8 & 0;
+ i11 = 0;
+ i12 = 0;
+ return (tempRet0 = i11, i12) | 0;
+ }
+ }
+ i12 = (i11 | 0) == 0;
+ do {
+ if ((i10 | 0) != 0) {
+ if (!i12) {
+ i10 = (_llvm_ctlz_i32(i11 | 0) | 0) - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
+ if (i10 >>> 0 <= 31) {
+ i11 = i10 + 1 | 0;
+ i12 = 31 - i10 | 0;
+ i8 = i10 - 31 >> 31;
+ i9 = i11;
+ i6 = i5 >>> (i11 >>> 0) & i8 | i7 << i12;
+ i8 = i7 >>> (i11 >>> 0) & i8;
+ i11 = 0;
+ i7 = i5 << i12;
+ break;
+ }
+ if ((i1 | 0) == 0) {
+ i11 = 0;
+ i12 = 0;
+ return (tempRet0 = i11, i12) | 0;
+ }
+ HEAP32[i1 >> 2] = i6 | 0;
+ HEAP32[i1 + 4 >> 2] = i9 | i8 & 0;
+ i11 = 0;
+ i12 = 0;
+ return (tempRet0 = i11, i12) | 0;
+ }
+ i11 = i10 - 1 | 0;
+ if ((i11 & i10 | 0) != 0) {
+ i12 = (_llvm_ctlz_i32(i10 | 0) | 0) + 33 - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
+ i15 = 64 - i12 | 0;
+ i10 = 32 - i12 | 0;
+ i13 = i10 >> 31;
+ i14 = i12 - 32 | 0;
+ i8 = i14 >> 31;
+ i9 = i12;
+ i6 = i10 - 1 >> 31 & i7 >>> (i14 >>> 0) | (i7 << i10 | i5 >>> (i12 >>> 0)) & i8;
+ i8 = i8 & i7 >>> (i12 >>> 0);
+ i11 = i5 << i15 & i13;
+ i7 = (i7 << i15 | i5 >>> (i14 >>> 0)) & i13 | i5 << i10 & i12 - 33 >> 31;
+ break;
+ }
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = i11 & i5;
+ HEAP32[i1 + 4 >> 2] = 0;
+ }
+ if ((i10 | 0) == 1) {
+ i14 = i9 | i8 & 0;
+ i15 = i6 | 0 | 0;
+ return (tempRet0 = i14, i15) | 0;
+ } else {
+ i15 = _llvm_cttz_i32(i10 | 0) | 0;
+ i14 = i7 >>> (i15 >>> 0) | 0;
+ i15 = i7 << 32 - i15 | i5 >>> (i15 >>> 0) | 0;
+ return (tempRet0 = i14, i15) | 0;
+ }
+ } else {
+ if (i12) {
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = (i7 >>> 0) % (i10 >>> 0);
+ HEAP32[i1 + 4 >> 2] = 0;
+ }
+ i14 = 0;
+ i15 = (i7 >>> 0) / (i10 >>> 0) >>> 0;
+ return (tempRet0 = i14, i15) | 0;
+ }
+ if ((i5 | 0) == 0) {
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = 0;
+ HEAP32[i1 + 4 >> 2] = (i7 >>> 0) % (i11 >>> 0);
+ }
+ i14 = 0;
+ i15 = (i7 >>> 0) / (i11 >>> 0) >>> 0;
+ return (tempRet0 = i14, i15) | 0;
+ }
+ i10 = i11 - 1 | 0;
+ if ((i10 & i11 | 0) == 0) {
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = i6 | 0;
+ HEAP32[i1 + 4 >> 2] = i10 & i7 | i8 & 0;
+ }
+ i14 = 0;
+ i15 = i7 >>> ((_llvm_cttz_i32(i11 | 0) | 0) >>> 0);
+ return (tempRet0 = i14, i15) | 0;
+ }
+ i10 = (_llvm_ctlz_i32(i11 | 0) | 0) - (_llvm_ctlz_i32(i7 | 0) | 0) | 0;
+ if (i10 >>> 0 <= 30) {
+ i8 = i10 + 1 | 0;
+ i15 = 31 - i10 | 0;
+ i9 = i8;
+ i6 = i7 << i15 | i5 >>> (i8 >>> 0);
+ i8 = i7 >>> (i8 >>> 0);
+ i11 = 0;
+ i7 = i5 << i15;
+ break;
+ }
+ if ((i1 | 0) == 0) {
+ i14 = 0;
+ i15 = 0;
+ return (tempRet0 = i14, i15) | 0;
+ }
+ HEAP32[i1 >> 2] = i6 | 0;
+ HEAP32[i1 + 4 >> 2] = i9 | i8 & 0;
+ i14 = 0;
+ i15 = 0;
+ return (tempRet0 = i14, i15) | 0;
+ }
+ } while (0);
+ if ((i9 | 0) == 0) {
+ i12 = i6;
+ i2 = 0;
+ i6 = 0;
+ } else {
+ i2 = i2 | 0 | 0;
+ i3 = i3 | i4 & 0;
+ i4 = _i64Add(i2, i3, -1, -1) | 0;
+ i5 = tempRet0;
+ i10 = i8;
+ i12 = i6;
+ i6 = 0;
+ while (1) {
+ i8 = i11 >>> 31 | i7 << 1;
+ i11 = i6 | i11 << 1;
+ i7 = i12 << 1 | i7 >>> 31 | 0;
+ i10 = i12 >>> 31 | i10 << 1 | 0;
+ _i64Subtract(i4, i5, i7, i10) | 0;
+ i12 = tempRet0;
+ i15 = i12 >> 31 | ((i12 | 0) < 0 ? -1 : 0) << 1;
+ i6 = i15 & 1;
+ i12 = _i64Subtract(i7, i10, i15 & i2, (((i12 | 0) < 0 ? -1 : 0) >> 31 | ((i12 | 0) < 0 ? -1 : 0) << 1) & i3) | 0;
+ i10 = tempRet0;
+ i9 = i9 - 1 | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i8;
+ }
+ }
+ i7 = i8;
+ i8 = i10;
+ i2 = 0;
+ }
+ i3 = 0;
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = i12;
+ HEAP32[i1 + 4 >> 2] = i8;
+ }
+ i14 = (i11 | 0) >>> 31 | (i7 | i3) << 1 | (i3 << 1 | i11 >>> 31) & 0 | i2;
+ i15 = (i11 << 1 | 0 >>> 31) & -2 | i6;
+ return (tempRet0 = i14, i15) | 0;
+}
+function _leaveblock(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i3;
+ i7 = i1 + 16 | 0;
+ i4 = HEAP32[i7 >> 2] | 0;
+ i2 = i1 + 12 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ if ((HEAP32[i4 >> 2] | 0) != 0 ? (HEAP8[i4 + 9 | 0] | 0) != 0 : 0) {
+ i16 = _luaK_jump(i1) | 0;
+ _luaK_patchclose(i1, i16, HEAPU8[i4 + 8 | 0] | 0);
+ _luaK_patchtohere(i1, i16);
+ }
+ L5 : do {
+ if ((HEAP8[i4 + 10 | 0] | 0) != 0) {
+ i15 = i6 + 52 | 0;
+ i14 = _luaS_new(HEAP32[i15 >> 2] | 0, 6304) | 0;
+ i13 = i6 + 64 | 0;
+ i16 = HEAP32[i13 >> 2] | 0;
+ i10 = i16 + 24 | 0;
+ i8 = i6 + 48 | 0;
+ i11 = HEAP32[(HEAP32[i8 >> 2] | 0) + 20 >> 2] | 0;
+ i12 = i16 + 28 | 0;
+ i9 = HEAP32[i12 >> 2] | 0;
+ i16 = i16 + 32 | 0;
+ if ((i9 | 0) < (HEAP32[i16 >> 2] | 0)) {
+ i15 = HEAP32[i10 >> 2] | 0;
+ } else {
+ i15 = _luaM_growaux_(HEAP32[i15 >> 2] | 0, HEAP32[i10 >> 2] | 0, i16, 16, 32767, 6312) | 0;
+ HEAP32[i10 >> 2] = i15;
+ }
+ HEAP32[i15 + (i9 << 4) >> 2] = i14;
+ i16 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i16 + (i9 << 4) + 8 >> 2] = 0;
+ HEAP8[i16 + (i9 << 4) + 12 | 0] = HEAP8[(HEAP32[i8 >> 2] | 0) + 46 | 0] | 0;
+ HEAP32[(HEAP32[i10 >> 2] | 0) + (i9 << 4) + 4 >> 2] = i11;
+ HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + 1;
+ i10 = HEAP32[i13 >> 2] | 0;
+ i9 = (HEAP32[i10 + 24 >> 2] | 0) + (i9 << 4) | 0;
+ i11 = HEAP16[(HEAP32[(HEAP32[i8 >> 2] | 0) + 16 >> 2] | 0) + 6 >> 1] | 0;
+ i8 = i10 + 16 | 0;
+ if ((i11 | 0) < (HEAP32[i8 >> 2] | 0)) {
+ i10 = i10 + 12 | 0;
+ do {
+ while (1) {
+ if ((_luaS_eqstr(HEAP32[(HEAP32[i10 >> 2] | 0) + (i11 << 4) >> 2] | 0, HEAP32[i9 >> 2] | 0) | 0) == 0) {
+ break;
+ }
+ _closegoto(i6, i11, i9);
+ if ((i11 | 0) >= (HEAP32[i8 >> 2] | 0)) {
+ break L5;
+ }
+ }
+ i11 = i11 + 1 | 0;
+ } while ((i11 | 0) < (HEAP32[i8 >> 2] | 0));
+ }
+ }
+ } while (0);
+ HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
+ i7 = i4 + 8 | 0;
+ i9 = HEAP8[i7] | 0;
+ i10 = i1 + 46 | 0;
+ i8 = (HEAP32[i2 >> 2] | 0) + 64 | 0;
+ i14 = (HEAP32[i8 >> 2] | 0) + 4 | 0;
+ HEAP32[i14 >> 2] = (i9 & 255) - (HEAPU8[i10] | 0) + (HEAP32[i14 >> 2] | 0);
+ i14 = HEAP8[i10] | 0;
+ if ((i14 & 255) > (i9 & 255)) {
+ i13 = i1 + 20 | 0;
+ i11 = i1 + 40 | 0;
+ i12 = (HEAP32[i1 >> 2] | 0) + 24 | 0;
+ do {
+ i16 = HEAP32[i13 >> 2] | 0;
+ i14 = i14 + -1 << 24 >> 24;
+ HEAP8[i10] = i14;
+ HEAP32[(HEAP32[i12 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[i8 >> 2] >> 2] | 0) + ((HEAP32[i11 >> 2] | 0) + (i14 & 255) << 1) >> 1] | 0) * 12 | 0) + 8 >> 2] = i16;
+ i14 = HEAP8[i10] | 0;
+ } while ((i14 & 255) > (i9 & 255));
+ }
+ HEAP8[i1 + 48 | 0] = i14;
+ i10 = HEAP32[i6 + 64 >> 2] | 0;
+ HEAP32[i10 + 28 >> 2] = HEAP16[i4 + 4 >> 1] | 0;
+ i9 = HEAP16[i4 + 6 >> 1] | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ if ((i9 | 0) >= (HEAP32[i10 + 16 >> 2] | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ i10 = HEAP32[i10 + 12 >> 2] | 0;
+ i11 = HEAP32[i10 + (i9 << 4) >> 2] | 0;
+ if ((HEAP8[i11 + 4 | 0] | 0) != 4) {
+ i16 = 6200;
+ i15 = i6 + 52 | 0;
+ i15 = HEAP32[i15 >> 2] | 0;
+ i14 = i11 + 16 | 0;
+ i13 = i10 + (i9 << 4) + 8 | 0;
+ i13 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i5 >> 2] = i14;
+ i14 = i5 + 4 | 0;
+ HEAP32[i14 >> 2] = i13;
+ i16 = _luaO_pushfstring(i15, i16, i5) | 0;
+ _semerror(i6, i16);
+ }
+ i16 = (HEAP8[i11 + 6 | 0] | 0) != 0 ? 6160 : 6200;
+ i15 = i6 + 52 | 0;
+ i15 = HEAP32[i15 >> 2] | 0;
+ i14 = i11 + 16 | 0;
+ i13 = i10 + (i9 << 4) + 8 | 0;
+ i13 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i5 >> 2] = i14;
+ i14 = i5 + 4 | 0;
+ HEAP32[i14 >> 2] = i13;
+ i16 = _luaO_pushfstring(i15, i16, i5) | 0;
+ _semerror(i6, i16);
+ }
+ i6 = HEAP32[i8 >> 2] | 0;
+ i5 = i6 + 16 | 0;
+ if ((i9 | 0) >= (HEAP32[i5 >> 2] | 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ i6 = i6 + 12 | 0;
+ i4 = i4 + 9 | 0;
+ do {
+ i10 = HEAP32[i6 >> 2] | 0;
+ i8 = i10 + (i9 << 4) + 12 | 0;
+ i11 = HEAP8[i7] | 0;
+ i12 = i11 & 255;
+ if ((HEAPU8[i8] | 0) > (i11 & 255)) {
+ if ((HEAP8[i4] | 0) != 0) {
+ _luaK_patchclose(i1, HEAP32[i10 + (i9 << 4) + 4 >> 2] | 0, i12);
+ i11 = HEAP8[i7] | 0;
+ }
+ HEAP8[i8] = i11;
+ }
+ i9 = ((_findlabel(HEAP32[i2 >> 2] | 0, i9) | 0) == 0) + i9 | 0;
+ } while ((i9 | 0) < (HEAP32[i5 >> 2] | 0));
+ STACKTOP = i3;
+ return;
+}
+function _getobjname(i3, i7, i9, i2) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ i9 = i9 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ i4 = i3 + 12 | 0;
+ L1 : while (1) {
+ i13 = _luaF_getlocalname(i3, i9 + 1 | 0, i7) | 0;
+ HEAP32[i2 >> 2] = i13;
+ if ((i13 | 0) != 0) {
+ i2 = 2040;
+ i4 = 42;
+ break;
+ }
+ if ((i7 | 0) <= 0) {
+ i2 = 0;
+ i4 = 42;
+ break;
+ }
+ i6 = HEAP32[i4 >> 2] | 0;
+ i8 = 0;
+ i5 = -1;
+ do {
+ i12 = HEAP32[i6 + (i8 << 2) >> 2] | 0;
+ i13 = i12 & 63;
+ i11 = i12 >>> 6 & 255;
+ switch (i13 | 0) {
+ case 27:
+ {
+ i10 = i8;
+ i5 = (i11 | 0) == (i9 | 0) ? i8 : i5;
+ break;
+ }
+ case 30:
+ case 29:
+ {
+ i10 = i8;
+ i5 = (i11 | 0) > (i9 | 0) ? i5 : i8;
+ break;
+ }
+ case 23:
+ {
+ i10 = (i12 >>> 14) + -131071 | 0;
+ i13 = i8 + 1 + i10 | 0;
+ i10 = ((i8 | 0) >= (i13 | 0) | (i13 | 0) > (i7 | 0) ? 0 : i10) + i8 | 0;
+ break;
+ }
+ case 4:
+ {
+ if ((i11 | 0) > (i9 | 0)) {
+ i10 = i8;
+ } else {
+ i10 = i8;
+ i5 = (i11 + (i12 >>> 23) | 0) < (i9 | 0) ? i5 : i8;
+ }
+ break;
+ }
+ case 34:
+ {
+ i10 = i8;
+ i5 = (i11 + 2 | 0) > (i9 | 0) ? i5 : i8;
+ break;
+ }
+ default:
+ {
+ i10 = i8;
+ i5 = (HEAP8[5584 + i13 | 0] & 64) != 0 & (i11 | 0) == (i9 | 0) ? i8 : i5;
+ }
+ }
+ i8 = i10 + 1 | 0;
+ } while ((i8 | 0) < (i7 | 0));
+ if ((i5 | 0) == -1) {
+ i2 = 0;
+ i4 = 42;
+ break;
+ }
+ i7 = HEAP32[i6 + (i5 << 2) >> 2] | 0;
+ i9 = i7 & 63;
+ switch (i9 | 0) {
+ case 0:
+ {
+ break;
+ }
+ case 7:
+ case 6:
+ {
+ i4 = 17;
+ break L1;
+ }
+ case 5:
+ {
+ i4 = 29;
+ break L1;
+ }
+ case 1:
+ {
+ i4 = 32;
+ break L1;
+ }
+ case 2:
+ {
+ i4 = 33;
+ break L1;
+ }
+ case 12:
+ {
+ i4 = 36;
+ break L1;
+ }
+ default:
+ {
+ i2 = 0;
+ i4 = 42;
+ break L1;
+ }
+ }
+ i9 = i7 >>> 23;
+ if (i9 >>> 0 < (i7 >>> 6 & 255) >>> 0) {
+ i7 = i5;
+ } else {
+ i2 = 0;
+ i4 = 42;
+ break;
+ }
+ }
+ if ((i4 | 0) == 17) {
+ i6 = i7 >>> 14;
+ i8 = i6 & 511;
+ i7 = i7 >>> 23;
+ if ((i9 | 0) != 7) {
+ i7 = HEAP32[(HEAP32[i3 + 28 >> 2] | 0) + (i7 << 3) >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i7 = 2104;
+ } else {
+ i7 = i7 + 16 | 0;
+ }
+ } else {
+ i7 = _luaF_getlocalname(i3, i7 + 1 | 0, i5) | 0;
+ }
+ if ((i6 & 256 | 0) == 0) {
+ i3 = _getobjname(i3, i5, i8, i2) | 0;
+ if (!((i3 | 0) != 0 ? (HEAP8[i3] | 0) == 99 : 0)) {
+ i4 = 26;
+ }
+ } else {
+ i5 = i6 & 255;
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + (i5 << 4) + 8 >> 2] & 15 | 0) == 4) {
+ HEAP32[i2 >> 2] = (HEAP32[i3 + (i5 << 4) >> 2] | 0) + 16;
+ } else {
+ i4 = 26;
+ }
+ }
+ if ((i4 | 0) == 26) {
+ HEAP32[i2 >> 2] = 2104;
+ }
+ if ((i7 | 0) == 0) {
+ i13 = 2064;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i13 = (_strcmp(i7, 2048) | 0) == 0;
+ i13 = i13 ? 2056 : 2064;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else if ((i4 | 0) == 29) {
+ i3 = HEAP32[(HEAP32[i3 + 28 >> 2] | 0) + (i7 >>> 23 << 3) >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 2104;
+ } else {
+ i3 = i3 + 16 | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ i13 = 2072;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else if ((i4 | 0) == 32) {
+ i5 = i7 >>> 14;
+ } else if ((i4 | 0) == 33) {
+ i5 = (HEAP32[i6 + (i5 + 1 << 2) >> 2] | 0) >>> 6;
+ } else if ((i4 | 0) == 36) {
+ i4 = i7 >>> 14;
+ if ((i4 & 256 | 0) == 0) {
+ i3 = _getobjname(i3, i5, i4 & 511, i2) | 0;
+ if ((i3 | 0) != 0 ? (HEAP8[i3] | 0) == 99 : 0) {
+ i13 = 2096;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ } else {
+ i4 = i4 & 255;
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + (i4 << 4) + 8 >> 2] & 15 | 0) == 4) {
+ HEAP32[i2 >> 2] = (HEAP32[i3 + (i4 << 4) >> 2] | 0) + 16;
+ i13 = 2096;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ }
+ HEAP32[i2 >> 2] = 2104;
+ i13 = 2096;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else if ((i4 | 0) == 42) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + (i5 << 4) + 8 >> 2] & 15 | 0) != 4) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ HEAP32[i2 >> 2] = (HEAP32[i3 + (i5 << 4) >> 2] | 0) + 16;
+ i13 = 2080;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _assignment(i2, i16, i5) {
+ i2 = i2 | 0;
+ i16 = i16 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 80 | 0;
+ i6 = i3 + 56 | 0;
+ i1 = i3 + 32 | 0;
+ i8 = i3;
+ i4 = i16 + 8 | 0;
+ if (!(((HEAP32[i4 >> 2] | 0) + -7 | 0) >>> 0 < 3)) {
+ _luaX_syntaxerror(i2, 6344);
+ }
+ i13 = i2 + 16 | 0;
+ i14 = HEAP32[i13 >> 2] | 0;
+ do {
+ if ((i14 | 0) == 44) {
+ _luaX_next(i2);
+ HEAP32[i8 >> 2] = i16;
+ i14 = i8 + 8 | 0;
+ _suffixedexp(i2, i14);
+ i15 = i2 + 48 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != 9 ? (i10 = HEAP32[i15 >> 2] | 0, i11 = HEAP8[i10 + 48 | 0] | 0, i9 = i11 & 255, (i16 | 0) != 0) : 0) {
+ i13 = i8 + 16 | 0;
+ i12 = i11 & 255;
+ i18 = 0;
+ do {
+ if ((HEAP32[i16 + 8 >> 2] | 0) == 9) {
+ i17 = i16 + 16 | 0;
+ i19 = i17 + 3 | 0;
+ i20 = HEAPU8[i19] | 0;
+ i21 = HEAP32[i14 >> 2] | 0;
+ if ((i20 | 0) == (i21 | 0)) {
+ i21 = i17 + 2 | 0;
+ if ((HEAPU8[i21] | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP8[i19] = 7;
+ HEAP8[i21] = i11;
+ i20 = HEAP32[i14 >> 2] | 0;
+ i18 = 1;
+ }
+ } else {
+ i20 = i21;
+ }
+ if ((i20 | 0) == 7 ? (HEAP16[i17 >> 1] | 0) == (HEAP32[i13 >> 2] | 0) : 0) {
+ HEAP16[i17 >> 1] = i12;
+ i18 = 1;
+ }
+ }
+ i16 = HEAP32[i16 >> 2] | 0;
+ } while ((i16 | 0) != 0);
+ if ((i18 | 0) != 0) {
+ _luaK_codeABC(i10, (HEAP32[i14 >> 2] | 0) == 7 ? 0 : 5, i9, HEAP32[i13 >> 2] | 0, 0) | 0;
+ _luaK_reserveregs(i10, 1);
+ }
+ }
+ i9 = HEAP32[i15 >> 2] | 0;
+ if (((HEAPU16[(HEAP32[i2 + 52 >> 2] | 0) + 38 >> 1] | 0) + i5 | 0) <= 200) {
+ _assignment(i2, i8, i5 + 1 | 0);
+ i7 = i1;
+ break;
+ }
+ i8 = i9 + 12 | 0;
+ i5 = HEAP32[(HEAP32[i8 >> 2] | 0) + 52 >> 2] | 0;
+ i9 = HEAP32[(HEAP32[i9 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i20 = 6552;
+ HEAP32[i6 >> 2] = 6360;
+ i21 = i6 + 4 | 0;
+ HEAP32[i21 >> 2] = 200;
+ i21 = i6 + 8 | 0;
+ HEAP32[i21 >> 2] = i20;
+ i21 = _luaO_pushfstring(i5, 6592, i6) | 0;
+ i20 = HEAP32[i8 >> 2] | 0;
+ _luaX_syntaxerror(i20, i21);
+ }
+ HEAP32[i6 >> 2] = i9;
+ i20 = _luaO_pushfstring(i5, 6568, i6) | 0;
+ HEAP32[i6 >> 2] = 6360;
+ i21 = i6 + 4 | 0;
+ HEAP32[i21 >> 2] = 200;
+ i21 = i6 + 8 | 0;
+ HEAP32[i21 >> 2] = i20;
+ i21 = _luaO_pushfstring(i5, 6592, i6) | 0;
+ i20 = HEAP32[i8 >> 2] | 0;
+ _luaX_syntaxerror(i20, i21);
+ } else if ((i14 | 0) == 61) {
+ _luaX_next(i2);
+ _subexpr(i2, i1, 0) | 0;
+ i6 = i2 + 48 | 0;
+ if ((HEAP32[i13 >> 2] | 0) == 44) {
+ i9 = 1;
+ do {
+ _luaX_next(i2);
+ _luaK_exp2nextreg(HEAP32[i6 >> 2] | 0, i1);
+ _subexpr(i2, i1, 0) | 0;
+ i9 = i9 + 1 | 0;
+ } while ((HEAP32[i13 >> 2] | 0) == 44);
+ } else {
+ i9 = 1;
+ }
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i9 | 0) == (i5 | 0)) {
+ _luaK_setoneret(i8, i1);
+ _luaK_storevar(HEAP32[i6 >> 2] | 0, i4, i1);
+ STACKTOP = i3;
+ return;
+ }
+ i7 = i5 - i9 | 0;
+ i10 = HEAP32[i1 >> 2] | 0;
+ if ((i10 | 0) == 13 | (i10 | 0) == 12) {
+ i10 = i7 + 1 | 0;
+ i10 = (i10 | 0) < 0 ? 0 : i10;
+ _luaK_setreturns(i8, i1, i10);
+ if ((i10 | 0) > 1) {
+ _luaK_reserveregs(i8, i10 + -1 | 0);
+ }
+ } else if ((i10 | 0) == 0) {
+ i12 = 30;
+ } else {
+ _luaK_exp2nextreg(i8, i1);
+ i12 = 30;
+ }
+ if ((i12 | 0) == 30 ? (i7 | 0) > 0 : 0) {
+ i21 = HEAPU8[i8 + 48 | 0] | 0;
+ _luaK_reserveregs(i8, i7);
+ _luaK_nil(i8, i21, i7);
+ }
+ if ((i9 | 0) > (i5 | 0)) {
+ i21 = (HEAP32[i6 >> 2] | 0) + 48 | 0;
+ HEAP8[i21] = i7 + (HEAPU8[i21] | 0);
+ i7 = i1;
+ } else {
+ i7 = i1;
+ }
+ } else {
+ _error_expected(i2, 61);
+ }
+ } while (0);
+ i21 = HEAP32[i2 + 48 >> 2] | 0;
+ i20 = (HEAPU8[i21 + 48 | 0] | 0) + -1 | 0;
+ HEAP32[i1 + 16 >> 2] = -1;
+ HEAP32[i1 + 20 >> 2] = -1;
+ HEAP32[i7 >> 2] = 6;
+ HEAP32[i1 + 8 >> 2] = i20;
+ _luaK_storevar(i21, i4, i1);
+ STACKTOP = i3;
+ return;
+}
+function _str_find_aux(i3, i7) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 288 | 0;
+ i9 = i1 + 284 | 0;
+ i5 = i1 + 280 | 0;
+ i4 = i1;
+ i2 = _luaL_checklstring(i3, 1, i9) | 0;
+ i8 = _luaL_checklstring(i3, 2, i5) | 0;
+ i12 = _luaL_optinteger(i3, 3, 1) | 0;
+ i10 = HEAP32[i9 >> 2] | 0;
+ if (!((i12 | 0) > -1)) {
+ if (i10 >>> 0 < (0 - i12 | 0) >>> 0) {
+ i12 = 1;
+ } else {
+ i12 = i12 + 1 + i10 | 0;
+ i6 = 4;
+ }
+ } else {
+ i6 = 4;
+ }
+ if ((i6 | 0) == 4) {
+ if ((i12 | 0) != 0) {
+ if (i12 >>> 0 > (i10 + 1 | 0) >>> 0) {
+ _lua_pushnil(i3);
+ i13 = 1;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ } else {
+ i12 = 1;
+ }
+ }
+ i7 = (i7 | 0) != 0;
+ L10 : do {
+ if (i7) {
+ i13 = (_lua_toboolean(i3, 4) | 0) == 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ if (i13) {
+ i11 = 0;
+ do {
+ i13 = i8 + i11 | 0;
+ if ((_strpbrk(i13, 7512) | 0) != 0) {
+ i6 = 20;
+ break L10;
+ }
+ i11 = i11 + 1 + (_strlen(i13 | 0) | 0) | 0;
+ } while (!(i11 >>> 0 > i10 >>> 0));
+ }
+ i11 = i2 + (i12 + -1) | 0;
+ i9 = (HEAP32[i9 >> 2] | 0) - i12 + 1 | 0;
+ L17 : do {
+ if ((i10 | 0) == 0) {
+ if ((i11 | 0) == 0) {
+ break L10;
+ }
+ } else {
+ if (i10 >>> 0 > i9 >>> 0) {
+ break L10;
+ }
+ i4 = i10 + -1 | 0;
+ if ((i4 | 0) == (i9 | 0)) {
+ break L10;
+ }
+ i7 = HEAP8[i8] | 0;
+ i8 = i8 + 1 | 0;
+ i9 = i9 - i4 | 0;
+ i12 = i11;
+ while (1) {
+ i11 = _memchr(i12, i7, i9) | 0;
+ if ((i11 | 0) == 0) {
+ break L10;
+ }
+ i10 = i11 + 1 | 0;
+ if ((_memcmp(i10, i8, i4) | 0) == 0) {
+ break L17;
+ }
+ i11 = i10;
+ i9 = i12 + i9 | 0;
+ if ((i9 | 0) == (i11 | 0)) {
+ break L10;
+ } else {
+ i9 = i9 - i11 | 0;
+ i12 = i10;
+ }
+ }
+ }
+ } while (0);
+ i13 = i11 - i2 | 0;
+ _lua_pushinteger(i3, i13 + 1 | 0);
+ _lua_pushinteger(i3, i13 + (HEAP32[i5 >> 2] | 0) | 0);
+ i13 = 2;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else {
+ i6 = 20;
+ }
+ } while (0);
+ L28 : do {
+ if ((i6 | 0) == 20) {
+ i6 = i2 + (i12 + -1) | 0;
+ i10 = (HEAP8[i8] | 0) == 94;
+ if (i10) {
+ i12 = (HEAP32[i5 >> 2] | 0) + -1 | 0;
+ HEAP32[i5 >> 2] = i12;
+ i8 = i8 + 1 | 0;
+ } else {
+ i12 = HEAP32[i5 >> 2] | 0;
+ }
+ i5 = i4 + 16 | 0;
+ HEAP32[i5 >> 2] = i3;
+ HEAP32[i4 >> 2] = 200;
+ HEAP32[i4 + 4 >> 2] = i2;
+ i11 = i4 + 8 | 0;
+ HEAP32[i11 >> 2] = i2 + (HEAP32[i9 >> 2] | 0);
+ HEAP32[i4 + 12 >> 2] = i8 + i12;
+ i9 = i4 + 20 | 0;
+ L34 : do {
+ if (i10) {
+ HEAP32[i9 >> 2] = 0;
+ i8 = _match(i4, i6, i8) | 0;
+ if ((i8 | 0) == 0) {
+ break L28;
+ }
+ } else {
+ while (1) {
+ HEAP32[i9 >> 2] = 0;
+ i10 = _match(i4, i6, i8) | 0;
+ if ((i10 | 0) != 0) {
+ i8 = i10;
+ break L34;
+ }
+ if (!(i6 >>> 0 < (HEAP32[i11 >> 2] | 0) >>> 0)) {
+ break L28;
+ }
+ i6 = i6 + 1 | 0;
+ }
+ }
+ } while (0);
+ if (i7) {
+ _lua_pushinteger(i3, 1 - i2 + i6 | 0);
+ _lua_pushinteger(i3, i8 - i2 | 0);
+ i2 = HEAP32[i9 >> 2] | 0;
+ _luaL_checkstack(HEAP32[i5 >> 2] | 0, i2, 7200);
+ if ((i2 | 0) > 0) {
+ i3 = 0;
+ do {
+ _push_onecapture(i4, i3, 0, 0);
+ i3 = i3 + 1 | 0;
+ } while ((i3 | 0) != (i2 | 0));
+ }
+ i13 = i2 + 2 | 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ } else {
+ i3 = HEAP32[i9 >> 2] | 0;
+ i2 = (i3 | 0) != 0 | (i6 | 0) == 0 ? i3 : 1;
+ _luaL_checkstack(HEAP32[i5 >> 2] | 0, i2, 7200);
+ if ((i2 | 0) > 0) {
+ i3 = 0;
+ } else {
+ i13 = i3;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ do {
+ _push_onecapture(i4, i3, i6, i8);
+ i3 = i3 + 1 | 0;
+ } while ((i3 | 0) != (i2 | 0));
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ }
+ } while (0);
+ _lua_pushnil(i3);
+ i13 = 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _luaO_pushvfstring(i2, i13, i10) {
+ i2 = i2 | 0;
+ i13 = i13 | 0;
+ i10 = i10 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, d18 = 0.0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i7 = i3;
+ i9 = i3 + 32 | 0;
+ i8 = i3 + 8 | 0;
+ i14 = _strchr(i13, 37) | 0;
+ i6 = i2 + 24 | 0;
+ i4 = i2 + 8 | 0;
+ i15 = HEAP32[i4 >> 2] | 0;
+ i17 = (HEAP32[i6 >> 2] | 0) - i15 | 0;
+ L1 : do {
+ if ((i14 | 0) == 0) {
+ i5 = i13;
+ i11 = i17;
+ i12 = i15;
+ i1 = 0;
+ } else {
+ i16 = 0;
+ L3 : while (1) {
+ if ((i17 | 0) < 48) {
+ _luaD_growstack(i2, 2);
+ i15 = HEAP32[i4 >> 2] | 0;
+ }
+ HEAP32[i4 >> 2] = i15 + 16;
+ i13 = _luaS_newlstr(i2, i13, i14 - i13 | 0) | 0;
+ HEAP32[i15 >> 2] = i13;
+ HEAP32[i15 + 8 >> 2] = HEAPU8[i13 + 4 | 0] | 64;
+ i13 = HEAP8[i14 + 1 | 0] | 0;
+ switch (i13 | 0) {
+ case 115:
+ {
+ i17 = HEAP32[i10 >> 2] | 0;
+ i13 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i10 >> 2] = i17 + 4;
+ i13 = (i13 | 0) == 0 ? 5480 : i13;
+ i15 = _strlen(i13 | 0) | 0;
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i15 = _luaS_newlstr(i2, i13, i15) | 0;
+ HEAP32[i17 >> 2] = i15;
+ HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
+ break;
+ }
+ case 100:
+ {
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i13 = HEAP32[i10 >> 2] | 0;
+ i15 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i10 >> 2] = i13 + 4;
+ HEAPF64[i17 >> 3] = +(i15 | 0);
+ HEAP32[i17 + 8 >> 2] = 3;
+ break;
+ }
+ case 37:
+ {
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i15 = _luaS_newlstr(i2, 5496, 1) | 0;
+ HEAP32[i17 >> 2] = i15;
+ HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
+ break;
+ }
+ case 99:
+ {
+ i15 = HEAP32[i10 >> 2] | 0;
+ i17 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i10 >> 2] = i15 + 4;
+ HEAP8[i9] = i17;
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i15 = _luaS_newlstr(i2, i9, 1) | 0;
+ HEAP32[i17 >> 2] = i15;
+ HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
+ break;
+ }
+ case 102:
+ {
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i15 = HEAP32[i10 >> 2] | 0;
+ d18 = +HEAPF64[i15 >> 3];
+ HEAP32[i10 >> 2] = i15 + 8;
+ HEAPF64[i17 >> 3] = d18;
+ HEAP32[i17 + 8 >> 2] = 3;
+ break;
+ }
+ case 112:
+ {
+ i17 = HEAP32[i10 >> 2] | 0;
+ i15 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i10 >> 2] = i17 + 4;
+ HEAP32[i7 >> 2] = i15;
+ i15 = _sprintf(i8 | 0, 5488, i7 | 0) | 0;
+ i17 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i17 + 16;
+ i15 = _luaS_newlstr(i2, i8, i15) | 0;
+ HEAP32[i17 >> 2] = i15;
+ HEAP32[i17 + 8 >> 2] = HEAPU8[i15 + 4 | 0] | 64;
+ break;
+ }
+ default:
+ {
+ break L3;
+ }
+ }
+ i16 = i16 + 2 | 0;
+ i13 = i14 + 2 | 0;
+ i14 = _strchr(i13, 37) | 0;
+ i15 = HEAP32[i4 >> 2] | 0;
+ i17 = (HEAP32[i6 >> 2] | 0) - i15 | 0;
+ if ((i14 | 0) == 0) {
+ i5 = i13;
+ i11 = i17;
+ i12 = i15;
+ i1 = i16;
+ break L1;
+ }
+ }
+ HEAP32[i7 >> 2] = i13;
+ _luaG_runerror(i2, 5504, i7);
+ }
+ } while (0);
+ if ((i11 | 0) < 32) {
+ _luaD_growstack(i2, 1);
+ i12 = HEAP32[i4 >> 2] | 0;
+ }
+ i17 = _strlen(i5 | 0) | 0;
+ HEAP32[i4 >> 2] = i12 + 16;
+ i17 = _luaS_newlstr(i2, i5, i17) | 0;
+ HEAP32[i12 >> 2] = i17;
+ HEAP32[i12 + 8 >> 2] = HEAPU8[i17 + 4 | 0] | 64;
+ if ((i1 | 0) <= 0) {
+ i17 = HEAP32[i4 >> 2] | 0;
+ i17 = i17 + -16 | 0;
+ i17 = HEAP32[i17 >> 2] | 0;
+ i17 = i17 + 16 | 0;
+ STACKTOP = i3;
+ return i17 | 0;
+ }
+ _luaV_concat(i2, i1 | 1);
+ i17 = HEAP32[i4 >> 2] | 0;
+ i17 = i17 + -16 | 0;
+ i17 = HEAP32[i17 >> 2] | 0;
+ i17 = i17 + 16 | 0;
+ STACKTOP = i3;
+ return i17 | 0;
+}
+function _luaH_getn(i6) {
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ i3 = i6 + 28 | 0;
+ i12 = HEAP32[i3 >> 2] | 0;
+ if ((i12 | 0) != 0 ? (i4 = HEAP32[i6 + 12 >> 2] | 0, (HEAP32[i4 + (i12 + -1 << 4) + 8 >> 2] | 0) == 0) : 0) {
+ if (i12 >>> 0 > 1) {
+ i10 = 0;
+ } else {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ do {
+ i2 = (i10 + i12 | 0) >>> 1;
+ i3 = (HEAP32[i4 + (i2 + -1 << 4) + 8 >> 2] | 0) == 0;
+ i12 = i3 ? i2 : i12;
+ i10 = i3 ? i10 : i2;
+ } while ((i12 - i10 | 0) >>> 0 > 1);
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i4 = i6 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 8016) {
+ i13 = i12;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i5 = i6 + 12 | 0;
+ i6 = i6 + 7 | 0;
+ i9 = i2 + 4 | 0;
+ i8 = i12 + 1 | 0;
+ i13 = i12;
+ i10 = i12;
+ while (1) {
+ i12 = i8 + -1 | 0;
+ L15 : do {
+ if (i12 >>> 0 < i13 >>> 0) {
+ i12 = (HEAP32[i5 >> 2] | 0) + (i12 << 4) | 0;
+ } else {
+ d11 = +(i8 | 0);
+ HEAPF64[i2 >> 3] = d11 + 1.0;
+ i13 = (HEAP32[i9 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
+ if ((i13 | 0) < 0) {
+ i12 = 0 - i13 | 0;
+ i13 = (i13 | 0) == (i12 | 0) ? 0 : i12;
+ }
+ i12 = (HEAP32[i4 >> 2] | 0) + (((i13 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i12 + 24 >> 2] | 0) == 3 ? +HEAPF64[i12 + 16 >> 3] == d11 : 0) {
+ break;
+ }
+ i12 = HEAP32[i12 + 28 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i12 = 5192;
+ break L15;
+ }
+ }
+ }
+ } while (0);
+ if ((HEAP32[i12 + 8 >> 2] | 0) == 0) {
+ break;
+ }
+ i10 = i8 << 1;
+ if (i10 >>> 0 > 2147483645) {
+ i7 = 21;
+ break;
+ }
+ i12 = i8;
+ i8 = i10;
+ i13 = HEAP32[i3 >> 2] | 0;
+ i10 = i12;
+ }
+ if ((i7 | 0) == 21) {
+ i8 = i2 + 4 | 0;
+ i7 = 1;
+ while (1) {
+ i10 = i7 + -1 | 0;
+ L34 : do {
+ if (i10 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0) {
+ i9 = (HEAP32[i5 >> 2] | 0) + (i10 << 4) | 0;
+ } else {
+ d11 = +(i7 | 0);
+ HEAPF64[i2 >> 3] = d11 + 1.0;
+ i9 = (HEAP32[i8 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
+ if ((i9 | 0) < 0) {
+ i12 = 0 - i9 | 0;
+ i9 = (i9 | 0) == (i12 | 0) ? 0 : i12;
+ }
+ i9 = (HEAP32[i4 >> 2] | 0) + (((i9 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i9 + 24 >> 2] | 0) == 3 ? +HEAPF64[i9 + 16 >> 3] == d11 : 0) {
+ break;
+ }
+ i9 = HEAP32[i9 + 28 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = 5192;
+ break L34;
+ }
+ }
+ }
+ } while (0);
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ break;
+ }
+ i7 = i7 + 1 | 0;
+ }
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ if (!((i8 - i10 | 0) >>> 0 > 1)) {
+ i13 = i10;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i7 = i2 + 4 | 0;
+ do {
+ i9 = (i8 + i10 | 0) >>> 1;
+ i12 = i9 + -1 | 0;
+ L55 : do {
+ if (i12 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0) {
+ i12 = (HEAP32[i5 >> 2] | 0) + (i12 << 4) | 0;
+ } else {
+ d11 = +(i9 | 0);
+ HEAPF64[i2 >> 3] = d11 + 1.0;
+ i13 = (HEAP32[i7 >> 2] | 0) + (HEAP32[i2 >> 2] | 0) | 0;
+ if ((i13 | 0) < 0) {
+ i12 = 0 - i13 | 0;
+ i13 = (i13 | 0) == (i12 | 0) ? 0 : i12;
+ }
+ i12 = (HEAP32[i4 >> 2] | 0) + (((i13 | 0) % ((1 << (HEAPU8[i6] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i12 + 24 >> 2] | 0) == 3 ? +HEAPF64[i12 + 16 >> 3] == d11 : 0) {
+ break;
+ }
+ i12 = HEAP32[i12 + 28 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i12 = 5192;
+ break L55;
+ }
+ }
+ }
+ } while (0);
+ i12 = (HEAP32[i12 + 8 >> 2] | 0) == 0;
+ i8 = i12 ? i9 : i8;
+ i10 = i12 ? i10 : i9;
+ } while ((i8 - i10 | 0) >>> 0 > 1);
+ STACKTOP = i1;
+ return i10 | 0;
+}
+function _lua_resume(i4, i3, i7) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i3 | 0) == 0) {
+ i5 = 1;
+ } else {
+ i5 = (HEAPU16[i3 + 38 >> 1] | 0) + 1 & 65535;
+ }
+ i3 = i4 + 38 | 0;
+ HEAP16[i3 >> 1] = i5;
+ i5 = i4 + 36 | 0;
+ HEAP16[i5 >> 1] = 0;
+ i6 = i4 + 8 | 0;
+ i13 = _luaD_rawrunprotected(i4, 4, (HEAP32[i6 >> 2] | 0) + (0 - i7 << 4) | 0) | 0;
+ if ((i13 | 0) == -1) {
+ i18 = 2;
+ HEAP16[i5 >> 1] = 1;
+ i17 = HEAP16[i3 >> 1] | 0;
+ i17 = i17 + -1 << 16 >> 16;
+ HEAP16[i3 >> 1] = i17;
+ STACKTOP = i1;
+ return i18 | 0;
+ }
+ if (!(i13 >>> 0 > 1)) {
+ i18 = i13;
+ HEAP16[i5 >> 1] = 1;
+ i17 = HEAP16[i3 >> 1] | 0;
+ i17 = i17 + -1 << 16 >> 16;
+ HEAP16[i3 >> 1] = i17;
+ STACKTOP = i1;
+ return i18 | 0;
+ }
+ i7 = i4 + 16 | 0;
+ i12 = i4 + 28 | 0;
+ i11 = i4 + 41 | 0;
+ i10 = i4 + 68 | 0;
+ i9 = i4 + 32 | 0;
+ i8 = i4 + 12 | 0;
+ L10 : while (1) {
+ i15 = HEAP32[i7 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ }
+ while (1) {
+ i14 = i15 + 18 | 0;
+ if (!((HEAP8[i14] & 16) == 0)) {
+ break;
+ }
+ i15 = HEAP32[i15 + 8 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break L10;
+ }
+ }
+ i16 = HEAP32[i12 >> 2] | 0;
+ i17 = HEAP32[i15 + 20 >> 2] | 0;
+ i18 = i16 + i17 | 0;
+ _luaF_close(i4, i18);
+ if ((i13 | 0) == 4) {
+ i19 = HEAP32[(HEAP32[i8 >> 2] | 0) + 180 >> 2] | 0;
+ HEAP32[i18 >> 2] = i19;
+ HEAP32[i16 + (i17 + 8) >> 2] = HEAPU8[i19 + 4 | 0] | 0 | 64;
+ } else if ((i13 | 0) == 6) {
+ i19 = _luaS_newlstr(i4, 2424, 23) | 0;
+ HEAP32[i18 >> 2] = i19;
+ HEAP32[i16 + (i17 + 8) >> 2] = HEAPU8[i19 + 4 | 0] | 0 | 64;
+ } else {
+ i19 = HEAP32[i6 >> 2] | 0;
+ i21 = i19 + -16 | 0;
+ i20 = HEAP32[i21 + 4 >> 2] | 0;
+ HEAP32[i18 >> 2] = HEAP32[i21 >> 2];
+ HEAP32[i18 + 4 >> 2] = i20;
+ HEAP32[i16 + (i17 + 8) >> 2] = HEAP32[i19 + -8 >> 2];
+ }
+ i17 = i16 + (i17 + 16) | 0;
+ HEAP32[i6 >> 2] = i17;
+ HEAP32[i7 >> 2] = i15;
+ HEAP8[i11] = HEAP8[i15 + 36 | 0] | 0;
+ HEAP16[i5 >> 1] = 0;
+ if ((i15 | 0) != 0) {
+ i16 = i15;
+ do {
+ i18 = HEAP32[i16 + 4 >> 2] | 0;
+ i17 = i17 >>> 0 < i18 >>> 0 ? i18 : i17;
+ i16 = HEAP32[i16 + 8 >> 2] | 0;
+ } while ((i16 | 0) != 0);
+ }
+ i16 = i17 - (HEAP32[i12 >> 2] | 0) | 0;
+ i17 = (i16 >> 4) + 1 | 0;
+ i17 = ((i17 | 0) / 8 | 0) + 10 + i17 | 0;
+ i17 = (i17 | 0) > 1e6 ? 1e6 : i17;
+ if ((i16 | 0) <= 15999984 ? (i17 | 0) < (HEAP32[i9 >> 2] | 0) : 0) {
+ _luaD_reallocstack(i4, i17);
+ }
+ HEAP32[i10 >> 2] = HEAP32[i15 + 32 >> 2];
+ HEAP8[i14] = HEAPU8[i14] | 0 | 32;
+ HEAP8[i15 + 37 | 0] = i13;
+ i13 = _luaD_rawrunprotected(i4, 5, 0) | 0;
+ if (!(i13 >>> 0 > 1)) {
+ i2 = 24;
+ break;
+ }
+ }
+ if ((i2 | 0) == 24) {
+ HEAP16[i5 >> 1] = 1;
+ i21 = HEAP16[i3 >> 1] | 0;
+ i21 = i21 + -1 << 16 >> 16;
+ HEAP16[i3 >> 1] = i21;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ HEAP8[i4 + 6 | 0] = i13;
+ i2 = HEAP32[i6 >> 2] | 0;
+ if ((i13 | 0) == 4) {
+ i21 = HEAP32[(HEAP32[i8 >> 2] | 0) + 180 >> 2] | 0;
+ HEAP32[i2 >> 2] = i21;
+ HEAP32[i2 + 8 >> 2] = HEAPU8[i21 + 4 | 0] | 0 | 64;
+ } else if ((i13 | 0) == 6) {
+ i21 = _luaS_newlstr(i4, 2424, 23) | 0;
+ HEAP32[i2 >> 2] = i21;
+ HEAP32[i2 + 8 >> 2] = HEAPU8[i21 + 4 | 0] | 0 | 64;
+ } else {
+ i19 = i2 + -16 | 0;
+ i20 = HEAP32[i19 + 4 >> 2] | 0;
+ i21 = i2;
+ HEAP32[i21 >> 2] = HEAP32[i19 >> 2];
+ HEAP32[i21 + 4 >> 2] = i20;
+ HEAP32[i2 + 8 >> 2] = HEAP32[i2 + -8 >> 2];
+ }
+ i21 = i2 + 16 | 0;
+ HEAP32[i6 >> 2] = i21;
+ HEAP32[(HEAP32[i7 >> 2] | 0) + 4 >> 2] = i21;
+ i21 = i13;
+ HEAP16[i5 >> 1] = 1;
+ i20 = HEAP16[i3 >> 1] | 0;
+ i20 = i20 + -1 << 16 >> 16;
+ HEAP16[i3 >> 1] = i20;
+ STACKTOP = i1;
+ return i21 | 0;
+}
+function _luaK_goiftrue(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i2 = STACKTOP;
+ _luaK_dischargevars(i1, i3);
+ i12 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i12 | 0) == 10) {
+ i9 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ i5 = i3 + 8 | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i7 = i9 + (i8 << 2) | 0;
+ if (!((i8 | 0) > 0 ? (i10 = i9 + (i8 + -1 << 2) | 0, i6 = HEAP32[i10 >> 2] | 0, (HEAP8[5584 + (i6 & 63) | 0] | 0) < 0) : 0)) {
+ i10 = i7;
+ i6 = HEAP32[i7 >> 2] | 0;
+ }
+ HEAP32[i10 >> 2] = ((i6 & 16320 | 0) == 0) << 6 | i6 & -16321;
+ i5 = HEAP32[i5 >> 2] | 0;
+ i8 = 18;
+ } else if (!((i12 | 0) == 2 | (i12 | 0) == 5 | (i12 | 0) == 4)) {
+ i5 = i3 + 8 | 0;
+ if ((i12 | 0) == 6) {
+ i8 = 14;
+ } else if ((i12 | 0) == 11 ? (i11 = HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i5 >> 2] << 2) >> 2] | 0, (i11 & 63 | 0) == 20) : 0) {
+ i5 = i1 + 20 | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + -1;
+ i5 = _condjump(i1, 27, i11 >>> 23, 0, 1) | 0;
+ i8 = 18;
+ break;
+ } else {
+ i8 = 9;
+ }
+ if ((i8 | 0) == 9) {
+ i12 = i1 + 48 | 0;
+ i10 = HEAP8[i12] | 0;
+ i11 = (i10 & 255) + 1 | 0;
+ i6 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
+ do {
+ if (i11 >>> 0 > (HEAPU8[i6] | 0) >>> 0) {
+ if (i11 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i6] = i11;
+ i9 = HEAP8[i12] | 0;
+ break;
+ }
+ } else {
+ i9 = i10;
+ }
+ } while (0);
+ i11 = (i9 & 255) + 1 | 0;
+ HEAP8[i12] = i11;
+ _discharge2reg(i1, i3, (i11 & 255) + -1 | 0);
+ if ((HEAP32[i3 >> 2] | 0) == 6) {
+ i8 = 14;
+ }
+ }
+ if (((i8 | 0) == 14 ? (i7 = HEAP32[i5 >> 2] | 0, (i7 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0) <= (i7 | 0) : 0) {
+ i12 = i1 + 48 | 0;
+ HEAP8[i12] = (HEAP8[i12] | 0) + -1 << 24 >> 24;
+ }
+ i5 = _condjump(i1, 28, 255, HEAP32[i5 >> 2] | 0, 0) | 0;
+ i8 = 18;
+ }
+ } while (0);
+ do {
+ if ((i8 | 0) == 18 ? (i4 = i3 + 20 | 0, !((i5 | 0) == -1)) : 0) {
+ i8 = HEAP32[i4 >> 2] | 0;
+ if ((i8 | 0) == -1) {
+ HEAP32[i4 >> 2] = i5;
+ break;
+ }
+ i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i7 = i4 + (i8 << 2) | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ i9 = (i6 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i8 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i4 = i5 + ~i8 | 0;
+ if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i7 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
+ break;
+ }
+ }
+ } while (0);
+ i3 = i3 + 16 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
+ i5 = i1 + 28 | 0;
+ if ((i4 | 0) == -1) {
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == -1) {
+ HEAP32[i5 >> 2] = i4;
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+ }
+ i7 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i5 = i7 + (i8 << 2) | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i9 = (i6 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i8 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i4 = i4 + ~i8 | 0;
+ if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i5 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+}
+function _luaO_str2d(i1, i3, i5) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, d9 = 0.0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ if ((_strpbrk(i1, 5464) | 0) != 0) {
+ i13 = 0;
+ STACKTOP = i2;
+ return i13 | 0;
+ }
+ do {
+ if ((_strpbrk(i1, 5472) | 0) == 0) {
+ d9 = +_strtod(i1, i4);
+ i10 = HEAP32[i4 >> 2] | 0;
+ } else {
+ HEAP32[i4 >> 2] = i1;
+ i8 = i1;
+ while (1) {
+ i6 = HEAP8[i8] | 0;
+ i10 = i8 + 1 | 0;
+ if ((HEAP8[(i6 & 255) + 10913 | 0] & 8) == 0) {
+ break;
+ } else {
+ i8 = i10;
+ }
+ }
+ if (i6 << 24 >> 24 == 43) {
+ i6 = 0;
+ i8 = i10;
+ } else if (i6 << 24 >> 24 == 45) {
+ i6 = 1;
+ i8 = i10;
+ } else {
+ i6 = 0;
+ }
+ if ((HEAP8[i8] | 0) == 48 ? (i13 = HEAP8[i8 + 1 | 0] | 0, i13 << 24 >> 24 == 88 | i13 << 24 >> 24 == 120) : 0) {
+ i10 = i8 + 2 | 0;
+ i8 = HEAP8[i10] | 0;
+ i12 = i8 & 255;
+ i11 = HEAP8[i12 + 10913 | 0] | 0;
+ if ((i11 & 16) == 0) {
+ d9 = 0.0;
+ i11 = i8;
+ i8 = 0;
+ } else {
+ d9 = 0.0;
+ i8 = 0;
+ while (1) {
+ if ((i11 & 2) == 0) {
+ i11 = (i12 | 32) + -87 | 0;
+ } else {
+ i11 = i12 + -48 | 0;
+ }
+ d9 = d9 * 16.0 + +(i11 | 0);
+ i8 = i8 + 1 | 0;
+ i10 = i10 + 1 | 0;
+ i13 = HEAP8[i10] | 0;
+ i12 = i13 & 255;
+ i11 = HEAP8[i12 + 10913 | 0] | 0;
+ if ((i11 & 16) == 0) {
+ i11 = i13;
+ break;
+ }
+ }
+ }
+ if (i11 << 24 >> 24 == 46) {
+ i10 = i10 + 1 | 0;
+ i13 = HEAPU8[i10] | 0;
+ i11 = HEAP8[i13 + 10913 | 0] | 0;
+ if ((i11 & 16) == 0) {
+ i12 = 0;
+ } else {
+ i12 = 0;
+ do {
+ if ((i11 & 2) == 0) {
+ i11 = (i13 | 32) + -87 | 0;
+ } else {
+ i11 = i13 + -48 | 0;
+ }
+ d9 = d9 * 16.0 + +(i11 | 0);
+ i12 = i12 + 1 | 0;
+ i10 = i10 + 1 | 0;
+ i13 = HEAPU8[i10] | 0;
+ i11 = HEAP8[i13 + 10913 | 0] | 0;
+ } while (!((i11 & 16) == 0));
+ }
+ } else {
+ i12 = 0;
+ }
+ if ((i12 | i8 | 0) != 0) {
+ i8 = Math_imul(i12, -4) | 0;
+ HEAP32[i4 >> 2] = i10;
+ i13 = HEAP8[i10] | 0;
+ if (i13 << 24 >> 24 == 80 | i13 << 24 >> 24 == 112) {
+ i13 = i10 + 1 | 0;
+ i11 = HEAP8[i13] | 0;
+ if (i11 << 24 >> 24 == 45) {
+ i11 = 1;
+ i13 = i10 + 2 | 0;
+ } else if (i11 << 24 >> 24 == 43) {
+ i11 = 0;
+ i13 = i10 + 2 | 0;
+ } else {
+ i11 = 0;
+ }
+ i12 = HEAP8[i13] | 0;
+ if (!((HEAP8[(i12 & 255) + 10913 | 0] & 2) == 0)) {
+ i10 = i13;
+ i7 = 0;
+ do {
+ i10 = i10 + 1 | 0;
+ i7 = (i12 << 24 >> 24) + -48 + (i7 * 10 | 0) | 0;
+ i12 = HEAP8[i10] | 0;
+ } while (!((HEAP8[(i12 & 255) + 10913 | 0] & 2) == 0));
+ i8 = ((i11 | 0) == 0 ? i7 : 0 - i7 | 0) + i8 | 0;
+ i7 = 29;
+ }
+ } else {
+ i7 = 29;
+ }
+ if ((i7 | 0) == 29) {
+ HEAP32[i4 >> 2] = i10;
+ }
+ if ((i6 | 0) != 0) {
+ d9 = -d9;
+ }
+ d9 = +_ldexp(d9, i8);
+ break;
+ }
+ }
+ HEAPF64[i5 >> 3] = 0.0;
+ i13 = 0;
+ STACKTOP = i2;
+ return i13 | 0;
+ }
+ } while (0);
+ HEAPF64[i5 >> 3] = d9;
+ if ((i10 | 0) == (i1 | 0)) {
+ i13 = 0;
+ STACKTOP = i2;
+ return i13 | 0;
+ }
+ if (!((HEAP8[(HEAPU8[i10] | 0) + 10913 | 0] & 8) == 0)) {
+ do {
+ i10 = i10 + 1 | 0;
+ } while (!((HEAP8[(HEAPU8[i10] | 0) + 10913 | 0] & 8) == 0));
+ HEAP32[i4 >> 2] = i10;
+ }
+ i13 = (i10 | 0) == (i1 + i3 | 0) | 0;
+ STACKTOP = i2;
+ return i13 | 0;
+}
+function _luaV_equalobj_(i2, i4, i5) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ i3 = i4 + 8 | 0;
+ L1 : do {
+ switch (HEAP32[i3 >> 2] & 63 | 0) {
+ case 7:
+ {
+ i6 = HEAP32[i4 >> 2] | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == (i7 | 0)) {
+ i7 = 1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ if ((i2 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ } else {
+ i6 = _get_equalTM(i2, HEAP32[i6 + 8 >> 2] | 0, HEAP32[i7 + 8 >> 2] | 0) | 0;
+ break L1;
+ }
+ }
+ case 5:
+ {
+ i7 = HEAP32[i4 >> 2] | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i7 | 0) == (i6 | 0)) {
+ i7 = 1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ if ((i2 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ } else {
+ i6 = _get_equalTM(i2, HEAP32[i7 + 8 >> 2] | 0, HEAP32[i6 + 8 >> 2] | 0) | 0;
+ break L1;
+ }
+ }
+ case 4:
+ {
+ i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 20:
+ {
+ i7 = _luaS_eqlngstr(HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 3:
+ {
+ i7 = +HEAPF64[i4 >> 3] == +HEAPF64[i5 >> 3] | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 1:
+ {
+ i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 22:
+ {
+ i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 2:
+ {
+ i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ case 0:
+ {
+ i7 = 1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ default:
+ {
+ i7 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ }
+ } while (0);
+ if ((i6 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i7 = i2 + 8 | 0;
+ i10 = HEAP32[i7 >> 2] | 0;
+ i9 = i2 + 28 | 0;
+ i8 = i10 - (HEAP32[i9 >> 2] | 0) | 0;
+ HEAP32[i7 >> 2] = i10 + 16;
+ i13 = i6;
+ i12 = HEAP32[i13 + 4 >> 2] | 0;
+ i11 = i10;
+ HEAP32[i11 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i11 + 4 >> 2] = i12;
+ HEAP32[i10 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i10 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i10 + 16;
+ i11 = i4;
+ i4 = HEAP32[i11 + 4 >> 2] | 0;
+ i6 = i10;
+ HEAP32[i6 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i6 + 4 >> 2] = i4;
+ HEAP32[i10 + 8 >> 2] = HEAP32[i3 >> 2];
+ i3 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i3 + 16;
+ i10 = i5;
+ i6 = HEAP32[i10 + 4 >> 2] | 0;
+ i4 = i3;
+ HEAP32[i4 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i4 + 4 >> 2] = i6;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ _luaD_call(i2, (HEAP32[i7 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i2 = HEAP32[i9 >> 2] | 0;
+ i3 = HEAP32[i7 >> 2] | 0;
+ i4 = i3 + -16 | 0;
+ HEAP32[i7 >> 2] = i4;
+ i5 = HEAP32[i4 + 4 >> 2] | 0;
+ i6 = i2 + i8 | 0;
+ HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i6 + 4 >> 2] = i5;
+ HEAP32[i2 + (i8 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
+ i2 = HEAP32[i7 >> 2] | 0;
+ i3 = HEAP32[i2 + 8 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if ((i3 | 0) == 1) {
+ i2 = (HEAP32[i2 >> 2] | 0) != 0;
+ } else {
+ i2 = 1;
+ }
+ } else {
+ i2 = 0;
+ }
+ i13 = i2 & 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _forbody(i1, i5, i6, i4, i9) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i8 = i3 + 12 | 0;
+ i19 = i3;
+ i11 = i1 + 48 | 0;
+ i7 = HEAP32[i11 >> 2] | 0;
+ i18 = i7 + 46 | 0;
+ i22 = (HEAPU8[i18] | 0) + 3 | 0;
+ HEAP8[i18] = i22;
+ i21 = i7 + 20 | 0;
+ i17 = i7 + 12 | 0;
+ i2 = i7 + 40 | 0;
+ i20 = HEAP32[(HEAP32[i7 >> 2] | 0) + 24 >> 2] | 0;
+ i10 = HEAP32[HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] >> 2] | 0;
+ HEAP32[i20 + ((HEAP16[i10 + ((i22 & 255) + -3 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
+ HEAP32[i20 + ((HEAP16[i10 + ((HEAPU8[i18] | 0) + -2 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
+ HEAP32[i20 + ((HEAP16[i10 + ((HEAPU8[i18] | 0) + -1 + (HEAP32[i2 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i21 >> 2];
+ i2 = i1 + 16 | 0;
+ if ((HEAP32[i2 >> 2] | 0) != 259) {
+ _error_expected(i1, 259);
+ }
+ _luaX_next(i1);
+ i10 = (i9 | 0) != 0;
+ if (i10) {
+ i9 = _luaK_codeABx(i7, 33, i5, 131070) | 0;
+ } else {
+ i9 = _luaK_jump(i7) | 0;
+ }
+ HEAP8[i19 + 10 | 0] = 0;
+ HEAP8[i19 + 8 | 0] = HEAP8[i18] | 0;
+ i17 = HEAP32[(HEAP32[i17 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i19 + 4 >> 1] = HEAP32[i17 + 28 >> 2];
+ HEAP16[i19 + 6 >> 1] = HEAP32[i17 + 16 >> 2];
+ HEAP8[i19 + 9 | 0] = 0;
+ i17 = i7 + 16 | 0;
+ HEAP32[i19 >> 2] = HEAP32[i17 >> 2];
+ HEAP32[i17 >> 2] = i19;
+ i19 = HEAP32[i11 >> 2] | 0;
+ i17 = i19 + 46 | 0;
+ i18 = (HEAPU8[i17] | 0) + i4 | 0;
+ HEAP8[i17] = i18;
+ if ((i4 | 0) != 0 ? (i13 = i19 + 20 | 0, i12 = i19 + 40 | 0, i14 = HEAP32[(HEAP32[i19 >> 2] | 0) + 24 >> 2] | 0, i15 = HEAP32[HEAP32[(HEAP32[i19 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0, HEAP32[i14 + ((HEAP16[i15 + ((i18 & 255) - i4 + (HEAP32[i12 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i13 >> 2], i16 = i4 + -1 | 0, (i16 | 0) != 0) : 0) {
+ do {
+ HEAP32[i14 + ((HEAP16[i15 + ((HEAPU8[i17] | 0) - i16 + (HEAP32[i12 >> 2] | 0) << 1) >> 1] | 0) * 12 | 0) + 4 >> 2] = HEAP32[i13 >> 2];
+ i16 = i16 + -1 | 0;
+ } while ((i16 | 0) != 0);
+ }
+ _luaK_reserveregs(i7, i4);
+ i11 = HEAP32[i11 >> 2] | 0;
+ HEAP8[i8 + 10 | 0] = 0;
+ HEAP8[i8 + 8 | 0] = HEAP8[i11 + 46 | 0] | 0;
+ i22 = HEAP32[(HEAP32[i11 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i8 + 4 >> 1] = HEAP32[i22 + 28 >> 2];
+ HEAP16[i8 + 6 >> 1] = HEAP32[i22 + 16 >> 2];
+ HEAP8[i8 + 9 | 0] = 0;
+ i22 = i11 + 16 | 0;
+ HEAP32[i8 >> 2] = HEAP32[i22 >> 2];
+ HEAP32[i22 >> 2] = i8;
+ L13 : do {
+ i8 = HEAP32[i2 >> 2] | 0;
+ switch (i8 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L13;
+ }
+ default:
+ {}
+ }
+ _statement(i1);
+ } while ((i8 | 0) != 274);
+ _leaveblock(i11);
+ _leaveblock(i7);
+ _luaK_patchtohere(i7, i9);
+ if (i10) {
+ i21 = _luaK_codeABx(i7, 32, i5, 131070) | 0;
+ i22 = i9 + 1 | 0;
+ _luaK_patchlist(i7, i21, i22);
+ _luaK_fixline(i7, i6);
+ STACKTOP = i3;
+ return;
+ } else {
+ _luaK_codeABC(i7, 34, i5, 0, i4) | 0;
+ _luaK_fixline(i7, i6);
+ i21 = _luaK_codeABx(i7, 35, i5 + 2 | 0, 131070) | 0;
+ i22 = i9 + 1 | 0;
+ _luaK_patchlist(i7, i21, i22);
+ _luaK_fixline(i7, i6);
+ STACKTOP = i3;
+ return;
+ }
+}
+function _dotty(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i6;
+ i4 = i6 + 4 | 0;
+ i2 = HEAP32[20] | 0;
+ HEAP32[20] = 0;
+ _lua_settop(i1, 0);
+ if ((_pushline(i1, 1) | 0) == 0) {
+ _lua_settop(i1, 0);
+ i10 = HEAP32[_stdout >> 2] | 0;
+ _fputc(10, i10 | 0) | 0;
+ _fflush(i10 | 0) | 0;
+ HEAP32[20] = i2;
+ STACKTOP = i6;
+ return;
+ }
+ i5 = HEAP32[_stderr >> 2] | 0;
+ L4 : while (1) {
+ i8 = _lua_tolstring(i1, 1, i4) | 0;
+ i8 = _luaL_loadbufferx(i1, i8, HEAP32[i4 >> 2] | 0, 256, 0) | 0;
+ L6 : do {
+ if ((i8 | 0) == 3) {
+ while (1) {
+ i8 = _lua_tolstring(i1, -1, i3) | 0;
+ i7 = HEAP32[i3 >> 2] | 0;
+ if (!(i7 >>> 0 > 4)) {
+ break;
+ }
+ if ((_strcmp(i8 + (i7 + -5) | 0, 264) | 0) != 0) {
+ break;
+ }
+ _lua_settop(i1, -2);
+ if ((_pushline(i1, 0) | 0) == 0) {
+ i7 = 23;
+ break L4;
+ }
+ _lua_pushlstring(i1, 184, 1) | 0;
+ _lua_insert(i1, -2);
+ _lua_concat(i1, 3);
+ i8 = _lua_tolstring(i1, 1, i4) | 0;
+ i8 = _luaL_loadbufferx(i1, i8, HEAP32[i4 >> 2] | 0, 256, 0) | 0;
+ if ((i8 | 0) != 3) {
+ i7 = 9;
+ break L6;
+ }
+ }
+ _lua_remove(i1, 1);
+ i8 = 3;
+ i7 = 10;
+ } else {
+ i7 = 9;
+ }
+ } while (0);
+ do {
+ if ((i7 | 0) == 9) {
+ _lua_remove(i1, 1);
+ if ((i8 | 0) == -1) {
+ i7 = 23;
+ break L4;
+ } else if ((i8 | 0) != 0) {
+ i7 = 10;
+ break;
+ }
+ i9 = _lua_gettop(i1) | 0;
+ _lua_pushcclosure(i1, 142, 0);
+ _lua_insert(i1, i9);
+ HEAP32[48] = i1;
+ _signal(2, 1) | 0;
+ i10 = _lua_pcallk(i1, 0, -1, i9, 0, 0) | 0;
+ _signal(2, 0) | 0;
+ _lua_remove(i1, i9);
+ if ((i10 | 0) == 0) {
+ i7 = 17;
+ } else {
+ i9 = 0;
+ i7 = 12;
+ }
+ }
+ } while (0);
+ if ((i7 | 0) == 10) {
+ i9 = (i8 | 0) == 0;
+ i7 = 12;
+ }
+ do {
+ if ((i7 | 0) == 12) {
+ i7 = 0;
+ if ((_lua_type(i1, -1) | 0) == 0) {
+ if (i9) {
+ i7 = 17;
+ break;
+ } else {
+ break;
+ }
+ }
+ i10 = _lua_tolstring(i1, -1, 0) | 0;
+ i8 = HEAP32[20] | 0;
+ if ((i8 | 0) != 0) {
+ HEAP32[i3 >> 2] = i8;
+ _fprintf(i5 | 0, 496, i3 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ }
+ HEAP32[i3 >> 2] = (i10 | 0) == 0 ? 48 : i10;
+ _fprintf(i5 | 0, 912, i3 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ _lua_settop(i1, -2);
+ _lua_gc(i1, 2, 0) | 0;
+ if (i9) {
+ i7 = 17;
+ }
+ }
+ } while (0);
+ if (((i7 | 0) == 17 ? (0, (_lua_gettop(i1) | 0) > 0) : 0) ? (_luaL_checkstack(i1, 20, 112), _lua_getglobal(i1, 144), _lua_insert(i1, 1), (_lua_pcallk(i1, (_lua_gettop(i1) | 0) + -1 | 0, 0, 0, 0, 0) | 0) != 0) : 0) {
+ i7 = HEAP32[20] | 0;
+ HEAP32[i3 >> 2] = _lua_tolstring(i1, -1, 0) | 0;
+ i8 = _lua_pushfstring(i1, 152, i3) | 0;
+ if ((i7 | 0) != 0) {
+ HEAP32[i3 >> 2] = i7;
+ _fprintf(i5 | 0, 496, i3 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ }
+ HEAP32[i3 >> 2] = i8;
+ _fprintf(i5 | 0, 912, i3 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ }
+ _lua_settop(i1, 0);
+ if ((_pushline(i1, 1) | 0) == 0) {
+ i7 = 23;
+ break;
+ }
+ }
+ if ((i7 | 0) == 23) {
+ _lua_settop(i1, 0);
+ i10 = HEAP32[_stdout >> 2] | 0;
+ _fputc(10, i10 | 0) | 0;
+ _fflush(i10 | 0) | 0;
+ HEAP32[20] = i2;
+ STACKTOP = i6;
+ return;
+ }
+}
+function _test_then_block(i5, i1) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i10 = i2 + 24 | 0;
+ i9 = i2;
+ i8 = i5 + 48 | 0;
+ i4 = HEAP32[i8 >> 2] | 0;
+ _luaX_next(i5);
+ _subexpr(i5, i9, 0) | 0;
+ i3 = i5 + 16 | 0;
+ if ((HEAP32[i3 >> 2] | 0) != 275) {
+ _error_expected(i5, 275);
+ }
+ _luaX_next(i5);
+ i14 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i14 | 0) == 258 | (i14 | 0) == 266) {
+ _luaK_goiffalse(HEAP32[i8 >> 2] | 0, i9);
+ HEAP8[i10 + 10 | 0] = 0;
+ HEAP8[i10 + 8 | 0] = HEAP8[i4 + 46 | 0] | 0;
+ i11 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i10 + 4 >> 1] = HEAP32[i11 + 28 >> 2];
+ HEAP16[i10 + 6 >> 1] = HEAP32[i11 + 16 >> 2];
+ HEAP8[i10 + 9 | 0] = 0;
+ i11 = i4 + 16 | 0;
+ HEAP32[i10 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i11 >> 2] = i10;
+ i11 = HEAP32[i9 + 16 >> 2] | 0;
+ i10 = HEAP32[i5 + 4 >> 2] | 0;
+ i14 = (HEAP32[i3 >> 2] | 0) == 266;
+ _luaX_next(i5);
+ do {
+ if (i14) {
+ if ((HEAP32[i3 >> 2] | 0) == 288) {
+ i7 = HEAP32[i5 + 24 >> 2] | 0;
+ _luaX_next(i5);
+ break;
+ } else {
+ _error_expected(i5, 288);
+ }
+ } else {
+ i7 = _luaS_new(HEAP32[i5 + 52 >> 2] | 0, 6304) | 0;
+ }
+ } while (0);
+ i14 = HEAP32[i5 + 64 >> 2] | 0;
+ i12 = i14 + 12 | 0;
+ i13 = i14 + 16 | 0;
+ i9 = HEAP32[i13 >> 2] | 0;
+ i14 = i14 + 20 | 0;
+ if ((i9 | 0) < (HEAP32[i14 >> 2] | 0)) {
+ i14 = HEAP32[i12 >> 2] | 0;
+ } else {
+ i14 = _luaM_growaux_(HEAP32[i5 + 52 >> 2] | 0, HEAP32[i12 >> 2] | 0, i14, 16, 32767, 6312) | 0;
+ HEAP32[i12 >> 2] = i14;
+ }
+ HEAP32[i14 + (i9 << 4) >> 2] = i7;
+ i14 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i14 + (i9 << 4) + 8 >> 2] = i10;
+ HEAP8[i14 + (i9 << 4) + 12 | 0] = HEAP8[(HEAP32[i8 >> 2] | 0) + 46 | 0] | 0;
+ HEAP32[(HEAP32[i12 >> 2] | 0) + (i9 << 4) + 4 >> 2] = i11;
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + 1;
+ _findlabel(i5, i9) | 0;
+ L18 : while (1) {
+ switch (HEAP32[i3 >> 2] | 0) {
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L18;
+ }
+ case 285:
+ case 59:
+ {
+ break;
+ }
+ default:
+ {
+ i6 = 16;
+ break L18;
+ }
+ }
+ _statement(i5);
+ }
+ if ((i6 | 0) == 16) {
+ i6 = _luaK_jump(i4) | 0;
+ break;
+ }
+ _leaveblock(i4);
+ STACKTOP = i2;
+ return;
+ } else {
+ _luaK_goiftrue(HEAP32[i8 >> 2] | 0, i9);
+ HEAP8[i10 + 10 | 0] = 0;
+ HEAP8[i10 + 8 | 0] = HEAP8[i4 + 46 | 0] | 0;
+ i6 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i10 + 4 >> 1] = HEAP32[i6 + 28 >> 2];
+ HEAP16[i10 + 6 >> 1] = HEAP32[i6 + 16 >> 2];
+ HEAP8[i10 + 9 | 0] = 0;
+ i6 = i4 + 16 | 0;
+ HEAP32[i10 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i6 >> 2] = i10;
+ i6 = HEAP32[i9 + 20 >> 2] | 0;
+ }
+ } while (0);
+ L26 : do {
+ i7 = HEAP32[i3 >> 2] | 0;
+ switch (i7 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L26;
+ }
+ default:
+ {}
+ }
+ _statement(i5);
+ } while ((i7 | 0) != 274);
+ _leaveblock(i4);
+ if (((HEAP32[i3 >> 2] | 0) + -260 | 0) >>> 0 < 2) {
+ _luaK_concat(i4, i1, _luaK_jump(i4) | 0);
+ }
+ _luaK_patchtohere(i4, i6);
+ STACKTOP = i2;
+ return;
+}
+function _luaL_gsub(i2, i13, i11, i10) {
+ i2 = i2 | 0;
+ i13 = i13 | 0;
+ i11 = i11 | 0;
+ i10 = i10 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i8 = i1;
+ i4 = i1 + 8 | 0;
+ i9 = _strlen(i11 | 0) | 0;
+ i6 = i4 + 12 | 0;
+ HEAP32[i6 >> 2] = i2;
+ i3 = i4 + 16 | 0;
+ HEAP32[i4 >> 2] = i3;
+ i5 = i4 + 8 | 0;
+ HEAP32[i5 >> 2] = 0;
+ i7 = i4 + 4 | 0;
+ HEAP32[i7 >> 2] = 1024;
+ i12 = _strstr(i13, i11) | 0;
+ if ((i12 | 0) == 0) {
+ i14 = 0;
+ i17 = 1024;
+ i16 = i2;
+ } else {
+ i14 = 0;
+ i17 = 1024;
+ i16 = i2;
+ do {
+ i15 = i12 - i13 | 0;
+ if ((i17 - i14 | 0) >>> 0 < i15 >>> 0) {
+ i17 = i17 << 1;
+ i17 = (i17 - i14 | 0) >>> 0 < i15 >>> 0 ? i14 + i15 | 0 : i17;
+ if (i17 >>> 0 < i14 >>> 0 | (i17 - i14 | 0) >>> 0 < i15 >>> 0) {
+ _luaL_error(i16, 1272, i8) | 0;
+ }
+ i14 = _lua_newuserdata(i16, i17) | 0;
+ _memcpy(i14 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
+ _lua_remove(i16, -2);
+ }
+ HEAP32[i4 >> 2] = i14;
+ HEAP32[i7 >> 2] = i17;
+ i16 = i14;
+ i14 = HEAP32[i5 >> 2] | 0;
+ } else {
+ i16 = HEAP32[i4 >> 2] | 0;
+ }
+ _memcpy(i16 + i14 | 0, i13 | 0, i15 | 0) | 0;
+ i15 = (HEAP32[i5 >> 2] | 0) + i15 | 0;
+ HEAP32[i5 >> 2] = i15;
+ i13 = _strlen(i10 | 0) | 0;
+ i14 = HEAP32[i6 >> 2] | 0;
+ i16 = HEAP32[i7 >> 2] | 0;
+ if ((i16 - i15 | 0) >>> 0 < i13 >>> 0) {
+ i16 = i16 << 1;
+ i16 = (i16 - i15 | 0) >>> 0 < i13 >>> 0 ? i15 + i13 | 0 : i16;
+ if (i16 >>> 0 < i15 >>> 0 | (i16 - i15 | 0) >>> 0 < i13 >>> 0) {
+ _luaL_error(i14, 1272, i8) | 0;
+ }
+ i15 = _lua_newuserdata(i14, i16) | 0;
+ _memcpy(i15 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
+ _lua_remove(i14, -2);
+ }
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i7 >> 2] = i16;
+ i14 = i15;
+ i15 = HEAP32[i5 >> 2] | 0;
+ } else {
+ i14 = HEAP32[i4 >> 2] | 0;
+ }
+ _memcpy(i14 + i15 | 0, i10 | 0, i13 | 0) | 0;
+ i14 = (HEAP32[i5 >> 2] | 0) + i13 | 0;
+ HEAP32[i5 >> 2] = i14;
+ i13 = i12 + i9 | 0;
+ i12 = _strstr(i13, i11) | 0;
+ i16 = HEAP32[i6 >> 2] | 0;
+ i17 = HEAP32[i7 >> 2] | 0;
+ } while ((i12 | 0) != 0);
+ }
+ i9 = _strlen(i13 | 0) | 0;
+ if ((i17 - i14 | 0) >>> 0 < i9 >>> 0) {
+ i10 = i17 << 1;
+ i10 = (i10 - i14 | 0) >>> 0 < i9 >>> 0 ? i14 + i9 | 0 : i10;
+ if (i10 >>> 0 < i14 >>> 0 | (i10 - i14 | 0) >>> 0 < i9 >>> 0) {
+ _luaL_error(i16, 1272, i8) | 0;
+ }
+ i8 = _lua_newuserdata(i16, i10) | 0;
+ _memcpy(i8 | 0, HEAP32[i4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ if ((HEAP32[i4 >> 2] | 0) != (i3 | 0)) {
+ _lua_remove(i16, -2);
+ }
+ HEAP32[i4 >> 2] = i8;
+ HEAP32[i7 >> 2] = i10;
+ i14 = HEAP32[i5 >> 2] | 0;
+ } else {
+ i8 = HEAP32[i4 >> 2] | 0;
+ }
+ _memcpy(i8 + i14 | 0, i13 | 0, i9 | 0) | 0;
+ i17 = (HEAP32[i5 >> 2] | 0) + i9 | 0;
+ HEAP32[i5 >> 2] = i17;
+ i5 = HEAP32[i6 >> 2] | 0;
+ _lua_pushlstring(i5, HEAP32[i4 >> 2] | 0, i17) | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i3 | 0)) {
+ i17 = _lua_tolstring(i2, -1, 0) | 0;
+ STACKTOP = i1;
+ return i17 | 0;
+ }
+ _lua_remove(i5, -2);
+ i17 = _lua_tolstring(i2, -1, 0) | 0;
+ STACKTOP = i1;
+ return i17 | 0;
+}
+function _luaK_goiffalse(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i2 = STACKTOP;
+ _luaK_dischargevars(i1, i3);
+ i9 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i9 | 0) == 10) {
+ i4 = HEAP32[i3 + 8 >> 2] | 0;
+ i8 = 15;
+ } else if (!((i9 | 0) == 3 | (i9 | 0) == 1)) {
+ i4 = i3 + 8 | 0;
+ if ((i9 | 0) == 6) {
+ i8 = 11;
+ } else if ((i9 | 0) == 11 ? (i10 = HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 >> 2] << 2) >> 2] | 0, (i10 & 63 | 0) == 20) : 0) {
+ i4 = i1 + 20 | 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -1;
+ i4 = _condjump(i1, 27, i10 >>> 23, 0, 0) | 0;
+ i8 = 15;
+ break;
+ } else {
+ i8 = 6;
+ }
+ if ((i8 | 0) == 6) {
+ i9 = i1 + 48 | 0;
+ i11 = HEAP8[i9] | 0;
+ i10 = (i11 & 255) + 1 | 0;
+ i12 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
+ do {
+ if (i10 >>> 0 > (HEAPU8[i12] | 0) >>> 0) {
+ if (i10 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i12] = i10;
+ i7 = HEAP8[i9] | 0;
+ break;
+ }
+ } else {
+ i7 = i11;
+ }
+ } while (0);
+ i12 = (i7 & 255) + 1 | 0;
+ HEAP8[i9] = i12;
+ _discharge2reg(i1, i3, (i12 & 255) + -1 | 0);
+ if ((HEAP32[i3 >> 2] | 0) == 6) {
+ i8 = 11;
+ }
+ }
+ if (((i8 | 0) == 11 ? (i6 = HEAP32[i4 >> 2] | 0, (i6 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0 | 0) <= (i6 | 0) : 0) {
+ i12 = i1 + 48 | 0;
+ HEAP8[i12] = (HEAP8[i12] | 0) + -1 << 24 >> 24;
+ }
+ i4 = _condjump(i1, 28, 255, HEAP32[i4 >> 2] | 0, 1) | 0;
+ i8 = 15;
+ }
+ } while (0);
+ do {
+ if ((i8 | 0) == 15 ? (i5 = i3 + 16 | 0, !((i4 | 0) == -1)) : 0) {
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == -1) {
+ HEAP32[i5 >> 2] = i4;
+ break;
+ }
+ i5 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i7 = i5 + (i8 << 2) | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ i9 = (i6 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i8 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i4 = i4 + ~i8 | 0;
+ if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ } else {
+ HEAP32[i7 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
+ break;
+ }
+ }
+ } while (0);
+ i3 = i3 + 20 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
+ i5 = i1 + 28 | 0;
+ if ((i4 | 0) == -1) {
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ if ((i8 | 0) == -1) {
+ HEAP32[i5 >> 2] = i4;
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+ }
+ i7 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i5 = i7 + (i8 << 2) | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i9 = (i6 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i8 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i4 = i4 + ~i8 | 0;
+ if ((((i4 | 0) > -1 ? i4 : 0 - i4 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i5 >> 2] = (i4 << 14) + 2147467264 | i6 & 16383;
+ HEAP32[i3 >> 2] = -1;
+ STACKTOP = i2;
+ return;
+}
+function _luaV_settable(i2, i11, i7, i9) {
+ i2 = i2 | 0;
+ i11 = i11 | 0;
+ i7 = i7 | 0;
+ i9 = i9 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i6;
+ i4 = i2 + 12 | 0;
+ i3 = i11;
+ i13 = HEAP32[i11 + 8 >> 2] | 0;
+ i12 = 0;
+ while (1) {
+ i11 = i3 + 8 | 0;
+ if ((i13 | 0) != 69) {
+ i14 = _luaT_gettmbyobj(i2, i3, 1) | 0;
+ i13 = HEAP32[i14 + 8 >> 2] | 0;
+ if ((i13 | 0) == 0) {
+ i1 = 16;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 >> 2] | 0;
+ i13 = _luaH_get(i8, i7) | 0;
+ if ((HEAP32[i13 + 8 >> 2] | 0) != 0) {
+ i10 = i13;
+ break;
+ }
+ i14 = HEAP32[i8 + 8 >> 2] | 0;
+ if ((i14 | 0) == 0) {
+ i1 = 9;
+ break;
+ }
+ if (!((HEAP8[i14 + 6 | 0] & 2) == 0)) {
+ i1 = 9;
+ break;
+ }
+ i14 = _luaT_gettm(i14, 1, HEAP32[(HEAP32[i4 >> 2] | 0) + 188 >> 2] | 0) | 0;
+ if ((i14 | 0) == 0) {
+ i1 = 9;
+ break;
+ }
+ i13 = HEAP32[i14 + 8 >> 2] | 0;
+ }
+ i12 = i12 + 1 | 0;
+ if ((i13 & 15 | 0) == 6) {
+ i1 = 18;
+ break;
+ }
+ if ((i12 | 0) < 100) {
+ i3 = i14;
+ } else {
+ i1 = 19;
+ break;
+ }
+ }
+ if ((i1 | 0) == 9) {
+ if ((i13 | 0) == 5192) {
+ i10 = _luaH_newkey(i2, i8, i7) | 0;
+ } else {
+ i10 = i13;
+ }
+ } else if ((i1 | 0) == 16) {
+ _luaG_typeerror(i2, i3, 8944);
+ } else if ((i1 | 0) == 18) {
+ i13 = i2 + 8 | 0;
+ i8 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i8 + 16;
+ i5 = i14;
+ i12 = HEAP32[i5 + 4 >> 2] | 0;
+ i10 = i8;
+ HEAP32[i10 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i10 + 4 >> 2] = i12;
+ HEAP32[i8 + 8 >> 2] = HEAP32[i14 + 8 >> 2];
+ i14 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i14 + 16;
+ i8 = i3;
+ i10 = HEAP32[i8 + 4 >> 2] | 0;
+ i12 = i14;
+ HEAP32[i12 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i12 + 4 >> 2] = i10;
+ HEAP32[i14 + 8 >> 2] = HEAP32[i11 >> 2];
+ i14 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i14 + 16;
+ i12 = i7;
+ i11 = HEAP32[i12 + 4 >> 2] | 0;
+ i10 = i14;
+ HEAP32[i10 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i10 + 4 >> 2] = i11;
+ HEAP32[i14 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i14 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i14 + 16;
+ i10 = i9;
+ i11 = HEAP32[i10 + 4 >> 2] | 0;
+ i12 = i14;
+ HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAP32[i14 + 8 >> 2] = HEAP32[i9 + 8 >> 2];
+ _luaD_call(i2, (HEAP32[i13 >> 2] | 0) + -64 | 0, 0, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
+ STACKTOP = i6;
+ return;
+ } else if ((i1 | 0) == 19) {
+ _luaG_runerror(i2, 8976, i5);
+ }
+ i12 = i9;
+ i13 = HEAP32[i12 + 4 >> 2] | 0;
+ i14 = i10;
+ HEAP32[i14 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i14 + 4 >> 2] = i13;
+ i14 = i9 + 8 | 0;
+ HEAP32[i10 + 8 >> 2] = HEAP32[i14 >> 2];
+ HEAP8[i8 + 6 | 0] = 0;
+ if ((HEAP32[i14 >> 2] & 64 | 0) == 0) {
+ STACKTOP = i6;
+ return;
+ }
+ if ((HEAP8[(HEAP32[i9 >> 2] | 0) + 5 | 0] & 3) == 0) {
+ STACKTOP = i6;
+ return;
+ }
+ if ((HEAP8[i8 + 5 | 0] & 4) == 0) {
+ STACKTOP = i6;
+ return;
+ }
+ _luaC_barrierback_(i2, i8);
+ STACKTOP = i6;
+ return;
+}
+function _luaK_code(i4, i5) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
+ i2 = STACKTOP;
+ i1 = HEAP32[i4 >> 2] | 0;
+ i7 = i4 + 28 | 0;
+ i15 = HEAP32[i7 >> 2] | 0;
+ i3 = i4 + 20 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ do {
+ if (!((i15 | 0) == -1)) {
+ i11 = HEAP32[i1 + 12 >> 2] | 0;
+ while (1) {
+ i12 = i11 + (i15 << 2) | 0;
+ i14 = HEAP32[i12 >> 2] | 0;
+ i13 = (i14 >>> 14) + -131071 | 0;
+ if ((i13 | 0) == -1) {
+ i13 = -1;
+ } else {
+ i13 = i15 + 1 + i13 | 0;
+ }
+ if ((i15 | 0) > 0 ? (i9 = i11 + (i15 + -1 << 2) | 0, i10 = HEAP32[i9 >> 2] | 0, (HEAP8[5584 + (i10 & 63) | 0] | 0) < 0) : 0) {
+ i17 = i9;
+ i16 = i10;
+ } else {
+ i17 = i12;
+ i16 = i14;
+ }
+ if ((i16 & 63 | 0) == 28) {
+ HEAP32[i17 >> 2] = i16 & 8372224 | i16 >>> 23 << 6 | 27;
+ i14 = i8 + ~i15 | 0;
+ if ((((i14 | 0) > -1 ? i14 : 0 - i14 | 0) | 0) > 131071) {
+ i8 = 10;
+ break;
+ }
+ i14 = HEAP32[i12 >> 2] & 16383 | (i14 << 14) + 2147467264;
+ } else {
+ i15 = i8 + ~i15 | 0;
+ if ((((i15 | 0) > -1 ? i15 : 0 - i15 | 0) | 0) > 131071) {
+ i8 = 13;
+ break;
+ }
+ i14 = (i15 << 14) + 2147467264 | i14 & 16383;
+ }
+ HEAP32[i12 >> 2] = i14;
+ if ((i13 | 0) == -1) {
+ i8 = 16;
+ break;
+ } else {
+ i15 = i13;
+ }
+ }
+ if ((i8 | 0) == 10) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else if ((i8 | 0) == 13) {
+ _luaX_syntaxerror(HEAP32[i4 + 12 >> 2] | 0, 10624);
+ } else if ((i8 | 0) == 16) {
+ i6 = HEAP32[i3 >> 2] | 0;
+ break;
+ }
+ } else {
+ i6 = i8;
+ }
+ } while (0);
+ HEAP32[i7 >> 2] = -1;
+ i7 = i1 + 48 | 0;
+ if ((i6 | 0) < (HEAP32[i7 >> 2] | 0)) {
+ i7 = i1 + 12 | 0;
+ } else {
+ i6 = i1 + 12 | 0;
+ HEAP32[i6 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i6 >> 2] | 0, i7, 4, 2147483645, 10616) | 0;
+ i7 = i6;
+ i6 = HEAP32[i3 >> 2] | 0;
+ }
+ HEAP32[(HEAP32[i7 >> 2] | 0) + (i6 << 2) >> 2] = i5;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i6 = i1 + 52 | 0;
+ i4 = i4 + 12 | 0;
+ if ((i5 | 0) < (HEAP32[i6 >> 2] | 0)) {
+ i15 = i1 + 20 | 0;
+ i17 = i5;
+ i16 = HEAP32[i4 >> 2] | 0;
+ i16 = i16 + 8 | 0;
+ i16 = HEAP32[i16 >> 2] | 0;
+ i15 = HEAP32[i15 >> 2] | 0;
+ i17 = i15 + (i17 << 2) | 0;
+ HEAP32[i17 >> 2] = i16;
+ i17 = HEAP32[i3 >> 2] | 0;
+ i16 = i17 + 1 | 0;
+ HEAP32[i3 >> 2] = i16;
+ STACKTOP = i2;
+ return i17 | 0;
+ } else {
+ i15 = i1 + 20 | 0;
+ HEAP32[i15 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i4 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i15 >> 2] | 0, i6, 4, 2147483645, 10616) | 0;
+ i17 = HEAP32[i3 >> 2] | 0;
+ i16 = HEAP32[i4 >> 2] | 0;
+ i16 = i16 + 8 | 0;
+ i16 = HEAP32[i16 >> 2] | 0;
+ i15 = HEAP32[i15 >> 2] | 0;
+ i17 = i15 + (i17 << 2) | 0;
+ HEAP32[i17 >> 2] = i16;
+ i17 = HEAP32[i3 >> 2] | 0;
+ i16 = i17 + 1 | 0;
+ HEAP32[i3 >> 2] = i16;
+ STACKTOP = i2;
+ return i17 | 0;
+ }
+ return 0;
+}
+function _luaH_next(i9, i5, i2) {
+ i9 = i9 | 0;
+ i5 = i5 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i8 = i1 + 8 | 0;
+ i11 = i1;
+ i3 = i2 + 8 | 0;
+ i10 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i10 | 0) != 0) {
+ if ((((i10 | 0) == 3 ? (d14 = +HEAPF64[i2 >> 3], HEAPF64[i11 >> 3] = d14 + 6755399441055744.0, i12 = HEAP32[i11 >> 2] | 0, +(i12 | 0) == d14) : 0) ? (i12 | 0) > 0 : 0) ? (i13 = HEAP32[i5 + 28 >> 2] | 0, (i12 | 0) <= (i13 | 0)) : 0) {
+ i6 = i13;
+ i7 = i12 + -1 | 0;
+ break;
+ }
+ i10 = _mainposition(i5, i2) | 0;
+ while (1) {
+ i4 = i10 + 16 | 0;
+ i11 = i10 + 24 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ if ((i12 | 0) == (HEAP32[i3 >> 2] | 0)) {
+ if ((_luaV_equalobj_(0, i4, i2) | 0) != 0) {
+ i4 = 15;
+ break;
+ }
+ i12 = HEAP32[i11 >> 2] | 0;
+ }
+ if (((i12 | 0) == 11 ? (HEAP32[i3 >> 2] & 64 | 0) != 0 : 0) ? (HEAP32[i4 >> 2] | 0) == (HEAP32[i2 >> 2] | 0) : 0) {
+ i4 = 15;
+ break;
+ }
+ i10 = HEAP32[i10 + 28 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i4 = 18;
+ break;
+ }
+ }
+ if ((i4 | 0) == 15) {
+ i7 = HEAP32[i5 + 28 >> 2] | 0;
+ i6 = i7;
+ i7 = (i10 - (HEAP32[i5 + 16 >> 2] | 0) >> 5) + i7 | 0;
+ break;
+ } else if ((i4 | 0) == 18) {
+ _luaG_runerror(i9, 8064, i8);
+ }
+ } else {
+ i6 = HEAP32[i5 + 28 >> 2] | 0;
+ i7 = -1;
+ }
+ } while (0);
+ i8 = i5 + 12 | 0;
+ while (1) {
+ i9 = i7 + 1 | 0;
+ if ((i9 | 0) >= (i6 | 0)) {
+ break;
+ }
+ i11 = HEAP32[i8 >> 2] | 0;
+ i10 = i11 + (i9 << 4) + 8 | 0;
+ if ((HEAP32[i10 >> 2] | 0) == 0) {
+ i7 = i9;
+ } else {
+ i4 = 21;
+ break;
+ }
+ }
+ if ((i4 | 0) == 21) {
+ HEAPF64[i2 >> 3] = +(i7 + 2 | 0);
+ HEAP32[i3 >> 2] = 3;
+ i11 = i11 + (i9 << 4) | 0;
+ i12 = HEAP32[i11 + 4 >> 2] | 0;
+ i13 = i2 + 16 | 0;
+ HEAP32[i13 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i13 + 4 >> 2] = i12;
+ HEAP32[i2 + 24 >> 2] = HEAP32[i10 >> 2];
+ i13 = 1;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i8 = i9 - i6 | 0;
+ i6 = 1 << (HEAPU8[i5 + 7 | 0] | 0);
+ if ((i8 | 0) >= (i6 | 0)) {
+ i13 = 0;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i7 = i5 + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ while (1) {
+ i9 = i8 + 1 | 0;
+ if ((HEAP32[i5 + (i8 << 5) + 8 >> 2] | 0) != 0) {
+ break;
+ }
+ if ((i9 | 0) < (i6 | 0)) {
+ i8 = i9;
+ } else {
+ i2 = 0;
+ i4 = 27;
+ break;
+ }
+ }
+ if ((i4 | 0) == 27) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ i11 = i5 + (i8 << 5) + 16 | 0;
+ i10 = HEAP32[i11 + 4 >> 2] | 0;
+ i13 = i2;
+ HEAP32[i13 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i13 + 4 >> 2] = i10;
+ HEAP32[i3 >> 2] = HEAP32[i5 + (i8 << 5) + 24 >> 2];
+ i13 = HEAP32[i7 >> 2] | 0;
+ i10 = i13 + (i8 << 5) | 0;
+ i11 = HEAP32[i10 + 4 >> 2] | 0;
+ i12 = i2 + 16 | 0;
+ HEAP32[i12 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAP32[i2 + 24 >> 2] = HEAP32[i13 + (i8 << 5) + 8 >> 2];
+ i13 = 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _g_read(i1, i3, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i7 = i4 + 8 | 0;
+ i9 = i4;
+ i10 = _lua_gettop(i1) | 0;
+ _clearerr(i3 | 0);
+ L1 : do {
+ if ((i10 | 0) == 1) {
+ i11 = i2 + 1 | 0;
+ i12 = _read_line(i1, i3, 1) | 0;
+ } else {
+ _luaL_checkstack(i1, i10 + 19 | 0, 3256);
+ i6 = i7 + 8 | 0;
+ i5 = i7 + 8 | 0;
+ i10 = i10 + -2 | 0;
+ i11 = i2;
+ L4 : while (1) {
+ do {
+ if ((_lua_type(i1, i11) | 0) == 3) {
+ i12 = _lua_tointegerx(i1, i11, 0) | 0;
+ if ((i12 | 0) == 0) {
+ i12 = _fgetc(i3 | 0) | 0;
+ _ungetc(i12 | 0, i3 | 0) | 0;
+ _lua_pushlstring(i1, 0, 0) | 0;
+ i12 = (i12 | 0) != -1 | 0;
+ break;
+ } else {
+ _luaL_buffinit(i1, i7);
+ i12 = _fread(_luaL_prepbuffsize(i7, i12) | 0, 1, i12 | 0, i3 | 0) | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i12;
+ _luaL_pushresult(i7);
+ i12 = (i12 | 0) != 0 | 0;
+ break;
+ }
+ } else {
+ i12 = _lua_tolstring(i1, i11, 0) | 0;
+ if (!((i12 | 0) != 0 ? (HEAP8[i12] | 0) == 42 : 0)) {
+ _luaL_argerror(i1, i11, 3280) | 0;
+ }
+ i12 = HEAP8[i12 + 1 | 0] | 0;
+ if ((i12 | 0) == 110) {
+ HEAP32[i7 >> 2] = i9;
+ if ((_fscanf(i3 | 0, 3312, i7 | 0) | 0) != 1) {
+ i8 = 14;
+ break L4;
+ }
+ _lua_pushnumber(i1, +HEAPF64[i9 >> 3]);
+ i12 = 1;
+ break;
+ } else if ((i12 | 0) == 108) {
+ i12 = _read_line(i1, i3, 1) | 0;
+ break;
+ } else if ((i12 | 0) == 76) {
+ i12 = _read_line(i1, i3, 0) | 0;
+ break;
+ } else if ((i12 | 0) == 97) {
+ _luaL_buffinit(i1, i7);
+ i12 = _fread(_luaL_prepbuffsize(i7, 1024) | 0, 1, 1024, i3 | 0) | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i12;
+ if (!(i12 >>> 0 < 1024)) {
+ i12 = 1024;
+ do {
+ i12 = i12 << (i12 >>> 0 < 1073741824);
+ i13 = _fread(_luaL_prepbuffsize(i7, i12) | 0, 1, i12 | 0, i3 | 0) | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i13;
+ } while (!(i13 >>> 0 < i12 >>> 0));
+ }
+ _luaL_pushresult(i7);
+ i12 = 1;
+ break;
+ } else {
+ break L4;
+ }
+ }
+ } while (0);
+ i11 = i11 + 1 | 0;
+ if ((i10 | 0) == 0 | (i12 | 0) == 0) {
+ break L1;
+ } else {
+ i10 = i10 + -1 | 0;
+ }
+ }
+ if ((i8 | 0) == 14) {
+ _lua_pushnil(i1);
+ i11 = i11 + 1 | 0;
+ i12 = 0;
+ break;
+ }
+ i13 = _luaL_argerror(i1, i11, 3296) | 0;
+ STACKTOP = i4;
+ return i13 | 0;
+ }
+ } while (0);
+ if ((_ferror(i3 | 0) | 0) != 0) {
+ i13 = _luaL_fileresult(i1, 0, 0) | 0;
+ STACKTOP = i4;
+ return i13 | 0;
+ }
+ if ((i12 | 0) == 0) {
+ _lua_settop(i1, -2);
+ _lua_pushnil(i1);
+ }
+ i13 = i11 - i2 | 0;
+ STACKTOP = i4;
+ return i13 | 0;
+}
+function _luaY_parser(i8, i12, i10, i11, i9, i13) {
+ i8 = i8 | 0;
+ i12 = i12 | 0;
+ i10 = i10 | 0;
+ i11 = i11 | 0;
+ i9 = i9 | 0;
+ i13 = i13 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i14 = 0, i15 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 176 | 0;
+ i5 = i2 + 156 | 0;
+ i7 = i2 + 80 | 0;
+ i4 = i2;
+ i6 = i2 + 104 | 0;
+ i3 = _luaF_newLclosure(i8, 1) | 0;
+ i15 = i8 + 8 | 0;
+ i14 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i14 >> 2] = i3;
+ HEAP32[i14 + 8 >> 2] = 70;
+ i14 = (HEAP32[i15 >> 2] | 0) + 16 | 0;
+ HEAP32[i15 >> 2] = i14;
+ if (((HEAP32[i8 + 24 >> 2] | 0) - i14 | 0) < 16) {
+ _luaD_growstack(i8, 0);
+ }
+ i14 = _luaF_newproto(i8) | 0;
+ HEAP32[i3 + 12 >> 2] = i14;
+ HEAP32[i6 >> 2] = i14;
+ i9 = _luaS_new(i8, i9) | 0;
+ HEAP32[(HEAP32[i6 >> 2] | 0) + 36 >> 2] = i9;
+ HEAP32[i4 + 60 >> 2] = i10;
+ i9 = i4 + 64 | 0;
+ HEAP32[i9 >> 2] = i11;
+ HEAP32[i11 + 28 >> 2] = 0;
+ HEAP32[i11 + 16 >> 2] = 0;
+ HEAP32[i11 + 4 >> 2] = 0;
+ _luaX_setinput(i8, i4, i12, HEAP32[(HEAP32[i6 >> 2] | 0) + 36 >> 2] | 0, i13);
+ i10 = HEAP32[i4 + 52 >> 2] | 0;
+ i13 = i4 + 48 | 0;
+ HEAP32[i6 + 8 >> 2] = HEAP32[i13 >> 2];
+ i8 = i6 + 12 | 0;
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i13 >> 2] = i6;
+ HEAP32[i6 + 20 >> 2] = 0;
+ HEAP32[i6 + 24 >> 2] = 0;
+ HEAP32[i6 + 28 >> 2] = -1;
+ HEAP32[i6 + 32 >> 2] = 0;
+ HEAP32[i6 + 36 >> 2] = 0;
+ i13 = i6 + 44 | 0;
+ HEAP32[i13 + 0 >> 2] = 0;
+ HEAP8[i13 + 4 | 0] = 0;
+ HEAP32[i6 + 40 >> 2] = HEAP32[(HEAP32[i9 >> 2] | 0) + 4 >> 2];
+ i9 = i6 + 16 | 0;
+ HEAP32[i9 >> 2] = 0;
+ i13 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i13 + 36 >> 2] = HEAP32[i4 + 68 >> 2];
+ HEAP8[i13 + 78 | 0] = 2;
+ i13 = _luaH_new(i10) | 0;
+ HEAP32[i6 + 4 >> 2] = i13;
+ i14 = i10 + 8 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i15 >> 2] = i13;
+ HEAP32[i15 + 8 >> 2] = 69;
+ i15 = (HEAP32[i14 >> 2] | 0) + 16 | 0;
+ HEAP32[i14 >> 2] = i15;
+ if (((HEAP32[i10 + 24 >> 2] | 0) - i15 | 0) < 16) {
+ _luaD_growstack(i10, 0);
+ }
+ HEAP8[i5 + 10 | 0] = 0;
+ HEAP8[i5 + 8 | 0] = HEAP8[i6 + 46 | 0] | 0;
+ i15 = HEAP32[(HEAP32[i8 >> 2] | 0) + 64 >> 2] | 0;
+ HEAP16[i5 + 4 >> 1] = HEAP32[i15 + 28 >> 2];
+ HEAP16[i5 + 6 >> 1] = HEAP32[i15 + 16 >> 2];
+ HEAP8[i5 + 9 | 0] = 0;
+ HEAP32[i5 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i9 >> 2] = i5;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + 77 | 0] = 1;
+ HEAP32[i7 + 16 >> 2] = -1;
+ HEAP32[i7 + 20 >> 2] = -1;
+ HEAP32[i7 >> 2] = 7;
+ HEAP32[i7 + 8 >> 2] = 0;
+ _newupvalue(i6, HEAP32[i4 + 72 >> 2] | 0, i7) | 0;
+ _luaX_next(i4);
+ i5 = i4 + 16 | 0;
+ L7 : while (1) {
+ i6 = HEAP32[i5 >> 2] | 0;
+ switch (i6 | 0) {
+ case 277:
+ case 286:
+ case 262:
+ case 261:
+ case 260:
+ {
+ break L7;
+ }
+ default:
+ {}
+ }
+ _statement(i4);
+ if ((i6 | 0) == 274) {
+ i1 = 8;
+ break;
+ }
+ }
+ if ((i1 | 0) == 8) {
+ i6 = HEAP32[i5 >> 2] | 0;
+ }
+ if ((i6 | 0) == 286) {
+ _close_func(i4);
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ _error_expected(i4, 286);
+ }
+ return 0;
+}
+function _luaV_lessthan(i5, i4, i2) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ i6 = i4 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if ((i7 | 0) == 3) {
+ if ((HEAP32[i2 + 8 >> 2] | 0) == 3) {
+ i9 = +HEAPF64[i4 >> 3] < +HEAPF64[i2 >> 3] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ } else {
+ if ((i7 & 15 | 0) == 4 ? (HEAP32[i2 + 8 >> 2] & 15 | 0) == 4 : 0) {
+ i6 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ i3 = i6 + 16 | 0;
+ i5 = i4 + 16 | 0;
+ i7 = _strcmp(i3, i5) | 0;
+ L8 : do {
+ if ((i7 | 0) == 0) {
+ i2 = HEAP32[i6 + 12 >> 2] | 0;
+ i4 = HEAP32[i4 + 12 >> 2] | 0;
+ while (1) {
+ i7 = _strlen(i3 | 0) | 0;
+ i6 = (i7 | 0) == (i2 | 0);
+ if ((i7 | 0) == (i4 | 0)) {
+ break;
+ }
+ if (i6) {
+ i7 = -1;
+ break L8;
+ }
+ i6 = i7 + 1 | 0;
+ i3 = i3 + i6 | 0;
+ i5 = i5 + i6 | 0;
+ i7 = _strcmp(i3, i5) | 0;
+ if ((i7 | 0) == 0) {
+ i2 = i2 - i6 | 0;
+ i4 = i4 - i6 | 0;
+ } else {
+ break L8;
+ }
+ }
+ i7 = i6 & 1 ^ 1;
+ }
+ } while (0);
+ i9 = i7 >>> 31;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ }
+ i8 = i5 + 8 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ i9 = _luaT_gettmbyobj(i5, i4, 13) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ i9 = _luaT_gettmbyobj(i5, i2, 13) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ _luaG_ordererror(i5, i4, i2);
+ } else {
+ i3 = i9;
+ }
+ } else {
+ i3 = i9;
+ }
+ i10 = i5 + 28 | 0;
+ i9 = i7 - (HEAP32[i10 >> 2] | 0) | 0;
+ i11 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i11 + 16;
+ i13 = i3;
+ i12 = HEAP32[i13 + 4 >> 2] | 0;
+ i7 = i11;
+ HEAP32[i7 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i7 + 4 >> 2] = i12;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ i3 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i3 + 16;
+ i11 = i4;
+ i7 = HEAP32[i11 + 4 >> 2] | 0;
+ i4 = i3;
+ HEAP32[i4 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i4 + 4 >> 2] = i7;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 >> 2];
+ i3 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i3 + 16;
+ i4 = i2;
+ i7 = HEAP32[i4 + 4 >> 2] | 0;
+ i6 = i3;
+ HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i6 + 4 >> 2] = i7;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i2 + 8 >> 2];
+ _luaD_call(i5, (HEAP32[i8 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i5 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i2 = HEAP32[i10 >> 2] | 0;
+ i3 = HEAP32[i8 >> 2] | 0;
+ i5 = i3 + -16 | 0;
+ HEAP32[i8 >> 2] = i5;
+ i6 = HEAP32[i5 + 4 >> 2] | 0;
+ i7 = i2 + i9 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i7 + 4 >> 2] = i6;
+ HEAP32[i2 + (i9 + 8) >> 2] = HEAP32[i3 + -8 >> 2];
+ i2 = HEAP32[i8 >> 2] | 0;
+ i3 = HEAP32[i2 + 8 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if ((i3 | 0) == 1) {
+ i2 = (HEAP32[i2 >> 2] | 0) != 0;
+ } else {
+ i2 = 1;
+ }
+ } else {
+ i2 = 0;
+ }
+ i13 = i2 & 1;
+ STACKTOP = i1;
+ return i13 | 0;
+}
+function _discharge2reg(i4, i3, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i9 = i2 + 16 | 0;
+ i8 = i2;
+ _luaK_dischargevars(i4, i3);
+ i10 = HEAP32[i3 >> 2] | 0;
+ L1 : do {
+ switch (i10 | 0) {
+ case 5:
+ {
+ d11 = +HEAPF64[i3 + 8 >> 3];
+ HEAPF64[i9 >> 3] = d11;
+ i5 = HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 52 >> 2] | 0;
+ HEAPF64[i8 >> 3] = d11;
+ HEAP32[i8 + 8 >> 2] = 3;
+ if (d11 != d11 | 0.0 != 0.0 | d11 == 0.0) {
+ i10 = i5 + 8 | 0;
+ i7 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i10 >> 2] = i7 + 16;
+ i5 = _luaS_newlstr(i5, i9, 8) | 0;
+ HEAP32[i7 >> 2] = i5;
+ HEAP32[i7 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
+ i5 = _addk(i4, (HEAP32[i10 >> 2] | 0) + -16 | 0, i8) | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
+ } else {
+ i5 = _addk(i4, i8, i8) | 0;
+ }
+ i6 = i1 << 6;
+ if ((i5 | 0) < 262144) {
+ _luaK_code(i4, i6 | i5 << 14 | 1) | 0;
+ break L1;
+ } else {
+ _luaK_code(i4, i6 | 2) | 0;
+ _luaK_code(i4, i5 << 6 | 39) | 0;
+ break L1;
+ }
+ }
+ case 2:
+ case 3:
+ {
+ _luaK_code(i4, i1 << 6 | ((i10 | 0) == 2) << 23 | 3) | 0;
+ break;
+ }
+ case 4:
+ {
+ i6 = HEAP32[i3 + 8 >> 2] | 0;
+ i5 = i1 << 6;
+ if ((i6 | 0) < 262144) {
+ _luaK_code(i4, i5 | i6 << 14 | 1) | 0;
+ break L1;
+ } else {
+ _luaK_code(i4, i5 | 2) | 0;
+ _luaK_code(i4, i6 << 6 | 39) | 0;
+ break L1;
+ }
+ }
+ case 1:
+ {
+ i9 = i1 + 1 | 0;
+ i8 = HEAP32[i4 + 20 >> 2] | 0;
+ do {
+ if ((i8 | 0) > (HEAP32[i4 + 24 >> 2] | 0) ? (i5 = (HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0) + (i8 + -1 << 2) | 0, i6 = HEAP32[i5 >> 2] | 0, (i6 & 63 | 0) == 4) : 0) {
+ i10 = i6 >>> 6 & 255;
+ i8 = i10 + (i6 >>> 23) | 0;
+ if (!((i10 | 0) <= (i1 | 0) ? (i8 + 1 | 0) >= (i1 | 0) : 0)) {
+ i7 = 6;
+ }
+ if ((i7 | 0) == 6 ? (i10 | 0) < (i1 | 0) | (i10 | 0) > (i9 | 0) : 0) {
+ break;
+ }
+ i4 = (i10 | 0) < (i1 | 0) ? i10 : i1;
+ HEAP32[i5 >> 2] = i4 << 6 & 16320 | i6 & 8372287 | ((i8 | 0) > (i1 | 0) ? i8 : i1) - i4 << 23;
+ break L1;
+ }
+ } while (0);
+ _luaK_code(i4, i1 << 6 | 4) | 0;
+ break;
+ }
+ case 6:
+ {
+ i5 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i5 | 0) != (i1 | 0)) {
+ _luaK_code(i4, i5 << 23 | i1 << 6) | 0;
+ }
+ break;
+ }
+ case 11:
+ {
+ i10 = (HEAP32[(HEAP32[i4 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i3 + 8 >> 2] << 2) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i10 >> 2] & -16321 | i1 << 6 & 16320;
+ break;
+ }
+ default:
+ {
+ STACKTOP = i2;
+ return;
+ }
+ }
+ } while (0);
+ HEAP32[i3 + 8 >> 2] = i1;
+ HEAP32[i3 >> 2] = 6;
+ STACKTOP = i2;
+ return;
+}
+function _unroll(i3, i4) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
+ i9 = STACKTOP;
+ i11 = i3 + 16 | 0;
+ i13 = HEAP32[i11 >> 2] | 0;
+ i5 = i3 + 72 | 0;
+ if ((i13 | 0) == (i5 | 0)) {
+ STACKTOP = i9;
+ return;
+ }
+ i6 = i3 + 8 | 0;
+ i10 = i3 + 40 | 0;
+ i7 = i3 + 20 | 0;
+ i8 = i3 + 28 | 0;
+ i4 = i3 + 68 | 0;
+ do {
+ i12 = i13 + 18 | 0;
+ i14 = HEAP8[i12] | 0;
+ if ((i14 & 1) == 0) {
+ i14 = i14 & 255;
+ if ((i14 & 16 | 0) != 0) {
+ HEAP8[i12] = i14 & 239;
+ HEAP32[i4 >> 2] = HEAP32[i13 + 32 >> 2];
+ }
+ if ((HEAP16[i13 + 16 >> 1] | 0) == -1 ? (i2 = (HEAP32[i11 >> 2] | 0) + 4 | 0, i1 = HEAP32[i6 >> 2] | 0, (HEAP32[i2 >> 2] | 0) >>> 0 < i1 >>> 0) : 0) {
+ HEAP32[i2 >> 2] = i1;
+ }
+ i14 = HEAP8[i12] | 0;
+ if ((i14 & 32) == 0) {
+ HEAP8[i13 + 37 | 0] = 1;
+ }
+ HEAP8[i12] = i14 & 199 | 8;
+ i14 = FUNCTION_TABLE_ii[HEAP32[i13 + 28 >> 2] & 255](i3) | 0;
+ i14 = (HEAP32[i6 >> 2] | 0) + (0 - i14 << 4) | 0;
+ i13 = HEAP32[i11 >> 2] | 0;
+ i12 = HEAPU8[i10] | 0;
+ if ((i12 & 6 | 0) == 0) {
+ i15 = i13 + 8 | 0;
+ } else {
+ if ((i12 & 2 | 0) != 0) {
+ i14 = i14 - (HEAP32[i8 >> 2] | 0) | 0;
+ _luaD_hook(i3, 1, -1);
+ i14 = (HEAP32[i8 >> 2] | 0) + i14 | 0;
+ }
+ i15 = i13 + 8 | 0;
+ HEAP32[i7 >> 2] = HEAP32[(HEAP32[i15 >> 2] | 0) + 28 >> 2];
+ }
+ i12 = HEAP32[i13 >> 2] | 0;
+ i13 = HEAP16[i13 + 16 >> 1] | 0;
+ HEAP32[i11 >> 2] = HEAP32[i15 >> 2];
+ L25 : do {
+ if (!(i13 << 16 >> 16 == 0)) {
+ i15 = i13 << 16 >> 16;
+ if (i14 >>> 0 < (HEAP32[i6 >> 2] | 0) >>> 0) {
+ i13 = i14;
+ i14 = i15;
+ i15 = i12;
+ while (1) {
+ i12 = i15 + 16 | 0;
+ i18 = i13;
+ i17 = HEAP32[i18 + 4 >> 2] | 0;
+ i16 = i15;
+ HEAP32[i16 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i16 + 4 >> 2] = i17;
+ HEAP32[i15 + 8 >> 2] = HEAP32[i13 + 8 >> 2];
+ i14 = i14 + -1 | 0;
+ i13 = i13 + 16 | 0;
+ if ((i14 | 0) == 0) {
+ break L25;
+ }
+ if (i13 >>> 0 < (HEAP32[i6 >> 2] | 0) >>> 0) {
+ i15 = i12;
+ } else {
+ i13 = i14;
+ break;
+ }
+ }
+ } else {
+ i13 = i15;
+ }
+ if ((i13 | 0) > 0) {
+ i14 = i13;
+ i15 = i12;
+ while (1) {
+ i14 = i14 + -1 | 0;
+ HEAP32[i15 + 8 >> 2] = 0;
+ if ((i14 | 0) <= 0) {
+ break;
+ } else {
+ i15 = i15 + 16 | 0;
+ }
+ }
+ i12 = i12 + (i13 << 4) | 0;
+ }
+ }
+ } while (0);
+ HEAP32[i6 >> 2] = i12;
+ } else {
+ _luaV_finishOp(i3);
+ _luaV_execute(i3);
+ }
+ i13 = HEAP32[i11 >> 2] | 0;
+ } while ((i13 | 0) != (i5 | 0));
+ STACKTOP = i9;
+ return;
+}
+function _traverseephemeron(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i3 = STACKTOP;
+ i11 = i2 + 16 | 0;
+ i9 = HEAP32[i11 >> 2] | 0;
+ i5 = i9 + (1 << (HEAPU8[i2 + 7 | 0] | 0) << 5) | 0;
+ i10 = i2 + 28 | 0;
+ i13 = HEAP32[i10 >> 2] | 0;
+ if ((i13 | 0) > 0) {
+ i9 = i2 + 12 | 0;
+ i12 = 0;
+ i8 = 0;
+ do {
+ i14 = HEAP32[i9 >> 2] | 0;
+ if ((HEAP32[i14 + (i12 << 4) + 8 >> 2] & 64 | 0) != 0 ? (i7 = HEAP32[i14 + (i12 << 4) >> 2] | 0, !((HEAP8[i7 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i1, i7);
+ i13 = HEAP32[i10 >> 2] | 0;
+ i8 = 1;
+ }
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) < (i13 | 0));
+ i9 = HEAP32[i11 >> 2] | 0;
+ } else {
+ i8 = 0;
+ }
+ if (i9 >>> 0 < i5 >>> 0) {
+ i7 = 0;
+ i10 = 0;
+ do {
+ i11 = i9 + 8 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ i14 = i9 + 24 | 0;
+ i13 = HEAP32[i14 >> 2] | 0;
+ i15 = (i13 & 64 | 0) == 0;
+ L14 : do {
+ if ((i12 | 0) == 0) {
+ if (!i15 ? !((HEAP8[(HEAP32[i9 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
+ HEAP32[i14 >> 2] = 11;
+ }
+ } else {
+ do {
+ if (i15) {
+ i6 = i12;
+ i4 = 18;
+ } else {
+ i14 = HEAP32[i9 + 16 >> 2] | 0;
+ if ((i13 & 15 | 0) == 4) {
+ if ((i14 | 0) == 0) {
+ i6 = i12;
+ i4 = 18;
+ break;
+ }
+ if ((HEAP8[i14 + 5 | 0] & 3) == 0) {
+ i6 = i12;
+ i4 = 18;
+ break;
+ }
+ _reallymarkobject(i1, i14);
+ i6 = HEAP32[i11 >> 2] | 0;
+ i4 = 18;
+ break;
+ }
+ i11 = (i12 & 64 | 0) == 0;
+ if ((HEAP8[i14 + 5 | 0] & 3) == 0) {
+ if (i11) {
+ break L14;
+ } else {
+ break;
+ }
+ }
+ if (i11) {
+ i7 = 1;
+ break L14;
+ }
+ i7 = 1;
+ i10 = (HEAP8[(HEAP32[i9 >> 2] | 0) + 5 | 0] & 3) == 0 ? i10 : 1;
+ break L14;
+ }
+ } while (0);
+ if ((i4 | 0) == 18 ? (i4 = 0, (i6 & 64 | 0) == 0) : 0) {
+ break;
+ }
+ i11 = HEAP32[i9 >> 2] | 0;
+ if (!((HEAP8[i11 + 5 | 0] & 3) == 0)) {
+ _reallymarkobject(i1, i11);
+ i8 = 1;
+ }
+ }
+ } while (0);
+ i9 = i9 + 32 | 0;
+ } while (i9 >>> 0 < i5 >>> 0);
+ if ((i10 | 0) != 0) {
+ i15 = i1 + 96 | 0;
+ HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i2;
+ i15 = i8;
+ STACKTOP = i3;
+ return i15 | 0;
+ }
+ if ((i7 | 0) != 0) {
+ i15 = i1 + 100 | 0;
+ HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i2;
+ i15 = i8;
+ STACKTOP = i3;
+ return i15 | 0;
+ }
+ }
+ i15 = i1 + 88 | 0;
+ HEAP32[i2 + 24 >> 2] = HEAP32[i15 >> 2];
+ HEAP32[i15 >> 2] = i2;
+ i15 = i8;
+ STACKTOP = i3;
+ return i15 | 0;
+}
+function _luaV_gettable(i2, i7, i5, i1) {
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i6;
+ i8 = i2 + 12 | 0;
+ i3 = i7;
+ i10 = HEAP32[i7 + 8 >> 2] | 0;
+ i9 = 0;
+ while (1) {
+ i7 = i3 + 8 | 0;
+ if ((i10 | 0) != 69) {
+ i12 = _luaT_gettmbyobj(i2, i3, 0) | 0;
+ i10 = HEAP32[i12 + 8 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i8 = 11;
+ break;
+ }
+ } else {
+ i12 = HEAP32[i3 >> 2] | 0;
+ i11 = _luaH_get(i12, i5) | 0;
+ i10 = i11 + 8 | 0;
+ if ((HEAP32[i10 >> 2] | 0) != 0) {
+ i8 = 9;
+ break;
+ }
+ i12 = HEAP32[i12 + 8 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i8 = 9;
+ break;
+ }
+ if (!((HEAP8[i12 + 6 | 0] & 1) == 0)) {
+ i8 = 9;
+ break;
+ }
+ i12 = _luaT_gettm(i12, 0, HEAP32[(HEAP32[i8 >> 2] | 0) + 184 >> 2] | 0) | 0;
+ if ((i12 | 0) == 0) {
+ i8 = 9;
+ break;
+ }
+ i10 = HEAP32[i12 + 8 >> 2] | 0;
+ }
+ i9 = i9 + 1 | 0;
+ if ((i10 & 15 | 0) == 6) {
+ i8 = 13;
+ break;
+ }
+ if ((i9 | 0) < 100) {
+ i3 = i12;
+ } else {
+ i8 = 14;
+ break;
+ }
+ }
+ if ((i8 | 0) == 9) {
+ i9 = i11;
+ i11 = HEAP32[i9 + 4 >> 2] | 0;
+ i12 = i1;
+ HEAP32[i12 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ HEAP32[i1 + 8 >> 2] = HEAP32[i10 >> 2];
+ STACKTOP = i6;
+ return;
+ } else if ((i8 | 0) == 11) {
+ _luaG_typeerror(i2, i3, 8944);
+ } else if ((i8 | 0) == 13) {
+ i10 = i2 + 28 | 0;
+ i11 = i1 - (HEAP32[i10 >> 2] | 0) | 0;
+ i8 = i2 + 8 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i9 + 16;
+ i13 = i12;
+ i1 = HEAP32[i13 + 4 >> 2] | 0;
+ i4 = i9;
+ HEAP32[i4 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i4 + 4 >> 2] = i1;
+ HEAP32[i9 + 8 >> 2] = HEAP32[i12 + 8 >> 2];
+ i12 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i12 + 16;
+ i9 = HEAP32[i3 + 4 >> 2] | 0;
+ i4 = i12;
+ HEAP32[i4 >> 2] = HEAP32[i3 >> 2];
+ HEAP32[i4 + 4 >> 2] = i9;
+ HEAP32[i12 + 8 >> 2] = HEAP32[i7 >> 2];
+ i12 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i12 + 16;
+ i4 = i5;
+ i9 = HEAP32[i4 + 4 >> 2] | 0;
+ i7 = i12;
+ HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i7 + 4 >> 2] = i9;
+ HEAP32[i12 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ _luaD_call(i2, (HEAP32[i8 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i12 = HEAP32[i10 >> 2] | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ i7 = i10 + -16 | 0;
+ HEAP32[i8 >> 2] = i7;
+ i8 = HEAP32[i7 + 4 >> 2] | 0;
+ i9 = i12 + i11 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ HEAP32[i12 + (i11 + 8) >> 2] = HEAP32[i10 + -8 >> 2];
+ STACKTOP = i6;
+ return;
+ } else if ((i8 | 0) == 14) {
+ _luaG_runerror(i2, 8952, i4);
+ }
+}
+function _db_getinfo(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i3 = i2;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i4 = _lua_tothread(i1, 1) | 0;
+ i7 = 1;
+ } else {
+ i4 = i1;
+ i7 = 0;
+ }
+ i5 = i7 | 2;
+ i6 = _luaL_optlstring(i1, i5, 11784, 0) | 0;
+ i7 = i7 + 1 | 0;
+ do {
+ if ((_lua_isnumber(i1, i7) | 0) != 0) {
+ if ((_lua_getstack(i4, _lua_tointegerx(i1, i7, 0) | 0, i3) | 0) == 0) {
+ _lua_pushnil(i1);
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ } else {
+ if ((_lua_type(i1, i7) | 0) == 6) {
+ HEAP32[i3 >> 2] = i6;
+ _lua_pushfstring(i1, 11792, i3) | 0;
+ i6 = _lua_tolstring(i1, -1, 0) | 0;
+ _lua_pushvalue(i1, i7);
+ _lua_xmove(i1, i4, 1);
+ break;
+ }
+ i7 = _luaL_argerror(i1, i7, 11800) | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ } while (0);
+ if ((_lua_getinfo(i4, i6, i3) | 0) == 0) {
+ i7 = _luaL_argerror(i1, i5, 11832) | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ _lua_createtable(i1, 0, 2);
+ if ((_strchr(i6, 83) | 0) != 0) {
+ _lua_pushstring(i1, HEAP32[i3 + 16 >> 2] | 0) | 0;
+ _lua_setfield(i1, -2, 11848);
+ _lua_pushstring(i1, i3 + 36 | 0) | 0;
+ _lua_setfield(i1, -2, 11856);
+ _lua_pushinteger(i1, HEAP32[i3 + 24 >> 2] | 0);
+ _lua_setfield(i1, -2, 11872);
+ _lua_pushinteger(i1, HEAP32[i3 + 28 >> 2] | 0);
+ _lua_setfield(i1, -2, 11888);
+ _lua_pushstring(i1, HEAP32[i3 + 12 >> 2] | 0) | 0;
+ _lua_setfield(i1, -2, 11904);
+ }
+ if ((_strchr(i6, 108) | 0) != 0) {
+ _lua_pushinteger(i1, HEAP32[i3 + 20 >> 2] | 0);
+ _lua_setfield(i1, -2, 11912);
+ }
+ if ((_strchr(i6, 117) | 0) != 0) {
+ _lua_pushinteger(i1, HEAPU8[i3 + 32 | 0] | 0);
+ _lua_setfield(i1, -2, 11928);
+ _lua_pushinteger(i1, HEAPU8[i3 + 33 | 0] | 0);
+ _lua_setfield(i1, -2, 11936);
+ _lua_pushboolean(i1, HEAP8[i3 + 34 | 0] | 0);
+ _lua_setfield(i1, -2, 11944);
+ }
+ if ((_strchr(i6, 110) | 0) != 0) {
+ _lua_pushstring(i1, HEAP32[i3 + 4 >> 2] | 0) | 0;
+ _lua_setfield(i1, -2, 11960);
+ _lua_pushstring(i1, HEAP32[i3 + 8 >> 2] | 0) | 0;
+ _lua_setfield(i1, -2, 11968);
+ }
+ if ((_strchr(i6, 116) | 0) != 0) {
+ _lua_pushboolean(i1, HEAP8[i3 + 35 | 0] | 0);
+ _lua_setfield(i1, -2, 11984);
+ }
+ if ((_strchr(i6, 76) | 0) != 0) {
+ if ((i4 | 0) == (i1 | 0)) {
+ _lua_pushvalue(i1, -2);
+ _lua_remove(i1, -3);
+ } else {
+ _lua_xmove(i4, i1, 1);
+ }
+ _lua_setfield(i1, -2, 12e3);
+ }
+ if ((_strchr(i6, 102) | 0) == 0) {
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ if ((i4 | 0) == (i1 | 0)) {
+ _lua_pushvalue(i1, -2);
+ _lua_remove(i1, -3);
+ } else {
+ _lua_xmove(i4, i1, 1);
+ }
+ _lua_setfield(i1, -2, 12016);
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _luaL_traceback(i4, i1, i9, i7) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i9 = i9 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 208 | 0;
+ i6 = i3;
+ i5 = i3 + 100 | 0;
+ i2 = _lua_gettop(i4) | 0;
+ i8 = 1;
+ i10 = 1;
+ while (1) {
+ if ((_lua_getstack(i1, i8, i6) | 0) == 0) {
+ break;
+ } else {
+ i10 = i8;
+ i8 = i8 << 1;
+ }
+ }
+ if ((i10 | 0) < (i8 | 0)) {
+ while (1) {
+ i11 = (i8 + i10 | 0) / 2 | 0;
+ i12 = (_lua_getstack(i1, i11, i6) | 0) == 0;
+ i8 = i12 ? i11 : i8;
+ i10 = i12 ? i10 : i11 + 1 | 0;
+ if ((i10 | 0) >= (i8 | 0)) {
+ i10 = i8;
+ break;
+ }
+ }
+ } else {
+ i10 = i8;
+ }
+ i8 = (i10 + -1 | 0) > 22 ? 12 : 0;
+ if ((i9 | 0) != 0) {
+ HEAP32[i6 >> 2] = i9;
+ _lua_pushfstring(i4, 944, i6) | 0;
+ }
+ _lua_pushlstring(i4, 952, 16) | 0;
+ if ((_lua_getstack(i1, i7, i5) | 0) == 0) {
+ i17 = _lua_gettop(i4) | 0;
+ i17 = i17 - i2 | 0;
+ _lua_concat(i4, i17);
+ STACKTOP = i3;
+ return;
+ }
+ i10 = i10 + -11 | 0;
+ i13 = i5 + 36 | 0;
+ i9 = i5 + 20 | 0;
+ i16 = i5 + 8 | 0;
+ i12 = i5 + 12 | 0;
+ i15 = i5 + 24 | 0;
+ i14 = i5 + 35 | 0;
+ i11 = i5 + 4 | 0;
+ do {
+ i7 = i7 + 1 | 0;
+ if ((i7 | 0) == (i8 | 0)) {
+ _lua_pushlstring(i4, 976, 5) | 0;
+ i7 = i10;
+ } else {
+ _lua_getinfo(i1, 984, i5) | 0;
+ HEAP32[i6 >> 2] = i13;
+ _lua_pushfstring(i4, 992, i6) | 0;
+ i17 = HEAP32[i9 >> 2] | 0;
+ if ((i17 | 0) > 0) {
+ HEAP32[i6 >> 2] = i17;
+ _lua_pushfstring(i4, 1e3, i6) | 0;
+ }
+ _lua_pushlstring(i4, 1008, 4) | 0;
+ do {
+ if ((HEAP8[HEAP32[i16 >> 2] | 0] | 0) == 0) {
+ i17 = HEAP8[HEAP32[i12 >> 2] | 0] | 0;
+ if (i17 << 24 >> 24 == 109) {
+ _lua_pushlstring(i4, 1800, 10) | 0;
+ break;
+ } else if (i17 << 24 >> 24 == 67) {
+ if ((_pushglobalfuncname(i4, i5) | 0) == 0) {
+ _lua_pushlstring(i4, 1112, 1) | 0;
+ break;
+ } else {
+ HEAP32[i6 >> 2] = _lua_tolstring(i4, -1, 0) | 0;
+ _lua_pushfstring(i4, 1784, i6) | 0;
+ _lua_remove(i4, -2);
+ break;
+ }
+ } else {
+ i17 = HEAP32[i15 >> 2] | 0;
+ HEAP32[i6 >> 2] = i13;
+ HEAP32[i6 + 4 >> 2] = i17;
+ _lua_pushfstring(i4, 1816, i6) | 0;
+ break;
+ }
+ } else {
+ HEAP32[i6 >> 2] = HEAP32[i11 >> 2];
+ _lua_pushfstring(i4, 1784, i6) | 0;
+ }
+ } while (0);
+ if ((HEAP8[i14] | 0) != 0) {
+ _lua_pushlstring(i4, 1016, 20) | 0;
+ }
+ _lua_concat(i4, (_lua_gettop(i4) | 0) - i2 | 0);
+ }
+ } while ((_lua_getstack(i1, i7, i5) | 0) != 0);
+ i17 = _lua_gettop(i4) | 0;
+ i17 = i17 - i2 | 0;
+ _lua_concat(i4, i17);
+ STACKTOP = i3;
+ return;
+}
+function _luaK_exp2RK(i3, i1) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0, i12 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i7 = i2 + 16 | 0;
+ i6 = i2;
+ i4 = i1 + 16 | 0;
+ i5 = i1 + 20 | 0;
+ i10 = (HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0);
+ _luaK_dischargevars(i3, i1);
+ do {
+ if (!i10) {
+ if ((HEAP32[i1 >> 2] | 0) == 6) {
+ i10 = HEAP32[i1 + 8 >> 2] | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0)) {
+ break;
+ }
+ if ((i10 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i3, i1, i10);
+ break;
+ }
+ }
+ _luaK_exp2nextreg(i3, i1);
+ }
+ } while (0);
+ i10 = HEAP32[i1 >> 2] | 0;
+ switch (i10 | 0) {
+ case 4:
+ {
+ i8 = HEAP32[i1 + 8 >> 2] | 0;
+ i9 = 18;
+ break;
+ }
+ case 1:
+ case 3:
+ case 2:
+ {
+ if ((HEAP32[i3 + 32 >> 2] | 0) < 256) {
+ if ((i10 | 0) == 1) {
+ HEAP32[i6 + 8 >> 2] = 0;
+ HEAP32[i7 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i7 + 8 >> 2] = 69;
+ i3 = _addk(i3, i7, i6) | 0;
+ } else {
+ HEAP32[i7 >> 2] = (i10 | 0) == 2;
+ HEAP32[i7 + 8 >> 2] = 1;
+ i3 = _addk(i3, i7, i7) | 0;
+ }
+ HEAP32[i1 + 8 >> 2] = i3;
+ HEAP32[i1 >> 2] = 4;
+ i10 = i3 | 256;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ break;
+ }
+ case 5:
+ {
+ i9 = i1 + 8 | 0;
+ d11 = +HEAPF64[i9 >> 3];
+ HEAPF64[i7 >> 3] = d11;
+ i8 = HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0;
+ HEAPF64[i6 >> 3] = d11;
+ HEAP32[i6 + 8 >> 2] = 3;
+ if (d11 != d11 | 0.0 != 0.0 | d11 == 0.0) {
+ i10 = i8 + 8 | 0;
+ i12 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i10 >> 2] = i12 + 16;
+ i8 = _luaS_newlstr(i8, i7, 8) | 0;
+ HEAP32[i12 >> 2] = i8;
+ HEAP32[i12 + 8 >> 2] = HEAPU8[i8 + 4 | 0] | 0 | 64;
+ i8 = _addk(i3, (HEAP32[i10 >> 2] | 0) + -16 | 0, i6) | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
+ } else {
+ i8 = _addk(i3, i6, i6) | 0;
+ }
+ HEAP32[i9 >> 2] = i8;
+ HEAP32[i1 >> 2] = 4;
+ i9 = 18;
+ break;
+ }
+ default:
+ {}
+ }
+ if ((i9 | 0) == 18 ? (i8 | 0) < 256 : 0) {
+ i12 = i8 | 256;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ _luaK_dischargevars(i3, i1);
+ if ((HEAP32[i1 >> 2] | 0) == 6) {
+ i7 = i1 + 8 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (HEAP32[i5 >> 2] | 0)) {
+ i12 = i6;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ if ((i6 | 0) >= (HEAPU8[i3 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i3, i1, i6);
+ i12 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ } else {
+ i7 = i1 + 8 | 0;
+ }
+ _luaK_exp2nextreg(i3, i1);
+ i12 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i2;
+ return i12 | 0;
+}
+function _os_date(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1264 | 0;
+ i4 = i2;
+ i7 = i2 + 1048 | 0;
+ i6 = i2 + 1256 | 0;
+ i3 = i2 + 8 | 0;
+ i5 = i2 + 1056 | 0;
+ i12 = _luaL_optlstring(i1, 1, 6064, 0) | 0;
+ if ((_lua_type(i1, 2) | 0) < 1) {
+ i8 = _time(0) | 0;
+ } else {
+ i8 = ~~+_luaL_checknumber(i1, 2);
+ }
+ HEAP32[i7 >> 2] = i8;
+ if ((HEAP8[i12] | 0) == 33) {
+ i12 = i12 + 1 | 0;
+ i10 = _gmtime(i7 | 0) | 0;
+ } else {
+ i10 = _localtime(i7 | 0) | 0;
+ }
+ if ((i10 | 0) == 0) {
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return 1;
+ }
+ if ((_strcmp(i12, 6072) | 0) == 0) {
+ _lua_createtable(i1, 0, 9);
+ _lua_pushinteger(i1, HEAP32[i10 >> 2] | 0);
+ _lua_setfield(i1, -2, 5864);
+ _lua_pushinteger(i1, HEAP32[i10 + 4 >> 2] | 0);
+ _lua_setfield(i1, -2, 5872);
+ _lua_pushinteger(i1, HEAP32[i10 + 8 >> 2] | 0);
+ _lua_setfield(i1, -2, 5880);
+ _lua_pushinteger(i1, HEAP32[i10 + 12 >> 2] | 0);
+ _lua_setfield(i1, -2, 5888);
+ _lua_pushinteger(i1, (HEAP32[i10 + 16 >> 2] | 0) + 1 | 0);
+ _lua_setfield(i1, -2, 5896);
+ _lua_pushinteger(i1, (HEAP32[i10 + 20 >> 2] | 0) + 1900 | 0);
+ _lua_setfield(i1, -2, 5904);
+ _lua_pushinteger(i1, (HEAP32[i10 + 24 >> 2] | 0) + 1 | 0);
+ _lua_setfield(i1, -2, 6080);
+ _lua_pushinteger(i1, (HEAP32[i10 + 28 >> 2] | 0) + 1 | 0);
+ _lua_setfield(i1, -2, 6088);
+ i3 = HEAP32[i10 + 32 >> 2] | 0;
+ if ((i3 | 0) < 0) {
+ STACKTOP = i2;
+ return 1;
+ }
+ _lua_pushboolean(i1, i3);
+ _lua_setfield(i1, -2, 5912);
+ STACKTOP = i2;
+ return 1;
+ }
+ HEAP8[i6] = 37;
+ _luaL_buffinit(i1, i3);
+ i11 = i3 + 8 | 0;
+ i9 = i3 + 4 | 0;
+ i8 = i6 + 1 | 0;
+ i7 = i6 + 2 | 0;
+ while (1) {
+ i14 = HEAP8[i12] | 0;
+ if (i14 << 24 >> 24 == 0) {
+ break;
+ } else if (!(i14 << 24 >> 24 == 37)) {
+ i13 = HEAP32[i11 >> 2] | 0;
+ if (!(i13 >>> 0 < (HEAP32[i9 >> 2] | 0) >>> 0)) {
+ _luaL_prepbuffsize(i3, 1) | 0;
+ i13 = HEAP32[i11 >> 2] | 0;
+ i14 = HEAP8[i12] | 0;
+ }
+ HEAP32[i11 >> 2] = i13 + 1;
+ HEAP8[(HEAP32[i3 >> 2] | 0) + i13 | 0] = i14;
+ i12 = i12 + 1 | 0;
+ continue;
+ }
+ i13 = i12 + 1 | 0;
+ i12 = i12 + 2 | 0;
+ i14 = HEAP8[i13] | 0;
+ if (!(i14 << 24 >> 24 == 0) ? (_memchr(6096, i14 << 24 >> 24, 23) | 0) != 0 : 0) {
+ HEAP8[i8] = i14;
+ HEAP8[i7] = 0;
+ } else {
+ HEAP32[i4 >> 2] = i13;
+ _luaL_argerror(i1, 1, _lua_pushfstring(i1, 6120, i4) | 0) | 0;
+ i12 = i13;
+ }
+ _luaL_addlstring(i3, i5, _strftime(i5 | 0, 200, i6 | 0, i10 | 0) | 0);
+ }
+ _luaL_pushresult(i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaV_finishOp(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ i8 = HEAP32[i3 + 16 >> 2] | 0;
+ i7 = i8 + 24 | 0;
+ i4 = HEAP32[i7 >> 2] | 0;
+ i5 = i8 + 28 | 0;
+ i2 = HEAP32[(HEAP32[i5 >> 2] | 0) + -4 >> 2] | 0;
+ i6 = i2 & 63;
+ switch (i6 | 0) {
+ case 34:
+ {
+ HEAP32[i3 + 8 >> 2] = HEAP32[i8 + 4 >> 2];
+ STACKTOP = i1;
+ return;
+ }
+ case 24:
+ case 25:
+ case 26:
+ {
+ i7 = i3 + 8 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i9 = HEAP32[i8 + -8 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if ((i9 | 0) == 1) {
+ i9 = (HEAP32[i8 + -16 >> 2] | 0) == 0;
+ } else {
+ i9 = 0;
+ }
+ } else {
+ i9 = 1;
+ }
+ i9 = i9 & 1;
+ i10 = i9 ^ 1;
+ HEAP32[i7 >> 2] = i8 + -16;
+ if ((i6 | 0) == 26) {
+ i8 = (HEAP32[(_luaT_gettmbyobj(i3, i4 + (i2 >>> 23 << 4) | 0, 14) | 0) + 8 >> 2] | 0) == 0;
+ i10 = i8 ? i9 : i10;
+ }
+ if ((i10 | 0) == (i2 >>> 6 & 255 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 4;
+ STACKTOP = i1;
+ return;
+ }
+ case 22:
+ {
+ i5 = i3 + 8 | 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ i6 = i10 + -32 | 0;
+ i4 = i6 - (i4 + (i2 >>> 23 << 4)) | 0;
+ i12 = i10 + -16 | 0;
+ i11 = HEAP32[i12 + 4 >> 2] | 0;
+ i9 = i10 + -48 | 0;
+ HEAP32[i9 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i9 + 4 >> 2] = i11;
+ HEAP32[i10 + -40 >> 2] = HEAP32[i10 + -8 >> 2];
+ if ((i4 | 0) > 16) {
+ HEAP32[i5 >> 2] = i6;
+ _luaV_concat(i3, i4 >> 4);
+ }
+ i10 = HEAP32[i5 >> 2] | 0;
+ i11 = HEAP32[i7 >> 2] | 0;
+ i12 = i2 >>> 6 & 255;
+ i6 = i10 + -16 | 0;
+ i7 = HEAP32[i6 + 4 >> 2] | 0;
+ i9 = i11 + (i12 << 4) | 0;
+ HEAP32[i9 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i9 + 4 >> 2] = i7;
+ HEAP32[i11 + (i12 << 4) + 8 >> 2] = HEAP32[i10 + -8 >> 2];
+ HEAP32[i5 >> 2] = HEAP32[i8 + 4 >> 2];
+ STACKTOP = i1;
+ return;
+ }
+ case 12:
+ case 7:
+ case 6:
+ case 21:
+ case 19:
+ case 18:
+ case 17:
+ case 16:
+ case 15:
+ case 14:
+ case 13:
+ {
+ i12 = i3 + 8 | 0;
+ i11 = HEAP32[i12 >> 2] | 0;
+ i8 = i11 + -16 | 0;
+ HEAP32[i12 >> 2] = i8;
+ i12 = i2 >>> 6 & 255;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i10 = i4 + (i12 << 4) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP32[i4 + (i12 << 4) + 8 >> 2] = HEAP32[i11 + -8 >> 2];
+ STACKTOP = i1;
+ return;
+ }
+ case 29:
+ {
+ if ((i2 & 8372224 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i3 + 8 >> 2] = HEAP32[i8 + 4 >> 2];
+ STACKTOP = i1;
+ return;
+ }
+ default:
+ {
+ STACKTOP = i1;
+ return;
+ }
+ }
+}
+function _auxsort(i2, i4, i5) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ if ((i4 | 0) >= (i5 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ _lua_rawgeti(i2, 1, i4);
+ _lua_rawgeti(i2, 1, i5);
+ if ((_sort_comp(i2, -1, -2) | 0) == 0) {
+ _lua_settop(i2, -3);
+ } else {
+ _lua_rawseti(i2, 1, i4);
+ _lua_rawseti(i2, 1, i5);
+ }
+ i6 = i5 - i4 | 0;
+ if ((i6 | 0) == 1) {
+ i2 = 24;
+ break;
+ }
+ i7 = (i5 + i4 | 0) / 2 | 0;
+ _lua_rawgeti(i2, 1, i7);
+ _lua_rawgeti(i2, 1, i4);
+ do {
+ if ((_sort_comp(i2, -2, -1) | 0) == 0) {
+ _lua_settop(i2, -2);
+ _lua_rawgeti(i2, 1, i5);
+ if ((_sort_comp(i2, -1, -2) | 0) == 0) {
+ _lua_settop(i2, -3);
+ break;
+ } else {
+ _lua_rawseti(i2, 1, i7);
+ _lua_rawseti(i2, 1, i5);
+ break;
+ }
+ } else {
+ _lua_rawseti(i2, 1, i7);
+ _lua_rawseti(i2, 1, i4);
+ }
+ } while (0);
+ if ((i6 | 0) == 2) {
+ i2 = 24;
+ break;
+ }
+ _lua_rawgeti(i2, 1, i7);
+ _lua_pushvalue(i2, -1);
+ i6 = i5 + -1 | 0;
+ _lua_rawgeti(i2, 1, i6);
+ _lua_rawseti(i2, 1, i7);
+ _lua_rawseti(i2, 1, i6);
+ i7 = i4;
+ i9 = i6;
+ while (1) {
+ i8 = i7 + 1 | 0;
+ _lua_rawgeti(i2, 1, i8);
+ if ((_sort_comp(i2, -1, -2) | 0) != 0) {
+ i7 = i8;
+ while (1) {
+ if ((i7 | 0) >= (i5 | 0)) {
+ _luaL_error(i2, 8216, i3) | 0;
+ }
+ _lua_settop(i2, -2);
+ i8 = i7 + 1 | 0;
+ _lua_rawgeti(i2, 1, i8);
+ if ((_sort_comp(i2, -1, -2) | 0) == 0) {
+ break;
+ } else {
+ i7 = i8;
+ }
+ }
+ }
+ i10 = i9 + -1 | 0;
+ _lua_rawgeti(i2, 1, i10);
+ if ((_sort_comp(i2, -3, -1) | 0) != 0) {
+ i9 = i10;
+ while (1) {
+ if ((i9 | 0) <= (i4 | 0)) {
+ _luaL_error(i2, 8216, i3) | 0;
+ }
+ _lua_settop(i2, -2);
+ i10 = i9 + -1 | 0;
+ _lua_rawgeti(i2, 1, i10);
+ if ((_sort_comp(i2, -3, -1) | 0) == 0) {
+ break;
+ } else {
+ i9 = i10;
+ }
+ }
+ }
+ if ((i9 | 0) <= (i8 | 0)) {
+ break;
+ }
+ _lua_rawseti(i2, 1, i8);
+ _lua_rawseti(i2, 1, i10);
+ i7 = i8;
+ i9 = i10;
+ }
+ _lua_settop(i2, -4);
+ _lua_rawgeti(i2, 1, i6);
+ _lua_rawgeti(i2, 1, i8);
+ _lua_rawseti(i2, 1, i6);
+ _lua_rawseti(i2, 1, i8);
+ i8 = (i8 - i4 | 0) < (i5 - i8 | 0);
+ i9 = i7 + 2 | 0;
+ i10 = i8 ? i9 : i4;
+ i6 = i8 ? i5 : i7;
+ _auxsort(i2, i8 ? i4 : i9, i8 ? i7 : i5);
+ if ((i10 | 0) < (i6 | 0)) {
+ i4 = i10;
+ i5 = i6;
+ } else {
+ i2 = 24;
+ break;
+ }
+ }
+ if ((i2 | 0) == 24) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _skip_sep(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i3 >> 2] | 0;
+ i4 = i3 + 60 | 0;
+ i10 = HEAP32[i4 >> 2] | 0;
+ i8 = i10 + 4 | 0;
+ i11 = HEAP32[i8 >> 2] | 0;
+ i7 = i10 + 8 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ do {
+ if ((i11 + 1 | 0) >>> 0 > i5 >>> 0) {
+ if (i5 >>> 0 > 2147483645) {
+ _lexerror(i3, 12368, 0);
+ }
+ i12 = i5 << 1;
+ i11 = HEAP32[i3 + 52 >> 2] | 0;
+ if ((i12 | 0) == -2) {
+ _luaM_toobig(i11);
+ } else {
+ i9 = _luaM_realloc_(i11, HEAP32[i10 >> 2] | 0, i5, i12) | 0;
+ HEAP32[i10 >> 2] = i9;
+ HEAP32[i7 >> 2] = i12;
+ i6 = HEAP32[i8 >> 2] | 0;
+ break;
+ }
+ } else {
+ i6 = i11;
+ i9 = HEAP32[i10 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i8 >> 2] = i6 + 1;
+ HEAP8[i9 + i6 | 0] = i2;
+ i5 = i3 + 56 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i13 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i13 + -1;
+ if ((i13 | 0) == 0) {
+ i6 = _luaZ_fill(i6) | 0;
+ } else {
+ i13 = i6 + 4 | 0;
+ i6 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i6 + 1;
+ i6 = HEAPU8[i6] | 0;
+ }
+ HEAP32[i3 >> 2] = i6;
+ if ((i6 | 0) != 61) {
+ i12 = i6;
+ i13 = 0;
+ i12 = (i12 | 0) != (i2 | 0);
+ i12 = i12 << 31 >> 31;
+ i13 = i12 ^ i13;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ i6 = i3 + 52 | 0;
+ i7 = 0;
+ while (1) {
+ i9 = HEAP32[i4 >> 2] | 0;
+ i8 = i9 + 4 | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ i11 = i9 + 8 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ if ((i10 + 1 | 0) >>> 0 > i12 >>> 0) {
+ if (i12 >>> 0 > 2147483645) {
+ i4 = 16;
+ break;
+ }
+ i13 = i12 << 1;
+ i10 = HEAP32[i6 >> 2] | 0;
+ if ((i13 | 0) == -2) {
+ i4 = 18;
+ break;
+ }
+ i12 = _luaM_realloc_(i10, HEAP32[i9 >> 2] | 0, i12, i13) | 0;
+ HEAP32[i9 >> 2] = i12;
+ HEAP32[i11 >> 2] = i13;
+ i10 = HEAP32[i8 >> 2] | 0;
+ i9 = i12;
+ } else {
+ i9 = HEAP32[i9 >> 2] | 0;
+ }
+ HEAP32[i8 >> 2] = i10 + 1;
+ HEAP8[i9 + i10 | 0] = 61;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i13 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i13 + -1;
+ if ((i13 | 0) == 0) {
+ i8 = _luaZ_fill(i8) | 0;
+ } else {
+ i13 = i8 + 4 | 0;
+ i8 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i8 + 1;
+ i8 = HEAPU8[i8] | 0;
+ }
+ HEAP32[i3 >> 2] = i8;
+ i7 = i7 + 1 | 0;
+ if ((i8 | 0) != 61) {
+ i4 = 24;
+ break;
+ }
+ }
+ if ((i4 | 0) == 16) {
+ _lexerror(i3, 12368, 0);
+ } else if ((i4 | 0) == 18) {
+ _luaM_toobig(i10);
+ } else if ((i4 | 0) == 24) {
+ i13 = (i8 | 0) != (i2 | 0);
+ i13 = i13 << 31 >> 31;
+ i13 = i13 ^ i7;
+ STACKTOP = i1;
+ return i13 | 0;
+ }
+ return 0;
+}
+function _luaV_arith(i8, i2, i3, i5, i4) {
+ i8 = i8 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, d14 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i9 = i1 + 24 | 0;
+ i13 = i1 + 16 | 0;
+ i12 = i1;
+ i6 = i3 + 8 | 0;
+ i11 = HEAP32[i6 >> 2] | 0;
+ if ((i11 | 0) != 3) {
+ if ((i11 & 15 | 0) == 4 ? (i11 = HEAP32[i3 >> 2] | 0, (_luaO_str2d(i11 + 16 | 0, HEAP32[i11 + 12 >> 2] | 0, i13) | 0) != 0) : 0) {
+ HEAPF64[i12 >> 3] = +HEAPF64[i13 >> 3];
+ HEAP32[i12 + 8 >> 2] = 3;
+ i10 = 5;
+ }
+ } else {
+ i12 = i3;
+ i10 = 5;
+ }
+ do {
+ if ((i10 | 0) == 5) {
+ i10 = HEAP32[i5 + 8 >> 2] | 0;
+ if ((i10 | 0) == 3) {
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ d14 = +HEAPF64[i5 >> 3];
+ } else {
+ if ((i10 & 15 | 0) != 4) {
+ break;
+ }
+ i13 = HEAP32[i5 >> 2] | 0;
+ if ((_luaO_str2d(i13 + 16 | 0, HEAP32[i13 + 12 >> 2] | 0, i9) | 0) == 0) {
+ break;
+ }
+ d14 = +HEAPF64[i9 >> 3];
+ }
+ HEAPF64[i2 >> 3] = +_luaO_arith(i4 + -6 | 0, +HEAPF64[i12 >> 3], d14);
+ HEAP32[i2 + 8 >> 2] = 3;
+ STACKTOP = i1;
+ return;
+ }
+ } while (0);
+ i9 = _luaT_gettmbyobj(i8, i3, i4) | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) == 0) {
+ i4 = _luaT_gettmbyobj(i8, i5, i4) | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) == 0) {
+ _luaG_aritherror(i8, i3, i5);
+ } else {
+ i7 = i4;
+ }
+ } else {
+ i7 = i9;
+ }
+ i12 = i8 + 28 | 0;
+ i13 = i2 - (HEAP32[i12 >> 2] | 0) | 0;
+ i9 = i8 + 8 | 0;
+ i11 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i11 + 16;
+ i2 = i7;
+ i10 = HEAP32[i2 + 4 >> 2] | 0;
+ i4 = i11;
+ HEAP32[i4 >> 2] = HEAP32[i2 >> 2];
+ HEAP32[i4 + 4 >> 2] = i10;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i11 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i11 + 16;
+ i4 = i3;
+ i10 = HEAP32[i4 + 4 >> 2] | 0;
+ i7 = i11;
+ HEAP32[i7 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[i7 + 4 >> 2] = i10;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i6 >> 2];
+ i11 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i11 + 16;
+ i6 = i5;
+ i7 = HEAP32[i6 + 4 >> 2] | 0;
+ i10 = i11;
+ HEAP32[i10 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i10 + 4 >> 2] = i7;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i5 + 8 >> 2];
+ _luaD_call(i8, (HEAP32[i9 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i8 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i12 = HEAP32[i12 >> 2] | 0;
+ i11 = HEAP32[i9 >> 2] | 0;
+ i8 = i11 + -16 | 0;
+ HEAP32[i9 >> 2] = i8;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i10 = i12 + i13 | 0;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP32[i12 + (i13 + 8) >> 2] = HEAP32[i11 + -8 >> 2];
+ STACKTOP = i1;
+ return;
+}
+function _new_localvar(i1, i8) {
+ i1 = i1 | 0;
+ i8 = i8 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ i5 = HEAP32[i1 + 48 >> 2] | 0;
+ i2 = HEAP32[i1 + 64 >> 2] | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i10 = i7 + 60 | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ i6 = i5 + 44 | 0;
+ if ((HEAP16[i6 >> 1] | 0) < (i11 | 0)) {
+ i9 = i7 + 24 | 0;
+ i10 = i11;
+ } else {
+ i9 = i7 + 24 | 0;
+ HEAP32[i9 >> 2] = _luaM_growaux_(HEAP32[i1 + 52 >> 2] | 0, HEAP32[i9 >> 2] | 0, i10, 12, 32767, 6496) | 0;
+ i10 = HEAP32[i10 >> 2] | 0;
+ }
+ if ((i11 | 0) < (i10 | 0)) {
+ i12 = i11;
+ while (1) {
+ i11 = i12 + 1 | 0;
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i12 * 12 | 0) >> 2] = 0;
+ if ((i11 | 0) == (i10 | 0)) {
+ break;
+ } else {
+ i12 = i11;
+ }
+ }
+ }
+ i10 = HEAP16[i6 >> 1] | 0;
+ HEAP32[(HEAP32[i9 >> 2] | 0) + ((i10 << 16 >> 16) * 12 | 0) >> 2] = i8;
+ if (!((HEAP8[i8 + 5 | 0] & 3) == 0) ? !((HEAP8[i7 + 5 | 0] & 4) == 0) : 0) {
+ _luaC_barrier_(HEAP32[i1 + 52 >> 2] | 0, i7, i8);
+ i7 = HEAP16[i6 >> 1] | 0;
+ } else {
+ i7 = i10;
+ }
+ HEAP16[i6 >> 1] = i7 + 1 << 16 >> 16;
+ i6 = i2 + 4 | 0;
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i8 + 1 - (HEAP32[i5 + 40 >> 2] | 0) | 0) > 200) {
+ i10 = i5 + 12 | 0;
+ i9 = HEAP32[(HEAP32[i10 >> 2] | 0) + 52 >> 2] | 0;
+ i5 = HEAP32[(HEAP32[i5 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i11 = 6552;
+ HEAP32[i4 >> 2] = 6496;
+ i12 = i4 + 4 | 0;
+ HEAP32[i12 >> 2] = 200;
+ i12 = i4 + 8 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = _luaO_pushfstring(i9, 6592, i4) | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ _luaX_syntaxerror(i11, i12);
+ }
+ HEAP32[i4 >> 2] = i5;
+ i11 = _luaO_pushfstring(i9, 6568, i4) | 0;
+ HEAP32[i4 >> 2] = 6496;
+ i12 = i4 + 4 | 0;
+ HEAP32[i12 >> 2] = 200;
+ i12 = i4 + 8 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = _luaO_pushfstring(i9, 6592, i4) | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ _luaX_syntaxerror(i11, i12);
+ }
+ i4 = i2 + 8 | 0;
+ if ((i8 + 2 | 0) > (HEAP32[i4 >> 2] | 0)) {
+ i11 = _luaM_growaux_(HEAP32[i1 + 52 >> 2] | 0, HEAP32[i2 >> 2] | 0, i4, 2, 2147483645, 6496) | 0;
+ HEAP32[i2 >> 2] = i11;
+ i12 = HEAP32[i6 >> 2] | 0;
+ i10 = i12 + 1 | 0;
+ HEAP32[i6 >> 2] = i10;
+ i12 = i11 + (i12 << 1) | 0;
+ HEAP16[i12 >> 1] = i7;
+ STACKTOP = i3;
+ return;
+ } else {
+ i12 = i8;
+ i11 = HEAP32[i2 >> 2] | 0;
+ i10 = i12 + 1 | 0;
+ HEAP32[i6 >> 2] = i10;
+ i12 = i11 + (i12 << 1) | 0;
+ HEAP16[i12 >> 1] = i7;
+ STACKTOP = i3;
+ return;
+ }
+}
+function _luaC_fullgc(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ i4 = i1 + 12 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i6 = i3 + 62 | 0;
+ i8 = HEAP8[i6] | 0;
+ i5 = (i5 | 0) != 0;
+ if (!i5) {
+ HEAP8[i6] = 0;
+ i9 = (HEAP32[i4 >> 2] | 0) + 104 | 0;
+ i10 = HEAP32[i9 >> 2] | 0;
+ if ((i10 | 0) != 0) {
+ do {
+ i11 = i10 + 5 | 0;
+ HEAP8[i11] = HEAP8[i11] & 191;
+ _GCTM(i1, 1);
+ i10 = HEAP32[i9 >> 2] | 0;
+ } while ((i10 | 0) != 0);
+ if ((HEAP8[i6] | 0) == 2) {
+ i9 = 7;
+ } else {
+ i9 = 6;
+ }
+ } else {
+ i9 = 6;
+ }
+ } else {
+ HEAP8[i6] = 1;
+ i9 = 6;
+ }
+ if ((i9 | 0) == 6 ? (HEAPU8[i3 + 61 | 0] | 0) < 2 : 0) {
+ i9 = 7;
+ }
+ if ((i9 | 0) == 7) {
+ i9 = HEAP32[i4 >> 2] | 0;
+ HEAP8[i9 + 61 | 0] = 2;
+ HEAP32[i9 + 64 >> 2] = 0;
+ i10 = i9 + 72 | 0;
+ do {
+ i11 = _sweeplist(i1, i10, 1) | 0;
+ } while ((i11 | 0) == (i10 | 0));
+ HEAP32[i9 + 80 >> 2] = i11;
+ i11 = i9 + 68 | 0;
+ do {
+ i10 = _sweeplist(i1, i11, 1) | 0;
+ } while ((i10 | 0) == (i11 | 0));
+ HEAP32[i9 + 76 >> 2] = i10;
+ }
+ i11 = HEAP32[i4 >> 2] | 0;
+ i9 = i11 + 61 | 0;
+ if ((HEAP8[i9] | 0) == 5) {
+ i9 = 5;
+ } else {
+ do {
+ _singlestep(i1) | 0;
+ } while ((HEAP8[i9] | 0) != 5);
+ i9 = HEAP32[i4 >> 2] | 0;
+ i11 = i9;
+ i9 = HEAP8[i9 + 61 | 0] | 0;
+ }
+ i10 = i11 + 61 | 0;
+ if ((1 << (i9 & 255) & -33 | 0) == 0) {
+ do {
+ _singlestep(i1) | 0;
+ } while ((1 << HEAPU8[i10] & -33 | 0) == 0);
+ i9 = HEAP32[i4 >> 2] | 0;
+ i11 = i9;
+ i9 = HEAP8[i9 + 61 | 0] | 0;
+ }
+ i10 = i11 + 61 | 0;
+ if (!(i9 << 24 >> 24 == 5)) {
+ do {
+ _singlestep(i1) | 0;
+ } while ((HEAP8[i10] | 0) != 5);
+ }
+ if (i8 << 24 >> 24 == 2 ? (i7 = (HEAP32[i4 >> 2] | 0) + 61 | 0, (HEAP8[i7] | 0) != 0) : 0) {
+ do {
+ _singlestep(i1) | 0;
+ } while ((HEAP8[i7] | 0) != 0);
+ }
+ HEAP8[i6] = i8;
+ i6 = HEAP32[i3 + 8 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ i8 = (i7 + i6 | 0) / 100 | 0;
+ i9 = HEAP32[i3 + 156 >> 2] | 0;
+ if ((i9 | 0) < (2147483644 / (i8 | 0) | 0 | 0)) {
+ i8 = Math_imul(i9, i8) | 0;
+ } else {
+ i8 = 2147483644;
+ }
+ _luaE_setdebt(i3, i6 - i8 + i7 | 0);
+ if (i5) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = (HEAP32[i4 >> 2] | 0) + 104 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ do {
+ i11 = i4 + 5 | 0;
+ HEAP8[i11] = HEAP8[i11] & 191;
+ _GCTM(i1, 1);
+ i4 = HEAP32[i3 >> 2] | 0;
+ } while ((i4 | 0) != 0);
+ STACKTOP = i2;
+ return;
+}
+function _scanexp(i3, i6) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ i2 = i3 + 4 | 0;
+ i5 = HEAP32[i2 >> 2] | 0;
+ i4 = i3 + 100 | 0;
+ if (i5 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
+ HEAP32[i2 >> 2] = i5 + 1;
+ i8 = HEAPU8[i5] | 0;
+ } else {
+ i8 = ___shgetc(i3) | 0;
+ }
+ if ((i8 | 0) == 43 | (i8 | 0) == 45) {
+ i5 = (i8 | 0) == 45 | 0;
+ i7 = HEAP32[i2 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
+ HEAP32[i2 >> 2] = i7 + 1;
+ i8 = HEAPU8[i7] | 0;
+ } else {
+ i8 = ___shgetc(i3) | 0;
+ }
+ if (!((i8 + -48 | 0) >>> 0 < 10 | (i6 | 0) == 0) ? (HEAP32[i4 >> 2] | 0) != 0 : 0) {
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
+ }
+ } else {
+ i5 = 0;
+ }
+ if ((i8 + -48 | 0) >>> 0 > 9) {
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ i7 = -2147483648;
+ i8 = 0;
+ tempRet0 = i7;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
+ i7 = -2147483648;
+ i8 = 0;
+ tempRet0 = i7;
+ STACKTOP = i1;
+ return i8 | 0;
+ } else {
+ i6 = 0;
+ }
+ while (1) {
+ i6 = i8 + -48 + i6 | 0;
+ i7 = HEAP32[i2 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
+ HEAP32[i2 >> 2] = i7 + 1;
+ i8 = HEAPU8[i7] | 0;
+ } else {
+ i8 = ___shgetc(i3) | 0;
+ }
+ if (!((i8 + -48 | 0) >>> 0 < 10 & (i6 | 0) < 214748364)) {
+ break;
+ }
+ i6 = i6 * 10 | 0;
+ }
+ i7 = ((i6 | 0) < 0) << 31 >> 31;
+ if ((i8 + -48 | 0) >>> 0 < 10) {
+ do {
+ i7 = ___muldi3(i6 | 0, i7 | 0, 10, 0) | 0;
+ i6 = tempRet0;
+ i8 = _i64Add(i8 | 0, ((i8 | 0) < 0) << 31 >> 31 | 0, -48, -1) | 0;
+ i6 = _i64Add(i8 | 0, tempRet0 | 0, i7 | 0, i6 | 0) | 0;
+ i7 = tempRet0;
+ i8 = HEAP32[i2 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
+ HEAP32[i2 >> 2] = i8 + 1;
+ i8 = HEAPU8[i8] | 0;
+ } else {
+ i8 = ___shgetc(i3) | 0;
+ }
+ } while ((i8 + -48 | 0) >>> 0 < 10 & ((i7 | 0) < 21474836 | (i7 | 0) == 21474836 & i6 >>> 0 < 2061584302));
+ }
+ if ((i8 + -48 | 0) >>> 0 < 10) {
+ do {
+ i8 = HEAP32[i2 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0) {
+ HEAP32[i2 >> 2] = i8 + 1;
+ i8 = HEAPU8[i8] | 0;
+ } else {
+ i8 = ___shgetc(i3) | 0;
+ }
+ } while ((i8 + -48 | 0) >>> 0 < 10);
+ }
+ if ((HEAP32[i4 >> 2] | 0) != 0) {
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + -1;
+ }
+ i3 = (i5 | 0) != 0;
+ i2 = _i64Subtract(0, 0, i6 | 0, i7 | 0) | 0;
+ i4 = i3 ? tempRet0 : i7;
+ i8 = i3 ? i2 : i6;
+ tempRet0 = i4;
+ STACKTOP = i1;
+ return i8 | 0;
+}
+function _sweeplist(i3, i8, i9) {
+ i3 = i3 | 0;
+ i8 = i8 | 0;
+ i9 = i9 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ i5 = i3 + 12 | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAPU8[i7 + 60 | 0] | 0;
+ i2 = i6 ^ 3;
+ i7 = (HEAP8[i7 + 62 | 0] | 0) == 2;
+ i4 = i7 ? 255 : 184;
+ i6 = i7 ? 64 : i6 & 3;
+ i7 = i7 ? 64 : 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ L1 : do {
+ if ((i10 | 0) == 0) {
+ i10 = 0;
+ } else {
+ i11 = i9;
+ L2 : while (1) {
+ i9 = i11 + -1 | 0;
+ if ((i11 | 0) == 0) {
+ break L1;
+ }
+ i11 = i10 + 5 | 0;
+ i12 = HEAPU8[i11] | 0;
+ L5 : do {
+ if (((i12 ^ 3) & i2 | 0) == 0) {
+ HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
+ switch (HEAPU8[i10 + 4 | 0] | 0) {
+ case 4:
+ {
+ i12 = (HEAP32[i5 >> 2] | 0) + 28 | 0;
+ HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + -1;
+ break;
+ }
+ case 38:
+ {
+ _luaM_realloc_(i3, i10, (HEAPU8[i10 + 6 | 0] << 4) + 16 | 0, 0) | 0;
+ break L5;
+ }
+ case 6:
+ {
+ _luaM_realloc_(i3, i10, (HEAPU8[i10 + 6 | 0] << 2) + 16 | 0, 0) | 0;
+ break L5;
+ }
+ case 20:
+ {
+ break;
+ }
+ case 5:
+ {
+ _luaH_free(i3, i10);
+ break L5;
+ }
+ case 10:
+ {
+ _luaF_freeupval(i3, i10);
+ break L5;
+ }
+ case 8:
+ {
+ _luaE_freethread(i3, i10);
+ break L5;
+ }
+ case 9:
+ {
+ _luaF_freeproto(i3, i10);
+ break L5;
+ }
+ case 7:
+ {
+ _luaM_realloc_(i3, i10, (HEAP32[i10 + 16 >> 2] | 0) + 24 | 0, 0) | 0;
+ break L5;
+ }
+ default:
+ {
+ break L5;
+ }
+ }
+ _luaM_realloc_(i3, i10, (HEAP32[i10 + 12 >> 2] | 0) + 17 | 0, 0) | 0;
+ } else {
+ if ((i12 & i7 | 0) != 0) {
+ i2 = 0;
+ break L2;
+ }
+ if (((HEAP8[i10 + 4 | 0] | 0) == 8 ? (HEAP32[i10 + 28 >> 2] | 0) != 0 : 0) ? (_sweeplist(i3, i10 + 56 | 0, -3) | 0, _luaE_freeCI(i10), (HEAP8[(HEAP32[i5 >> 2] | 0) + 62 | 0] | 0) != 1) : 0) {
+ _luaD_shrinkstack(i10);
+ }
+ HEAP8[i11] = i12 & i4 | i6;
+ i8 = i10;
+ }
+ } while (0);
+ i10 = HEAP32[i8 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i10 = 0;
+ break L1;
+ } else {
+ i11 = i9;
+ }
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ } while (0);
+ i12 = (i10 | 0) == 0 ? 0 : i8;
+ STACKTOP = i1;
+ return i12 | 0;
+}
+function _resume(i1, i6) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ i3 = i1 + 16 | 0;
+ i5 = HEAP32[i3 >> 2] | 0;
+ if ((HEAPU16[i1 + 38 >> 1] | 0) > 199) {
+ _resume_error(i1, 2240, i6);
+ }
+ i4 = i1 + 6 | 0;
+ i7 = HEAP8[i4] | 0;
+ if (i7 << 24 >> 24 == 0) {
+ if ((i5 | 0) != (i1 + 72 | 0)) {
+ _resume_error(i1, 2448, i6);
+ }
+ if ((_luaD_precall(i1, i6 + -16 | 0, -1) | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaV_execute(i1);
+ STACKTOP = i2;
+ return;
+ } else if (i7 << 24 >> 24 == 1) {
+ HEAP8[i4] = 0;
+ i4 = i1 + 28 | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i4 >> 2] | 0) + (HEAP32[i5 + 20 >> 2] | 0);
+ i8 = i5 + 18 | 0;
+ i7 = HEAP8[i8] | 0;
+ if ((i7 & 1) == 0) {
+ i9 = HEAP32[i5 + 28 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ HEAP8[i5 + 37 | 0] = 1;
+ HEAP8[i8] = i7 & 255 | 8;
+ i6 = FUNCTION_TABLE_ii[i9 & 255](i1) | 0;
+ i6 = (HEAP32[i1 + 8 >> 2] | 0) + (0 - i6 << 4) | 0;
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ i7 = HEAPU8[i1 + 40 | 0] | 0;
+ if ((i7 & 6 | 0) == 0) {
+ i7 = i5 + 8 | 0;
+ } else {
+ if ((i7 & 2 | 0) != 0) {
+ i6 = i6 - (HEAP32[i4 >> 2] | 0) | 0;
+ _luaD_hook(i1, 1, -1);
+ i6 = (HEAP32[i4 >> 2] | 0) + i6 | 0;
+ }
+ i7 = i5 + 8 | 0;
+ HEAP32[i1 + 20 >> 2] = HEAP32[(HEAP32[i7 >> 2] | 0) + 28 >> 2];
+ }
+ i4 = HEAP32[i5 >> 2] | 0;
+ i5 = HEAP16[i5 + 16 >> 1] | 0;
+ HEAP32[i3 >> 2] = HEAP32[i7 >> 2];
+ i3 = i1 + 8 | 0;
+ L27 : do {
+ if (!(i5 << 16 >> 16 == 0)) {
+ i5 = i5 << 16 >> 16;
+ while (1) {
+ if (!(i6 >>> 0 < (HEAP32[i3 >> 2] | 0) >>> 0)) {
+ break;
+ }
+ i7 = i4 + 16 | 0;
+ i10 = i6;
+ i8 = HEAP32[i10 + 4 >> 2] | 0;
+ i9 = i4;
+ HEAP32[i9 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i9 + 4 >> 2] = i8;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i6 + 8 >> 2];
+ i5 = i5 + -1 | 0;
+ if ((i5 | 0) == 0) {
+ i4 = i7;
+ break L27;
+ }
+ i6 = i6 + 16 | 0;
+ i4 = i7;
+ }
+ if ((i5 | 0) > 0) {
+ i7 = i5;
+ i6 = i4;
+ while (1) {
+ i7 = i7 + -1 | 0;
+ HEAP32[i6 + 8 >> 2] = 0;
+ if ((i7 | 0) <= 0) {
+ break;
+ } else {
+ i6 = i6 + 16 | 0;
+ }
+ }
+ i4 = i4 + (i5 << 4) | 0;
+ }
+ }
+ } while (0);
+ HEAP32[i3 >> 2] = i4;
+ } else {
+ _luaV_execute(i1);
+ }
+ _unroll(i1, 0);
+ STACKTOP = i2;
+ return;
+ } else {
+ _resume_error(i1, 2488, i6);
+ }
+}
+function _lua_setupvalue(i1, i5, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ i6 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i4 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
+ i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i4 = HEAP32[i5 + 8 >> 2] & 63;
+ do {
+ if ((i4 | 0) == 6) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ i4 = HEAP32[i5 + 12 >> 2] | 0;
+ if ((i3 | 0) <= 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((HEAP32[i4 + 40 >> 2] | 0) < (i3 | 0)) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i6 = i3 + -1 | 0;
+ i3 = HEAP32[i5 + 16 + (i6 << 2) >> 2] | 0;
+ i5 = HEAP32[i3 + 8 >> 2] | 0;
+ i4 = HEAP32[(HEAP32[i4 + 28 >> 2] | 0) + (i6 << 3) >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i4 = 936;
+ } else {
+ i4 = i4 + 16 | 0;
+ }
+ } else if ((i4 | 0) == 38) {
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i3 | 0) <= 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((HEAPU8[i6 + 6 | 0] | 0 | 0) >= (i3 | 0)) {
+ i4 = 936;
+ i5 = i6 + (i3 + -1 << 4) + 16 | 0;
+ i3 = i6;
+ break;
+ } else {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ } else {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ } while (0);
+ i6 = i1 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ i10 = i7 + -16 | 0;
+ HEAP32[i6 >> 2] = i10;
+ i9 = HEAP32[i10 + 4 >> 2] | 0;
+ i8 = i5;
+ HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i8 + 4 >> 2] = i9;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + -8 >> 2];
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] & 64 | 0) == 0) {
+ i10 = i4;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP8[i5 + 5 | 0] & 3) == 0) {
+ i10 = i4;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ if ((HEAP8[i3 + 5 | 0] & 4) == 0) {
+ i10 = i4;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ _luaC_barrier_(i1, i3, i5);
+ i10 = i4;
+ STACKTOP = i2;
+ return i10 | 0;
+}
+function _luaC_forcestep(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i2 + 12 >> 2] | 0;
+ do {
+ if ((HEAP8[i3 + 62 | 0] | 0) == 2) {
+ i4 = i3 + 20 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ i5 = i3 + 61 | 0;
+ if ((HEAP8[i5] | 0) != 5) {
+ do {
+ _singlestep(i2) | 0;
+ } while ((HEAP8[i5] | 0) != 5);
+ }
+ HEAP8[i5] = 0;
+ i5 = HEAP32[i3 + 8 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ if ((i7 + i5 | 0) >>> 0 > (Math_imul(HEAP32[i3 + 160 >> 2] | 0, (i6 >>> 0) / 100 | 0) | 0) >>> 0) {
+ HEAP32[i4 >> 2] = 0;
+ break;
+ } else {
+ HEAP32[i4 >> 2] = i6;
+ break;
+ }
+ } else {
+ _luaC_fullgc(i2, 0);
+ i5 = HEAP32[i3 + 8 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ HEAP32[i4 >> 2] = i7 + i5;
+ }
+ } while (0);
+ i4 = i5 + i7 | 0;
+ i5 = (i4 | 0) / 100 | 0;
+ i6 = HEAP32[i3 + 156 >> 2] | 0;
+ if ((i6 | 0) < (2147483644 / (i5 | 0) | 0 | 0)) {
+ i5 = Math_imul(i6, i5) | 0;
+ } else {
+ i5 = 2147483644;
+ }
+ _luaE_setdebt(i3, i4 - i5 | 0);
+ i5 = i3 + 61 | 0;
+ } else {
+ i4 = i3 + 12 | 0;
+ i5 = HEAP32[i3 + 164 >> 2] | 0;
+ i7 = (i5 | 0) < 40 ? 40 : i5;
+ i5 = ((HEAP32[i4 >> 2] | 0) / 200 | 0) + 1 | 0;
+ if ((i5 | 0) < (2147483644 / (i7 | 0) | 0 | 0)) {
+ i8 = Math_imul(i5, i7) | 0;
+ } else {
+ i8 = 2147483644;
+ }
+ i5 = i3 + 61 | 0;
+ do {
+ i8 = i8 - (_singlestep(i2) | 0) | 0;
+ i9 = (HEAP8[i5] | 0) == 5;
+ if (!((i8 | 0) > -1600)) {
+ i6 = 17;
+ break;
+ }
+ } while (!i9);
+ if ((i6 | 0) == 17 ? !i9 : 0) {
+ _luaE_setdebt(i3, ((i8 | 0) / (i7 | 0) | 0) * 200 | 0);
+ break;
+ }
+ i6 = (HEAP32[i3 + 20 >> 2] | 0) / 100 | 0;
+ i7 = HEAP32[i3 + 156 >> 2] | 0;
+ if ((i7 | 0) < (2147483644 / (i6 | 0) | 0 | 0)) {
+ i6 = Math_imul(i7, i6) | 0;
+ } else {
+ i6 = 2147483644;
+ }
+ _luaE_setdebt(i3, (HEAP32[i3 + 8 >> 2] | 0) - i6 + (HEAP32[i4 >> 2] | 0) | 0);
+ }
+ } while (0);
+ i3 = i3 + 104 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ } else {
+ i4 = 0;
+ }
+ while (1) {
+ if ((i4 | 0) >= 4 ? (HEAP8[i5] | 0) != 5 : 0) {
+ i6 = 26;
+ break;
+ }
+ _GCTM(i2, 1);
+ if ((HEAP32[i3 >> 2] | 0) == 0) {
+ i6 = 26;
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ if ((i6 | 0) == 26) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _luaL_loadfilex(i1, i9, i7) {
+ i1 = i1 | 0;
+ i9 = i9 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i10 = 0, i11 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i3 = i5;
+ i6 = i5 + 16 | 0;
+ i8 = i5 + 12 | 0;
+ i2 = (_lua_gettop(i1) | 0) + 1 | 0;
+ i4 = (i9 | 0) == 0;
+ if (!i4) {
+ HEAP32[i3 >> 2] = i9;
+ _lua_pushfstring(i1, 1304, i3) | 0;
+ i10 = _fopen(i9 | 0, 1312) | 0;
+ HEAP32[i6 + 4 >> 2] = i10;
+ if ((i10 | 0) == 0) {
+ i10 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
+ i9 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
+ HEAP32[i3 >> 2] = 1320;
+ HEAP32[i3 + 4 >> 2] = i9;
+ HEAP32[i3 + 8 >> 2] = i10;
+ _lua_pushfstring(i1, 1720, i3) | 0;
+ _lua_remove(i1, i2);
+ i10 = 7;
+ STACKTOP = i5;
+ return i10 | 0;
+ }
+ } else {
+ _lua_pushlstring(i1, 1296, 6) | 0;
+ HEAP32[i6 + 4 >> 2] = HEAP32[_stdin >> 2];
+ }
+ if ((_skipcomment(i6, i8) | 0) != 0) {
+ i10 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i10 + 1;
+ HEAP8[i6 + i10 + 8 | 0] = 10;
+ }
+ i10 = HEAP32[i8 >> 2] | 0;
+ do {
+ if (!((i10 | 0) != 27 | i4)) {
+ i11 = i6 + 4 | 0;
+ i10 = _freopen(i9 | 0, 1328, HEAP32[i11 >> 2] | 0) | 0;
+ HEAP32[i11 >> 2] = i10;
+ if ((i10 | 0) != 0) {
+ _skipcomment(i6, i8) | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ break;
+ }
+ i11 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
+ i10 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
+ HEAP32[i3 >> 2] = 1336;
+ HEAP32[i3 + 4 >> 2] = i10;
+ HEAP32[i3 + 8 >> 2] = i11;
+ _lua_pushfstring(i1, 1720, i3) | 0;
+ _lua_remove(i1, i2);
+ i11 = 7;
+ STACKTOP = i5;
+ return i11 | 0;
+ }
+ } while (0);
+ if (!((i10 | 0) == -1)) {
+ i11 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i11 + 1;
+ HEAP8[i6 + i11 + 8 | 0] = i10;
+ }
+ i7 = _lua_load(i1, 1, i6, _lua_tolstring(i1, -1, 0) | 0, i7) | 0;
+ i8 = HEAP32[i6 + 4 >> 2] | 0;
+ i6 = _ferror(i8 | 0) | 0;
+ if (!i4) {
+ _fclose(i8 | 0) | 0;
+ }
+ if ((i6 | 0) == 0) {
+ _lua_remove(i1, i2);
+ i11 = i7;
+ STACKTOP = i5;
+ return i11 | 0;
+ } else {
+ _lua_settop(i1, i2);
+ i11 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
+ i10 = (_lua_tolstring(i1, i2, 0) | 0) + 1 | 0;
+ HEAP32[i3 >> 2] = 1344;
+ HEAP32[i3 + 4 >> 2] = i10;
+ HEAP32[i3 + 8 >> 2] = i11;
+ _lua_pushfstring(i1, 1720, i3) | 0;
+ _lua_remove(i1, i2);
+ i11 = 7;
+ STACKTOP = i5;
+ return i11 | 0;
+ }
+ return 0;
+}
+function _newupvalue(i3, i1, i2) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i12 = i4;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i9 = i5 + 40 | 0;
+ i7 = HEAP32[i9 >> 2] | 0;
+ i6 = i3 + 47 | 0;
+ i10 = HEAPU8[i6] | 0;
+ if ((i10 + 1 | 0) >>> 0 > 255) {
+ i11 = i3 + 12 | 0;
+ i8 = HEAP32[(HEAP32[i11 >> 2] | 0) + 52 >> 2] | 0;
+ i13 = HEAP32[i5 + 64 >> 2] | 0;
+ if ((i13 | 0) == 0) {
+ i15 = 6552;
+ HEAP32[i12 >> 2] = 6880;
+ i14 = i12 + 4 | 0;
+ HEAP32[i14 >> 2] = 255;
+ i14 = i12 + 8 | 0;
+ HEAP32[i14 >> 2] = i15;
+ i14 = _luaO_pushfstring(i8, 6592, i12) | 0;
+ i15 = HEAP32[i11 >> 2] | 0;
+ _luaX_syntaxerror(i15, i14);
+ }
+ HEAP32[i12 >> 2] = i13;
+ i14 = _luaO_pushfstring(i8, 6568, i12) | 0;
+ HEAP32[i12 >> 2] = 6880;
+ i15 = i12 + 4 | 0;
+ HEAP32[i15 >> 2] = 255;
+ i15 = i12 + 8 | 0;
+ HEAP32[i15 >> 2] = i14;
+ i15 = _luaO_pushfstring(i8, 6592, i12) | 0;
+ i14 = HEAP32[i11 >> 2] | 0;
+ _luaX_syntaxerror(i14, i15);
+ }
+ if ((i10 | 0) < (i7 | 0)) {
+ i8 = i7;
+ } else {
+ i8 = i5 + 28 | 0;
+ HEAP32[i8 >> 2] = _luaM_growaux_(HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0, HEAP32[i8 >> 2] | 0, i9, 8, 255, 6880) | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ }
+ i9 = i5 + 28 | 0;
+ if ((i7 | 0) < (i8 | 0)) {
+ while (1) {
+ i10 = i7 + 1 | 0;
+ HEAP32[(HEAP32[i9 >> 2] | 0) + (i7 << 3) >> 2] = 0;
+ if ((i10 | 0) < (i8 | 0)) {
+ i7 = i10;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP8[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) + 4 | 0] = (HEAP32[i2 >> 2] | 0) == 7 | 0;
+ HEAP8[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) + 5 | 0] = HEAP32[i2 + 8 >> 2];
+ HEAP32[(HEAP32[i9 >> 2] | 0) + ((HEAPU8[i6] | 0) << 3) >> 2] = i1;
+ if ((HEAP8[i1 + 5 | 0] & 3) == 0) {
+ i15 = HEAP8[i6] | 0;
+ i14 = i15 + 1 << 24 >> 24;
+ HEAP8[i6] = i14;
+ i15 = i15 & 255;
+ STACKTOP = i4;
+ return i15 | 0;
+ }
+ if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
+ i15 = HEAP8[i6] | 0;
+ i14 = i15 + 1 << 24 >> 24;
+ HEAP8[i6] = i14;
+ i15 = i15 & 255;
+ STACKTOP = i4;
+ return i15 | 0;
+ }
+ _luaC_barrier_(HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 52 >> 2] | 0, i5, i1);
+ i15 = HEAP8[i6] | 0;
+ i14 = i15 + 1 << 24 >> 24;
+ HEAP8[i6] = i14;
+ i15 = i15 & 255;
+ STACKTOP = i4;
+ return i15 | 0;
+}
+function _close_func(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i6 = STACKTOP;
+ i2 = HEAP32[i1 + 52 >> 2] | 0;
+ i5 = i1 + 48 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ _luaK_ret(i4, 0, 0);
+ _leaveblock(i4);
+ i7 = i4 + 20 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i2);
+ }
+ i10 = i3 + 12 | 0;
+ i9 = i3 + 48 | 0;
+ HEAP32[i10 >> 2] = _luaM_realloc_(i2, HEAP32[i10 >> 2] | 0, HEAP32[i9 >> 2] << 2, i8 << 2) | 0;
+ HEAP32[i9 >> 2] = HEAP32[i7 >> 2];
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i2);
+ }
+ i9 = i3 + 20 | 0;
+ i10 = i3 + 52 | 0;
+ HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 2, i8 << 2) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i7 >> 2];
+ i8 = i4 + 32 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 + 1 | 0) >>> 0 > 268435455) {
+ _luaM_toobig(i2);
+ }
+ i9 = i3 + 8 | 0;
+ i10 = i3 + 44 | 0;
+ HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 4, i7 << 4) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ i8 = i4 + 36 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i2);
+ }
+ i9 = i3 + 16 | 0;
+ i10 = i3 + 56 | 0;
+ HEAP32[i9 >> 2] = _luaM_realloc_(i2, HEAP32[i9 >> 2] | 0, HEAP32[i10 >> 2] << 2, i7 << 2) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i8 >> 2];
+ i7 = i4 + 44 | 0;
+ i8 = HEAP16[i7 >> 1] | 0;
+ if ((i8 + 1 | 0) >>> 0 > 357913941) {
+ _luaM_toobig(i2);
+ }
+ i10 = i3 + 24 | 0;
+ i9 = i3 + 60 | 0;
+ HEAP32[i10 >> 2] = _luaM_realloc_(i2, HEAP32[i10 >> 2] | 0, (HEAP32[i9 >> 2] | 0) * 12 | 0, i8 * 12 | 0) | 0;
+ HEAP32[i9 >> 2] = HEAP16[i7 >> 1] | 0;
+ i9 = i4 + 47 | 0;
+ i8 = i3 + 28 | 0;
+ i10 = i3 + 40 | 0;
+ HEAP32[i8 >> 2] = _luaM_realloc_(i2, HEAP32[i8 >> 2] | 0, HEAP32[i10 >> 2] << 3, HEAPU8[i9] << 3) | 0;
+ HEAP32[i10 >> 2] = HEAPU8[i9] | 0;
+ HEAP32[i5 >> 2] = HEAP32[i4 + 8 >> 2];
+ if (((HEAP32[i1 + 16 >> 2] | 0) + -288 | 0) >>> 0 < 2) {
+ i10 = HEAP32[i1 + 24 >> 2] | 0;
+ _luaX_newstring(i1, i10 + 16 | 0, HEAP32[i10 + 12 >> 2] | 0) | 0;
+ }
+ i10 = i2 + 8 | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -16;
+ if ((HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 12 >> 2] | 0) <= 0) {
+ STACKTOP = i6;
+ return;
+ }
+ _luaC_step(i2);
+ STACKTOP = i6;
+ return;
+}
+function _lua_topointer(i3, i6) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ i5 = (i6 | 0) > 0;
+ do {
+ if (!i5) {
+ if (!((i6 | 0) < -1000999)) {
+ i7 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i7 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i8 = -1001e3 - i6 | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i7 = HEAP32[i9 >> 2] | 0, (i8 | 0) <= (HEAPU8[i7 + 6 | 0] | 0 | 0)) : 0) {
+ i7 = i7 + (i8 + -1 << 4) + 16 | 0;
+ } else {
+ i7 = 5192;
+ }
+ } else {
+ i7 = (HEAP32[i4 >> 2] | 0) + (i6 << 4) | 0;
+ i7 = i7 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i7 : 5192;
+ }
+ } while (0);
+ switch (HEAP32[i7 + 8 >> 2] & 63 | 0) {
+ case 22:
+ {
+ i9 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ case 2:
+ case 7:
+ {
+ do {
+ if (!i5) {
+ if (!((i6 | 0) < -1000999)) {
+ i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i6 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i2 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i2 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i6 << 4) | 0;
+ i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ i3 = HEAP32[i2 + 8 >> 2] & 15;
+ if ((i3 | 0) == 7) {
+ i9 = (HEAP32[i2 >> 2] | 0) + 24 | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ } else if ((i3 | 0) == 2) {
+ i9 = HEAP32[i2 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ } else {
+ i9 = 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ }
+ case 8:
+ {
+ i9 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ case 5:
+ {
+ i9 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ case 38:
+ {
+ i9 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ case 6:
+ {
+ i9 = HEAP32[i7 >> 2] | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ default:
+ {
+ i9 = 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ }
+ }
+ return 0;
+}
+function _luaH_get(i4, i6) {
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, d5 = 0.0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, d11 = 0.0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i8 = i3 + 8 | 0;
+ i9 = i3;
+ i7 = i6 + 8 | 0;
+ i10 = HEAP32[i7 >> 2] & 63;
+ if ((i10 | 0) == 4) {
+ i6 = HEAP32[i6 >> 2] | 0;
+ i7 = (HEAP32[i4 + 16 >> 2] | 0) + (((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 & HEAP32[i6 + 8 >> 2]) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i7 + 24 >> 2] | 0) == 68 ? (HEAP32[i7 + 16 >> 2] | 0) == (i6 | 0) : 0) {
+ break;
+ }
+ i4 = HEAP32[i7 + 28 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i2 = 5192;
+ i1 = 22;
+ break;
+ } else {
+ i7 = i4;
+ }
+ }
+ if ((i1 | 0) == 22) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ i10 = i7;
+ STACKTOP = i3;
+ return i10 | 0;
+ } else if ((i10 | 0) == 3) {
+ d11 = +HEAPF64[i6 >> 3];
+ HEAPF64[i9 >> 3] = d11 + 6755399441055744.0;
+ i9 = HEAP32[i9 >> 2] | 0;
+ d5 = +(i9 | 0);
+ if (d5 == d11) {
+ i6 = i9 + -1 | 0;
+ if (i6 >>> 0 < (HEAP32[i4 + 28 >> 2] | 0) >>> 0) {
+ i10 = (HEAP32[i4 + 12 >> 2] | 0) + (i6 << 4) | 0;
+ STACKTOP = i3;
+ return i10 | 0;
+ }
+ HEAPF64[i8 >> 3] = d5 + 1.0;
+ i6 = (HEAP32[i8 + 4 >> 2] | 0) + (HEAP32[i8 >> 2] | 0) | 0;
+ if ((i6 | 0) < 0) {
+ i7 = 0 - i6 | 0;
+ i6 = (i6 | 0) == (i7 | 0) ? 0 : i7;
+ }
+ i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((i6 | 0) % ((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i4 + 24 >> 2] | 0) == 3 ? +HEAPF64[i4 + 16 >> 3] == d5 : 0) {
+ break;
+ }
+ i6 = HEAP32[i4 + 28 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ i2 = 5192;
+ i1 = 22;
+ break;
+ } else {
+ i4 = i6;
+ }
+ }
+ if ((i1 | 0) == 22) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ i10 = i4;
+ STACKTOP = i3;
+ return i10 | 0;
+ }
+ } else if ((i10 | 0) == 0) {
+ i10 = 5192;
+ STACKTOP = i3;
+ return i10 | 0;
+ }
+ i8 = _mainposition(i4, i6) | 0;
+ while (1) {
+ if ((HEAP32[i8 + 24 >> 2] | 0) == (HEAP32[i7 >> 2] | 0) ? (_luaV_equalobj_(0, i8 + 16 | 0, i6) | 0) != 0 : 0) {
+ break;
+ }
+ i4 = HEAP32[i8 + 28 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i2 = 5192;
+ i1 = 22;
+ break;
+ } else {
+ i8 = i4;
+ }
+ }
+ if ((i1 | 0) == 22) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ i10 = i8;
+ STACKTOP = i3;
+ return i10 | 0;
+}
+function _suffixedexp(i1, i8) {
+ i1 = i1 | 0;
+ i8 = i8 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 80 | 0;
+ i10 = i2 + 48 | 0;
+ i3 = i2 + 24 | 0;
+ i6 = i2;
+ i4 = i1 + 48 | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[i1 + 4 >> 2] | 0;
+ i7 = i1 + 16 | 0;
+ i12 = HEAP32[i7 >> 2] | 0;
+ if ((i12 | 0) == 40) {
+ _luaX_next(i1);
+ _subexpr(i1, i8, 0) | 0;
+ _check_match(i1, 41, 40, i5);
+ _luaK_dischargevars(HEAP32[i4 >> 2] | 0, i8);
+ i11 = i1 + 24 | 0;
+ } else if ((i12 | 0) == 288) {
+ i11 = i1 + 24 | 0;
+ i13 = HEAP32[i11 >> 2] | 0;
+ _luaX_next(i1);
+ i12 = HEAP32[i4 >> 2] | 0;
+ if ((_singlevaraux(i12, i13, i8, 1) | 0) == 0) {
+ _singlevaraux(i12, HEAP32[i1 + 72 >> 2] | 0, i8, 1) | 0;
+ i13 = _luaK_stringK(HEAP32[i4 >> 2] | 0, i13) | 0;
+ HEAP32[i10 + 16 >> 2] = -1;
+ HEAP32[i10 + 20 >> 2] = -1;
+ HEAP32[i10 >> 2] = 4;
+ HEAP32[i10 + 8 >> 2] = i13;
+ _luaK_indexed(i12, i8, i10);
+ }
+ } else {
+ _luaX_syntaxerror(i1, 6656);
+ }
+ i10 = i6 + 16 | 0;
+ i12 = i6 + 20 | 0;
+ i13 = i6 + 8 | 0;
+ L7 : while (1) {
+ switch (HEAP32[i7 >> 2] | 0) {
+ case 46:
+ {
+ _fieldsel(i1, i8);
+ continue L7;
+ }
+ case 91:
+ {
+ _luaK_exp2anyregup(i9, i8);
+ _luaX_next(i1);
+ _subexpr(i1, i3, 0) | 0;
+ _luaK_exp2val(HEAP32[i4 >> 2] | 0, i3);
+ if ((HEAP32[i7 >> 2] | 0) != 93) {
+ i3 = 10;
+ break L7;
+ }
+ _luaX_next(i1);
+ _luaK_indexed(i9, i8, i3);
+ continue L7;
+ }
+ case 58:
+ {
+ _luaX_next(i1);
+ if ((HEAP32[i7 >> 2] | 0) != 288) {
+ i3 = 13;
+ break L7;
+ }
+ i14 = HEAP32[i11 >> 2] | 0;
+ _luaX_next(i1);
+ i14 = _luaK_stringK(HEAP32[i4 >> 2] | 0, i14) | 0;
+ HEAP32[i10 >> 2] = -1;
+ HEAP32[i12 >> 2] = -1;
+ HEAP32[i6 >> 2] = 4;
+ HEAP32[i13 >> 2] = i14;
+ _luaK_self(i9, i8, i6);
+ _funcargs(i1, i8, i5);
+ continue L7;
+ }
+ case 123:
+ case 289:
+ case 40:
+ {
+ _luaK_exp2nextreg(i9, i8);
+ _funcargs(i1, i8, i5);
+ continue L7;
+ }
+ default:
+ {
+ i3 = 16;
+ break L7;
+ }
+ }
+ }
+ if ((i3 | 0) == 10) {
+ _error_expected(i1, 93);
+ } else if ((i3 | 0) == 13) {
+ _error_expected(i1, 288);
+ } else if ((i3 | 0) == 16) {
+ STACKTOP = i2;
+ return;
+ }
+}
+function _luaK_patchlist(i2, i7, i3) {
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ if ((HEAP32[i2 + 20 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i2 + 24 >> 2] = i3;
+ i3 = i2 + 28 | 0;
+ if ((i7 | 0) == -1) {
+ STACKTOP = i1;
+ return;
+ }
+ i6 = HEAP32[i3 >> 2] | 0;
+ if ((i6 | 0) == -1) {
+ HEAP32[i3 >> 2] = i7;
+ STACKTOP = i1;
+ return;
+ }
+ i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i3 = i5 + (i6 << 2) | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ i8 = (i4 >>> 14) + -131071 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ }
+ i8 = i6 + 1 + i8 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ } else {
+ i6 = i8;
+ }
+ }
+ i5 = ~i6 + i7 | 0;
+ if ((((i5 | 0) > -1 ? i5 : 0 - i5 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i3 >> 2] = (i5 << 14) + 2147467264 | i4 & 16383;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i7 | 0) == -1) {
+ STACKTOP = i1;
+ return;
+ }
+ i6 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
+ i10 = i7;
+ while (1) {
+ i7 = i6 + (i10 << 2) | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ i8 = (i9 >>> 14) + -131071 | 0;
+ if ((i8 | 0) == -1) {
+ i8 = -1;
+ } else {
+ i8 = i10 + 1 + i8 | 0;
+ }
+ if ((i10 | 0) > 0 ? (i4 = i6 + (i10 + -1 << 2) | 0, i5 = HEAP32[i4 >> 2] | 0, (HEAP8[5584 + (i5 & 63) | 0] | 0) < 0) : 0) {
+ i12 = i4;
+ i11 = i5;
+ } else {
+ i12 = i7;
+ i11 = i9;
+ }
+ if ((i11 & 63 | 0) == 28) {
+ HEAP32[i12 >> 2] = i11 & 8372224 | i11 >>> 23 << 6 | 27;
+ i9 = ~i10 + i3 | 0;
+ if ((((i9 | 0) > -1 ? i9 : 0 - i9 | 0) | 0) > 131071) {
+ i3 = 20;
+ break;
+ }
+ i9 = HEAP32[i7 >> 2] & 16383 | (i9 << 14) + 2147467264;
+ } else {
+ i10 = ~i10 + i3 | 0;
+ if ((((i10 | 0) > -1 ? i10 : 0 - i10 | 0) | 0) > 131071) {
+ i3 = 23;
+ break;
+ }
+ i9 = i9 & 16383 | (i10 << 14) + 2147467264;
+ }
+ HEAP32[i7 >> 2] = i9;
+ if ((i8 | 0) == -1) {
+ i3 = 26;
+ break;
+ } else {
+ i10 = i8;
+ }
+ }
+ if ((i3 | 0) == 20) {
+ _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
+ } else if ((i3 | 0) == 23) {
+ _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10624);
+ } else if ((i3 | 0) == 26) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _luaG_typeerror(i5, i6, i1) {
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i2;
+ i2 = i2 + 16 | 0;
+ i8 = HEAP32[i5 + 16 >> 2] | 0;
+ HEAP32[i2 >> 2] = 0;
+ i4 = HEAP32[8528 + ((HEAP32[i6 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
+ L1 : do {
+ if (!((HEAP8[i8 + 18 | 0] & 1) == 0)) {
+ i7 = HEAP32[HEAP32[i8 >> 2] >> 2] | 0;
+ i10 = HEAP8[i7 + 6 | 0] | 0;
+ L3 : do {
+ if (!(i10 << 24 >> 24 == 0)) {
+ i9 = i7 + 16 | 0;
+ i11 = i10 & 255;
+ i10 = 0;
+ while (1) {
+ i12 = i10 + 1 | 0;
+ if ((HEAP32[(HEAP32[i9 + (i10 << 2) >> 2] | 0) + 8 >> 2] | 0) == (i6 | 0)) {
+ break;
+ }
+ if ((i12 | 0) < (i11 | 0)) {
+ i10 = i12;
+ } else {
+ break L3;
+ }
+ }
+ i9 = HEAP32[(HEAP32[(HEAP32[i7 + 12 >> 2] | 0) + 28 >> 2] | 0) + (i10 << 3) >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = 2104;
+ } else {
+ i9 = i9 + 16 | 0;
+ }
+ HEAP32[i2 >> 2] = i9;
+ i11 = i9;
+ i10 = 2072;
+ HEAP32[i3 >> 2] = i1;
+ i12 = i3 + 4 | 0;
+ HEAP32[i12 >> 2] = i10;
+ i12 = i3 + 8 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = i3 + 12 | 0;
+ HEAP32[i12 >> 2] = i4;
+ _luaG_runerror(i5, 1840, i3);
+ }
+ } while (0);
+ i9 = HEAP32[i8 + 24 >> 2] | 0;
+ i10 = HEAP32[i8 + 4 >> 2] | 0;
+ if (i9 >>> 0 < i10 >>> 0) {
+ i12 = i9;
+ while (1) {
+ i11 = i12 + 16 | 0;
+ if ((i12 | 0) == (i6 | 0)) {
+ break;
+ }
+ if (i11 >>> 0 < i10 >>> 0) {
+ i12 = i11;
+ } else {
+ break L1;
+ }
+ }
+ i12 = HEAP32[i7 + 12 >> 2] | 0;
+ i6 = _getobjname(i12, ((HEAP32[i8 + 28 >> 2] | 0) - (HEAP32[i12 + 12 >> 2] | 0) >> 2) + -1 | 0, i6 - i9 >> 4, i2) | 0;
+ if ((i6 | 0) != 0) {
+ i11 = HEAP32[i2 >> 2] | 0;
+ i10 = i6;
+ HEAP32[i3 >> 2] = i1;
+ i12 = i3 + 4 | 0;
+ HEAP32[i12 >> 2] = i10;
+ i12 = i3 + 8 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i12 = i3 + 12 | 0;
+ HEAP32[i12 >> 2] = i4;
+ _luaG_runerror(i5, 1840, i3);
+ }
+ }
+ }
+ } while (0);
+ HEAP32[i3 >> 2] = i1;
+ HEAP32[i3 + 4 >> 2] = i4;
+ _luaG_runerror(i5, 1880, i3);
+}
+function _lua_setmetatable(i1, i7) {
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
+ i4 = STACKTOP;
+ i6 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i7 | 0) <= 0) {
+ if (!((i7 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i7 = -1001e3 - i7 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i7 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i5 + (i7 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i5 = (HEAP32[i6 >> 2] | 0) + (i7 << 4) | 0;
+ i5 = i5 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
+ }
+ } while (0);
+ i6 = i1 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i7 + -8 >> 2] | 0) == 0) {
+ i7 = 0;
+ } else {
+ i7 = HEAP32[i7 + -16 >> 2] | 0;
+ }
+ i8 = HEAP32[i5 + 8 >> 2] & 15;
+ if ((i8 | 0) == 5) {
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = i7;
+ if ((i7 | 0) == 0) {
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = i8 + -16 | 0;
+ HEAP32[i6 >> 2] = i8;
+ STACKTOP = i4;
+ return 1;
+ }
+ if (!((HEAP8[i7 + 5 | 0] & 3) == 0) ? (i2 = HEAP32[i5 >> 2] | 0, !((HEAP8[i2 + 5 | 0] & 4) == 0)) : 0) {
+ _luaC_barrierback_(i1, i2);
+ }
+ _luaC_checkfinalizer(i1, HEAP32[i5 >> 2] | 0, i7);
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = i8 + -16 | 0;
+ HEAP32[i6 >> 2] = i8;
+ STACKTOP = i4;
+ return 1;
+ } else if ((i8 | 0) == 7) {
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = i7;
+ if ((i7 | 0) == 0) {
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = i8 + -16 | 0;
+ HEAP32[i6 >> 2] = i8;
+ STACKTOP = i4;
+ return 1;
+ }
+ if (!((HEAP8[i7 + 5 | 0] & 3) == 0) ? (i3 = HEAP32[i5 >> 2] | 0, !((HEAP8[i3 + 5 | 0] & 4) == 0)) : 0) {
+ _luaC_barrier_(i1, i3, i7);
+ }
+ _luaC_checkfinalizer(i1, HEAP32[i5 >> 2] | 0, i7);
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = i8 + -16 | 0;
+ HEAP32[i6 >> 2] = i8;
+ STACKTOP = i4;
+ return 1;
+ } else {
+ HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i8 << 2) + 252 >> 2] = i7;
+ i8 = HEAP32[i6 >> 2] | 0;
+ i8 = i8 + -16 | 0;
+ HEAP32[i6 >> 2] = i8;
+ STACKTOP = i4;
+ return 1;
+ }
+ return 0;
+}
+function _recfield(i2, i10) {
+ i2 = i2 | 0;
+ i10 = i10 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i9 = i1 + 48 | 0;
+ i6 = i1 + 24 | 0;
+ i3 = i1;
+ i13 = i2 + 48 | 0;
+ i8 = HEAP32[i13 >> 2] | 0;
+ i5 = i8 + 48 | 0;
+ i4 = HEAP8[i5] | 0;
+ i7 = i2 + 16 | 0;
+ do {
+ if ((HEAP32[i7 >> 2] | 0) != 288) {
+ _luaX_next(i2);
+ _subexpr(i2, i6, 0) | 0;
+ _luaK_exp2val(HEAP32[i13 >> 2] | 0, i6);
+ if ((HEAP32[i7 >> 2] | 0) == 93) {
+ _luaX_next(i2);
+ i11 = i10 + 28 | 0;
+ break;
+ } else {
+ _error_expected(i2, 93);
+ }
+ } else {
+ i12 = i10 + 28 | 0;
+ if ((HEAP32[i12 >> 2] | 0) <= 2147483645) {
+ i11 = HEAP32[i2 + 24 >> 2] | 0;
+ _luaX_next(i2);
+ i11 = _luaK_stringK(HEAP32[i13 >> 2] | 0, i11) | 0;
+ HEAP32[i6 + 16 >> 2] = -1;
+ HEAP32[i6 + 20 >> 2] = -1;
+ HEAP32[i6 >> 2] = 4;
+ HEAP32[i6 + 8 >> 2] = i11;
+ i11 = i12;
+ break;
+ }
+ i14 = i8 + 12 | 0;
+ i13 = HEAP32[(HEAP32[i14 >> 2] | 0) + 52 >> 2] | 0;
+ i12 = HEAP32[(HEAP32[i8 >> 2] | 0) + 64 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i16 = 6552;
+ HEAP32[i9 >> 2] = 6528;
+ i15 = i9 + 4 | 0;
+ HEAP32[i15 >> 2] = 2147483645;
+ i15 = i9 + 8 | 0;
+ HEAP32[i15 >> 2] = i16;
+ i15 = _luaO_pushfstring(i13, 6592, i9) | 0;
+ i16 = HEAP32[i14 >> 2] | 0;
+ _luaX_syntaxerror(i16, i15);
+ }
+ HEAP32[i9 >> 2] = i12;
+ i15 = _luaO_pushfstring(i13, 6568, i9) | 0;
+ HEAP32[i9 >> 2] = 6528;
+ i16 = i9 + 4 | 0;
+ HEAP32[i16 >> 2] = 2147483645;
+ i16 = i9 + 8 | 0;
+ HEAP32[i16 >> 2] = i15;
+ i16 = _luaO_pushfstring(i13, 6592, i9) | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ _luaX_syntaxerror(i15, i16);
+ }
+ } while (0);
+ HEAP32[i11 >> 2] = (HEAP32[i11 >> 2] | 0) + 1;
+ if ((HEAP32[i7 >> 2] | 0) == 61) {
+ _luaX_next(i2);
+ i16 = _luaK_exp2RK(i8, i6) | 0;
+ _subexpr(i2, i3, 0) | 0;
+ i15 = HEAP32[(HEAP32[i10 + 24 >> 2] | 0) + 8 >> 2] | 0;
+ _luaK_codeABC(i8, 10, i15, i16, _luaK_exp2RK(i8, i3) | 0) | 0;
+ HEAP8[i5] = i4;
+ STACKTOP = i1;
+ return;
+ } else {
+ _error_expected(i2, 61);
+ }
+}
+function _lua_newstate(i3, i6) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i5 = i1 + 8 | 0;
+ i4 = i1;
+ i2 = FUNCTION_TABLE_iiiii[i3 & 3](i6, 0, 8, 400) | 0;
+ if ((i2 | 0) == 0) {
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ i7 = i2 + 112 | 0;
+ HEAP32[i2 >> 2] = 0;
+ HEAP8[i2 + 4 | 0] = 8;
+ HEAP8[i2 + 172 | 0] = 33;
+ HEAP8[i2 + 5 | 0] = 1;
+ HEAP8[i2 + 174 | 0] = 0;
+ HEAP32[i2 + 12 >> 2] = i7;
+ HEAP32[i2 + 28 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ HEAP32[i2 + 32 >> 2] = 0;
+ HEAP32[i2 + 64 >> 2] = 0;
+ HEAP16[i2 + 38 >> 1] = 0;
+ HEAP32[i2 + 52 >> 2] = 0;
+ HEAP8[i2 + 40 | 0] = 0;
+ HEAP32[i2 + 44 >> 2] = 0;
+ HEAP8[i2 + 41 | 0] = 1;
+ HEAP32[i2 + 48 >> 2] = 0;
+ HEAP32[i2 + 56 >> 2] = 0;
+ HEAP16[i2 + 36 >> 1] = 1;
+ HEAP8[i2 + 6 | 0] = 0;
+ HEAP32[i2 + 68 >> 2] = 0;
+ HEAP32[i7 >> 2] = i3;
+ HEAP32[i2 + 116 >> 2] = i6;
+ HEAP32[i2 + 284 >> 2] = i2;
+ i3 = _time(0) | 0;
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i5 + 4 >> 2] = i4;
+ HEAP32[i5 + 8 >> 2] = 5192;
+ HEAP32[i5 + 12 >> 2] = 1;
+ HEAP32[i2 + 168 >> 2] = _luaS_hash(i5, 16, i3) | 0;
+ i4 = i2 + 224 | 0;
+ HEAP32[i2 + 240 >> 2] = i4;
+ HEAP32[i2 + 244 >> 2] = i4;
+ HEAP8[i2 + 175 | 0] = 0;
+ i4 = i2 + 132 | 0;
+ HEAP32[i2 + 160 >> 2] = 0;
+ HEAP32[i2 + 256 >> 2] = 0;
+ HEAP32[i2 + 264 >> 2] = 0;
+ HEAP32[i2 + 280 >> 2] = 0;
+ HEAP32[i4 + 0 >> 2] = 0;
+ HEAP32[i4 + 4 >> 2] = 0;
+ HEAP32[i4 + 8 >> 2] = 0;
+ HEAP32[i4 + 12 >> 2] = 0;
+ HEAP32[i2 + 288 >> 2] = _lua_version(0) | 0;
+ HEAP8[i2 + 173 | 0] = 5;
+ i4 = i2 + 120 | 0;
+ i5 = i2 + 180 | 0;
+ i3 = i5 + 40 | 0;
+ do {
+ HEAP32[i5 >> 2] = 0;
+ i5 = i5 + 4 | 0;
+ } while ((i5 | 0) < (i3 | 0));
+ HEAP32[i4 >> 2] = 400;
+ HEAP32[i2 + 124 >> 2] = 0;
+ HEAP32[i2 + 268 >> 2] = 200;
+ HEAP32[i2 + 272 >> 2] = 200;
+ HEAP32[i2 + 276 >> 2] = 200;
+ i5 = i2 + 364 | 0;
+ i3 = i5 + 36 | 0;
+ do {
+ HEAP32[i5 >> 2] = 0;
+ i5 = i5 + 4 | 0;
+ } while ((i5 | 0) < (i3 | 0));
+ if ((_luaD_rawrunprotected(i2, 8, 0) | 0) == 0) {
+ i7 = i2;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ _close_state(i2);
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _luaU_undump(i1, i7, i8, i9) {
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i4 = i2 + 16 | 0;
+ i5 = i2 + 34 | 0;
+ i3 = i2;
+ i6 = HEAP8[i9] | 0;
+ if (i6 << 24 >> 24 == 27) {
+ HEAP32[i3 + 12 >> 2] = 8800;
+ } else if (i6 << 24 >> 24 == 61 | i6 << 24 >> 24 == 64) {
+ HEAP32[i3 + 12 >> 2] = i9 + 1;
+ } else {
+ HEAP32[i3 + 12 >> 2] = i9;
+ }
+ HEAP32[i3 >> 2] = i1;
+ HEAP32[i3 + 4 >> 2] = i7;
+ HEAP32[i3 + 8 >> 2] = i8;
+ HEAP32[i4 >> 2] = 1635077147;
+ HEAP8[i4 + 4 | 0] = 82;
+ HEAP8[i4 + 5 | 0] = 0;
+ HEAP8[i4 + 6 | 0] = 1;
+ HEAP8[i4 + 7 | 0] = 4;
+ HEAP8[i4 + 8 | 0] = 4;
+ HEAP8[i4 + 9 | 0] = 4;
+ HEAP8[i4 + 10 | 0] = 8;
+ i9 = i4 + 12 | 0;
+ HEAP8[i4 + 11 | 0] = 0;
+ HEAP8[i9 + 0 | 0] = HEAP8[8816 | 0] | 0;
+ HEAP8[i9 + 1 | 0] = HEAP8[8817 | 0] | 0;
+ HEAP8[i9 + 2 | 0] = HEAP8[8818 | 0] | 0;
+ HEAP8[i9 + 3 | 0] = HEAP8[8819 | 0] | 0;
+ HEAP8[i9 + 4 | 0] = HEAP8[8820 | 0] | 0;
+ HEAP8[i9 + 5 | 0] = HEAP8[8821 | 0] | 0;
+ HEAP8[i5] = 27;
+ if ((_luaZ_read(i7, i5 + 1 | 0, 17) | 0) != 0) {
+ _error(i3, 8824);
+ }
+ if ((_memcmp(i4, i5, 18) | 0) == 0) {
+ i4 = _luaF_newLclosure(i1, 1) | 0;
+ i5 = i1 + 8 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i9 >> 2] = i4;
+ HEAP32[i9 + 8 >> 2] = 70;
+ i9 = (HEAP32[i5 >> 2] | 0) + 16 | 0;
+ HEAP32[i5 >> 2] = i9;
+ if (((HEAP32[i1 + 24 >> 2] | 0) - i9 | 0) < 16) {
+ _luaD_growstack(i1, 0);
+ }
+ i9 = _luaF_newproto(i1) | 0;
+ i6 = i4 + 12 | 0;
+ HEAP32[i6 >> 2] = i9;
+ _LoadFunction(i3, i9);
+ i6 = HEAP32[i6 >> 2] | 0;
+ i3 = HEAP32[i6 + 40 >> 2] | 0;
+ if ((i3 | 0) == 1) {
+ i9 = i4;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ i9 = _luaF_newLclosure(i1, i3) | 0;
+ HEAP32[i9 + 12 >> 2] = i6;
+ i8 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i8 + -16 >> 2] = i9;
+ HEAP32[i8 + -8 >> 2] = 70;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ if ((_memcmp(i4, i5, 4) | 0) != 0) {
+ _error(i3, 8888);
+ }
+ if ((_memcmp(i4, i5, 6) | 0) != 0) {
+ _error(i3, 8896);
+ }
+ if ((_memcmp(i4, i5, 12) | 0) == 0) {
+ _error(i3, 8872);
+ } else {
+ _error(i3, 8920);
+ }
+ return 0;
+}
+function _lua_compare(i2, i7, i5, i3) {
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i6 = 0, i8 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i7 | 0) <= 0) {
+ if (!((i7 | 0) < -1000999)) {
+ i6 = (HEAP32[i2 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i6 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i7 = -1001e3 - i7 | 0;
+ i8 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i8 + 8 >> 2] | 0) != 22 ? (i6 = HEAP32[i8 >> 2] | 0, (i7 | 0) <= (HEAPU8[i6 + 6 | 0] | 0 | 0)) : 0) {
+ i6 = i6 + (i7 + -1 << 4) + 16 | 0;
+ } else {
+ i6 = 5192;
+ }
+ } else {
+ i6 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
+ i6 = i6 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i6 : 5192;
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i4 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i4 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) == 22) {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) > (HEAPU8[i4 + 6 | 0] | 0 | 0)) {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ } else {
+ i4 = i4 + (i5 + -1 << 4) + 16 | 0;
+ break;
+ }
+ } else {
+ i4 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ if ((i6 | 0) == 5192 | (i4 | 0) == 5192) {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ if ((i3 | 0) == 1) {
+ i8 = _luaV_lessthan(i2, i6, i4) | 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ } else if ((i3 | 0) == 2) {
+ i8 = _luaV_lessequal(i2, i6, i4) | 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ } else if ((i3 | 0) == 0) {
+ if ((HEAP32[i6 + 8 >> 2] | 0) == (HEAP32[i4 + 8 >> 2] | 0)) {
+ i2 = (_luaV_equalobj_(i2, i6, i4) | 0) != 0;
+ } else {
+ i2 = 0;
+ }
+ i8 = i2 & 1;
+ STACKTOP = i1;
+ return i8 | 0;
+ } else {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ return 0;
+}
+function _lexerror(i7, i3, i8) {
+ i7 = i7 | 0;
+ i3 = i3 | 0;
+ i8 = i8 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i12 = STACKTOP;
+ STACKTOP = STACKTOP + 80 | 0;
+ i2 = i12;
+ i12 = i12 + 12 | 0;
+ _luaO_chunkid(i12, (HEAP32[i7 + 68 >> 2] | 0) + 16 | 0, 60);
+ i1 = i7 + 52 | 0;
+ i4 = HEAP32[i1 >> 2] | 0;
+ i13 = HEAP32[i7 + 4 >> 2] | 0;
+ HEAP32[i2 >> 2] = i12;
+ HEAP32[i2 + 4 >> 2] = i13;
+ HEAP32[i2 + 8 >> 2] = i3;
+ i4 = _luaO_pushfstring(i4, 12592, i2) | 0;
+ if ((i8 | 0) == 0) {
+ i13 = HEAP32[i1 >> 2] | 0;
+ _luaD_throw(i13, 3);
+ }
+ i3 = HEAP32[i1 >> 2] | 0;
+ do {
+ if (!((i8 + -287 | 0) >>> 0 < 3)) {
+ if ((i8 | 0) >= 257) {
+ i5 = HEAP32[12096 + (i8 + -257 << 2) >> 2] | 0;
+ if ((i8 | 0) >= 286) {
+ break;
+ }
+ HEAP32[i2 >> 2] = i5;
+ i5 = _luaO_pushfstring(i3, 12256, i2) | 0;
+ break;
+ }
+ if ((HEAP8[i8 + 10913 | 0] & 4) == 0) {
+ HEAP32[i2 >> 2] = i8;
+ i5 = _luaO_pushfstring(i3, 12240, i2) | 0;
+ break;
+ } else {
+ HEAP32[i2 >> 2] = i8;
+ i5 = _luaO_pushfstring(i3, 12232, i2) | 0;
+ break;
+ }
+ } else {
+ i11 = i7 + 60 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ i10 = i12 + 4 | 0;
+ i13 = HEAP32[i10 >> 2] | 0;
+ i8 = i12 + 8 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ do {
+ if ((i13 + 1 | 0) >>> 0 > i9 >>> 0) {
+ if (i9 >>> 0 > 2147483645) {
+ _lexerror(i7, 12368, 0);
+ }
+ i7 = i9 << 1;
+ if ((i7 | 0) == -2) {
+ _luaM_toobig(i3);
+ } else {
+ i6 = _luaM_realloc_(i3, HEAP32[i12 >> 2] | 0, i9, i7) | 0;
+ HEAP32[i12 >> 2] = i6;
+ HEAP32[i8 >> 2] = i7;
+ i5 = HEAP32[i10 >> 2] | 0;
+ break;
+ }
+ } else {
+ i5 = i13;
+ i6 = HEAP32[i12 >> 2] | 0;
+ }
+ } while (0);
+ HEAP32[i10 >> 2] = i5 + 1;
+ HEAP8[i6 + i5 | 0] = 0;
+ i5 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i2 >> 2] = HEAP32[HEAP32[i11 >> 2] >> 2];
+ i5 = _luaO_pushfstring(i5, 12256, i2) | 0;
+ }
+ } while (0);
+ HEAP32[i2 >> 2] = i4;
+ HEAP32[i2 + 4 >> 2] = i5;
+ _luaO_pushfstring(i3, 12608, i2) | 0;
+ i13 = HEAP32[i1 >> 2] | 0;
+ _luaD_throw(i13, 3);
+}
+function _luaV_objlen(i2, i5, i1) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i3 = STACKTOP;
+ i4 = i1 + 8 | 0;
+ i8 = HEAP32[i4 >> 2] & 15;
+ do {
+ if ((i8 | 0) == 5) {
+ i7 = HEAP32[i1 >> 2] | 0;
+ i8 = HEAP32[i7 + 8 >> 2] | 0;
+ if (((i8 | 0) != 0 ? (HEAP8[i8 + 6 | 0] & 16) == 0 : 0) ? (i6 = _luaT_gettm(i8, 4, HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 200 >> 2] | 0) | 0, (i6 | 0) != 0) : 0) {
+ i7 = i6;
+ break;
+ }
+ HEAPF64[i5 >> 3] = +(_luaH_getn(i7) | 0);
+ HEAP32[i5 + 8 >> 2] = 3;
+ STACKTOP = i3;
+ return;
+ } else if ((i8 | 0) != 4) {
+ i6 = _luaT_gettmbyobj(i2, i1, 4) | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) == 0) {
+ _luaG_typeerror(i2, i1, 9024);
+ } else {
+ i7 = i6;
+ }
+ } else {
+ HEAPF64[i5 >> 3] = +((HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) >>> 0);
+ HEAP32[i5 + 8 >> 2] = 3;
+ STACKTOP = i3;
+ return;
+ }
+ } while (0);
+ i6 = i2 + 28 | 0;
+ i8 = i5 - (HEAP32[i6 >> 2] | 0) | 0;
+ i5 = i2 + 8 | 0;
+ i11 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i11 + 16;
+ i12 = i7;
+ i10 = HEAP32[i12 + 4 >> 2] | 0;
+ i9 = i11;
+ HEAP32[i9 >> 2] = HEAP32[i12 >> 2];
+ HEAP32[i9 + 4 >> 2] = i10;
+ HEAP32[i11 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i7 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i7 + 16;
+ i11 = i1;
+ i9 = HEAP32[i11 + 4 >> 2] | 0;
+ i10 = i7;
+ HEAP32[i10 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ HEAP32[i7 + 8 >> 2] = HEAP32[i4 >> 2];
+ i7 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i7 + 16;
+ i10 = i1;
+ i9 = HEAP32[i10 + 4 >> 2] | 0;
+ i1 = i7;
+ HEAP32[i1 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i1 + 4 >> 2] = i9;
+ HEAP32[i7 + 8 >> 2] = HEAP32[i4 >> 2];
+ _luaD_call(i2, (HEAP32[i5 >> 2] | 0) + -48 | 0, 1, HEAP8[(HEAP32[i2 + 16 >> 2] | 0) + 18 | 0] & 1);
+ i7 = HEAP32[i6 >> 2] | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i2 = i6 + -16 | 0;
+ HEAP32[i5 >> 2] = i2;
+ i4 = HEAP32[i2 + 4 >> 2] | 0;
+ i5 = i7 + i8 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i2 >> 2];
+ HEAP32[i5 + 4 >> 2] = i4;
+ HEAP32[i7 + (i8 + 8) >> 2] = HEAP32[i6 + -8 >> 2];
+ STACKTOP = i3;
+ return;
+}
+function _get_equalTM(i6, i5, i4) {
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i7 = 0;
+ i1 = STACKTOP;
+ L1 : do {
+ if (((i5 | 0) != 0 ? (HEAP8[i5 + 6 | 0] & 32) == 0 : 0) ? (i7 = i6 + 12 | 0, i2 = _luaT_gettm(i5, 5, HEAP32[(HEAP32[i7 >> 2] | 0) + 204 >> 2] | 0) | 0, (i2 | 0) != 0) : 0) {
+ if ((i5 | 0) != (i4 | 0)) {
+ if (((i4 | 0) != 0 ? (HEAP8[i4 + 6 | 0] & 32) == 0 : 0) ? (i3 = _luaT_gettm(i4, 5, HEAP32[(HEAP32[i7 >> 2] | 0) + 204 >> 2] | 0) | 0, (i3 | 0) != 0) : 0) {
+ i4 = HEAP32[i2 + 8 >> 2] | 0;
+ L9 : do {
+ if ((i4 | 0) == (HEAP32[i3 + 8 >> 2] | 0)) {
+ switch (i4 & 63 | 0) {
+ case 3:
+ {
+ i3 = +HEAPF64[i2 >> 3] == +HEAPF64[i3 >> 3] | 0;
+ break;
+ }
+ case 22:
+ {
+ i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
+ break;
+ }
+ case 5:
+ {
+ if ((HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0)) {
+ break L1;
+ } else {
+ break L9;
+ }
+ }
+ case 1:
+ {
+ i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
+ break;
+ }
+ case 4:
+ {
+ i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
+ break;
+ }
+ case 0:
+ {
+ break L1;
+ }
+ case 7:
+ {
+ if ((HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0)) {
+ break L1;
+ } else {
+ break L9;
+ }
+ }
+ case 2:
+ {
+ i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
+ break;
+ }
+ case 20:
+ {
+ i3 = _luaS_eqlngstr(HEAP32[i2 >> 2] | 0, HEAP32[i3 >> 2] | 0) | 0;
+ break;
+ }
+ default:
+ {
+ i3 = (HEAP32[i2 >> 2] | 0) == (HEAP32[i3 >> 2] | 0) | 0;
+ }
+ }
+ if ((i3 | 0) != 0) {
+ break L1;
+ }
+ }
+ } while (0);
+ i2 = 0;
+ } else {
+ i2 = 0;
+ }
+ }
+ } else {
+ i2 = 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaS_newlstr(i2, i4, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ if (!(i3 >>> 0 < 41)) {
+ if ((i3 + 1 | 0) >>> 0 > 4294967277) {
+ _luaM_toobig(i2);
+ }
+ i10 = HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 56 >> 2] | 0;
+ i11 = _luaC_newobj(i2, 20, i3 + 17 | 0, 0, 0) | 0;
+ HEAP32[i11 + 12 >> 2] = i3;
+ HEAP32[i11 + 8 >> 2] = i10;
+ HEAP8[i11 + 6 | 0] = 0;
+ i10 = i11 + 16 | 0;
+ _memcpy(i10 | 0, i4 | 0, i3 | 0) | 0;
+ HEAP8[i10 + i3 | 0] = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i5 = HEAP32[i2 + 12 >> 2] | 0;
+ i6 = HEAP32[i5 + 56 >> 2] ^ i3;
+ i7 = (i3 >>> 5) + 1 | 0;
+ if (!(i7 >>> 0 > i3 >>> 0)) {
+ i8 = i3;
+ do {
+ i6 = (i6 << 5) + (i6 >>> 2) + (HEAPU8[i4 + (i8 + -1) | 0] | 0) ^ i6;
+ i8 = i8 - i7 | 0;
+ } while (!(i8 >>> 0 < i7 >>> 0));
+ }
+ i10 = i5 + 32 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ i7 = i5 + 24 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ i11 = HEAP32[i8 + ((i9 + -1 & i6) << 2) >> 2] | 0;
+ L12 : do {
+ if ((i11 | 0) != 0) {
+ while (1) {
+ if (((i6 | 0) == (HEAP32[i11 + 8 >> 2] | 0) ? (HEAP32[i11 + 12 >> 2] | 0) == (i3 | 0) : 0) ? (_memcmp(i4, i11 + 16 | 0, i3) | 0) == 0 : 0) {
+ break;
+ }
+ i11 = HEAP32[i11 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ break L12;
+ }
+ }
+ i2 = i11 + 5 | 0;
+ i3 = (HEAPU8[i2] | 0) ^ 3;
+ if ((((HEAPU8[i5 + 60 | 0] | 0) ^ 3) & i3 | 0) != 0) {
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ HEAP8[i2] = i3;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ } while (0);
+ i5 = i5 + 28 | 0;
+ if ((HEAP32[i5 >> 2] | 0) >>> 0 >= i9 >>> 0 & (i9 | 0) < 1073741823) {
+ _luaS_resize(i2, i9 << 1);
+ i9 = HEAP32[i10 >> 2] | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ }
+ i11 = _luaC_newobj(i2, 4, i3 + 17 | 0, i8 + ((i9 + -1 & i6) << 2) | 0, 0) | 0;
+ HEAP32[i11 + 12 >> 2] = i3;
+ HEAP32[i11 + 8 >> 2] = i6;
+ HEAP8[i11 + 6 | 0] = 0;
+ i10 = i11 + 16 | 0;
+ _memcpy(i10 | 0, i4 | 0, i3 | 0) | 0;
+ HEAP8[i10 + i3 | 0] = 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ STACKTOP = i1;
+ return i11 | 0;
+}
+function _lua_pcallk(i3, i7, i2, i9, i6, i5) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ i2 = i2 | 0;
+ i9 = i9 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i4 = 0, i8 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i1;
+ if ((i9 | 0) == 0) {
+ i9 = 0;
+ } else {
+ i10 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i9 | 0) <= 0) {
+ if (!((i9 | 0) < -1000999)) {
+ i8 = (HEAP32[i3 + 8 >> 2] | 0) + (i9 << 4) | 0;
+ break;
+ }
+ if ((i9 | 0) == -1001e3) {
+ i8 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i9 = -1001e3 - i9 | 0;
+ i10 = HEAP32[i10 >> 2] | 0;
+ if ((HEAP32[i10 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i10 >> 2] | 0, (i9 | 0) <= (HEAPU8[i8 + 6 | 0] | 0)) : 0) {
+ i8 = i8 + (i9 + -1 << 4) + 16 | 0;
+ } else {
+ i8 = 5192;
+ }
+ } else {
+ i8 = (HEAP32[i10 >> 2] | 0) + (i9 << 4) | 0;
+ i8 = i8 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
+ }
+ } while (0);
+ i9 = i8 - (HEAP32[i3 + 28 >> 2] | 0) | 0;
+ }
+ i8 = i3 + 8 | 0;
+ i7 = (HEAP32[i8 >> 2] | 0) + (~i7 << 4) | 0;
+ HEAP32[i4 >> 2] = i7;
+ if ((i5 | 0) != 0 ? (HEAP16[i3 + 36 >> 1] | 0) == 0 : 0) {
+ i11 = HEAP32[i3 + 16 >> 2] | 0;
+ HEAP32[i11 + 28 >> 2] = i5;
+ HEAP32[i11 + 24 >> 2] = i6;
+ HEAP32[i11 + 20 >> 2] = (HEAP32[i4 >> 2] | 0) - (HEAP32[i3 + 28 >> 2] | 0);
+ HEAP8[i11 + 36 | 0] = HEAP8[i3 + 41 | 0] | 0;
+ i10 = i3 + 68 | 0;
+ i7 = i11 + 32 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i10 >> 2] = i9;
+ i9 = i11 + 18 | 0;
+ HEAP8[i9] = HEAPU8[i9] | 16;
+ _luaD_call(i3, HEAP32[i4 >> 2] | 0, i2, 1);
+ HEAP8[i9] = HEAP8[i9] & 239;
+ HEAP32[i10 >> 2] = HEAP32[i7 >> 2];
+ i4 = 0;
+ } else {
+ HEAP32[i4 + 4 >> 2] = i2;
+ i4 = _luaD_pcall(i3, 3, i4, i7 - (HEAP32[i3 + 28 >> 2] | 0) | 0, i9) | 0;
+ }
+ if (!((i2 | 0) == -1)) {
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i2 = (HEAP32[i3 + 16 >> 2] | 0) + 4 | 0;
+ i3 = HEAP32[i8 >> 2] | 0;
+ if (!((HEAP32[i2 >> 2] | 0) >>> 0 < i3 >>> 0)) {
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _lua_getupvalue(i1, i6, i3) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i5 = HEAP32[i4 + 8 >> 2] & 63;
+ do {
+ if ((i5 | 0) == 38) {
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) <= 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((HEAPU8[i5 + 6 | 0] | 0 | 0) < (i3 | 0)) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ i4 = 936;
+ i3 = i5 + (i3 + -1 << 4) + 16 | 0;
+ break;
+ }
+ } else if ((i5 | 0) == 6) {
+ i5 = HEAP32[i4 >> 2] | 0;
+ i4 = HEAP32[i5 + 12 >> 2] | 0;
+ if ((i3 | 0) <= 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((HEAP32[i4 + 40 >> 2] | 0) < (i3 | 0)) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i6 = i3 + -1 | 0;
+ i3 = HEAP32[(HEAP32[i5 + 16 + (i6 << 2) >> 2] | 0) + 8 >> 2] | 0;
+ i4 = HEAP32[(HEAP32[i4 + 28 >> 2] | 0) + (i6 << 3) >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i4 = 936;
+ } else {
+ i4 = i4 + 16 | 0;
+ }
+ } else {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ } while (0);
+ i6 = i1 + 8 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i8 = i3;
+ i7 = HEAP32[i8 + 4 >> 2] | 0;
+ i1 = i5;
+ HEAP32[i1 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i1 + 4 >> 2] = i7;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
+ i6 = i4;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _lua_copy(i1, i8, i4) {
+ i1 = i1 | 0;
+ i8 = i8 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0;
+ i2 = STACKTOP;
+ i3 = i1 + 16 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ do {
+ if ((i8 | 0) <= 0) {
+ if (!((i8 | 0) < -1000999)) {
+ i7 = (HEAP32[i1 + 8 >> 2] | 0) + (i8 << 4) | 0;
+ break;
+ }
+ if ((i8 | 0) == -1001e3) {
+ i7 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i8 = -1001e3 - i8 | 0;
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i7 = HEAP32[i9 >> 2] | 0, (i8 | 0) <= (HEAPU8[i7 + 6 | 0] | 0 | 0)) : 0) {
+ i7 = i7 + (i8 + -1 << 4) + 16 | 0;
+ } else {
+ i7 = 5192;
+ }
+ } else {
+ i7 = (HEAP32[i6 >> 2] | 0) + (i8 << 4) | 0;
+ i7 = i7 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i7 : 5192;
+ }
+ } while (0);
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i8 = -1001e3 - i4 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i8 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i5 + (i8 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i5 = (HEAP32[i6 >> 2] | 0) + (i4 << 4) | 0;
+ i5 = i5 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
+ }
+ } while (0);
+ i8 = i7;
+ i9 = HEAP32[i8 + 4 >> 2] | 0;
+ i6 = i5;
+ HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i6 + 4 >> 2] = i9;
+ i6 = i7 + 8 | 0;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 >> 2];
+ if (!((i4 | 0) < -1001e3)) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP32[i6 >> 2] & 64 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((HEAP8[i4 + 5 | 0] & 3) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = HEAP32[HEAP32[HEAP32[i3 >> 2] >> 2] >> 2] | 0;
+ if ((HEAP8[i3 + 5 | 0] & 4) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaC_barrier_(i1, i3, i4);
+ STACKTOP = i2;
+ return;
+}
+function _lua_tolstring(i4, i5, i1) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ i7 = i4 + 16 | 0;
+ i10 = HEAP32[i7 >> 2] | 0;
+ i6 = (i5 | 0) > 0;
+ do {
+ if (!i6) {
+ if (!((i5 | 0) < -1000999)) {
+ i8 = (HEAP32[i4 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i8 = (HEAP32[i4 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i9 = -1001e3 - i5 | 0;
+ i10 = HEAP32[i10 >> 2] | 0;
+ if ((HEAP32[i10 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i10 >> 2] | 0, (i9 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
+ i8 = i8 + (i9 + -1 << 4) + 16 | 0;
+ } else {
+ i8 = 5192;
+ }
+ } else {
+ i8 = (HEAP32[i10 >> 2] | 0) + (i5 << 4) | 0;
+ i8 = i8 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
+ }
+ } while (0);
+ do {
+ if ((HEAP32[i8 + 8 >> 2] & 15 | 0) != 4) {
+ if ((_luaV_tostring(i4, i8) | 0) == 0) {
+ if ((i1 | 0) == 0) {
+ i10 = 0;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ HEAP32[i1 >> 2] = 0;
+ i10 = 0;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[(HEAP32[i8 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i4);
+ }
+ i7 = HEAP32[i7 >> 2] | 0;
+ if (i6) {
+ i3 = (HEAP32[i7 >> 2] | 0) + (i5 << 4) | 0;
+ i8 = i3 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ break;
+ }
+ if (!((i5 | 0) < -1000999)) {
+ i8 = (HEAP32[i4 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i8 = (HEAP32[i8 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i4 = -1001e3 - i5 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i8 = i3 + (i4 + -1 << 4) + 16 | 0;
+ } else {
+ i8 = 5192;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i8 >> 2] | 0;
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = HEAP32[i3 + 12 >> 2];
+ }
+ i10 = i3 + 16 | 0;
+ STACKTOP = i2;
+ return i10 | 0;
+}
+function _luaD_pcall(i3, i6, i5, i13, i14) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i13 = i13 | 0;
+ i14 = i14 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
+ i1 = STACKTOP;
+ i10 = i3 + 16 | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ i12 = i3 + 41 | 0;
+ i7 = HEAP8[i12] | 0;
+ i9 = i3 + 36 | 0;
+ i8 = HEAP16[i9 >> 1] | 0;
+ i4 = i3 + 68 | 0;
+ i2 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i14;
+ i5 = _luaD_rawrunprotected(i3, i6, i5) | 0;
+ if ((i5 | 0) == 0) {
+ HEAP32[i4 >> 2] = i2;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i6 = i3 + 28 | 0;
+ i14 = HEAP32[i6 >> 2] | 0;
+ i15 = i14 + i13 | 0;
+ _luaF_close(i3, i15);
+ if ((i5 | 0) == 6) {
+ i16 = _luaS_newlstr(i3, 2424, 23) | 0;
+ HEAP32[i15 >> 2] = i16;
+ HEAP32[i14 + (i13 + 8) >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
+ } else if ((i5 | 0) == 4) {
+ i16 = HEAP32[(HEAP32[i3 + 12 >> 2] | 0) + 180 >> 2] | 0;
+ HEAP32[i15 >> 2] = i16;
+ HEAP32[i14 + (i13 + 8) >> 2] = HEAPU8[i16 + 4 | 0] | 0 | 64;
+ } else {
+ i16 = HEAP32[i3 + 8 >> 2] | 0;
+ i18 = i16 + -16 | 0;
+ i17 = HEAP32[i18 + 4 >> 2] | 0;
+ HEAP32[i15 >> 2] = HEAP32[i18 >> 2];
+ HEAP32[i15 + 4 >> 2] = i17;
+ HEAP32[i14 + (i13 + 8) >> 2] = HEAP32[i16 + -8 >> 2];
+ }
+ i13 = i14 + (i13 + 16) | 0;
+ HEAP32[i3 + 8 >> 2] = i13;
+ HEAP32[i10 >> 2] = i11;
+ HEAP8[i12] = i7;
+ HEAP16[i9 >> 1] = i8;
+ if ((i11 | 0) != 0) {
+ do {
+ i7 = HEAP32[i11 + 4 >> 2] | 0;
+ i13 = i13 >>> 0 < i7 >>> 0 ? i7 : i13;
+ i11 = HEAP32[i11 + 8 >> 2] | 0;
+ } while ((i11 | 0) != 0);
+ }
+ i6 = i13 - (HEAP32[i6 >> 2] | 0) | 0;
+ i7 = (i6 >> 4) + 1 | 0;
+ i7 = ((i7 | 0) / 8 | 0) + 10 + i7 | 0;
+ i7 = (i7 | 0) > 1e6 ? 1e6 : i7;
+ if ((i6 | 0) > 15999984) {
+ HEAP32[i4 >> 2] = i2;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ if ((i7 | 0) >= (HEAP32[i3 + 32 >> 2] | 0)) {
+ HEAP32[i4 >> 2] = i2;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ _luaD_reallocstack(i3, i7);
+ HEAP32[i4 >> 2] = i2;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _luaH_resize(i1, i4, i6, i9) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0;
+ i3 = STACKTOP;
+ i8 = i4 + 28 | 0;
+ i5 = HEAP32[i8 >> 2] | 0;
+ i7 = HEAPU8[i4 + 7 | 0] | 0;
+ i2 = HEAP32[i4 + 16 >> 2] | 0;
+ if ((i5 | 0) < (i6 | 0)) {
+ if ((i6 + 1 | 0) >>> 0 > 268435455) {
+ _luaM_toobig(i1);
+ }
+ i11 = i4 + 12 | 0;
+ i10 = _luaM_realloc_(i1, HEAP32[i11 >> 2] | 0, i5 << 4, i6 << 4) | 0;
+ HEAP32[i11 >> 2] = i10;
+ i11 = HEAP32[i8 >> 2] | 0;
+ if ((i11 | 0) < (i6 | 0)) {
+ do {
+ HEAP32[i10 + (i11 << 4) + 8 >> 2] = 0;
+ i11 = i11 + 1 | 0;
+ } while ((i11 | 0) != (i6 | 0));
+ }
+ HEAP32[i8 >> 2] = i6;
+ }
+ _setnodevector(i1, i4, i9);
+ do {
+ if ((i5 | 0) > (i6 | 0)) {
+ HEAP32[i8 >> 2] = i6;
+ i8 = i4 + 12 | 0;
+ i9 = i6;
+ do {
+ i10 = HEAP32[i8 >> 2] | 0;
+ if ((HEAP32[i10 + (i9 << 4) + 8 >> 2] | 0) == 0) {
+ i9 = i9 + 1 | 0;
+ } else {
+ i11 = i9 + 1 | 0;
+ _luaH_setint(i1, i4, i11, i10 + (i9 << 4) | 0);
+ i9 = i11;
+ }
+ } while ((i9 | 0) != (i5 | 0));
+ if ((i6 + 1 | 0) >>> 0 > 268435455) {
+ _luaM_toobig(i1);
+ } else {
+ i11 = i4 + 12 | 0;
+ HEAP32[i11 >> 2] = _luaM_realloc_(i1, HEAP32[i11 >> 2] | 0, i5 << 4, i6 << 4) | 0;
+ break;
+ }
+ }
+ } while (0);
+ i5 = 1 << i7;
+ if ((i5 | 0) > 0) {
+ i6 = i5;
+ do {
+ i6 = i6 + -1 | 0;
+ i7 = i2 + (i6 << 5) + 8 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != 0) {
+ i8 = i2 + (i6 << 5) + 16 | 0;
+ i9 = _luaH_get(i4, i8) | 0;
+ if ((i9 | 0) == 5192) {
+ i9 = _luaH_newkey(i1, i4, i8) | 0;
+ }
+ i8 = i2 + (i6 << 5) | 0;
+ i10 = HEAP32[i8 + 4 >> 2] | 0;
+ i11 = i9;
+ HEAP32[i11 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i11 + 4 >> 2] = i10;
+ HEAP32[i9 + 8 >> 2] = HEAP32[i7 >> 2];
+ }
+ } while ((i6 | 0) > 0);
+ }
+ if ((i2 | 0) == 8016) {
+ STACKTOP = i3;
+ return;
+ }
+ _luaM_realloc_(i1, i2, i5 << 5, 0) | 0;
+ STACKTOP = i3;
+ return;
+}
+function _codearith(i4, i3, i2, i6, i5) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, d13 = 0.0;
+ i7 = STACKTOP;
+ if (((((((HEAP32[i2 >> 2] | 0) == 5 ? (HEAP32[i2 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i2 + 20 >> 2] | 0) == -1 : 0) ? (HEAP32[i6 >> 2] | 0) == 5 : 0) ? (HEAP32[i6 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i6 + 20 >> 2] | 0) == -1 : 0) ? (d13 = +HEAPF64[i6 + 8 >> 3], !((i3 & -2 | 0) == 16 & d13 == 0.0)) : 0) {
+ i12 = i2 + 8 | 0;
+ HEAPF64[i12 >> 3] = +_luaO_arith(i3 + -13 | 0, +HEAPF64[i12 >> 3], d13);
+ STACKTOP = i7;
+ return;
+ }
+ if ((i3 | 0) == 19 | (i3 | 0) == 21) {
+ i11 = 0;
+ } else {
+ i11 = _luaK_exp2RK(i4, i6) | 0;
+ }
+ i12 = _luaK_exp2RK(i4, i2) | 0;
+ if ((i12 | 0) > (i11 | 0)) {
+ if (((HEAP32[i2 >> 2] | 0) == 6 ? (i8 = HEAP32[i2 + 8 >> 2] | 0, (i8 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i8 | 0) : 0) {
+ i10 = i4 + 48 | 0;
+ HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
+ }
+ if (((HEAP32[i6 >> 2] | 0) == 6 ? (i1 = HEAP32[i6 + 8 >> 2] | 0, (i1 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i1 | 0) : 0) {
+ i10 = i4 + 48 | 0;
+ HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
+ }
+ } else {
+ if (((HEAP32[i6 >> 2] | 0) == 6 ? (i10 = HEAP32[i6 + 8 >> 2] | 0, (i10 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i10 | 0) : 0) {
+ i10 = i4 + 48 | 0;
+ HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
+ }
+ if (((HEAP32[i2 >> 2] | 0) == 6 ? (i9 = HEAP32[i2 + 8 >> 2] | 0, (i9 & 256 | 0) == 0) : 0) ? (HEAPU8[i4 + 46 | 0] | 0 | 0) <= (i9 | 0) : 0) {
+ i10 = i4 + 48 | 0;
+ HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
+ }
+ }
+ HEAP32[i2 + 8 >> 2] = _luaK_code(i4, i11 << 14 | i3 | i12 << 23) | 0;
+ HEAP32[i2 >> 2] = 11;
+ HEAP32[(HEAP32[(HEAP32[i4 >> 2] | 0) + 20 >> 2] | 0) + ((HEAP32[i4 + 20 >> 2] | 0) + -1 << 2) >> 2] = i5;
+ STACKTOP = i7;
+ return;
+}
+function _GCTM(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i2 = i4 + 16 | 0;
+ i5 = i4;
+ i6 = HEAP32[i1 + 12 >> 2] | 0;
+ i9 = i6 + 104 | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = HEAP32[i8 >> 2];
+ i9 = i6 + 68 | 0;
+ HEAP32[i8 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i9 >> 2] = i8;
+ i9 = i8 + 5 | 0;
+ i7 = HEAPU8[i9] | 0;
+ HEAP8[i9] = i7 & 239;
+ if ((HEAPU8[i6 + 61 | 0] | 0) >= 2) {
+ HEAP8[i9] = HEAP8[i6 + 60 | 0] & 3 | i7 & 168;
+ }
+ HEAP32[i5 >> 2] = i8;
+ i7 = i5 + 8 | 0;
+ HEAP32[i7 >> 2] = HEAPU8[i8 + 4 | 0] | 0 | 64;
+ i8 = _luaT_gettmbyobj(i1, i5, 2) | 0;
+ if ((i8 | 0) == 0) {
+ STACKTOP = i4;
+ return;
+ }
+ i9 = i8 + 8 | 0;
+ if ((HEAP32[i9 >> 2] & 15 | 0) != 6) {
+ STACKTOP = i4;
+ return;
+ }
+ i12 = i1 + 41 | 0;
+ i13 = HEAP8[i12] | 0;
+ i10 = i6 + 63 | 0;
+ i11 = HEAP8[i10] | 0;
+ HEAP8[i12] = 0;
+ HEAP8[i10] = 0;
+ i6 = i1 + 8 | 0;
+ i14 = HEAP32[i6 >> 2] | 0;
+ i16 = i8;
+ i15 = HEAP32[i16 + 4 >> 2] | 0;
+ i8 = i14;
+ HEAP32[i8 >> 2] = HEAP32[i16 >> 2];
+ HEAP32[i8 + 4 >> 2] = i15;
+ HEAP32[i14 + 8 >> 2] = HEAP32[i9 >> 2];
+ i9 = HEAP32[i6 >> 2] | 0;
+ i14 = i5;
+ i8 = HEAP32[i14 + 4 >> 2] | 0;
+ i5 = i9 + 16 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i5 + 4 >> 2] = i8;
+ HEAP32[i9 + 24 >> 2] = HEAP32[i7 >> 2];
+ i5 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 + 32;
+ i5 = _luaD_pcall(i1, 7, 0, i5 - (HEAP32[i1 + 28 >> 2] | 0) | 0, 0) | 0;
+ HEAP8[i12] = i13;
+ HEAP8[i10] = i11;
+ if ((i5 | 0) == 0 | (i3 | 0) == 0) {
+ STACKTOP = i4;
+ return;
+ }
+ if ((i5 | 0) != 2) {
+ i16 = i5;
+ _luaD_throw(i1, i16);
+ }
+ i3 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i3 + -8 >> 2] & 15 | 0) == 4) {
+ i3 = (HEAP32[i3 + -16 >> 2] | 0) + 16 | 0;
+ } else {
+ i3 = 2528;
+ }
+ HEAP32[i2 >> 2] = i3;
+ _luaO_pushfstring(i1, 2544, i2) | 0;
+ i16 = 5;
+ _luaD_throw(i1, i16);
+}
+function _lua_gc(i3, i5, i4) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i3 + 12 >> 2] | 0;
+ L1 : do {
+ switch (i5 | 0) {
+ case 8:
+ {
+ i5 = i2 + 160 | 0;
+ i2 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ }
+ case 11:
+ {
+ _luaC_changemode(i3, 0);
+ i2 = 0;
+ break;
+ }
+ case 2:
+ {
+ _luaC_fullgc(i3, 0);
+ i2 = 0;
+ break;
+ }
+ case 5:
+ {
+ if ((HEAP8[i2 + 62 | 0] | 0) == 2) {
+ i2 = (HEAP32[i2 + 20 >> 2] | 0) == 0 | 0;
+ _luaC_forcestep(i3);
+ break L1;
+ }
+ i4 = (i4 << 10) + -1600 | 0;
+ if ((HEAP8[i2 + 63 | 0] | 0) == 0) {
+ i5 = i4;
+ _luaE_setdebt(i2, i5);
+ _luaC_forcestep(i3);
+ i5 = i2 + 61 | 0;
+ i5 = HEAP8[i5] | 0;
+ i5 = i5 << 24 >> 24 == 5;
+ i5 = i5 & 1;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i5 = (HEAP32[i2 + 12 >> 2] | 0) + i4 | 0;
+ _luaE_setdebt(i2, i5);
+ _luaC_forcestep(i3);
+ i5 = i2 + 61 | 0;
+ i5 = HEAP8[i5] | 0;
+ i5 = i5 << 24 >> 24 == 5;
+ i5 = i5 & 1;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ case 4:
+ {
+ i2 = (HEAP32[i2 + 12 >> 2] | 0) + (HEAP32[i2 + 8 >> 2] | 0) & 1023;
+ break;
+ }
+ case 1:
+ {
+ _luaE_setdebt(i2, 0);
+ HEAP8[i2 + 63 | 0] = 1;
+ i2 = 0;
+ break;
+ }
+ case 3:
+ {
+ i2 = ((HEAP32[i2 + 12 >> 2] | 0) + (HEAP32[i2 + 8 >> 2] | 0) | 0) >>> 10;
+ break;
+ }
+ case 7:
+ {
+ i5 = i2 + 164 | 0;
+ i2 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ }
+ case 0:
+ {
+ HEAP8[i2 + 63 | 0] = 0;
+ i2 = 0;
+ break;
+ }
+ case 6:
+ {
+ i5 = i2 + 156 | 0;
+ i2 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ }
+ case 9:
+ {
+ i2 = HEAPU8[i2 + 63 | 0] | 0;
+ break;
+ }
+ case 10:
+ {
+ _luaC_changemode(i3, 2);
+ i2 = 0;
+ break;
+ }
+ default:
+ {
+ i2 = -1;
+ }
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _os_time(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i4 = i2;
+ i5 = i2 + 48 | 0;
+ i3 = i2 + 4 | 0;
+ if ((_lua_type(i1, 1) | 0) < 1) {
+ i3 = _time(0) | 0;
+ } else {
+ _luaL_checktype(i1, 1, 5);
+ _lua_settop(i1, 1);
+ _lua_getfield(i1, -1, 5864);
+ i6 = _lua_tointegerx(i1, -1, i4) | 0;
+ i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 0 : i6;
+ _lua_settop(i1, -2);
+ HEAP32[i3 >> 2] = i6;
+ _lua_getfield(i1, -1, 5872);
+ i6 = _lua_tointegerx(i1, -1, i4) | 0;
+ i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 0 : i6;
+ _lua_settop(i1, -2);
+ HEAP32[i3 + 4 >> 2] = i6;
+ _lua_getfield(i1, -1, 5880);
+ i6 = _lua_tointegerx(i1, -1, i4) | 0;
+ i6 = (HEAP32[i4 >> 2] | 0) == 0 ? 12 : i6;
+ _lua_settop(i1, -2);
+ HEAP32[i3 + 8 >> 2] = i6;
+ _lua_getfield(i1, -1, 5888);
+ i6 = _lua_tointegerx(i1, -1, i5) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 5888;
+ i6 = _luaL_error(i1, 5920, i4) | 0;
+ } else {
+ _lua_settop(i1, -2);
+ }
+ HEAP32[i3 + 12 >> 2] = i6;
+ _lua_getfield(i1, -1, 5896);
+ i6 = _lua_tointegerx(i1, -1, i5) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 5896;
+ i6 = _luaL_error(i1, 5920, i4) | 0;
+ } else {
+ _lua_settop(i1, -2);
+ }
+ HEAP32[i3 + 16 >> 2] = i6 + -1;
+ _lua_getfield(i1, -1, 5904);
+ i6 = _lua_tointegerx(i1, -1, i5) | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 5904;
+ i6 = _luaL_error(i1, 5920, i4) | 0;
+ } else {
+ _lua_settop(i1, -2);
+ }
+ HEAP32[i3 + 20 >> 2] = i6 + -1900;
+ _lua_getfield(i1, -1, 5912);
+ if ((_lua_type(i1, -1) | 0) == 0) {
+ i4 = -1;
+ } else {
+ i4 = _lua_toboolean(i1, -1) | 0;
+ }
+ _lua_settop(i1, -2);
+ HEAP32[i3 + 32 >> 2] = i4;
+ i3 = _mktime(i3 | 0) | 0;
+ }
+ if ((i3 | 0) == -1) {
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ _lua_pushnumber(i1, +(i3 | 0));
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _addk(i6, i4, i3) {
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i10 = i1;
+ i2 = HEAP32[(HEAP32[i6 + 12 >> 2] | 0) + 52 >> 2] | 0;
+ i8 = _luaH_set(i2, HEAP32[i6 + 4 >> 2] | 0, i4) | 0;
+ i4 = HEAP32[i6 >> 2] | 0;
+ i9 = i8 + 8 | 0;
+ if (((HEAP32[i9 >> 2] | 0) == 3 ? (HEAPF64[i10 >> 3] = +HEAPF64[i8 >> 3] + 6755399441055744.0, i7 = HEAP32[i10 >> 2] | 0, i5 = HEAP32[i4 + 8 >> 2] | 0, (HEAP32[i5 + (i7 << 4) + 8 >> 2] | 0) == (HEAP32[i3 + 8 >> 2] | 0)) : 0) ? (_luaV_equalobj_(0, i5 + (i7 << 4) | 0, i3) | 0) != 0 : 0) {
+ i10 = i7;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i5 = i4 + 44 | 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ i7 = i6 + 32 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ HEAPF64[i8 >> 3] = +(i6 | 0);
+ HEAP32[i9 >> 2] = 3;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) >= (i9 | 0)) {
+ i9 = i4 + 8 | 0;
+ HEAP32[i9 >> 2] = _luaM_growaux_(i2, HEAP32[i9 >> 2] | 0, i5, 16, 67108863, 10600) | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ }
+ i8 = HEAP32[i4 + 8 >> 2] | 0;
+ if ((i10 | 0) < (i9 | 0)) {
+ while (1) {
+ i9 = i10 + 1 | 0;
+ HEAP32[i8 + (i10 << 4) + 8 >> 2] = 0;
+ if ((i9 | 0) < (HEAP32[i5 >> 2] | 0)) {
+ i10 = i9;
+ } else {
+ break;
+ }
+ }
+ }
+ i5 = i3;
+ i9 = HEAP32[i5 + 4 >> 2] | 0;
+ i10 = i8 + (i6 << 4) | 0;
+ HEAP32[i10 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i10 + 4 >> 2] = i9;
+ i10 = i3 + 8 | 0;
+ HEAP32[i8 + (i6 << 4) + 8 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + 1;
+ if ((HEAP32[i10 >> 2] & 64 | 0) == 0) {
+ i10 = i6;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
+ i10 = i6;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ if ((HEAP8[i4 + 5 | 0] & 4) == 0) {
+ i10 = i6;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ _luaC_barrier_(i2, i4, i3);
+ i10 = i6;
+ STACKTOP = i1;
+ return i10 | 0;
+}
+function _singlevaraux(i5, i4, i2, i11) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i11 = i11 | 0;
+ var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ if ((i5 | 0) == 0) {
+ i11 = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i7 = i5 + 12 | 0;
+ i8 = i5 + 40 | 0;
+ i9 = HEAPU8[i5 + 46 | 0] | 0;
+ while (1) {
+ i6 = i9 + -1 | 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) <= 0) {
+ break;
+ }
+ if ((_luaS_eqstr(i4, HEAP32[(HEAP32[i10 + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i7 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i8 >> 2] | 0) + i6 << 1) >> 1] | 0) * 12 | 0) >> 2] | 0) | 0) == 0) {
+ i9 = i6;
+ } else {
+ i3 = 5;
+ break;
+ }
+ }
+ if ((i3 | 0) == 5) {
+ HEAP32[i2 + 16 >> 2] = -1;
+ HEAP32[i2 + 20 >> 2] = -1;
+ HEAP32[i2 >> 2] = 7;
+ HEAP32[i2 + 8 >> 2] = i6;
+ if ((i11 | 0) != 0) {
+ i11 = 7;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i2 = i5 + 16 | 0;
+ do {
+ i2 = HEAP32[i2 >> 2] | 0;
+ } while ((HEAPU8[i2 + 8 | 0] | 0) > (i6 | 0));
+ HEAP8[i2 + 9 | 0] = 1;
+ i11 = 7;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i7 = HEAP32[i10 + 28 >> 2] | 0;
+ i6 = i5 + 47 | 0;
+ L17 : do {
+ if ((HEAP8[i6] | 0) != 0) {
+ i8 = 0;
+ while (1) {
+ i9 = i8 + 1 | 0;
+ if ((_luaS_eqstr(HEAP32[i7 + (i8 << 3) >> 2] | 0, i4) | 0) != 0) {
+ break;
+ }
+ if ((i9 | 0) < (HEAPU8[i6] | 0)) {
+ i8 = i9;
+ } else {
+ i3 = 13;
+ break L17;
+ }
+ }
+ if ((i8 | 0) < 0) {
+ i3 = 13;
+ }
+ } else {
+ i3 = 13;
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) == 13) {
+ if ((_singlevaraux(HEAP32[i5 + 8 >> 2] | 0, i4, i2, 0) | 0) == 0) {
+ i11 = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ } else {
+ i8 = _newupvalue(i5, i4, i2) | 0;
+ break;
+ }
+ }
+ } while (0);
+ HEAP32[i2 + 16 >> 2] = -1;
+ HEAP32[i2 + 20 >> 2] = -1;
+ HEAP32[i2 >> 2] = 8;
+ HEAP32[i2 + 8 >> 2] = i8;
+ i11 = 8;
+ STACKTOP = i1;
+ return i11 | 0;
+}
+function _mainposition(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ switch (HEAP32[i3 + 8 >> 2] & 63 | 0) {
+ case 3:
+ {
+ HEAPF64[i4 >> 3] = +HEAPF64[i3 >> 3] + 1.0;
+ i3 = (HEAP32[i4 + 4 >> 2] | 0) + (HEAP32[i4 >> 2] | 0) | 0;
+ if ((i3 | 0) < 0) {
+ i4 = 0 - i3 | 0;
+ i3 = (i3 | 0) == (i4 | 0) ? 0 : i4;
+ }
+ i5 = (HEAP32[i1 + 16 >> 2] | 0) + (((i3 | 0) % ((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1 | 0) | 0) << 5) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ case 2:
+ {
+ i5 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ case 20:
+ {
+ i5 = HEAP32[i3 >> 2] | 0;
+ i4 = i5 + 6 | 0;
+ if ((HEAP8[i4] | 0) == 0) {
+ i6 = i5 + 8 | 0;
+ HEAP32[i6 >> 2] = _luaS_hash(i5 + 16 | 0, HEAP32[i5 + 12 >> 2] | 0, HEAP32[i6 >> 2] | 0) | 0;
+ HEAP8[i4] = 1;
+ i5 = HEAP32[i3 >> 2] | 0;
+ }
+ i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[i5 + 8 >> 2]) << 5) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ case 22:
+ {
+ i6 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ case 4:
+ {
+ i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[(HEAP32[i3 >> 2] | 0) + 8 >> 2]) << 5) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ case 1:
+ {
+ i6 = (HEAP32[i1 + 16 >> 2] | 0) + (((1 << HEAPU8[i1 + 7 | 0]) + -1 & HEAP32[i3 >> 2]) << 5) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ default:
+ {
+ i6 = (HEAP32[i1 + 16 >> 2] | 0) + ((((HEAP32[i3 >> 2] | 0) >>> 0) % (((1 << HEAPU8[i1 + 7 | 0]) + -1 | 1) >>> 0) | 0) << 5) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ }
+ return 0;
+}
+function _clearvalues(i2, i5, i1) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i4 = STACKTOP;
+ if ((i5 | 0) == (i1 | 0)) {
+ STACKTOP = i4;
+ return;
+ }
+ do {
+ i7 = i5 + 16 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ i6 = i9 + (1 << (HEAPU8[i5 + 7 | 0] | 0) << 5) | 0;
+ i8 = i5 + 28 | 0;
+ if ((HEAP32[i8 >> 2] | 0) > 0) {
+ i11 = i5 + 12 | 0;
+ i12 = 0;
+ do {
+ i13 = HEAP32[i11 >> 2] | 0;
+ i10 = i13 + (i12 << 4) + 8 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ do {
+ if ((i9 & 64 | 0) != 0) {
+ i13 = HEAP32[i13 + (i12 << 4) >> 2] | 0;
+ if ((i9 & 15 | 0) != 4) {
+ if ((HEAP8[i13 + 5 | 0] & 3) == 0) {
+ break;
+ }
+ HEAP32[i10 >> 2] = 0;
+ break;
+ }
+ if ((i13 | 0) != 0 ? !((HEAP8[i13 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i2, i13);
+ }
+ }
+ } while (0);
+ i12 = i12 + 1 | 0;
+ } while ((i12 | 0) < (HEAP32[i8 >> 2] | 0));
+ i7 = HEAP32[i7 >> 2] | 0;
+ } else {
+ i7 = i9;
+ }
+ if (i7 >>> 0 < i6 >>> 0) {
+ do {
+ i8 = i7 + 8 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ do {
+ if (!((i9 | 0) == 0 | (i9 & 64 | 0) == 0)) {
+ i10 = HEAP32[i7 >> 2] | 0;
+ if ((i9 & 15 | 0) == 4) {
+ if ((i10 | 0) == 0) {
+ break;
+ }
+ if ((HEAP8[i10 + 5 | 0] & 3) == 0) {
+ break;
+ }
+ _reallymarkobject(i2, i10);
+ break;
+ }
+ if ((!((HEAP8[i10 + 5 | 0] & 3) == 0) ? (HEAP32[i8 >> 2] = 0, i3 = i7 + 24 | 0, (HEAP32[i3 >> 2] & 64 | 0) != 0) : 0) ? !((HEAP8[(HEAP32[i7 + 16 >> 2] | 0) + 5 | 0] & 3) == 0) : 0) {
+ HEAP32[i3 >> 2] = 11;
+ }
+ }
+ } while (0);
+ i7 = i7 + 32 | 0;
+ } while (i7 >>> 0 < i6 >>> 0);
+ }
+ i5 = HEAP32[i5 + 24 >> 2] | 0;
+ } while ((i5 | 0) != (i1 | 0));
+ STACKTOP = i4;
+ return;
+}
+function _reallymarkobject(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ i2 = i4 + 5 | 0;
+ HEAP8[i2] = HEAP8[i2] & 252;
+ switch (HEAPU8[i4 + 4 | 0] | 0 | 0) {
+ case 6:
+ {
+ i7 = i1 + 84 | 0;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i4;
+ STACKTOP = i3;
+ return;
+ }
+ case 20:
+ case 4:
+ {
+ i4 = (HEAP32[i4 + 12 >> 2] | 0) + 17 | 0;
+ break;
+ }
+ case 7:
+ {
+ i5 = HEAP32[i4 + 8 >> 2] | 0;
+ if ((i5 | 0) != 0 ? !((HEAP8[i5 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i5);
+ }
+ i5 = HEAP32[i4 + 12 >> 2] | 0;
+ if ((i5 | 0) != 0 ? !((HEAP8[i5 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i5);
+ }
+ i4 = (HEAP32[i4 + 16 >> 2] | 0) + 24 | 0;
+ break;
+ }
+ case 8:
+ {
+ i7 = i1 + 84 | 0;
+ HEAP32[i4 + 60 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i4;
+ STACKTOP = i3;
+ return;
+ }
+ case 10:
+ {
+ i6 = i4 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i7 + 8 >> 2] & 64 | 0) != 0 ? (i5 = HEAP32[i7 >> 2] | 0, !((HEAP8[i5 + 5 | 0] & 3) == 0)) : 0) {
+ _reallymarkobject(i1, i5);
+ i7 = HEAP32[i6 >> 2] | 0;
+ }
+ if ((i7 | 0) == (i4 + 16 | 0)) {
+ i4 = 32;
+ } else {
+ STACKTOP = i3;
+ return;
+ }
+ break;
+ }
+ case 5:
+ {
+ i7 = i1 + 84 | 0;
+ HEAP32[i4 + 24 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i4;
+ STACKTOP = i3;
+ return;
+ }
+ case 38:
+ {
+ i7 = i1 + 84 | 0;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i4;
+ STACKTOP = i3;
+ return;
+ }
+ case 9:
+ {
+ i7 = i1 + 84 | 0;
+ HEAP32[i4 + 72 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i4;
+ STACKTOP = i3;
+ return;
+ }
+ default:
+ {
+ STACKTOP = i3;
+ return;
+ }
+ }
+ HEAP8[i2] = HEAPU8[i2] | 0 | 4;
+ i7 = i1 + 16 | 0;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + i4;
+ STACKTOP = i3;
+ return;
+}
+function _lua_upvaluejoin(i1, i9, i7, i6, i3) {
+ i1 = i1 | 0;
+ i9 = i9 | 0;
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i8 = 0, i10 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i9 | 0) <= 0) {
+ if (!((i9 | 0) < -1000999)) {
+ i8 = (HEAP32[i1 + 8 >> 2] | 0) + (i9 << 4) | 0;
+ break;
+ }
+ if ((i9 | 0) == -1001e3) {
+ i8 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i10 = -1001e3 - i9 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i9 >> 2] | 0, (i10 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
+ i8 = i8 + (i10 + -1 << 4) + 16 | 0;
+ } else {
+ i8 = 5192;
+ }
+ } else {
+ i8 = (HEAP32[i5 >> 2] | 0) + (i9 << 4) | 0;
+ i8 = i8 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
+ }
+ } while (0);
+ i8 = HEAP32[i8 >> 2] | 0;
+ i7 = i8 + 16 + (i7 + -1 << 2) | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i3 = (HEAP32[i4 >> 2] | 0) + 16 + (i3 + -1 << 2) | 0;
+ HEAP32[i7 >> 2] = HEAP32[i3 >> 2];
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP8[i8 + 5 | 0] & 4) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaC_barrier_(i1, i8, i3);
+ STACKTOP = i2;
+ return;
+}
+function _lua_upvalueid(i5, i7, i1) {
+ i5 = i5 | 0;
+ i7 = i7 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i5 + 16 >> 2] | 0;
+ i6 = (i7 | 0) > 0;
+ do {
+ if (!i6) {
+ if (!((i7 | 0) < -1000999)) {
+ i8 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i8 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i10 = -1001e3 - i7 | 0;
+ i9 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i9 + 8 >> 2] | 0) != 22 ? (i8 = HEAP32[i9 >> 2] | 0, (i10 | 0) <= (HEAPU8[i8 + 6 | 0] | 0 | 0)) : 0) {
+ i8 = i8 + (i10 + -1 << 4) + 16 | 0;
+ } else {
+ i8 = 5192;
+ }
+ } else {
+ i8 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
+ i8 = i8 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i8 : 5192;
+ }
+ } while (0);
+ i9 = HEAP32[i8 + 8 >> 2] & 63;
+ if ((i9 | 0) == 38) {
+ i10 = (HEAP32[i8 >> 2] | 0) + (i1 + -1 << 4) + 16 | 0;
+ STACKTOP = i2;
+ return i10 | 0;
+ } else if ((i9 | 0) == 6) {
+ do {
+ if (!i6) {
+ if (!((i7 | 0) < -1000999)) {
+ i3 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i3 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i7 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i7 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i10 = HEAP32[(HEAP32[i3 >> 2] | 0) + 16 + (i1 + -1 << 2) >> 2] | 0;
+ STACKTOP = i2;
+ return i10 | 0;
+ } else {
+ i10 = 0;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ return 0;
+}
+function _lua_rawequal(i2, i6, i4) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0, i5 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i5 = (HEAP32[i2 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i5 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i7 = -1001e3 - i6 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i6 >> 2] | 0, (i7 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i5 + (i7 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i5 = (HEAP32[i3 >> 2] | 0) + (i6 << 4) | 0;
+ i5 = i5 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
+ }
+ } while (0);
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i2 = -1001e3 - i4 | 0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ } else {
+ i2 = i3 + (i2 + -1 << 4) + 16 | 0;
+ break;
+ }
+ } else {
+ i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
+ i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ if ((i5 | 0) == 5192 | (i2 | 0) == 5192) {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ if ((HEAP32[i5 + 8 >> 2] | 0) == (HEAP32[i2 + 8 >> 2] | 0)) {
+ i2 = (_luaV_equalobj_(0, i5, i2) | 0) != 0;
+ } else {
+ i2 = 0;
+ }
+ i7 = i2 & 1;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _luaO_chunkid(i1, i4, i6) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ i3 = _strlen(i4 | 0) | 0;
+ i5 = HEAP8[i4] | 0;
+ if (i5 << 24 >> 24 == 64) {
+ if (i3 >>> 0 > i6 >>> 0) {
+ HEAP8[i1 + 0 | 0] = HEAP8[5552 | 0] | 0;
+ HEAP8[i1 + 1 | 0] = HEAP8[5553 | 0] | 0;
+ HEAP8[i1 + 2 | 0] = HEAP8[5554 | 0] | 0;
+ _memcpy(i1 + 3 | 0, i4 + (4 - i6 + i3) | 0, i6 + -3 | 0) | 0;
+ STACKTOP = i2;
+ return;
+ } else {
+ _memcpy(i1 | 0, i4 + 1 | 0, i3 | 0) | 0;
+ STACKTOP = i2;
+ return;
+ }
+ } else if (i5 << 24 >> 24 == 61) {
+ i4 = i4 + 1 | 0;
+ if (i3 >>> 0 > i6 >>> 0) {
+ i9 = i6 + -1 | 0;
+ _memcpy(i1 | 0, i4 | 0, i9 | 0) | 0;
+ HEAP8[i1 + i9 | 0] = 0;
+ STACKTOP = i2;
+ return;
+ } else {
+ _memcpy(i1 | 0, i4 | 0, i3 | 0) | 0;
+ STACKTOP = i2;
+ return;
+ }
+ } else {
+ i5 = _strchr(i4, 10) | 0;
+ i9 = i1 + 0 | 0;
+ i8 = 5560 | 0;
+ i7 = i9 + 9 | 0;
+ do {
+ HEAP8[i9] = HEAP8[i8] | 0;
+ i9 = i9 + 1 | 0;
+ i8 = i8 + 1 | 0;
+ } while ((i9 | 0) < (i7 | 0));
+ i7 = i1 + 9 | 0;
+ i6 = i6 + -15 | 0;
+ i8 = (i5 | 0) == 0;
+ if (i3 >>> 0 < i6 >>> 0 & i8) {
+ _memcpy(i7 | 0, i4 | 0, i3 | 0) | 0;
+ i3 = i3 + 9 | 0;
+ } else {
+ if (!i8) {
+ i3 = i5 - i4 | 0;
+ }
+ i3 = i3 >>> 0 > i6 >>> 0 ? i6 : i3;
+ _memcpy(i7 | 0, i4 | 0, i3 | 0) | 0;
+ i9 = i1 + (i3 + 9) | 0;
+ HEAP8[i9 + 0 | 0] = HEAP8[5552 | 0] | 0;
+ HEAP8[i9 + 1 | 0] = HEAP8[5553 | 0] | 0;
+ HEAP8[i9 + 2 | 0] = HEAP8[5554 | 0] | 0;
+ i3 = i3 + 12 | 0;
+ }
+ i9 = i1 + i3 | 0;
+ HEAP8[i9 + 0 | 0] = HEAP8[5576 | 0] | 0;
+ HEAP8[i9 + 1 | 0] = HEAP8[5577 | 0] | 0;
+ HEAP8[i9 + 2 | 0] = HEAP8[5578 | 0] | 0;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _luaS_resize(i4, i1) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i3 = STACKTOP;
+ i5 = HEAP32[i4 + 12 >> 2] | 0;
+ i2 = i5 + 24 | 0;
+ _luaC_runtilstate(i4, -5);
+ i5 = i5 + 32 | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ L1 : do {
+ if ((i8 | 0) < (i1 | 0)) {
+ if ((i1 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i4);
+ }
+ i7 = _luaM_realloc_(i4, HEAP32[i2 >> 2] | 0, i8 << 2, i1 << 2) | 0;
+ HEAP32[i2 >> 2] = i7;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) < (i1 | 0)) {
+ i8 = i6;
+ while (1) {
+ HEAP32[i7 + (i8 << 2) >> 2] = 0;
+ i8 = i8 + 1 | 0;
+ if ((i8 | 0) == (i1 | 0)) {
+ i8 = i6;
+ break L1;
+ }
+ i7 = HEAP32[i2 >> 2] | 0;
+ }
+ } else {
+ i8 = i6;
+ }
+ }
+ } while (0);
+ if ((i8 | 0) > 0) {
+ i6 = i1 + -1 | 0;
+ i7 = 0;
+ do {
+ i10 = (HEAP32[i2 >> 2] | 0) + (i7 << 2) | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i10 >> 2] = 0;
+ if ((i9 | 0) != 0) {
+ while (1) {
+ i8 = HEAP32[i9 >> 2] | 0;
+ i10 = HEAP32[i9 + 8 >> 2] & i6;
+ HEAP32[i9 >> 2] = HEAP32[(HEAP32[i2 >> 2] | 0) + (i10 << 2) >> 2];
+ HEAP32[(HEAP32[i2 >> 2] | 0) + (i10 << 2) >> 2] = i9;
+ i10 = i9 + 5 | 0;
+ HEAP8[i10] = HEAP8[i10] & 191;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i9 = i8;
+ }
+ }
+ i8 = HEAP32[i5 >> 2] | 0;
+ }
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) < (i8 | 0));
+ }
+ if ((i8 | 0) <= (i1 | 0)) {
+ HEAP32[i5 >> 2] = i1;
+ STACKTOP = i3;
+ return;
+ }
+ if ((i1 + 1 | 0) >>> 0 > 1073741823) {
+ _luaM_toobig(i4);
+ }
+ HEAP32[i2 >> 2] = _luaM_realloc_(i4, HEAP32[i2 >> 2] | 0, i8 << 2, i1 << 2) | 0;
+ HEAP32[i5 >> 2] = i1;
+ STACKTOP = i3;
+ return;
+}
+function _luaD_poscall(i6, i7) {
+ i6 = i6 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ i4 = i6 + 16 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAPU8[i6 + 40 | 0] | 0;
+ if ((i5 & 6 | 0) == 0) {
+ i8 = i3 + 8 | 0;
+ } else {
+ if ((i5 & 2 | 0) != 0) {
+ i8 = i6 + 28 | 0;
+ i7 = i7 - (HEAP32[i8 >> 2] | 0) | 0;
+ _luaD_hook(i6, 1, -1);
+ i7 = (HEAP32[i8 >> 2] | 0) + i7 | 0;
+ }
+ i8 = i3 + 8 | 0;
+ HEAP32[i6 + 20 >> 2] = HEAP32[(HEAP32[i8 >> 2] | 0) + 28 >> 2];
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ i9 = HEAP16[i3 + 16 >> 1] | 0;
+ i3 = i9 << 16 >> 16;
+ HEAP32[i4 >> 2] = HEAP32[i8 >> 2];
+ i4 = i6 + 8 | 0;
+ if (i9 << 16 >> 16 == 0) {
+ i9 = i5;
+ HEAP32[i4 >> 2] = i9;
+ i9 = i3 + 1 | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+ } else {
+ i6 = i3;
+ }
+ while (1) {
+ if (!(i7 >>> 0 < (HEAP32[i4 >> 2] | 0) >>> 0)) {
+ break;
+ }
+ i8 = i5 + 16 | 0;
+ i11 = i7;
+ i10 = HEAP32[i11 + 4 >> 2] | 0;
+ i9 = i5;
+ HEAP32[i9 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i9 + 4 >> 2] = i10;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i7 + 8 >> 2];
+ i6 = i6 + -1 | 0;
+ if ((i6 | 0) == 0) {
+ i2 = 12;
+ break;
+ } else {
+ i7 = i7 + 16 | 0;
+ i5 = i8;
+ }
+ }
+ if ((i2 | 0) == 12) {
+ HEAP32[i4 >> 2] = i8;
+ i11 = i3 + 1 | 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ if ((i6 | 0) > 0) {
+ i2 = i6;
+ i7 = i5;
+ } else {
+ i11 = i5;
+ HEAP32[i4 >> 2] = i11;
+ i11 = i3 + 1 | 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ while (1) {
+ i2 = i2 + -1 | 0;
+ HEAP32[i7 + 8 >> 2] = 0;
+ if ((i2 | 0) <= 0) {
+ break;
+ } else {
+ i7 = i7 + 16 | 0;
+ }
+ }
+ i11 = i5 + (i6 << 4) | 0;
+ HEAP32[i4 >> 2] = i11;
+ i11 = i3 + 1 | 0;
+ STACKTOP = i1;
+ return i11 | 0;
+}
+function _lua_rawset(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i4 = -1001e3 - i4 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i3 + (i4 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
+ i5 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i4 = i1 + 8 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ i3 = _luaH_set(i1, HEAP32[i5 >> 2] | 0, i6 + -32 | 0) | 0;
+ i9 = i6 + -16 | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i3;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
+ HEAP8[(HEAP32[i5 >> 2] | 0) + 6 | 0] = 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i3 + -8 >> 2] & 64 | 0) == 0) {
+ i9 = i3;
+ i9 = i9 + -32 | 0;
+ HEAP32[i4 >> 2] = i9;
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP8[(HEAP32[i3 + -16 >> 2] | 0) + 5 | 0] & 3) == 0) {
+ i9 = i3;
+ i9 = i9 + -32 | 0;
+ HEAP32[i4 >> 2] = i9;
+ STACKTOP = i2;
+ return;
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
+ i9 = i3;
+ i9 = i9 + -32 | 0;
+ HEAP32[i4 >> 2] = i9;
+ STACKTOP = i2;
+ return;
+ }
+ _luaC_barrierback_(i1, i5);
+ i9 = HEAP32[i4 >> 2] | 0;
+ i9 = i9 + -32 | 0;
+ HEAP32[i4 >> 2] = i9;
+ STACKTOP = i2;
+ return;
+}
+function _saveSetjmp(i4, i3, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0;
+ setjmpId = setjmpId + 1 | 0;
+ HEAP32[i4 >> 2] = setjmpId;
+ while ((i2 | 0) < 40) {
+ if ((HEAP32[i1 + (i2 << 2) >> 2] | 0) == 0) {
+ HEAP32[i1 + (i2 << 2) >> 2] = setjmpId;
+ HEAP32[i1 + ((i2 << 2) + 4) >> 2] = i3;
+ HEAP32[i1 + ((i2 << 2) + 8) >> 2] = 0;
+ return 0;
+ }
+ i2 = i2 + 2 | 0;
+ }
+ _putchar(116);
+ _putchar(111);
+ _putchar(111);
+ _putchar(32);
+ _putchar(109);
+ _putchar(97);
+ _putchar(110);
+ _putchar(121);
+ _putchar(32);
+ _putchar(115);
+ _putchar(101);
+ _putchar(116);
+ _putchar(106);
+ _putchar(109);
+ _putchar(112);
+ _putchar(115);
+ _putchar(32);
+ _putchar(105);
+ _putchar(110);
+ _putchar(32);
+ _putchar(97);
+ _putchar(32);
+ _putchar(102);
+ _putchar(117);
+ _putchar(110);
+ _putchar(99);
+ _putchar(116);
+ _putchar(105);
+ _putchar(111);
+ _putchar(110);
+ _putchar(32);
+ _putchar(99);
+ _putchar(97);
+ _putchar(108);
+ _putchar(108);
+ _putchar(44);
+ _putchar(32);
+ _putchar(98);
+ _putchar(117);
+ _putchar(105);
+ _putchar(108);
+ _putchar(100);
+ _putchar(32);
+ _putchar(119);
+ _putchar(105);
+ _putchar(116);
+ _putchar(104);
+ _putchar(32);
+ _putchar(97);
+ _putchar(32);
+ _putchar(104);
+ _putchar(105);
+ _putchar(103);
+ _putchar(104);
+ _putchar(101);
+ _putchar(114);
+ _putchar(32);
+ _putchar(118);
+ _putchar(97);
+ _putchar(108);
+ _putchar(117);
+ _putchar(101);
+ _putchar(32);
+ _putchar(102);
+ _putchar(111);
+ _putchar(114);
+ _putchar(32);
+ _putchar(77);
+ _putchar(65);
+ _putchar(88);
+ _putchar(95);
+ _putchar(83);
+ _putchar(69);
+ _putchar(84);
+ _putchar(74);
+ _putchar(77);
+ _putchar(80);
+ _putchar(83);
+ _putchar(10);
+ abort(0);
+ return 0;
+}
+function _lua_newthread(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ i3 = i5 + 12 | 0;
+ if ((HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i5);
+ }
+ i2 = _luaC_newobj(i5, 8, 112, 0, 0) | 0;
+ i6 = i5 + 8 | 0;
+ i4 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i4 + 8 >> 2] = 72;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
+ HEAP32[i2 + 12 >> 2] = HEAP32[i3 >> 2];
+ i6 = i2 + 28 | 0;
+ HEAP32[i6 >> 2] = 0;
+ i4 = i2 + 16 | 0;
+ HEAP32[i4 >> 2] = 0;
+ i3 = i2 + 32 | 0;
+ HEAP32[i3 >> 2] = 0;
+ HEAP32[i2 + 64 >> 2] = 0;
+ HEAP16[i2 + 38 >> 1] = 0;
+ i9 = i2 + 52 | 0;
+ HEAP32[i9 >> 2] = 0;
+ i8 = i2 + 40 | 0;
+ HEAP8[i8] = 0;
+ i10 = i2 + 44 | 0;
+ HEAP32[i10 >> 2] = 0;
+ HEAP8[i2 + 41 | 0] = 1;
+ i7 = i2 + 48 | 0;
+ HEAP32[i7 >> 2] = 0;
+ HEAP32[i2 + 56 >> 2] = 0;
+ HEAP16[i2 + 36 >> 1] = 1;
+ HEAP8[i2 + 6 | 0] = 0;
+ HEAP32[i2 + 68 >> 2] = 0;
+ HEAP8[i8] = HEAP8[i5 + 40 | 0] | 0;
+ i8 = HEAP32[i5 + 44 >> 2] | 0;
+ HEAP32[i10 >> 2] = i8;
+ HEAP32[i9 >> 2] = HEAP32[i5 + 52 >> 2];
+ HEAP32[i7 >> 2] = i8;
+ i5 = _luaM_realloc_(i5, 0, 0, 640) | 0;
+ HEAP32[i6 >> 2] = i5;
+ HEAP32[i3 >> 2] = 40;
+ i6 = 0;
+ do {
+ HEAP32[i5 + (i6 << 4) + 8 >> 2] = 0;
+ i6 = i6 + 1 | 0;
+ } while ((i6 | 0) != 40);
+ HEAP32[i2 + 24 >> 2] = i5 + ((HEAP32[i3 >> 2] | 0) + -5 << 4);
+ i10 = i2 + 72 | 0;
+ HEAP32[i2 + 80 >> 2] = 0;
+ HEAP32[i2 + 84 >> 2] = 0;
+ HEAP8[i2 + 90 | 0] = 0;
+ HEAP32[i10 >> 2] = i5;
+ HEAP32[i2 + 8 >> 2] = i5 + 16;
+ HEAP32[i5 + 8 >> 2] = 0;
+ HEAP32[i2 + 76 >> 2] = i5 + 336;
+ HEAP32[i4 >> 2] = i10;
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaK_self(i2, i5, i3) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ _luaK_dischargevars(i2, i5);
+ if ((HEAP32[i5 >> 2] | 0) == 6) {
+ i6 = i5 + 8 | 0;
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i5 + 16 >> 2] | 0) != (HEAP32[i5 + 20 >> 2] | 0)) {
+ if ((i8 | 0) < (HEAPU8[i2 + 46 | 0] | 0 | 0)) {
+ i7 = 6;
+ } else {
+ _exp2reg(i2, i5, i8);
+ }
+ }
+ } else {
+ i6 = i5 + 8 | 0;
+ i7 = 6;
+ }
+ if ((i7 | 0) == 6) {
+ _luaK_exp2nextreg(i2, i5);
+ }
+ i8 = HEAP32[i6 >> 2] | 0;
+ if (((HEAP32[i5 >> 2] | 0) == 6 ? (i8 & 256 | 0) == 0 : 0) ? (HEAPU8[i2 + 46 | 0] | 0 | 0) <= (i8 | 0) : 0) {
+ i10 = i2 + 48 | 0;
+ HEAP8[i10] = (HEAP8[i10] | 0) + -1 << 24 >> 24;
+ }
+ i7 = i2 + 48 | 0;
+ HEAP32[i6 >> 2] = HEAPU8[i7] | 0;
+ HEAP32[i5 >> 2] = 6;
+ i10 = HEAP8[i7] | 0;
+ i5 = (i10 & 255) + 2 | 0;
+ i9 = (HEAP32[i2 >> 2] | 0) + 78 | 0;
+ do {
+ if (i5 >>> 0 > (HEAPU8[i9] | 0) >>> 0) {
+ if (i5 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i2 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i9] = i5;
+ i4 = HEAP8[i7] | 0;
+ break;
+ }
+ } else {
+ i4 = i10;
+ }
+ } while (0);
+ HEAP8[i7] = (i4 & 255) + 2;
+ i10 = HEAP32[i6 >> 2] | 0;
+ _luaK_code(i2, i8 << 23 | i10 << 6 | (_luaK_exp2RK(i2, i3) | 0) << 14 | 12) | 0;
+ if ((HEAP32[i3 >> 2] | 0) != 6) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i3 & 256 | 0) != 0) {
+ STACKTOP = i1;
+ return;
+ }
+ if ((HEAPU8[i2 + 46 | 0] | 0 | 0) > (i3 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
+ STACKTOP = i1;
+ return;
+}
+function _luaD_rawrunprotected(i10, i9, i11) {
+ i10 = i10 | 0;
+ i9 = i9 | 0;
+ i11 = i11 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i12 = 0, i13 = 0;
+ i7 = STACKTOP;
+ STACKTOP = STACKTOP + 176 | 0;
+ i8 = STACKTOP;
+ STACKTOP = STACKTOP + 168 | 0;
+ HEAP32[i8 >> 2] = 0;
+ i6 = i7;
+ i5 = i10 + 38 | 0;
+ i4 = HEAP16[i5 >> 1] | 0;
+ i1 = i6 + 160 | 0;
+ HEAP32[i1 >> 2] = 0;
+ i3 = i10 + 64 | 0;
+ HEAP32[i6 >> 2] = HEAP32[i3 >> 2];
+ HEAP32[i3 >> 2] = i6;
+ _saveSetjmp(i6 + 4 | 0, 1, i8 | 0) | 0;
+ __THREW__ = 0;
+ i13 = __THREW__;
+ __THREW__ = 0;
+ if ((i13 | 0) != 0 & (threwValue | 0) != 0) {
+ i12 = _testSetjmp(HEAP32[i13 >> 2] | 0, i8) | 0;
+ if ((i12 | 0) == 0) {
+ _longjmp(i13 | 0, threwValue | 0);
+ }
+ tempRet0 = threwValue;
+ } else {
+ i12 = -1;
+ }
+ if ((i12 | 0) == 1) {
+ i12 = tempRet0;
+ } else {
+ i12 = 0;
+ }
+ while (1) {
+ if ((i12 | 0) != 0) {
+ i2 = 6;
+ break;
+ }
+ __THREW__ = 0;
+ invoke_vii(i9 | 0, i10 | 0, i11 | 0);
+ i13 = __THREW__;
+ __THREW__ = 0;
+ if ((i13 | 0) != 0 & (threwValue | 0) != 0) {
+ i12 = _testSetjmp(HEAP32[i13 >> 2] | 0, i8) | 0;
+ if ((i12 | 0) == 0) {
+ _longjmp(i13 | 0, threwValue | 0);
+ }
+ tempRet0 = threwValue;
+ } else {
+ i12 = -1;
+ }
+ if ((i12 | 0) == 1) {
+ i12 = tempRet0;
+ } else {
+ break;
+ }
+ }
+ if ((i2 | 0) == 6) {
+ i13 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i3 >> 2] = i13;
+ HEAP16[i5 >> 1] = i4;
+ i13 = HEAP32[i1 >> 2] | 0;
+ STACKTOP = i7;
+ return i13 | 0;
+ }
+ i13 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i3 >> 2] = i13;
+ HEAP16[i5 >> 1] = i4;
+ i13 = HEAP32[i1 >> 2] | 0;
+ STACKTOP = i7;
+ return i13 | 0;
+}
+function _luaB_tonumber(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = 0.0, i7 = 0, d8 = 0.0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2 + 4 | 0;
+ i4 = i2;
+ do {
+ if ((_lua_type(i1, 2) | 0) >= 1) {
+ i9 = _luaL_checklstring(i1, 1, i4) | 0;
+ i3 = i9 + (HEAP32[i4 >> 2] | 0) | 0;
+ i5 = _luaL_checkinteger(i1, 2) | 0;
+ if (!((i5 + -2 | 0) >>> 0 < 35)) {
+ _luaL_argerror(i1, 2, 9648) | 0;
+ }
+ i10 = _strspn(i9, 9672) | 0;
+ i7 = i9 + i10 | 0;
+ i4 = HEAP8[i7] | 0;
+ if (i4 << 24 >> 24 == 43) {
+ i4 = 0;
+ i7 = i9 + (i10 + 1) | 0;
+ } else if (i4 << 24 >> 24 == 45) {
+ i4 = 1;
+ i7 = i9 + (i10 + 1) | 0;
+ } else {
+ i4 = 0;
+ }
+ if ((_isalnum(HEAPU8[i7] | 0 | 0) | 0) != 0) {
+ d6 = +(i5 | 0);
+ d8 = 0.0;
+ do {
+ i9 = HEAP8[i7] | 0;
+ i10 = i9 & 255;
+ if ((i10 + -48 | 0) >>> 0 < 10) {
+ i9 = (i9 << 24 >> 24) + -48 | 0;
+ } else {
+ i9 = (_toupper(i10 | 0) | 0) + -55 | 0;
+ }
+ if ((i9 | 0) >= (i5 | 0)) {
+ break;
+ }
+ d8 = d6 * d8 + +(i9 | 0);
+ i7 = i7 + 1 | 0;
+ } while ((_isalnum(HEAPU8[i7] | 0 | 0) | 0) != 0);
+ if ((i7 + (_strspn(i7, 9672) | 0) | 0) == (i3 | 0)) {
+ if ((i4 | 0) != 0) {
+ d8 = -d8;
+ }
+ _lua_pushnumber(i1, d8);
+ STACKTOP = i2;
+ return 1;
+ }
+ }
+ } else {
+ d6 = +_lua_tonumberx(i1, 1, i3);
+ if ((HEAP32[i3 >> 2] | 0) == 0) {
+ _luaL_checkany(i1, 1);
+ break;
+ }
+ _lua_pushnumber(i1, d6);
+ STACKTOP = i2;
+ return 1;
+ }
+ } while (0);
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaK_storevar(i1, i5, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ i7 = HEAP32[i5 >> 2] | 0;
+ if ((i7 | 0) == 7) {
+ if (((HEAP32[i3 >> 2] | 0) == 6 ? (i6 = HEAP32[i3 + 8 >> 2] | 0, (i6 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0) <= (i6 | 0) : 0) {
+ i7 = i1 + 48 | 0;
+ HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
+ }
+ _exp2reg(i1, i3, HEAP32[i5 + 8 >> 2] | 0);
+ STACKTOP = i2;
+ return;
+ } else if ((i7 | 0) == 9) {
+ i4 = i5 + 8 | 0;
+ i7 = (HEAP8[i4 + 3 | 0] | 0) == 7 ? 10 : 8;
+ i6 = _luaK_exp2RK(i1, i3) | 0;
+ _luaK_code(i1, i6 << 14 | i7 | HEAPU8[i4 + 2 | 0] << 6 | HEAPU16[i4 >> 1] << 23) | 0;
+ } else if ((i7 | 0) == 8) {
+ _luaK_dischargevars(i1, i3);
+ if ((HEAP32[i3 >> 2] | 0) == 6) {
+ i6 = i3 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i3 + 16 >> 2] | 0) != (HEAP32[i3 + 20 >> 2] | 0)) {
+ if ((i7 | 0) < (HEAPU8[i1 + 46 | 0] | 0)) {
+ i4 = 12;
+ } else {
+ _exp2reg(i1, i3, i7);
+ i7 = HEAP32[i6 >> 2] | 0;
+ }
+ }
+ } else {
+ i6 = i3 + 8 | 0;
+ i4 = 12;
+ }
+ if ((i4 | 0) == 12) {
+ _luaK_exp2nextreg(i1, i3);
+ i7 = HEAP32[i6 >> 2] | 0;
+ }
+ _luaK_code(i1, i7 << 6 | HEAP32[i5 + 8 >> 2] << 23 | 9) | 0;
+ }
+ if ((HEAP32[i3 >> 2] | 0) != 6) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i3 & 256 | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAPU8[i1 + 46 | 0] | 0) > (i3 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = i1 + 48 | 0;
+ HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
+ STACKTOP = i2;
+ return;
+}
+function _closegoto(i10, i3, i9) {
+ i10 = i10 | 0;
+ i3 = i3 | 0;
+ i9 = i9 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i7 = i1;
+ i4 = HEAP32[i10 + 48 >> 2] | 0;
+ i6 = HEAP32[i10 + 64 >> 2] | 0;
+ i2 = i6 + 12 | 0;
+ i5 = HEAP32[i2 >> 2] | 0;
+ i8 = HEAP8[i5 + (i3 << 4) + 12 | 0] | 0;
+ if ((i8 & 255) < (HEAPU8[i9 + 12 | 0] | 0)) {
+ i11 = HEAP32[i10 + 52 >> 2] | 0;
+ i12 = HEAP32[i5 + (i3 << 4) + 8 >> 2] | 0;
+ i8 = (HEAP32[(HEAP32[(HEAP32[i4 >> 2] | 0) + 24 >> 2] | 0) + ((HEAP16[(HEAP32[HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 64 >> 2] >> 2] | 0) + ((HEAP32[i4 + 40 >> 2] | 0) + (i8 & 255) << 1) >> 1] | 0) * 12 | 0) >> 2] | 0) + 16 | 0;
+ HEAP32[i7 >> 2] = (HEAP32[i5 + (i3 << 4) >> 2] | 0) + 16;
+ HEAP32[i7 + 4 >> 2] = i12;
+ HEAP32[i7 + 8 >> 2] = i8;
+ _semerror(i10, _luaO_pushfstring(i11, 6248, i7) | 0);
+ }
+ _luaK_patchlist(i4, HEAP32[i5 + (i3 << 4) + 4 >> 2] | 0, HEAP32[i9 + 4 >> 2] | 0);
+ i4 = i6 + 16 | 0;
+ i5 = (HEAP32[i4 >> 2] | 0) + -1 | 0;
+ if ((i5 | 0) <= (i3 | 0)) {
+ i12 = i5;
+ HEAP32[i4 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ do {
+ i12 = HEAP32[i2 >> 2] | 0;
+ i5 = i12 + (i3 << 4) | 0;
+ i3 = i3 + 1 | 0;
+ i12 = i12 + (i3 << 4) | 0;
+ HEAP32[i5 + 0 >> 2] = HEAP32[i12 + 0 >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[i12 + 4 >> 2];
+ HEAP32[i5 + 8 >> 2] = HEAP32[i12 + 8 >> 2];
+ HEAP32[i5 + 12 >> 2] = HEAP32[i12 + 12 >> 2];
+ i5 = (HEAP32[i4 >> 2] | 0) + -1 | 0;
+ } while ((i3 | 0) < (i5 | 0));
+ HEAP32[i4 >> 2] = i5;
+ STACKTOP = i1;
+ return;
+}
+function _luaM_growaux_(i4, i5, i1, i7, i8, i9) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ i9 = i9 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i10 = i2;
+ i6 = HEAP32[i1 >> 2] | 0;
+ if ((i6 | 0) >= ((i8 | 0) / 2 | 0 | 0)) {
+ if ((i6 | 0) < (i8 | 0)) {
+ i3 = i8;
+ } else {
+ HEAP32[i10 >> 2] = i9;
+ HEAP32[i10 + 4 >> 2] = i8;
+ _luaG_runerror(i4, 4112, i10);
+ }
+ } else {
+ i3 = i6 << 1;
+ i3 = (i3 | 0) < 4 ? 4 : i3;
+ }
+ if ((i3 + 1 | 0) >>> 0 > (4294967293 / (i7 >>> 0) | 0) >>> 0) {
+ _luaM_toobig(i4);
+ }
+ i6 = Math_imul(i6, i7) | 0;
+ i8 = Math_imul(i3, i7) | 0;
+ i9 = HEAP32[i4 + 12 >> 2] | 0;
+ i7 = (i5 | 0) != 0;
+ i11 = i9 + 4 | 0;
+ i10 = FUNCTION_TABLE_iiiii[HEAP32[i9 >> 2] & 3](HEAP32[i11 >> 2] | 0, i5, i6, i8) | 0;
+ if ((i10 | 0) != 0 | (i8 | 0) == 0) {
+ i5 = i9 + 12 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = 0 - i6 | 0;
+ i11 = i7 ? i6 : 0;
+ i11 = i11 + i8 | 0;
+ i11 = i11 + i4 | 0;
+ HEAP32[i5 >> 2] = i11;
+ HEAP32[i1 >> 2] = i3;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ if ((HEAP8[i9 + 63 | 0] | 0) == 0) {
+ _luaD_throw(i4, 4);
+ }
+ _luaC_fullgc(i4, 1);
+ i10 = FUNCTION_TABLE_iiiii[HEAP32[i9 >> 2] & 3](HEAP32[i11 >> 2] | 0, i5, i6, i8) | 0;
+ if ((i10 | 0) == 0) {
+ _luaD_throw(i4, 4);
+ } else {
+ i5 = i9 + 12 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = 0 - i6 | 0;
+ i11 = i7 ? i6 : 0;
+ i11 = i11 + i8 | 0;
+ i11 = i11 + i4 | 0;
+ HEAP32[i5 >> 2] = i11;
+ HEAP32[i1 >> 2] = i3;
+ STACKTOP = i2;
+ return i10 | 0;
+ }
+ return 0;
+}
+function _luaD_hook(i5, i14, i13) {
+ i5 = i5 | 0;
+ i14 = i14 | 0;
+ i13 = i13 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i15 = 0, i16 = 0;
+ i11 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i11;
+ i3 = HEAP32[i5 + 52 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ STACKTOP = i11;
+ return;
+ }
+ i8 = i5 + 41 | 0;
+ if ((HEAP8[i8] | 0) == 0) {
+ STACKTOP = i11;
+ return;
+ }
+ i10 = HEAP32[i5 + 16 >> 2] | 0;
+ i6 = i5 + 8 | 0;
+ i15 = HEAP32[i6 >> 2] | 0;
+ i1 = i5 + 28 | 0;
+ i16 = i15;
+ i12 = HEAP32[i1 >> 2] | 0;
+ i7 = i16 - i12 | 0;
+ i9 = i10 + 4 | 0;
+ i12 = (HEAP32[i9 >> 2] | 0) - i12 | 0;
+ HEAP32[i4 >> 2] = i14;
+ HEAP32[i4 + 20 >> 2] = i13;
+ HEAP32[i4 + 96 >> 2] = i10;
+ do {
+ if (((HEAP32[i5 + 24 >> 2] | 0) - i16 | 0) < 336) {
+ i14 = HEAP32[i5 + 32 >> 2] | 0;
+ if ((i14 | 0) > 1e6) {
+ _luaD_throw(i5, 6);
+ }
+ i13 = (i7 >> 4) + 25 | 0;
+ i14 = i14 << 1;
+ i14 = (i14 | 0) > 1e6 ? 1e6 : i14;
+ i13 = (i14 | 0) < (i13 | 0) ? i13 : i14;
+ if ((i13 | 0) > 1e6) {
+ _luaD_reallocstack(i5, 1000200);
+ _luaG_runerror(i5, 2224, i4);
+ } else {
+ _luaD_reallocstack(i5, i13);
+ i2 = HEAP32[i6 >> 2] | 0;
+ break;
+ }
+ } else {
+ i2 = i15;
+ }
+ } while (0);
+ HEAP32[i9 >> 2] = i2 + 320;
+ HEAP8[i8] = 0;
+ i16 = i10 + 18 | 0;
+ HEAP8[i16] = HEAPU8[i16] | 2;
+ FUNCTION_TABLE_vii[i3 & 15](i5, i4);
+ HEAP8[i8] = 1;
+ HEAP32[i9 >> 2] = (HEAP32[i1 >> 2] | 0) + i12;
+ HEAP32[i6 >> 2] = (HEAP32[i1 >> 2] | 0) + i7;
+ HEAP8[i16] = HEAP8[i16] & 253;
+ STACKTOP = i11;
+ return;
+}
+function _funcargs(i10, i2, i1) {
+ i10 = i10 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i6 = i3;
+ i9 = i10 + 48 | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ i7 = i10 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 289) {
+ i9 = _luaK_stringK(i5, HEAP32[i10 + 24 >> 2] | 0) | 0;
+ HEAP32[i6 + 16 >> 2] = -1;
+ HEAP32[i6 + 20 >> 2] = -1;
+ HEAP32[i6 >> 2] = 4;
+ HEAP32[i6 + 8 >> 2] = i9;
+ _luaX_next(i10);
+ } else if ((i8 | 0) == 40) {
+ _luaX_next(i10);
+ if ((HEAP32[i7 >> 2] | 0) == 41) {
+ HEAP32[i6 >> 2] = 0;
+ } else {
+ _subexpr(i10, i6, 0) | 0;
+ if ((HEAP32[i7 >> 2] | 0) == 44) {
+ do {
+ _luaX_next(i10);
+ _luaK_exp2nextreg(HEAP32[i9 >> 2] | 0, i6);
+ _subexpr(i10, i6, 0) | 0;
+ } while ((HEAP32[i7 >> 2] | 0) == 44);
+ }
+ _luaK_setreturns(i5, i6, -1);
+ }
+ _check_match(i10, 41, 40, i1);
+ } else if ((i8 | 0) == 123) {
+ _constructor(i10, i6);
+ } else {
+ _luaX_syntaxerror(i10, 6624);
+ }
+ i8 = i2 + 8 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i4 = 13;
+ } else if ((i9 | 0) == 13 | (i9 | 0) == 12) {
+ i6 = 0;
+ } else {
+ _luaK_exp2nextreg(i5, i6);
+ i4 = 13;
+ }
+ if ((i4 | 0) == 13) {
+ i6 = (HEAPU8[i5 + 48 | 0] | 0) - i7 | 0;
+ }
+ i10 = _luaK_codeABC(i5, 29, i7, i6, 2) | 0;
+ HEAP32[i2 + 16 >> 2] = -1;
+ HEAP32[i2 + 20 >> 2] = -1;
+ HEAP32[i2 >> 2] = 12;
+ HEAP32[i8 >> 2] = i10;
+ _luaK_fixline(i5, i1);
+ HEAP8[i5 + 48 | 0] = i7 + 1;
+ STACKTOP = i3;
+ return;
+}
+function _luaD_reallocstack(i3, i6) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i1 = STACKTOP;
+ i2 = i3 + 28 | 0;
+ i8 = HEAP32[i2 >> 2] | 0;
+ i7 = i3 + 32 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ if ((i6 + 1 | 0) >>> 0 > 268435455) {
+ _luaM_toobig(i3);
+ }
+ i5 = _luaM_realloc_(i3, i8, i9 << 4, i6 << 4) | 0;
+ HEAP32[i2 >> 2] = i5;
+ if ((i9 | 0) < (i6 | 0)) {
+ do {
+ HEAP32[i5 + (i9 << 4) + 8 >> 2] = 0;
+ i9 = i9 + 1 | 0;
+ } while ((i9 | 0) != (i6 | 0));
+ }
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i3 + 24 >> 2] = i5 + (i6 + -5 << 4);
+ i6 = i3 + 8 | 0;
+ HEAP32[i6 >> 2] = i5 + ((HEAP32[i6 >> 2] | 0) - i8 >> 4 << 4);
+ i6 = HEAP32[i3 + 56 >> 2] | 0;
+ if ((i6 | 0) != 0 ? (i4 = i6 + 8 | 0, HEAP32[i4 >> 2] = i5 + ((HEAP32[i4 >> 2] | 0) - i8 >> 4 << 4), i4 = HEAP32[i6 >> 2] | 0, (i4 | 0) != 0) : 0) {
+ do {
+ i9 = i4 + 8 | 0;
+ HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
+ i4 = HEAP32[i4 >> 2] | 0;
+ } while ((i4 | 0) != 0);
+ }
+ i3 = HEAP32[i3 + 16 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ do {
+ i9 = i3 + 4 | 0;
+ HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
+ HEAP32[i3 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i3 >> 2] | 0) - i8 >> 4 << 4);
+ if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
+ i9 = i3 + 24 | 0;
+ HEAP32[i9 >> 2] = (HEAP32[i2 >> 2] | 0) + ((HEAP32[i9 >> 2] | 0) - i8 >> 4 << 4);
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ } while ((i3 | 0) != 0);
+ STACKTOP = i1;
+ return;
+}
+function _luaF_close(i7, i6) {
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i7 + 12 >> 2] | 0;
+ i3 = i7 + 56 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i5 = i4 + 60 | 0;
+ i2 = i4 + 68 | 0;
+ while (1) {
+ i9 = i8 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) >>> 0 < i6 >>> 0) {
+ i2 = 10;
+ break;
+ }
+ HEAP32[i3 >> 2] = HEAP32[i8 >> 2];
+ if ((((HEAPU8[i5] | 0) ^ 3) & ((HEAPU8[i8 + 5 | 0] | 0) ^ 3) | 0) == 0) {
+ if ((HEAP32[i9 >> 2] | 0) != (i8 + 16 | 0)) {
+ i9 = i8 + 16 | 0;
+ i10 = i9 + 4 | 0;
+ HEAP32[(HEAP32[i10 >> 2] | 0) + 16 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[(HEAP32[i9 >> 2] | 0) + 20 >> 2] = HEAP32[i10 >> 2];
+ }
+ _luaM_realloc_(i7, i8, 32, 0) | 0;
+ } else {
+ i11 = i8 + 16 | 0;
+ i10 = i11 + 4 | 0;
+ HEAP32[(HEAP32[i10 >> 2] | 0) + 16 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[(HEAP32[i11 >> 2] | 0) + 20 >> 2] = HEAP32[i10 >> 2];
+ i11 = HEAP32[i9 >> 2] | 0;
+ i10 = i8 + 16 | 0;
+ i14 = i11;
+ i13 = HEAP32[i14 + 4 >> 2] | 0;
+ i12 = i10;
+ HEAP32[i12 >> 2] = HEAP32[i14 >> 2];
+ HEAP32[i12 + 4 >> 2] = i13;
+ HEAP32[i8 + 24 >> 2] = HEAP32[i11 + 8 >> 2];
+ HEAP32[i9 >> 2] = i10;
+ HEAP32[i8 >> 2] = HEAP32[i2 >> 2];
+ HEAP32[i2 >> 2] = i8;
+ _luaC_checkupvalcolor(i4, i8);
+ }
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ i2 = 10;
+ break;
+ }
+ }
+ if ((i2 | 0) == 10) {
+ STACKTOP = i1;
+ return;
+ }
+}
+function _luaK_dischargevars(i3, i1) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ switch (HEAP32[i1 >> 2] | 0) {
+ case 12:
+ {
+ HEAP32[i1 >> 2] = 6;
+ i6 = i1 + 8 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[(HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i6 >> 2] << 2) >> 2] | 0) >>> 6 & 255;
+ STACKTOP = i2;
+ return;
+ }
+ case 13:
+ {
+ i6 = (HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i1 + 8 >> 2] << 2) | 0;
+ HEAP32[i6 >> 2] = HEAP32[i6 >> 2] & 8388607 | 16777216;
+ HEAP32[i1 >> 2] = 11;
+ STACKTOP = i2;
+ return;
+ }
+ case 9:
+ {
+ i4 = i1 + 8 | 0;
+ i5 = HEAP16[i4 >> 1] | 0;
+ if ((i5 & 256 | 0) == 0 ? (HEAPU8[i3 + 46 | 0] | 0) <= (i5 | 0) : 0) {
+ i6 = i3 + 48 | 0;
+ HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
+ }
+ i5 = i4 + 2 | 0;
+ if ((HEAP8[i4 + 3 | 0] | 0) == 7) {
+ if ((HEAPU8[i3 + 46 | 0] | 0) > (HEAPU8[i5] | 0)) {
+ i6 = 7;
+ } else {
+ i6 = i3 + 48 | 0;
+ HEAP8[i6] = (HEAP8[i6] | 0) + -1 << 24 >> 24;
+ i6 = 7;
+ }
+ } else {
+ i6 = 6;
+ }
+ HEAP32[i4 >> 2] = _luaK_code(i3, HEAPU8[i5] << 23 | i6 | HEAP16[i4 >> 1] << 14) | 0;
+ HEAP32[i1 >> 2] = 11;
+ STACKTOP = i2;
+ return;
+ }
+ case 7:
+ {
+ HEAP32[i1 >> 2] = 6;
+ STACKTOP = i2;
+ return;
+ }
+ case 8:
+ {
+ i6 = i1 + 8 | 0;
+ HEAP32[i6 >> 2] = _luaK_code(i3, HEAP32[i6 >> 2] << 23 | 5) | 0;
+ HEAP32[i1 >> 2] = 11;
+ STACKTOP = i2;
+ return;
+ }
+ default:
+ {
+ STACKTOP = i2;
+ return;
+ }
+ }
+}
+function _gmatch_aux(i10) {
+ i10 = i10 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 288 | 0;
+ i2 = i1 + 8 | 0;
+ i12 = i1 + 4 | 0;
+ i3 = i1;
+ i8 = _lua_tolstring(i10, -1001001, i12) | 0;
+ i7 = _lua_tolstring(i10, -1001002, i3) | 0;
+ i5 = i2 + 16 | 0;
+ HEAP32[i5 >> 2] = i10;
+ HEAP32[i2 >> 2] = 200;
+ HEAP32[i2 + 4 >> 2] = i8;
+ i9 = i2 + 8 | 0;
+ HEAP32[i9 >> 2] = i8 + (HEAP32[i12 >> 2] | 0);
+ HEAP32[i2 + 12 >> 2] = i7 + (HEAP32[i3 >> 2] | 0);
+ i3 = i8 + (_lua_tointegerx(i10, -1001003, 0) | 0) | 0;
+ if (i3 >>> 0 > (HEAP32[i9 >> 2] | 0) >>> 0) {
+ i12 = 0;
+ STACKTOP = i1;
+ return i12 | 0;
+ }
+ i11 = i2 + 20 | 0;
+ while (1) {
+ HEAP32[i11 >> 2] = 0;
+ i4 = _match(i2, i3, i7) | 0;
+ i12 = i3 + 1 | 0;
+ if ((i4 | 0) != 0) {
+ break;
+ }
+ if (i12 >>> 0 > (HEAP32[i9 >> 2] | 0) >>> 0) {
+ i2 = 0;
+ i6 = 7;
+ break;
+ } else {
+ i3 = i12;
+ }
+ }
+ if ((i6 | 0) == 7) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ _lua_pushinteger(i10, i4 - i8 + ((i4 | 0) == (i3 | 0)) | 0);
+ _lua_replace(i10, -1001003);
+ i7 = HEAP32[i11 >> 2] | 0;
+ i6 = (i7 | 0) != 0 | (i3 | 0) == 0 ? i7 : 1;
+ _luaL_checkstack(HEAP32[i5 >> 2] | 0, i6, 7200);
+ if ((i6 | 0) > 0) {
+ i5 = 0;
+ } else {
+ i12 = i7;
+ STACKTOP = i1;
+ return i12 | 0;
+ }
+ while (1) {
+ _push_onecapture(i2, i5, i3, i4);
+ i5 = i5 + 1 | 0;
+ if ((i5 | 0) == (i6 | 0)) {
+ i2 = i6;
+ break;
+ }
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _lua_rawseti(i1, i5, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i6 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i4 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
+ i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i4 = i1 + 8 | 0;
+ _luaH_setint(i1, HEAP32[i5 >> 2] | 0, i3, (HEAP32[i4 >> 2] | 0) + -16 | 0);
+ i3 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i3 + -8 >> 2] & 64 | 0) == 0) {
+ i6 = i3;
+ i6 = i6 + -16 | 0;
+ HEAP32[i4 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP8[(HEAP32[i3 + -16 >> 2] | 0) + 5 | 0] & 3) == 0) {
+ i6 = i3;
+ i6 = i6 + -16 | 0;
+ HEAP32[i4 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP8[i5 + 5 | 0] & 4) == 0) {
+ i6 = i3;
+ i6 = i6 + -16 | 0;
+ HEAP32[i4 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+ }
+ _luaC_barrierback_(i1, i5);
+ i6 = HEAP32[i4 >> 2] | 0;
+ i6 = i6 + -16 | 0;
+ HEAP32[i4 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+}
+function _ll_require(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i5 = i2;
+ i4 = i2 + 8 | 0;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ _lua_settop(i1, 1);
+ _lua_getfield(i1, -1001e3, 4576);
+ _lua_getfield(i1, 2, i3);
+ if ((_lua_toboolean(i1, -1) | 0) != 0) {
+ STACKTOP = i2;
+ return 1;
+ }
+ _lua_settop(i1, -2);
+ _luaL_buffinit(i1, i4);
+ _lua_getfield(i1, -1001001, 4240);
+ if ((_lua_type(i1, 3) | 0) == 5) {
+ i6 = 1;
+ } else {
+ _luaL_error(i1, 4656, i5) | 0;
+ i6 = 1;
+ }
+ while (1) {
+ _lua_rawgeti(i1, 3, i6);
+ if ((_lua_type(i1, -1) | 0) == 0) {
+ _lua_settop(i1, -2);
+ _luaL_pushresult(i4);
+ i7 = _lua_tolstring(i1, -1, 0) | 0;
+ HEAP32[i5 >> 2] = i3;
+ HEAP32[i5 + 4 >> 2] = i7;
+ _luaL_error(i1, 4696, i5) | 0;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_callk(i1, 1, 2, 0, 0);
+ if ((_lua_type(i1, -2) | 0) == 6) {
+ break;
+ }
+ if ((_lua_isstring(i1, -2) | 0) == 0) {
+ _lua_settop(i1, -3);
+ } else {
+ _lua_settop(i1, -2);
+ _luaL_addvalue(i4);
+ }
+ i6 = i6 + 1 | 0;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_insert(i1, -2);
+ _lua_callk(i1, 2, 1, 0, 0);
+ if ((_lua_type(i1, -1) | 0) != 0) {
+ _lua_setfield(i1, 2, i3);
+ }
+ _lua_getfield(i1, 2, i3);
+ if ((_lua_type(i1, -1) | 0) != 0) {
+ STACKTOP = i2;
+ return 1;
+ }
+ _lua_pushboolean(i1, 1);
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, 2, i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _f_parser(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i8 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i8 + -1;
+ if ((i8 | 0) == 0) {
+ i6 = _luaZ_fill(i5) | 0;
+ } else {
+ i8 = i5 + 4 | 0;
+ i6 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 + 1;
+ i6 = HEAPU8[i6] | 0;
+ }
+ i5 = HEAP32[i3 + 52 >> 2] | 0;
+ i7 = (i5 | 0) == 0;
+ if ((i6 | 0) == 27) {
+ if (!i7 ? (_strchr(i5, 98) | 0) == 0 : 0) {
+ HEAP32[i4 >> 2] = 2360;
+ HEAP32[i4 + 4 >> 2] = i5;
+ _luaO_pushfstring(i1, 2376, i4) | 0;
+ _luaD_throw(i1, 3);
+ }
+ i8 = _luaU_undump(i1, HEAP32[i3 >> 2] | 0, i3 + 4 | 0, HEAP32[i3 + 56 >> 2] | 0) | 0;
+ } else {
+ if (!i7 ? (_strchr(i5, 116) | 0) == 0 : 0) {
+ HEAP32[i4 >> 2] = 2368;
+ HEAP32[i4 + 4 >> 2] = i5;
+ _luaO_pushfstring(i1, 2376, i4) | 0;
+ _luaD_throw(i1, 3);
+ }
+ i8 = _luaY_parser(i1, HEAP32[i3 >> 2] | 0, i3 + 4 | 0, i3 + 16 | 0, HEAP32[i3 + 56 >> 2] | 0, i6) | 0;
+ }
+ i7 = i8 + 6 | 0;
+ if ((HEAP8[i7] | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i5 = i8 + 16 | 0;
+ i6 = i8 + 5 | 0;
+ i4 = 0;
+ do {
+ i3 = _luaF_newupval(i1) | 0;
+ HEAP32[i5 + (i4 << 2) >> 2] = i3;
+ if (!((HEAP8[i3 + 5 | 0] & 3) == 0) ? !((HEAP8[i6] & 4) == 0) : 0) {
+ _luaC_barrier_(i1, i8, i3);
+ }
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) < (HEAPU8[i7] | 0));
+ STACKTOP = i2;
+ return;
+}
+function _str_rep(i9) {
+ i9 = i9 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i4 = i6;
+ i2 = i6 + 1044 | 0;
+ i3 = i6 + 1040 | 0;
+ i1 = _luaL_checklstring(i9, 1, i2) | 0;
+ i8 = _luaL_checkinteger(i9, 2) | 0;
+ i5 = _luaL_optlstring(i9, 3, 7040, i3) | 0;
+ if ((i8 | 0) < 1) {
+ _lua_pushlstring(i9, 7040, 0) | 0;
+ i12 = 1;
+ STACKTOP = i6;
+ return i12 | 0;
+ }
+ i7 = HEAP32[i2 >> 2] | 0;
+ i10 = HEAP32[i3 >> 2] | 0;
+ i11 = i10 + i7 | 0;
+ if (!(i11 >>> 0 < i7 >>> 0) ? i11 >>> 0 < (2147483647 / (i8 >>> 0) | 0) >>> 0 : 0) {
+ i7 = (Math_imul(i10, i8 + -1 | 0) | 0) + (Math_imul(i7, i8) | 0) | 0;
+ i11 = _luaL_buffinitsize(i9, i4, i7) | 0;
+ _memcpy(i11 | 0, i1 | 0, HEAP32[i2 >> 2] | 0) | 0;
+ if ((i8 | 0) > 1) {
+ while (1) {
+ i8 = i8 + -1 | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ i10 = i11 + i9 | 0;
+ i12 = HEAP32[i3 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i12 = i9;
+ } else {
+ _memcpy(i10 | 0, i5 | 0, i12 | 0) | 0;
+ i12 = HEAP32[i2 >> 2] | 0;
+ i10 = i11 + ((HEAP32[i3 >> 2] | 0) + i9) | 0;
+ }
+ _memcpy(i10 | 0, i1 | 0, i12 | 0) | 0;
+ if ((i8 | 0) <= 1) {
+ break;
+ } else {
+ i11 = i10;
+ }
+ }
+ }
+ _luaL_pushresultsize(i4, i7);
+ i12 = 1;
+ STACKTOP = i6;
+ return i12 | 0;
+ }
+ i12 = _luaL_error(i9, 7168, i4) | 0;
+ STACKTOP = i6;
+ return i12 | 0;
+}
+function ___strchrnul(i6, i2) {
+ i6 = i6 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i3 = i2 & 255;
+ if ((i3 | 0) == 0) {
+ i7 = i6 + (_strlen(i6 | 0) | 0) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ L5 : do {
+ if ((i6 & 3 | 0) != 0) {
+ i4 = i2 & 255;
+ while (1) {
+ i5 = HEAP8[i6] | 0;
+ if (i5 << 24 >> 24 == 0) {
+ i4 = i6;
+ i5 = 13;
+ break;
+ }
+ i7 = i6 + 1 | 0;
+ if (i5 << 24 >> 24 == i4 << 24 >> 24) {
+ i4 = i6;
+ i5 = 13;
+ break;
+ }
+ if ((i7 & 3 | 0) == 0) {
+ i4 = i7;
+ break L5;
+ } else {
+ i6 = i7;
+ }
+ }
+ if ((i5 | 0) == 13) {
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ } else {
+ i4 = i6;
+ }
+ } while (0);
+ i3 = Math_imul(i3, 16843009) | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ L15 : do {
+ if (((i6 & -2139062144 ^ -2139062144) & i6 + -16843009 | 0) == 0) {
+ while (1) {
+ i7 = i6 ^ i3;
+ i5 = i4 + 4 | 0;
+ if (((i7 & -2139062144 ^ -2139062144) & i7 + -16843009 | 0) != 0) {
+ break L15;
+ }
+ i6 = HEAP32[i5 >> 2] | 0;
+ if (((i6 & -2139062144 ^ -2139062144) & i6 + -16843009 | 0) == 0) {
+ i4 = i5;
+ } else {
+ i4 = i5;
+ break;
+ }
+ }
+ }
+ } while (0);
+ i2 = i2 & 255;
+ while (1) {
+ i7 = HEAP8[i4] | 0;
+ if (i7 << 24 >> 24 == 0 | i7 << 24 >> 24 == i2 << 24 >> 24) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _lua_replace(i2, i6) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i3 = STACKTOP;
+ i7 = i2 + 8 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ i5 = i9 + -16 | 0;
+ i4 = i2 + 16 | 0;
+ i12 = HEAP32[i4 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i10 = i9 + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i10 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i11 = -1001e3 - i6 | 0;
+ i12 = HEAP32[i12 >> 2] | 0;
+ if ((HEAP32[i12 + 8 >> 2] | 0) != 22 ? (i10 = HEAP32[i12 >> 2] | 0, (i11 | 0) <= (HEAPU8[i10 + 6 | 0] | 0 | 0)) : 0) {
+ i10 = i10 + (i11 + -1 << 4) + 16 | 0;
+ } else {
+ i10 = 5192;
+ }
+ } else {
+ i10 = (HEAP32[i12 >> 2] | 0) + (i6 << 4) | 0;
+ i10 = i10 >>> 0 < i9 >>> 0 ? i10 : 5192;
+ }
+ } while (0);
+ i13 = i5;
+ i11 = HEAP32[i13 + 4 >> 2] | 0;
+ i12 = i10;
+ HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
+ HEAP32[i12 + 4 >> 2] = i11;
+ i9 = i9 + -8 | 0;
+ HEAP32[i10 + 8 >> 2] = HEAP32[i9 >> 2];
+ if ((((i6 | 0) < -1001e3 ? (HEAP32[i9 >> 2] & 64 | 0) != 0 : 0) ? (i1 = HEAP32[i5 >> 2] | 0, !((HEAP8[i1 + 5 | 0] & 3) == 0)) : 0) ? (i8 = HEAP32[HEAP32[HEAP32[i4 >> 2] >> 2] >> 2] | 0, !((HEAP8[i8 + 5 | 0] & 4) == 0)) : 0) {
+ _luaC_barrier_(i2, i8, i1);
+ }
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
+ STACKTOP = i3;
+ return;
+}
+function _memchr(i4, i3, i6) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i2 = i3 & 255;
+ i7 = (i6 | 0) == 0;
+ L1 : do {
+ if ((i4 & 3 | 0) == 0 | i7) {
+ i5 = i6;
+ i6 = 5;
+ } else {
+ i5 = i3 & 255;
+ while (1) {
+ if ((HEAP8[i4] | 0) == i5 << 24 >> 24) {
+ i5 = i6;
+ i6 = 6;
+ break L1;
+ }
+ i4 = i4 + 1 | 0;
+ i6 = i6 + -1 | 0;
+ i7 = (i6 | 0) == 0;
+ if ((i4 & 3 | 0) == 0 | i7) {
+ i5 = i6;
+ i6 = 5;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if ((i6 | 0) == 5) {
+ if (i7) {
+ i5 = 0;
+ } else {
+ i6 = 6;
+ }
+ }
+ L8 : do {
+ if ((i6 | 0) == 6) {
+ i3 = i3 & 255;
+ if (!((HEAP8[i4] | 0) == i3 << 24 >> 24)) {
+ i2 = Math_imul(i2, 16843009) | 0;
+ L11 : do {
+ if (i5 >>> 0 > 3) {
+ do {
+ i7 = HEAP32[i4 >> 2] ^ i2;
+ if (((i7 & -2139062144 ^ -2139062144) & i7 + -16843009 | 0) != 0) {
+ break L11;
+ }
+ i4 = i4 + 4 | 0;
+ i5 = i5 + -4 | 0;
+ } while (i5 >>> 0 > 3);
+ }
+ } while (0);
+ if ((i5 | 0) == 0) {
+ i5 = 0;
+ } else {
+ while (1) {
+ if ((HEAP8[i4] | 0) == i3 << 24 >> 24) {
+ break L8;
+ }
+ i4 = i4 + 1 | 0;
+ i5 = i5 + -1 | 0;
+ if ((i5 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+ } while (0);
+ STACKTOP = i1;
+ return ((i5 | 0) != 0 ? i4 : 0) | 0;
+}
+function _lua_insert(i2, i5) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i2 = i2 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if (i4 >>> 0 > i3 >>> 0) {
+ while (1) {
+ i5 = i4 + -16 | 0;
+ i8 = i5;
+ i7 = HEAP32[i8 + 4 >> 2] | 0;
+ i6 = i4;
+ HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i6 + 4 >> 2] = i7;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i4 + -8 >> 2];
+ if (i5 >>> 0 > i3 >>> 0) {
+ i4 = i5;
+ } else {
+ break;
+ }
+ }
+ i4 = HEAP32[i2 >> 2] | 0;
+ }
+ i6 = i4;
+ i7 = HEAP32[i6 + 4 >> 2] | 0;
+ i8 = i3;
+ HEAP32[i8 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i8 + 4 >> 2] = i7;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ STACKTOP = i1;
+ return;
+}
+function _findlocal(i6, i4, i1, i2) {
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ do {
+ if ((HEAP8[i4 + 18 | 0] & 1) == 0) {
+ i7 = (HEAP32[i4 >> 2] | 0) + 16 | 0;
+ i5 = 7;
+ } else {
+ if ((i1 | 0) >= 0) {
+ i8 = HEAP32[i4 + 24 >> 2] | 0;
+ i7 = HEAP32[(HEAP32[HEAP32[i4 >> 2] >> 2] | 0) + 12 >> 2] | 0;
+ i7 = _luaF_getlocalname(i7, i1, ((HEAP32[i4 + 28 >> 2] | 0) - (HEAP32[i7 + 12 >> 2] | 0) >> 2) + -1 | 0) | 0;
+ if ((i7 | 0) == 0) {
+ i7 = i8;
+ i5 = 7;
+ break;
+ } else {
+ break;
+ }
+ }
+ i5 = HEAP32[i4 >> 2] | 0;
+ i6 = HEAPU8[(HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] | 0) + 76 | 0] | 0;
+ if ((((HEAP32[i4 + 24 >> 2] | 0) - i5 >> 4) - i6 | 0) <= (0 - i1 | 0)) {
+ i8 = 0;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ HEAP32[i2 >> 2] = i5 + (i6 - i1 << 4);
+ i8 = 2208;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ } while (0);
+ if ((i5 | 0) == 7) {
+ if ((HEAP32[i6 + 16 >> 2] | 0) == (i4 | 0)) {
+ i4 = i6 + 8 | 0;
+ } else {
+ i4 = HEAP32[i4 + 12 >> 2] | 0;
+ }
+ if (((HEAP32[i4 >> 2] | 0) - i7 >> 4 | 0) >= (i1 | 0) & (i1 | 0) > 0) {
+ i8 = i7;
+ i7 = 2192;
+ } else {
+ i8 = 0;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ }
+ HEAP32[i2 >> 2] = i8 + (i1 + -1 << 4);
+ i8 = i7;
+ STACKTOP = i3;
+ return i8 | 0;
+}
+function _luaH_setint(i4, i5, i6, i1) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, d7 = 0.0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i8 = i2 + 16 | 0;
+ i3 = i2;
+ i9 = i6 + -1 | 0;
+ L1 : do {
+ if (i9 >>> 0 < (HEAP32[i5 + 28 >> 2] | 0) >>> 0) {
+ i9 = (HEAP32[i5 + 12 >> 2] | 0) + (i9 << 4) | 0;
+ i8 = 10;
+ } else {
+ d7 = +(i6 | 0);
+ HEAPF64[i8 >> 3] = d7 + 1.0;
+ i8 = (HEAP32[i8 + 4 >> 2] | 0) + (HEAP32[i8 >> 2] | 0) | 0;
+ if ((i8 | 0) < 0) {
+ i9 = 0 - i8 | 0;
+ i8 = (i8 | 0) == (i9 | 0) ? 0 : i9;
+ }
+ i9 = (HEAP32[i5 + 16 >> 2] | 0) + (((i8 | 0) % ((1 << (HEAPU8[i5 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i9 + 24 >> 2] | 0) == 3 ? +HEAPF64[i9 + 16 >> 3] == d7 : 0) {
+ break;
+ }
+ i9 = HEAP32[i9 + 28 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ i8 = 12;
+ break L1;
+ }
+ }
+ i8 = 10;
+ }
+ } while (0);
+ if ((i8 | 0) == 10) {
+ if ((i9 | 0) == 5192) {
+ d7 = +(i6 | 0);
+ i8 = 12;
+ }
+ }
+ if ((i8 | 0) == 12) {
+ HEAPF64[i3 >> 3] = d7;
+ HEAP32[i3 + 8 >> 2] = 3;
+ i9 = _luaH_newkey(i4, i5, i3) | 0;
+ }
+ i5 = i1;
+ i6 = HEAP32[i5 + 4 >> 2] | 0;
+ i8 = i9;
+ HEAP32[i8 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i8 + 4 >> 2] = i6;
+ HEAP32[i9 + 8 >> 2] = HEAP32[i1 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+}
+function _lua_tounsignedx(i6, i8, i1) {
+ i6 = i6 | 0;
+ i8 = i8 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i4 = i2 + 8 | 0;
+ i3 = i2;
+ i7 = HEAP32[i6 + 16 >> 2] | 0;
+ do {
+ if ((i8 | 0) <= 0) {
+ if (!((i8 | 0) < -1000999)) {
+ i5 = (HEAP32[i6 + 8 >> 2] | 0) + (i8 << 4) | 0;
+ break;
+ }
+ if ((i8 | 0) == -1001e3) {
+ i5 = (HEAP32[i6 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i8 | 0;
+ i7 = HEAP32[i7 >> 2] | 0;
+ if ((HEAP32[i7 + 8 >> 2] | 0) != 22 ? (i5 = HEAP32[i7 >> 2] | 0, (i6 | 0) <= (HEAPU8[i5 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i5 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i5 = (HEAP32[i7 >> 2] | 0) + (i8 << 4) | 0;
+ i5 = i5 >>> 0 < (HEAP32[i6 + 8 >> 2] | 0) >>> 0 ? i5 : 5192;
+ }
+ } while (0);
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 3) {
+ i5 = _luaV_tonumber(i5, i4) | 0;
+ if ((i5 | 0) == 0) {
+ if ((i1 | 0) == 0) {
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ HEAP32[i1 >> 2] = 0;
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ }
+ HEAPF64[i3 >> 3] = +HEAPF64[i5 >> 3] + 6755399441055744.0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((i1 | 0) == 0) {
+ i8 = i3;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ HEAP32[i1 >> 2] = 1;
+ i8 = i3;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function _luaC_freeallobjects(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i5 = i1 + 12 | 0;
+ i3 = HEAP32[i5 >> 2] | 0;
+ i7 = i3 + 104 | 0;
+ while (1) {
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ break;
+ } else {
+ i7 = i4;
+ }
+ }
+ i4 = i3 + 72 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ i5 = i3;
+ } else {
+ while (1) {
+ i8 = i6 + 5 | 0;
+ HEAP8[i8] = HEAPU8[i8] | 0 | 8;
+ HEAP32[i4 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i6 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i7 >> 2] = i6;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ break;
+ } else {
+ i8 = i6;
+ i6 = i7;
+ i7 = i8;
+ }
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ }
+ i5 = i5 + 104 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ do {
+ i8 = i6 + 5 | 0;
+ HEAP8[i8] = HEAP8[i8] & 191;
+ _GCTM(i1, 0);
+ i6 = HEAP32[i5 >> 2] | 0;
+ } while ((i6 | 0) != 0);
+ }
+ HEAP8[i3 + 60 | 0] = 3;
+ HEAP8[i3 + 62 | 0] = 0;
+ _sweeplist(i1, i4, -3) | 0;
+ _sweeplist(i1, i3 + 68 | 0, -3) | 0;
+ i4 = i3 + 32 | 0;
+ if ((HEAP32[i4 >> 2] | 0) <= 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i3 + 24 | 0;
+ i5 = 0;
+ do {
+ _sweeplist(i1, (HEAP32[i3 >> 2] | 0) + (i5 << 2) | 0, -3) | 0;
+ i5 = i5 + 1 | 0;
+ } while ((i5 | 0) < (HEAP32[i4 >> 2] | 0));
+ STACKTOP = i2;
+ return;
+}
+function _strspn(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i2;
+ HEAP32[i3 + 0 >> 2] = 0;
+ HEAP32[i3 + 4 >> 2] = 0;
+ HEAP32[i3 + 8 >> 2] = 0;
+ HEAP32[i3 + 12 >> 2] = 0;
+ HEAP32[i3 + 16 >> 2] = 0;
+ HEAP32[i3 + 20 >> 2] = 0;
+ HEAP32[i3 + 24 >> 2] = 0;
+ HEAP32[i3 + 28 >> 2] = 0;
+ i4 = HEAP8[i5] | 0;
+ if (i4 << 24 >> 24 == 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((HEAP8[i5 + 1 | 0] | 0) == 0) {
+ i3 = i1;
+ while (1) {
+ if ((HEAP8[i3] | 0) == i4 << 24 >> 24) {
+ i3 = i3 + 1 | 0;
+ } else {
+ break;
+ }
+ }
+ i6 = i3 - i1 | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ do {
+ i7 = i4 & 255;
+ i6 = i3 + (i7 >>> 5 << 2) | 0;
+ HEAP32[i6 >> 2] = HEAP32[i6 >> 2] | 1 << (i7 & 31);
+ i5 = i5 + 1 | 0;
+ i4 = HEAP8[i5] | 0;
+ } while (!(i4 << 24 >> 24 == 0));
+ i5 = HEAP8[i1] | 0;
+ L12 : do {
+ if (i5 << 24 >> 24 == 0) {
+ i4 = i1;
+ } else {
+ i4 = i1;
+ while (1) {
+ i7 = i5 & 255;
+ i6 = i4 + 1 | 0;
+ if ((HEAP32[i3 + (i7 >>> 5 << 2) >> 2] & 1 << (i7 & 31) | 0) == 0) {
+ break L12;
+ }
+ i5 = HEAP8[i6] | 0;
+ if (i5 << 24 >> 24 == 0) {
+ i4 = i6;
+ break;
+ } else {
+ i4 = i6;
+ }
+ }
+ }
+ } while (0);
+ i7 = i4 - i1 | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _lua_remove(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i5 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i4 = -1001e3 - i4 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i4 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i4 = i3 + 16 | 0;
+ i2 = i2 + 8 | 0;
+ i5 = HEAP32[i2 >> 2] | 0;
+ if (!(i4 >>> 0 < i5 >>> 0)) {
+ i5 = i5 + -16 | 0;
+ HEAP32[i2 >> 2] = i5;
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i7 = i4;
+ i6 = HEAP32[i7 + 4 >> 2] | 0;
+ i5 = i3;
+ HEAP32[i5 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i5 + 4 >> 2] = i6;
+ HEAP32[i3 + 8 >> 2] = HEAP32[i3 + 24 >> 2];
+ i5 = i4 + 16 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ if (i5 >>> 0 < i3 >>> 0) {
+ i3 = i4;
+ i4 = i5;
+ } else {
+ break;
+ }
+ }
+ i7 = i3 + -16 | 0;
+ HEAP32[i2 >> 2] = i7;
+ STACKTOP = i1;
+ return;
+}
+function _luaD_protectedparser(i1, i4, i3, i2) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i13 = i5;
+ i6 = i1 + 36 | 0;
+ HEAP16[i6 >> 1] = (HEAP16[i6 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP32[i13 >> 2] = i4;
+ HEAP32[i13 + 56 >> 2] = i3;
+ HEAP32[i13 + 52 >> 2] = i2;
+ i10 = i13 + 16 | 0;
+ HEAP32[i10 >> 2] = 0;
+ i9 = i13 + 24 | 0;
+ HEAP32[i9 >> 2] = 0;
+ i8 = i13 + 28 | 0;
+ HEAP32[i8 >> 2] = 0;
+ i7 = i13 + 36 | 0;
+ HEAP32[i7 >> 2] = 0;
+ i2 = i13 + 40 | 0;
+ HEAP32[i2 >> 2] = 0;
+ i3 = i13 + 48 | 0;
+ HEAP32[i3 >> 2] = 0;
+ i12 = i13 + 4 | 0;
+ HEAP32[i12 >> 2] = 0;
+ i11 = i13 + 12 | 0;
+ HEAP32[i11 >> 2] = 0;
+ i4 = _luaD_pcall(i1, 6, i13, (HEAP32[i1 + 8 >> 2] | 0) - (HEAP32[i1 + 28 >> 2] | 0) | 0, HEAP32[i1 + 68 >> 2] | 0) | 0;
+ HEAP32[i12 >> 2] = _luaM_realloc_(i1, HEAP32[i12 >> 2] | 0, HEAP32[i11 >> 2] | 0, 0) | 0;
+ HEAP32[i11 >> 2] = 0;
+ _luaM_realloc_(i1, HEAP32[i10 >> 2] | 0, HEAP32[i9 >> 2] << 1, 0) | 0;
+ _luaM_realloc_(i1, HEAP32[i8 >> 2] | 0, HEAP32[i7 >> 2] << 4, 0) | 0;
+ _luaM_realloc_(i1, HEAP32[i2 >> 2] | 0, HEAP32[i3 >> 2] << 4, 0) | 0;
+ HEAP16[i6 >> 1] = (HEAP16[i6 >> 1] | 0) + -1 << 16 >> 16;
+ STACKTOP = i5;
+ return i4 | 0;
+}
+function _markmt(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i1 + 252 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 256 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 260 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 264 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 268 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 272 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 276 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 280 >> 2] | 0;
+ if ((i3 | 0) != 0 ? !((HEAP8[i3 + 5 | 0] & 3) == 0) : 0) {
+ _reallymarkobject(i1, i3);
+ }
+ i3 = HEAP32[i1 + 284 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _reallymarkobject(i1, i3);
+ STACKTOP = i2;
+ return;
+}
+function _findlabel(i9, i2) {
+ i9 = i9 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0;
+ i1 = STACKTOP;
+ i3 = i9 + 48 | 0;
+ i7 = HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0;
+ i10 = HEAP32[i9 + 64 >> 2] | 0;
+ i4 = HEAP32[i10 + 12 >> 2] | 0;
+ i6 = i7 + 4 | 0;
+ i13 = HEAP16[i6 >> 1] | 0;
+ i5 = i10 + 28 | 0;
+ if ((i13 | 0) >= (HEAP32[i5 >> 2] | 0)) {
+ i15 = 0;
+ STACKTOP = i1;
+ return i15 | 0;
+ }
+ i10 = i10 + 24 | 0;
+ i11 = i4 + (i2 << 4) | 0;
+ while (1) {
+ i14 = HEAP32[i10 >> 2] | 0;
+ i12 = i14 + (i13 << 4) | 0;
+ i15 = i13 + 1 | 0;
+ if ((_luaS_eqstr(HEAP32[i12 >> 2] | 0, HEAP32[i11 >> 2] | 0) | 0) != 0) {
+ break;
+ }
+ if ((i15 | 0) < (HEAP32[i5 >> 2] | 0)) {
+ i13 = i15;
+ } else {
+ i2 = 0;
+ i8 = 10;
+ break;
+ }
+ }
+ if ((i8 | 0) == 10) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ i8 = HEAP8[i14 + (i13 << 4) + 12 | 0] | 0;
+ do {
+ if ((HEAPU8[i4 + (i2 << 4) + 12 | 0] | 0) > (i8 & 255)) {
+ if ((HEAP8[i7 + 9 | 0] | 0) == 0 ? (HEAP32[i5 >> 2] | 0) <= (HEAP16[i6 >> 1] | 0) : 0) {
+ break;
+ }
+ _luaK_patchclose(HEAP32[i3 >> 2] | 0, HEAP32[i4 + (i2 << 4) + 4 >> 2] | 0, i8 & 255);
+ }
+ } while (0);
+ _closegoto(i9, i2, i12);
+ i15 = 1;
+ STACKTOP = i1;
+ return i15 | 0;
+}
+function _lua_getmetatable(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i4 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i3 = HEAP32[i4 + 8 >> 2] & 15;
+ if ((i3 | 0) == 7) {
+ i3 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
+ } else if ((i3 | 0) == 5) {
+ i3 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
+ } else {
+ i3 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i3 << 2) + 252 >> 2] | 0;
+ }
+ if ((i3 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ i5 = i1 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i4 + 8 >> 2] = 69;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _str_byte(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i6 = i1;
+ i4 = i1 + 4 | 0;
+ i3 = _luaL_checklstring(i2, 1, i4) | 0;
+ i5 = _luaL_optinteger(i2, 2, 1) | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if (!((i5 | 0) > -1)) {
+ if (i7 >>> 0 < (0 - i5 | 0) >>> 0) {
+ i5 = 0;
+ } else {
+ i5 = i5 + 1 + i7 | 0;
+ }
+ }
+ i8 = _luaL_optinteger(i2, 3, i5) | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ if (!((i8 | 0) > -1)) {
+ if (i7 >>> 0 < (0 - i8 | 0) >>> 0) {
+ i8 = 0;
+ } else {
+ i8 = i8 + 1 + i7 | 0;
+ }
+ }
+ i9 = (i5 | 0) == 0 ? 1 : i5;
+ i10 = i8 >>> 0 > i7 >>> 0 ? i7 : i8;
+ if (i9 >>> 0 > i10 >>> 0) {
+ i10 = 0;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i4 = i10 - i9 + 1 | 0;
+ if ((i10 | 0) == -1) {
+ i10 = _luaL_error(i2, 7944, i6) | 0;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ _luaL_checkstack(i2, i4, 7944);
+ if ((i4 | 0) <= 0) {
+ i10 = i4;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i6 = i9 + -1 | 0;
+ i8 = ~i8;
+ i7 = ~i7;
+ i5 = 0 - (i8 >>> 0 > i7 >>> 0 ? i8 : i7) - (i5 >>> 0 > 1 ? i5 : 1) | 0;
+ i7 = 0;
+ do {
+ _lua_pushinteger(i2, HEAPU8[i3 + (i6 + i7) | 0] | 0);
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != (i5 | 0));
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _lua_setuservalue(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i6 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i5 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i5 = i4 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i5 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i6 >> 2] | 0) + (i5 << 4) | 0;
+ i5 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i4 = i1 + 8 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i6 + -8 >> 2] | 0) != 0) {
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] = HEAP32[i6 + -16 >> 2];
+ i6 = HEAP32[(HEAP32[i4 >> 2] | 0) + -16 >> 2] | 0;
+ if (!((HEAP8[i6 + 5 | 0] & 3) == 0) ? (i2 = HEAP32[i5 >> 2] | 0, !((HEAP8[i2 + 5 | 0] & 4) == 0)) : 0) {
+ _luaC_barrier_(i1, i2, i6);
+ }
+ } else {
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 12 >> 2] = 0;
+ }
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
+ STACKTOP = i3;
+ return;
+}
+function _f_luaopen(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i6;
+ i4 = HEAP32[i1 + 12 >> 2] | 0;
+ i2 = _luaM_realloc_(i1, 0, 0, 640) | 0;
+ HEAP32[i1 + 28 >> 2] = i2;
+ i3 = i1 + 32 | 0;
+ HEAP32[i3 >> 2] = 40;
+ i7 = 0;
+ do {
+ HEAP32[i2 + (i7 << 4) + 8 >> 2] = 0;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != 40);
+ HEAP32[i1 + 24 >> 2] = i2 + ((HEAP32[i3 >> 2] | 0) + -5 << 4);
+ i7 = i1 + 72 | 0;
+ HEAP32[i1 + 80 >> 2] = 0;
+ HEAP32[i1 + 84 >> 2] = 0;
+ HEAP8[i1 + 90 | 0] = 0;
+ HEAP32[i7 >> 2] = i2;
+ HEAP32[i1 + 8 >> 2] = i2 + 16;
+ HEAP32[i2 + 8 >> 2] = 0;
+ HEAP32[i1 + 76 >> 2] = i2 + 336;
+ HEAP32[i1 + 16 >> 2] = i7;
+ i7 = _luaH_new(i1) | 0;
+ HEAP32[i4 + 40 >> 2] = i7;
+ HEAP32[i4 + 48 >> 2] = 69;
+ _luaH_resize(i1, i7, 2, 0);
+ HEAP32[i5 >> 2] = i1;
+ i3 = i5 + 8 | 0;
+ HEAP32[i3 >> 2] = 72;
+ _luaH_setint(i1, i7, 1, i5);
+ HEAP32[i5 >> 2] = _luaH_new(i1) | 0;
+ HEAP32[i3 >> 2] = 69;
+ _luaH_setint(i1, i7, 2, i5);
+ _luaS_resize(i1, 32);
+ _luaT_init(i1);
+ _luaX_init(i1);
+ i7 = _luaS_newlstr(i1, 6896, 17) | 0;
+ HEAP32[i4 + 180 >> 2] = i7;
+ i7 = i7 + 5 | 0;
+ HEAP8[i7] = HEAPU8[i7] | 0 | 32;
+ HEAP8[i4 + 63 | 0] = 1;
+ STACKTOP = i6;
+ return;
+}
+function _lua_tointegerx(i6, i7, i1) {
+ i6 = i6 | 0;
+ i7 = i7 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ do {
+ if ((i7 | 0) <= 0) {
+ if (!((i7 | 0) < -1000999)) {
+ i4 = (HEAP32[i6 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i4 = (HEAP32[i6 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i7 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i7 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i6 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 3) {
+ i4 = _luaV_tonumber(i4, i3) | 0;
+ if ((i4 | 0) == 0) {
+ if ((i1 | 0) == 0) {
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ HEAP32[i1 >> 2] = 0;
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ }
+ i3 = ~~+HEAPF64[i4 >> 3];
+ if ((i1 | 0) == 0) {
+ i7 = i3;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ HEAP32[i1 >> 2] = 1;
+ i7 = i3;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _close_state(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ i6 = i1 + 12 | 0;
+ i3 = HEAP32[i6 >> 2] | 0;
+ i4 = i1 + 28 | 0;
+ _luaF_close(i1, HEAP32[i4 >> 2] | 0);
+ _luaC_freeallobjects(i1);
+ i6 = HEAP32[i6 >> 2] | 0;
+ _luaM_realloc_(i1, HEAP32[i6 + 24 >> 2] | 0, HEAP32[i6 + 32 >> 2] << 2, 0) | 0;
+ i6 = i3 + 144 | 0;
+ i5 = i3 + 152 | 0;
+ HEAP32[i6 >> 2] = _luaM_realloc_(i1, HEAP32[i6 >> 2] | 0, HEAP32[i5 >> 2] | 0, 0) | 0;
+ HEAP32[i5 >> 2] = 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i3 >> 2] | 0;
+ i6 = i3 + 4 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ FUNCTION_TABLE_iiiii[i5 & 3](i6, i1, 400, 0) | 0;
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i1 + 16 >> 2] = i1 + 72;
+ i7 = i1 + 84 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = 0;
+ if ((i6 | 0) != 0) {
+ while (1) {
+ i5 = HEAP32[i6 + 12 >> 2] | 0;
+ _luaM_realloc_(i1, i6, 40, 0) | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ } else {
+ i6 = i5;
+ }
+ }
+ i5 = HEAP32[i4 >> 2] | 0;
+ }
+ _luaM_realloc_(i1, i5, HEAP32[i1 + 32 >> 2] << 4, 0) | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i7 = i3 + 4 | 0;
+ i7 = HEAP32[i7 >> 2] | 0;
+ FUNCTION_TABLE_iiiii[i6 & 3](i7, i1, 400, 0) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _ll_module(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i2;
+ i5 = i2 + 4 | 0;
+ i6 = _luaL_checklstring(i1, 1, 0) | 0;
+ i3 = _lua_gettop(i1) | 0;
+ _luaL_pushmodule(i1, i6, 1);
+ _lua_getfield(i1, -1, 4728);
+ i7 = (_lua_type(i1, -1) | 0) == 0;
+ _lua_settop(i1, -2);
+ if (i7) {
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -2, 4784);
+ _lua_pushstring(i1, i6) | 0;
+ _lua_setfield(i1, -2, 4728);
+ i7 = _strrchr(i6, 46) | 0;
+ _lua_pushlstring(i1, i6, ((i7 | 0) == 0 ? i6 : i7 + 1 | 0) - i6 | 0) | 0;
+ _lua_setfield(i1, -2, 4792);
+ }
+ _lua_pushvalue(i1, -1);
+ if (!(((_lua_getstack(i1, 1, i5) | 0) != 0 ? (_lua_getinfo(i1, 4736, i5) | 0) != 0 : 0) ? (_lua_iscfunction(i1, -1) | 0) == 0 : 0)) {
+ _luaL_error(i1, 4744, i4) | 0;
+ }
+ _lua_pushvalue(i1, -2);
+ _lua_setupvalue(i1, -2, 1) | 0;
+ _lua_settop(i1, -2);
+ if ((i3 | 0) < 2) {
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i4 = 2;
+ }
+ while (1) {
+ if ((_lua_type(i1, i4) | 0) == 6) {
+ _lua_pushvalue(i1, i4);
+ _lua_pushvalue(i1, -2);
+ _lua_callk(i1, 1, 0, 0, 0);
+ }
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ STACKTOP = i2;
+ return 1;
+}
+function _strcspn(i2, i5) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i1;
+ i4 = HEAP8[i5] | 0;
+ if (!(i4 << 24 >> 24 == 0) ? (HEAP8[i5 + 1 | 0] | 0) != 0 : 0) {
+ HEAP32[i3 + 0 >> 2] = 0;
+ HEAP32[i3 + 4 >> 2] = 0;
+ HEAP32[i3 + 8 >> 2] = 0;
+ HEAP32[i3 + 12 >> 2] = 0;
+ HEAP32[i3 + 16 >> 2] = 0;
+ HEAP32[i3 + 20 >> 2] = 0;
+ HEAP32[i3 + 24 >> 2] = 0;
+ HEAP32[i3 + 28 >> 2] = 0;
+ do {
+ i7 = i4 & 255;
+ i6 = i3 + (i7 >>> 5 << 2) | 0;
+ HEAP32[i6 >> 2] = HEAP32[i6 >> 2] | 1 << (i7 & 31);
+ i5 = i5 + 1 | 0;
+ i4 = HEAP8[i5] | 0;
+ } while (!(i4 << 24 >> 24 == 0));
+ i5 = HEAP8[i2] | 0;
+ L7 : do {
+ if (i5 << 24 >> 24 == 0) {
+ i4 = i2;
+ } else {
+ i4 = i2;
+ while (1) {
+ i7 = i5 & 255;
+ i6 = i4 + 1 | 0;
+ if ((HEAP32[i3 + (i7 >>> 5 << 2) >> 2] & 1 << (i7 & 31) | 0) != 0) {
+ break L7;
+ }
+ i5 = HEAP8[i6] | 0;
+ if (i5 << 24 >> 24 == 0) {
+ i4 = i6;
+ break;
+ } else {
+ i4 = i6;
+ }
+ }
+ }
+ } while (0);
+ i7 = i4 - i2 | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i7 = (___strchrnul(i2, i4 << 24 >> 24) | 0) - i2 | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _main(i4, i5) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ i3 = _luaL_newstate() | 0;
+ if ((i3 | 0) == 0) {
+ i4 = HEAP32[i5 >> 2] | 0;
+ i3 = HEAP32[_stderr >> 2] | 0;
+ if ((i4 | 0) != 0) {
+ HEAP32[i2 >> 2] = i4;
+ _fprintf(i3 | 0, 496, i2 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = 8;
+ _fprintf(i3 | 0, 912, i2 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ i8 = 1;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ _lua_pushcclosure(i3, 141, 0);
+ _lua_pushinteger(i3, i4);
+ _lua_pushlightuserdata(i3, i5);
+ i6 = _lua_pcallk(i3, 2, 1, 0, 0, 0) | 0;
+ i7 = _lua_toboolean(i3, -1) | 0;
+ i6 = (i6 | 0) == 0;
+ if (!i6) {
+ if ((_lua_type(i3, -1) | 0) == 4) {
+ i8 = _lua_tolstring(i3, -1, 0) | 0;
+ } else {
+ i8 = 0;
+ }
+ i4 = HEAP32[20] | 0;
+ i5 = HEAP32[_stderr >> 2] | 0;
+ if ((i4 | 0) != 0) {
+ HEAP32[i2 >> 2] = i4;
+ _fprintf(i5 | 0, 496, i2 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = (i8 | 0) == 0 ? 48 : i8;
+ _fprintf(i5 | 0, 912, i2 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ _lua_settop(i3, -2);
+ }
+ _lua_close(i3);
+ i8 = i6 & (i7 | 0) != 0 & 1 ^ 1;
+ STACKTOP = i1;
+ return i8 | 0;
+}
+function _db_sethook(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i4 = STACKTOP;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i2 = _lua_tothread(i1, 1) | 0;
+ i5 = 1;
+ } else {
+ i2 = i1;
+ i5 = 0;
+ }
+ i3 = i5 + 1 | 0;
+ if ((_lua_type(i1, i3) | 0) < 1) {
+ _lua_settop(i1, i3);
+ i6 = 0;
+ i7 = 0;
+ i5 = 0;
+ } else {
+ i6 = _luaL_checklstring(i1, i5 | 2, 0) | 0;
+ _luaL_checktype(i1, i3, 6);
+ i5 = _luaL_optinteger(i1, i5 + 3 | 0, 0) | 0;
+ i7 = (_strchr(i6, 99) | 0) != 0 | 0;
+ i8 = (_strchr(i6, 114) | 0) == 0;
+ i7 = i8 ? i7 : i7 | 2;
+ i8 = (_strchr(i6, 108) | 0) == 0;
+ i8 = i8 ? i7 : i7 | 4;
+ i6 = i5;
+ i7 = 9;
+ i5 = (i5 | 0) > 0 ? i8 | 8 : i8;
+ }
+ if ((_luaL_getsubtable(i1, -1001e3, 11584) | 0) != 0) {
+ _lua_pushthread(i2) | 0;
+ _lua_xmove(i2, i1, 1);
+ _lua_pushvalue(i1, i3);
+ _lua_rawset(i1, -3);
+ _lua_sethook(i2, i7, i5, i6) | 0;
+ STACKTOP = i4;
+ return 0;
+ }
+ _lua_pushstring(i1, 11592) | 0;
+ _lua_setfield(i1, -2, 11600);
+ _lua_pushvalue(i1, -1);
+ _lua_setmetatable(i1, -2) | 0;
+ _lua_pushthread(i2) | 0;
+ _lua_xmove(i2, i1, 1);
+ _lua_pushvalue(i1, i3);
+ _lua_rawset(i1, -3);
+ _lua_sethook(i2, i7, i5, i6) | 0;
+ STACKTOP = i4;
+ return 0;
+}
+function _tconcat(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i6 = i3;
+ i2 = i3 + 16 | 0;
+ i5 = i3 + 8 | 0;
+ i4 = _luaL_optlstring(i1, 2, 8208, i5) | 0;
+ _luaL_checktype(i1, 1, 5);
+ i8 = _luaL_optinteger(i1, 3, 1) | 0;
+ if ((_lua_type(i1, 4) | 0) < 1) {
+ i7 = _luaL_len(i1, 1) | 0;
+ } else {
+ i7 = _luaL_checkinteger(i1, 4) | 0;
+ }
+ _luaL_buffinit(i1, i2);
+ if ((i8 | 0) >= (i7 | 0)) {
+ if ((i8 | 0) != (i7 | 0)) {
+ _luaL_pushresult(i2);
+ STACKTOP = i3;
+ return 1;
+ }
+ } else {
+ do {
+ _lua_rawgeti(i1, 1, i8);
+ if ((_lua_isstring(i1, -1) | 0) == 0) {
+ HEAP32[i6 >> 2] = _lua_typename(i1, _lua_type(i1, -1) | 0) | 0;
+ HEAP32[i6 + 4 >> 2] = i8;
+ _luaL_error(i1, 8360, i6) | 0;
+ }
+ _luaL_addvalue(i2);
+ _luaL_addlstring(i2, i4, HEAP32[i5 >> 2] | 0);
+ i8 = i8 + 1 | 0;
+ } while ((i8 | 0) != (i7 | 0));
+ }
+ _lua_rawgeti(i1, 1, i7);
+ if ((_lua_isstring(i1, -1) | 0) == 0) {
+ HEAP32[i6 >> 2] = _lua_typename(i1, _lua_type(i1, -1) | 0) | 0;
+ HEAP32[i6 + 4 >> 2] = i7;
+ _luaL_error(i1, 8360, i6) | 0;
+ }
+ _luaL_addvalue(i2);
+ _luaL_pushresult(i2);
+ STACKTOP = i3;
+ return 1;
+}
+function _searcher_Croot(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i4 = _luaL_checklstring(i1, 1, 0) | 0;
+ i5 = _strchr(i4, 46) | 0;
+ if ((i5 | 0) == 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ _lua_pushlstring(i1, i4, i5 - i4 | 0) | 0;
+ i5 = _lua_tolstring(i1, -1, 0) | 0;
+ _lua_getfield(i1, -1001001, 4440);
+ i6 = _lua_tolstring(i1, -1, 0) | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i3 >> 2] = 4440;
+ _luaL_error(i1, 5032, i3) | 0;
+ }
+ i5 = _searchpath(i1, i5, i6, 4936, 4848) | 0;
+ if ((i5 | 0) == 0) {
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i6 = _loadfunc(i1, i5, i4) | 0;
+ if ((i6 | 0) == 2) {
+ HEAP32[i3 >> 2] = i4;
+ HEAP32[i3 + 4 >> 2] = i5;
+ _lua_pushfstring(i1, 4856, i3) | 0;
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else if ((i6 | 0) == 0) {
+ _lua_pushstring(i1, i5) | 0;
+ i6 = 2;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ i4 = _lua_tolstring(i1, 1, 0) | 0;
+ i6 = _lua_tolstring(i1, -1, 0) | 0;
+ HEAP32[i3 >> 2] = i4;
+ HEAP32[i3 + 4 >> 2] = i5;
+ HEAP32[i3 + 8 >> 2] = i6;
+ i6 = _luaL_error(i1, 4888, i3) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ return 0;
+}
+function _lua_tonumberx(i5, i7, i1) {
+ i5 = i5 | 0;
+ i7 = i7 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, d8 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i6 = HEAP32[i5 + 16 >> 2] | 0;
+ do {
+ if ((i7 | 0) <= 0) {
+ if (!((i7 | 0) < -1000999)) {
+ i4 = (HEAP32[i5 + 8 >> 2] | 0) + (i7 << 4) | 0;
+ break;
+ }
+ if ((i7 | 0) == -1001e3) {
+ i4 = (HEAP32[i5 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i7 | 0;
+ i6 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i6 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i6 >> 2] | 0, (i5 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i6 >> 2] | 0) + (i7 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i5 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 3) {
+ i4 = _luaV_tonumber(i4, i3) | 0;
+ if ((i4 | 0) == 0) {
+ if ((i1 | 0) == 0) {
+ d8 = 0.0;
+ STACKTOP = i2;
+ return +d8;
+ }
+ HEAP32[i1 >> 2] = 0;
+ d8 = 0.0;
+ STACKTOP = i2;
+ return +d8;
+ }
+ }
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = 1;
+ }
+ d8 = +HEAPF64[i4 >> 3];
+ STACKTOP = i2;
+ return +d8;
+}
+function _luaopen_package(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_getsubtable(i1, -1001e3, 4184) | 0;
+ _lua_createtable(i1, 0, 1);
+ _lua_pushcclosure(i1, 158, 0);
+ _lua_setfield(i1, -2, 4192);
+ _lua_setmetatable(i1, -2) | 0;
+ _lua_createtable(i1, 0, 3);
+ _luaL_setfuncs(i1, 4200, 0);
+ _lua_createtable(i1, 4, 0);
+ _lua_pushvalue(i1, -2);
+ _lua_pushcclosure(i1, 159, 1);
+ _lua_rawseti(i1, -2, 1);
+ _lua_pushvalue(i1, -2);
+ _lua_pushcclosure(i1, 160, 1);
+ _lua_rawseti(i1, -2, 2);
+ _lua_pushvalue(i1, -2);
+ _lua_pushcclosure(i1, 161, 1);
+ _lua_rawseti(i1, -2, 3);
+ _lua_pushvalue(i1, -2);
+ _lua_pushcclosure(i1, 162, 1);
+ _lua_rawseti(i1, -2, 4);
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -3, 4232);
+ _lua_setfield(i1, -2, 4240);
+ _setpath(i1, 4256, 4264, 4280, 4296);
+ _setpath(i1, 4440, 4448, 4464, 4480);
+ _lua_pushlstring(i1, 4552, 10) | 0;
+ _lua_setfield(i1, -2, 4568);
+ _luaL_getsubtable(i1, -1001e3, 4576) | 0;
+ _lua_setfield(i1, -2, 4584);
+ _luaL_getsubtable(i1, -1001e3, 4592) | 0;
+ _lua_setfield(i1, -2, 4608);
+ _lua_rawgeti(i1, -1001e3, 2);
+ _lua_pushvalue(i1, -2);
+ _luaL_setfuncs(i1, 4616, 1);
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_rawlen(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i2 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i2 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ i3 = HEAP32[i2 + 8 >> 2] & 15;
+ if ((i3 | 0) == 5) {
+ i5 = _luaH_getn(HEAP32[i2 >> 2] | 0) | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else if ((i3 | 0) == 4) {
+ i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 12 >> 2] | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else if ((i3 | 0) == 7) {
+ i5 = HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _searchpath(i3, i5, i6, i7, i8) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i4 = i2;
+ i1 = i2 + 8 | 0;
+ _luaL_buffinit(i3, i1);
+ if ((HEAP8[i7] | 0) != 0) {
+ i5 = _luaL_gsub(i3, i5, i7, i8) | 0;
+ }
+ while (1) {
+ i7 = HEAP8[i6] | 0;
+ if (i7 << 24 >> 24 == 59) {
+ i6 = i6 + 1 | 0;
+ continue;
+ } else if (i7 << 24 >> 24 == 0) {
+ i3 = 12;
+ break;
+ }
+ i8 = _strchr(i6, 59) | 0;
+ if ((i8 | 0) == 0) {
+ i8 = i6 + (_strlen(i6 | 0) | 0) | 0;
+ }
+ _lua_pushlstring(i3, i6, i8 - i6 | 0) | 0;
+ if ((i8 | 0) == 0) {
+ i3 = 12;
+ break;
+ }
+ i6 = _luaL_gsub(i3, _lua_tolstring(i3, -1, 0) | 0, 5064, i5) | 0;
+ _lua_remove(i3, -2);
+ i7 = _fopen(i6 | 0, 5088) | 0;
+ if ((i7 | 0) != 0) {
+ i3 = 10;
+ break;
+ }
+ HEAP32[i4 >> 2] = i6;
+ _lua_pushfstring(i3, 5072, i4) | 0;
+ _lua_remove(i3, -2);
+ _luaL_addvalue(i1);
+ i6 = i8;
+ }
+ if ((i3 | 0) == 10) {
+ _fclose(i7 | 0) | 0;
+ i8 = i6;
+ STACKTOP = i2;
+ return i8 | 0;
+ } else if ((i3 | 0) == 12) {
+ _luaL_pushresult(i1);
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ return 0;
+}
+function _io_readline(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i4 = _lua_touserdata(i1, -1001001) | 0;
+ i5 = _lua_tointegerx(i1, -1001002, 0) | 0;
+ if ((HEAP32[i4 + 4 >> 2] | 0) == 0) {
+ i6 = _luaL_error(i1, 3344, i3) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ _lua_settop(i1, 1);
+ if ((i5 | 0) >= 1) {
+ i6 = 1;
+ while (1) {
+ _lua_pushvalue(i1, -1001003 - i6 | 0);
+ if ((i6 | 0) == (i5 | 0)) {
+ break;
+ } else {
+ i6 = i6 + 1 | 0;
+ }
+ }
+ }
+ i4 = _g_read(i1, HEAP32[i4 >> 2] | 0, 2) | 0;
+ if ((_lua_type(i1, 0 - i4 | 0) | 0) != 0) {
+ i6 = i4;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((i4 | 0) > 1) {
+ HEAP32[i3 >> 2] = _lua_tolstring(i1, 1 - i4 | 0, 0) | 0;
+ i6 = _luaL_error(i1, 3368, i3) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((_lua_toboolean(i1, -1001003) | 0) == 0) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ _lua_settop(i1, 0);
+ _lua_pushvalue(i1, -1001001);
+ i5 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = 0;
+ FUNCTION_TABLE_ii[i6 & 255](i1) | 0;
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _luaK_setreturns(i3, i5, i6) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 13) {
+ i7 = i5 + 8 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ i4 = HEAP32[i8 + 12 >> 2] | 0;
+ i5 = i4 + (HEAP32[i7 >> 2] << 2) | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & 8388607 | (i6 << 23) + 8388608;
+ i7 = i4 + (HEAP32[i7 >> 2] << 2) | 0;
+ i4 = i3 + 48 | 0;
+ HEAP32[i7 >> 2] = (HEAPU8[i4] | 0) << 6 | HEAP32[i7 >> 2] & -16321;
+ i7 = HEAP8[i4] | 0;
+ i5 = (i7 & 255) + 1 | 0;
+ i6 = i8 + 78 | 0;
+ do {
+ if (i5 >>> 0 > (HEAPU8[i6] | 0) >>> 0) {
+ if (i5 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i3 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i6] = i5;
+ i1 = HEAP8[i4] | 0;
+ break;
+ }
+ } else {
+ i1 = i7;
+ }
+ } while (0);
+ HEAP8[i4] = (i1 & 255) + 1;
+ STACKTOP = i2;
+ return;
+ } else if ((i4 | 0) == 12) {
+ i8 = (HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i5 + 8 >> 2] << 2) | 0;
+ HEAP32[i8 >> 2] = HEAP32[i8 >> 2] & -8372225 | (i6 << 14) + 16384 & 8372224;
+ STACKTOP = i2;
+ return;
+ } else {
+ STACKTOP = i2;
+ return;
+ }
+}
+function _luaZ_read(i2, i9, i8) {
+ i2 = i2 | 0;
+ i9 = i9 | 0;
+ i8 = i8 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ if ((i8 | 0) == 0) {
+ i11 = 0;
+ STACKTOP = i1;
+ return i11 | 0;
+ }
+ i7 = i2 + 16 | 0;
+ i6 = i2 + 8 | 0;
+ i4 = i2 + 12 | 0;
+ i5 = i2 + 4 | 0;
+ i11 = HEAP32[i2 >> 2] | 0;
+ while (1) {
+ if ((i11 | 0) == 0) {
+ i10 = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 3](HEAP32[i7 >> 2] | 0, HEAP32[i4 >> 2] | 0, i3) | 0;
+ if ((i10 | 0) == 0) {
+ i2 = 9;
+ break;
+ }
+ i11 = HEAP32[i3 >> 2] | 0;
+ if ((i11 | 0) == 0) {
+ i2 = 9;
+ break;
+ }
+ HEAP32[i2 >> 2] = i11;
+ HEAP32[i5 >> 2] = i10;
+ } else {
+ i10 = HEAP32[i5 >> 2] | 0;
+ }
+ i11 = i8 >>> 0 > i11 >>> 0 ? i11 : i8;
+ _memcpy(i9 | 0, i10 | 0, i11 | 0) | 0;
+ i10 = (HEAP32[i2 >> 2] | 0) - i11 | 0;
+ HEAP32[i2 >> 2] = i10;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i11;
+ if ((i8 | 0) == (i11 | 0)) {
+ i8 = 0;
+ i2 = 9;
+ break;
+ } else {
+ i8 = i8 - i11 | 0;
+ i9 = i9 + i11 | 0;
+ i11 = i10;
+ }
+ }
+ if ((i2 | 0) == 9) {
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ return 0;
+}
+function _lua_load(i1, i5, i4, i3, i6) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i7 = i2;
+ _luaZ_init(i1, i7, i5, i4);
+ i3 = _luaD_protectedparser(i1, i7, (i3 | 0) == 0 ? 928 : i3, i6) | 0;
+ if ((i3 | 0) != 0) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ i4 = HEAP32[(HEAP32[i1 + 8 >> 2] | 0) + -16 >> 2] | 0;
+ if ((HEAP8[i4 + 6 | 0] | 0) != 1) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ i5 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
+ i4 = i4 + 16 | 0;
+ i6 = HEAP32[(HEAP32[i4 >> 2] | 0) + 8 >> 2] | 0;
+ i9 = i5;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i6;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ i7 = i5 + 8 | 0;
+ HEAP32[i6 + 8 >> 2] = HEAP32[i7 >> 2];
+ if ((HEAP32[i7 >> 2] & 64 | 0) == 0) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP8[i5 + 5 | 0] & 3) == 0) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP8[i4 + 5 | 0] & 4) == 0) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _luaC_barrier_(i1, i4, i5);
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _g_write(i1, i4, i8) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i8 = i8 | 0;
+ var i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i9 = 0, d10 = 0.0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i5;
+ i3 = i5 + 8 | 0;
+ i7 = _lua_gettop(i1) | 0;
+ if ((i7 | 0) == (i8 | 0)) {
+ i9 = 1;
+ STACKTOP = i5;
+ return i9 | 0;
+ }
+ i6 = i8;
+ i7 = i7 - i8 | 0;
+ i9 = 1;
+ while (1) {
+ i7 = i7 + -1 | 0;
+ if ((_lua_type(i1, i6) | 0) == 3) {
+ if ((i9 | 0) == 0) {
+ i8 = 0;
+ } else {
+ d10 = +_lua_tonumberx(i1, i6, 0);
+ HEAPF64[tempDoublePtr >> 3] = d10;
+ HEAP32[i2 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i2 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i8 = (_fprintf(i4 | 0, 3072, i2 | 0) | 0) > 0;
+ }
+ } else {
+ i8 = _luaL_checklstring(i1, i6, i3) | 0;
+ if ((i9 | 0) == 0) {
+ i8 = 0;
+ } else {
+ i8 = _fwrite(i8 | 0, 1, HEAP32[i3 >> 2] | 0, i4 | 0) | 0;
+ i8 = (i8 | 0) == (HEAP32[i3 >> 2] | 0);
+ }
+ }
+ if ((i7 | 0) == 0) {
+ break;
+ } else {
+ i6 = i6 + 1 | 0;
+ i9 = i8 & 1;
+ }
+ }
+ if (i8) {
+ i9 = 1;
+ STACKTOP = i5;
+ return i9 | 0;
+ }
+ i9 = _luaL_fileresult(i1, 0, 0) | 0;
+ STACKTOP = i5;
+ return i9 | 0;
+}
+function _lua_getuservalue(i2, i5) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i2 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i3 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
+ i2 = i2 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ HEAP32[i4 + 8 >> 2] = 0;
+ i5 = i4;
+ i5 = i5 + 16 | 0;
+ HEAP32[i2 >> 2] = i5;
+ STACKTOP = i1;
+ return;
+ } else {
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i4 + 8 >> 2] = 69;
+ i5 = HEAP32[i2 >> 2] | 0;
+ i5 = i5 + 16 | 0;
+ HEAP32[i2 >> 2] = i5;
+ STACKTOP = i1;
+ return;
+ }
+}
+function _luaL_addlstring(i7, i6, i1) {
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = HEAP32[i7 + 12 >> 2] | 0;
+ i3 = i7 + 4 | 0;
+ i9 = HEAP32[i3 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i8 = HEAP32[i2 >> 2] | 0;
+ if (!((i9 - i8 | 0) >>> 0 < i1 >>> 0)) {
+ i7 = HEAP32[i7 >> 2] | 0;
+ i9 = i8;
+ i9 = i7 + i9 | 0;
+ _memcpy(i9 | 0, i6 | 0, i1 | 0) | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ i9 = i9 + i1 | 0;
+ HEAP32[i2 >> 2] = i9;
+ STACKTOP = i5;
+ return;
+ }
+ i9 = i9 << 1;
+ i9 = (i9 - i8 | 0) >>> 0 < i1 >>> 0 ? i8 + i1 | 0 : i9;
+ if (i9 >>> 0 < i8 >>> 0 | (i9 - i8 | 0) >>> 0 < i1 >>> 0) {
+ _luaL_error(i4, 1272, i5) | 0;
+ }
+ i8 = _lua_newuserdata(i4, i9) | 0;
+ _memcpy(i8 | 0, HEAP32[i7 >> 2] | 0, HEAP32[i2 >> 2] | 0) | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i7 + 16 | 0)) {
+ _lua_remove(i4, -2);
+ }
+ HEAP32[i7 >> 2] = i8;
+ HEAP32[i3 >> 2] = i9;
+ i9 = HEAP32[i2 >> 2] | 0;
+ i9 = i8 + i9 | 0;
+ _memcpy(i9 | 0, i6 | 0, i1 | 0) | 0;
+ i9 = HEAP32[i2 >> 2] | 0;
+ i9 = i9 + i1 | 0;
+ HEAP32[i2 >> 2] = i9;
+ STACKTOP = i5;
+ return;
+}
+function _lua_rawgeti(i3, i6, i1) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i4 = (HEAP32[i3 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i4 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i4 = _luaH_getint(HEAP32[i4 >> 2] | 0, i1) | 0;
+ i6 = i3 + 8 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i7 = i4;
+ i1 = HEAP32[i7 + 4 >> 2] | 0;
+ i3 = i5;
+ HEAP32[i3 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i3 + 4 >> 2] = i1;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i4 + 8 >> 2];
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return;
+}
+function _lua_setfield(i1, i6, i3) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i6 = i1 + 8 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 + 16;
+ i3 = _luaS_new(i1, i3) | 0;
+ HEAP32[i5 >> 2] = i3;
+ HEAP32[i5 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
+ i5 = HEAP32[i6 >> 2] | 0;
+ _luaV_settable(i1, i4, i5 + -16 | 0, i5 + -32 | 0);
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + -32;
+ STACKTOP = i2;
+ return;
+}
+function _luaopen_io(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 11);
+ _luaL_setfuncs(i1, 2680, 0);
+ _luaL_newmetatable(i1, 2832) | 0;
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -2, 2872);
+ _luaL_setfuncs(i1, 2880, 0);
+ _lua_settop(i1, -2);
+ i5 = HEAP32[_stdin >> 2] | 0;
+ i4 = _lua_newuserdata(i1, 8) | 0;
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i4 >> 2] = i5;
+ HEAP32[i3 >> 2] = 154;
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -1001e3, 2776);
+ _lua_setfield(i1, -2, 2792);
+ i3 = HEAP32[_stdout >> 2] | 0;
+ i4 = _lua_newuserdata(i1, 8) | 0;
+ i5 = i4 + 4 | 0;
+ HEAP32[i5 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i5 >> 2] = 154;
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -1001e3, 2800);
+ _lua_setfield(i1, -2, 2816);
+ i5 = HEAP32[_stderr >> 2] | 0;
+ i4 = _lua_newuserdata(i1, 8) | 0;
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i4 >> 2] = i5;
+ HEAP32[i3 >> 2] = 154;
+ _lua_setfield(i1, -2, 2824);
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_pushcclosure(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ if ((i5 | 0) == 0) {
+ i6 = HEAP32[i1 + 8 >> 2] | 0;
+ HEAP32[i6 >> 2] = i4;
+ HEAP32[i6 + 8 >> 2] = 22;
+ i6 = i1 + 8 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i5 = i5 + 16 | 0;
+ HEAP32[i6 >> 2] = i5;
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i3 = _luaF_newCclosure(i1, i5) | 0;
+ HEAP32[i3 + 12 >> 2] = i4;
+ i4 = i1 + 8 | 0;
+ i6 = (HEAP32[i4 >> 2] | 0) + (0 - i5 << 4) | 0;
+ HEAP32[i4 >> 2] = i6;
+ do {
+ i5 = i5 + -1 | 0;
+ i9 = i6 + (i5 << 4) | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i3 + (i5 << 4) + 16 | 0;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ HEAP32[i3 + (i5 << 4) + 24 >> 2] = HEAP32[i6 + (i5 << 4) + 8 >> 2];
+ i6 = HEAP32[i4 >> 2] | 0;
+ } while ((i5 | 0) != 0);
+ HEAP32[i6 >> 2] = i3;
+ HEAP32[i6 + 8 >> 2] = 102;
+ i9 = i1 + 8 | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ i8 = i8 + 16 | 0;
+ HEAP32[i9 >> 2] = i8;
+ STACKTOP = i2;
+ return;
+}
+function _luaF_findupval(i3, i4) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i3 + 12 >> 2] | 0;
+ i6 = i3 + 56 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ L1 : do {
+ if ((i5 | 0) == 0) {
+ i5 = i6;
+ } else {
+ while (1) {
+ i7 = HEAP32[i5 + 8 >> 2] | 0;
+ if (i7 >>> 0 < i4 >>> 0) {
+ i5 = i6;
+ break L1;
+ }
+ if ((i7 | 0) == (i4 | 0)) {
+ break;
+ }
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ break L1;
+ } else {
+ i7 = i5;
+ i5 = i6;
+ i6 = i7;
+ }
+ }
+ i4 = i5 + 5 | 0;
+ i3 = (HEAPU8[i4] | 0) ^ 3;
+ if ((((HEAPU8[i2 + 60 | 0] | 0) ^ 3) & i3 | 0) != 0) {
+ i7 = i5;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ HEAP8[i4] = i3;
+ i7 = i5;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ } while (0);
+ i7 = _luaC_newobj(i3, 10, 32, i5, 0) | 0;
+ HEAP32[i7 + 8 >> 2] = i4;
+ i4 = i7 + 16 | 0;
+ HEAP32[i4 >> 2] = i2 + 112;
+ i6 = i2 + 132 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i4 + 4 >> 2] = i5;
+ HEAP32[i5 + 16 >> 2] = i7;
+ HEAP32[i6 >> 2] = i7;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _luaC_checkfinalizer(i5, i4, i6) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ i1 = HEAP32[i5 + 12 >> 2] | 0;
+ i2 = i4 + 5 | 0;
+ if ((HEAP8[i2] & 24) != 0 | (i6 | 0) == 0) {
+ STACKTOP = i3;
+ return;
+ }
+ if (!((HEAP8[i6 + 6 | 0] & 4) == 0)) {
+ STACKTOP = i3;
+ return;
+ }
+ if ((_luaT_gettm(i6, 2, HEAP32[i1 + 192 >> 2] | 0) | 0) == 0) {
+ STACKTOP = i3;
+ return;
+ }
+ i7 = i1 + 76 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == (i4 | 0)) {
+ do {
+ i6 = _sweeplist(i5, i8, 1) | 0;
+ } while ((i6 | 0) == (i8 | 0));
+ HEAP32[i7 >> 2] = i6;
+ }
+ i5 = i1 + 68 | 0;
+ while (1) {
+ i6 = HEAP32[i5 >> 2] | 0;
+ if ((i6 | 0) == (i4 | 0)) {
+ break;
+ } else {
+ i5 = i6;
+ }
+ }
+ HEAP32[i5 >> 2] = HEAP32[i4 >> 2];
+ i8 = i1 + 72 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i8 >> 2] = i4;
+ i4 = HEAPU8[i2] | 0 | 16;
+ HEAP8[i2] = i4;
+ if ((HEAPU8[i1 + 61 | 0] | 0) < 2) {
+ HEAP8[i2] = i4 & 191;
+ STACKTOP = i3;
+ return;
+ } else {
+ HEAP8[i2] = HEAP8[i1 + 60 | 0] & 3 | i4 & 184;
+ STACKTOP = i3;
+ return;
+ }
+}
+function _io_lines(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((_lua_type(i1, 1) | 0) == -1) {
+ _lua_pushnil(i1);
+ }
+ if ((_lua_type(i1, 1) | 0) == 0) {
+ _lua_getfield(i1, -1001e3, 2776);
+ _lua_replace(i1, 1);
+ if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) != 0) {
+ i4 = 0;
+ _aux_lines(i1, i4);
+ STACKTOP = i2;
+ return 1;
+ }
+ _luaL_error(i1, 3080, i3) | 0;
+ i4 = 0;
+ _aux_lines(i1, i4);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i4 = _luaL_checklstring(i1, 1, 0) | 0;
+ i6 = _lua_newuserdata(i1, 8) | 0;
+ i5 = i6 + 4 | 0;
+ HEAP32[i5 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i6 >> 2] = 0;
+ HEAP32[i5 >> 2] = 156;
+ i5 = _fopen(i4 | 0, 3480) | 0;
+ HEAP32[i6 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ i6 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
+ HEAP32[i3 >> 2] = i4;
+ HEAP32[i3 + 4 >> 2] = i6;
+ _luaL_error(i1, 3520, i3) | 0;
+ }
+ _lua_replace(i1, 1);
+ i6 = 1;
+ _aux_lines(i1, i6);
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _luaC_changemode(i2, i6) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i3 = i2 + 12 | 0;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i4 = i5 + 62 | 0;
+ if ((HEAPU8[i4] | 0) == (i6 | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == 2) {
+ i3 = i5 + 61 | 0;
+ if ((HEAP8[i3] | 0) != 0) {
+ do {
+ _singlestep(i2) | 0;
+ } while ((HEAP8[i3] | 0) != 0);
+ }
+ HEAP32[i5 + 20 >> 2] = (HEAP32[i5 + 12 >> 2] | 0) + (HEAP32[i5 + 8 >> 2] | 0);
+ HEAP8[i4] = 2;
+ STACKTOP = i1;
+ return;
+ }
+ HEAP8[i4] = 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ HEAP8[i4 + 61 | 0] = 2;
+ HEAP32[i4 + 64 >> 2] = 0;
+ i5 = i4 + 72 | 0;
+ do {
+ i6 = _sweeplist(i2, i5, 1) | 0;
+ } while ((i6 | 0) == (i5 | 0));
+ HEAP32[i4 + 80 >> 2] = i6;
+ i5 = i4 + 68 | 0;
+ do {
+ i6 = _sweeplist(i2, i5, 1) | 0;
+ } while ((i6 | 0) == (i5 | 0));
+ HEAP32[i4 + 76 >> 2] = i6;
+ i3 = (HEAP32[i3 >> 2] | 0) + 61 | 0;
+ if ((1 << HEAPU8[i3] & -29 | 0) != 0) {
+ STACKTOP = i1;
+ return;
+ }
+ do {
+ _singlestep(i2) | 0;
+ } while ((1 << HEAPU8[i3] & -29 | 0) == 0);
+ STACKTOP = i1;
+ return;
+}
+function _lua_rawget(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i5 = i1 + 8 | 0;
+ i4 = _luaH_get(HEAP32[i3 >> 2] | 0, (HEAP32[i5 >> 2] | 0) + -16 | 0) | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ i6 = i4;
+ i1 = HEAP32[i6 + 4 >> 2] | 0;
+ i3 = i5 + -16 | 0;
+ HEAP32[i3 >> 2] = HEAP32[i6 >> 2];
+ HEAP32[i3 + 4 >> 2] = i1;
+ HEAP32[i5 + -8 >> 2] = HEAP32[i4 + 8 >> 2];
+ STACKTOP = i2;
+ return;
+}
+function _lua_isstring(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i2 = -1001e3 - i4 | 0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
+ i4 = 0;
+ i4 = i4 & 1;
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
+ i4 = 0;
+ i4 = i4 & 1;
+ STACKTOP = i1;
+ return i4 | 0;
+ } else {
+ i2 = i3 + (i2 + -1 << 4) + 16 | 0;
+ break;
+ }
+ } else {
+ i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
+ i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ if ((i2 | 0) == 5192) {
+ i4 = 0;
+ i4 = i4 & 1;
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i4 = ((HEAP32[i2 + 8 >> 2] & 15) + -3 | 0) >>> 0 < 2;
+ i4 = i4 & 1;
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _setnodevector(i5, i1, i3) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ if ((i3 | 0) == 0) {
+ HEAP32[i1 + 16 >> 2] = 8016;
+ i6 = 0;
+ i7 = 8016;
+ i4 = 0;
+ i5 = i1 + 7 | 0;
+ HEAP8[i5] = i4;
+ i6 = i7 + (i6 << 5) | 0;
+ i7 = i1 + 20 | 0;
+ HEAP32[i7 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+ }
+ i4 = _luaO_ceillog2(i3) | 0;
+ if ((i4 | 0) > 30) {
+ _luaG_runerror(i5, 8048, i2);
+ }
+ i3 = 1 << i4;
+ if ((i3 + 1 | 0) >>> 0 > 134217727) {
+ _luaM_toobig(i5);
+ }
+ i6 = _luaM_realloc_(i5, 0, 0, i3 << 5) | 0;
+ i5 = i1 + 16 | 0;
+ HEAP32[i5 >> 2] = i6;
+ if ((i3 | 0) > 0) {
+ i7 = 0;
+ do {
+ HEAP32[i6 + (i7 << 5) + 28 >> 2] = 0;
+ HEAP32[i6 + (i7 << 5) + 24 >> 2] = 0;
+ HEAP32[i6 + (i7 << 5) + 8 >> 2] = 0;
+ i7 = i7 + 1 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ } while ((i7 | 0) != (i3 | 0));
+ }
+ i7 = i3;
+ i4 = i4 & 255;
+ i5 = i1 + 7 | 0;
+ HEAP8[i5] = i4;
+ i6 = i6 + (i7 << 5) | 0;
+ i7 = i1 + 20 | 0;
+ HEAP32[i7 >> 2] = i6;
+ STACKTOP = i2;
+ return;
+}
+function _lua_pushvalue(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i5 = i1 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i7 = i3;
+ i6 = HEAP32[i7 + 4 >> 2] | 0;
+ i1 = i4;
+ HEAP32[i1 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i1 + 4 >> 2] = i6;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return;
+}
+function _luaL_setfuncs(i3, i6, i1) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ _luaL_checkversion_(i3, 502.0);
+ if ((_lua_checkstack(i3, i1 + 20 | 0) | 0) == 0) {
+ HEAP32[i4 >> 2] = 1472;
+ _luaL_error(i3, 1216, i4) | 0;
+ }
+ if ((HEAP32[i6 >> 2] | 0) == 0) {
+ i7 = ~i1;
+ _lua_settop(i3, i7);
+ STACKTOP = i2;
+ return;
+ }
+ i4 = -2 - i1 | 0;
+ i5 = 0 - i1 | 0;
+ if ((i1 | 0) <= 0) {
+ do {
+ _lua_pushcclosure(i3, HEAP32[i6 + 4 >> 2] | 0, i1);
+ _lua_setfield(i3, i4, HEAP32[i6 >> 2] | 0);
+ i6 = i6 + 8 | 0;
+ } while ((HEAP32[i6 >> 2] | 0) != 0);
+ i7 = ~i1;
+ _lua_settop(i3, i7);
+ STACKTOP = i2;
+ return;
+ }
+ do {
+ i7 = 0;
+ do {
+ _lua_pushvalue(i3, i5);
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != (i1 | 0));
+ _lua_pushcclosure(i3, HEAP32[i6 + 4 >> 2] | 0, i1);
+ _lua_setfield(i3, i4, HEAP32[i6 >> 2] | 0);
+ i6 = i6 + 8 | 0;
+ } while ((HEAP32[i6 >> 2] | 0) != 0);
+ i7 = ~i1;
+ _lua_settop(i3, i7);
+ STACKTOP = i2;
+ return;
+}
+function _lua_touserdata(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i2 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i2 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ i3 = HEAP32[i2 + 8 >> 2] & 15;
+ if ((i3 | 0) == 2) {
+ i5 = HEAP32[i2 >> 2] | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else if ((i3 | 0) == 7) {
+ i5 = (HEAP32[i2 >> 2] | 0) + 24 | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _luaL_checkoption(i2, i3, i6, i4) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i1;
+ if ((i6 | 0) == 0) {
+ i6 = _lua_tolstring(i2, i3, 0) | 0;
+ if ((i6 | 0) == 0) {
+ i9 = _lua_typename(i2, 4) | 0;
+ i6 = _lua_typename(i2, _lua_type(i2, i3) | 0) | 0;
+ HEAP32[i5 >> 2] = i9;
+ HEAP32[i5 + 4 >> 2] = i6;
+ _luaL_argerror(i2, i3, _lua_pushfstring(i2, 1744, i5) | 0) | 0;
+ i6 = 0;
+ }
+ } else {
+ i6 = _luaL_optlstring(i2, i3, i6, 0) | 0;
+ }
+ i9 = HEAP32[i4 >> 2] | 0;
+ L6 : do {
+ if ((i9 | 0) != 0) {
+ i8 = 0;
+ while (1) {
+ i7 = i8 + 1 | 0;
+ if ((_strcmp(i9, i6) | 0) == 0) {
+ break;
+ }
+ i9 = HEAP32[i4 + (i7 << 2) >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break L6;
+ } else {
+ i8 = i7;
+ }
+ }
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ } while (0);
+ HEAP32[i5 >> 2] = i6;
+ i9 = _luaL_argerror(i2, i3, _lua_pushfstring(i2, 1192, i5) | 0) | 0;
+ STACKTOP = i1;
+ return i9 | 0;
+}
+function _lua_toboolean(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ i2 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ i5 = 0;
+ i5 = i5 & 1;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ if ((i2 | 0) != 1) {
+ i5 = 1;
+ i5 = i5 & 1;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i5 = (HEAP32[i3 >> 2] | 0) != 0;
+ i5 = i5 & 1;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _lua_getfield(i1, i6, i3) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i5 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i4 = (HEAP32[i1 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i4 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i6 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i4 = HEAP32[i5 >> 2] | 0, (i6 | 0) <= (HEAPU8[i4 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i4 + (i6 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i4 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i4 = i4 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i4 : 5192;
+ }
+ } while (0);
+ i5 = i1 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i3 = _luaS_new(i1, i3) | 0;
+ HEAP32[i6 >> 2] = i3;
+ HEAP32[i6 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i6 + 16;
+ _luaV_gettable(i1, i4, i6, i6);
+ STACKTOP = i2;
+ return;
+}
+function _luaL_argerror(i1, i6, i3) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i2 = i4;
+ i5 = i4 + 12 | 0;
+ if ((_lua_getstack(i1, 0, i5) | 0) == 0) {
+ HEAP32[i2 >> 2] = i6;
+ HEAP32[i2 + 4 >> 2] = i3;
+ i8 = _luaL_error(i1, 1040, i2) | 0;
+ STACKTOP = i4;
+ return i8 | 0;
+ }
+ _lua_getinfo(i1, 1064, i5) | 0;
+ if ((_strcmp(HEAP32[i5 + 8 >> 2] | 0, 1072) | 0) == 0) {
+ i6 = i6 + -1 | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i2 >> 2] = HEAP32[i5 + 4 >> 2];
+ HEAP32[i2 + 4 >> 2] = i3;
+ i8 = _luaL_error(i1, 1080, i2) | 0;
+ STACKTOP = i4;
+ return i8 | 0;
+ }
+ }
+ i7 = i5 + 4 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ if ((_pushglobalfuncname(i1, i5) | 0) == 0) {
+ i8 = 1112;
+ } else {
+ i8 = _lua_tolstring(i1, -1, 0) | 0;
+ }
+ HEAP32[i7 >> 2] = i8;
+ }
+ HEAP32[i2 >> 2] = i6;
+ HEAP32[i2 + 4 >> 2] = i8;
+ HEAP32[i2 + 8 >> 2] = i3;
+ i8 = _luaL_error(i1, 1120, i2) | 0;
+ STACKTOP = i4;
+ return i8 | 0;
+}
+function _match_class(i3, i2) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ switch (_tolower(i2 | 0) | 0) {
+ case 117:
+ {
+ i3 = _isupper(i3 | 0) | 0;
+ break;
+ }
+ case 97:
+ {
+ i3 = _isalpha(i3 | 0) | 0;
+ break;
+ }
+ case 99:
+ {
+ i3 = _iscntrl(i3 | 0) | 0;
+ break;
+ }
+ case 120:
+ {
+ i3 = _isxdigit(i3 | 0) | 0;
+ break;
+ }
+ case 119:
+ {
+ i3 = _isalnum(i3 | 0) | 0;
+ break;
+ }
+ case 112:
+ {
+ i3 = _ispunct(i3 | 0) | 0;
+ break;
+ }
+ case 100:
+ {
+ i3 = (i3 + -48 | 0) >>> 0 < 10 | 0;
+ break;
+ }
+ case 108:
+ {
+ i3 = _islower(i3 | 0) | 0;
+ break;
+ }
+ case 122:
+ {
+ i3 = (i3 | 0) == 0 | 0;
+ break;
+ }
+ case 103:
+ {
+ i3 = _isgraph(i3 | 0) | 0;
+ break;
+ }
+ case 115:
+ {
+ i3 = _isspace(i3 | 0) | 0;
+ break;
+ }
+ default:
+ {
+ i3 = (i2 | 0) == (i3 | 0) | 0;
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ }
+ if ((_islower(i2 | 0) | 0) != 0) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ i3 = (i3 | 0) == 0 | 0;
+ STACKTOP = i1;
+ return i3 | 0;
+}
+function _condjump(i1, i3, i6, i4, i5) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ _luaK_code(i1, i6 << 6 | i3 | i4 << 23 | i5 << 14) | 0;
+ i3 = i1 + 28 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = -1;
+ i3 = _luaK_code(i1, 2147450903) | 0;
+ if ((i6 | 0) == -1) {
+ i9 = i3;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ if ((i3 | 0) == -1) {
+ i9 = i6;
+ STACKTOP = i2;
+ return i9 | 0;
+ }
+ i8 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ i7 = i3;
+ while (1) {
+ i4 = i8 + (i7 << 2) | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ i9 = (i5 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i7 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i7 = i9;
+ }
+ }
+ i6 = i6 + ~i7 | 0;
+ if ((((i6 | 0) > -1 ? i6 : 0 - i6 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i4 >> 2] = (i6 << 14) + 2147467264 | i5 & 16383;
+ i9 = i3;
+ STACKTOP = i2;
+ return i9 | 0;
+}
+function _skipcomment(i6, i1) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ HEAP32[i6 >> 2] = 0;
+ i3 = i6 + 4 | 0;
+ i5 = 1712;
+ while (1) {
+ i7 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
+ if ((i7 | 0) == -1) {
+ i4 = 3;
+ break;
+ }
+ i8 = i5 + 1 | 0;
+ if ((i7 | 0) != (HEAPU8[i5] | 0)) {
+ break;
+ }
+ i5 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 + 1;
+ HEAP8[i6 + i5 + 8 | 0] = i7;
+ if ((HEAP8[i8] | 0) == 0) {
+ i4 = 6;
+ break;
+ } else {
+ i5 = i8;
+ }
+ }
+ if ((i4 | 0) == 3) {
+ HEAP32[i1 >> 2] = -1;
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ } else if ((i4 | 0) == 6) {
+ HEAP32[i6 >> 2] = 0;
+ i7 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
+ }
+ HEAP32[i1 >> 2] = i7;
+ if ((i7 | 0) != 35) {
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ do {
+ i8 = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
+ } while (!((i8 | 0) == 10 | (i8 | 0) == -1));
+ HEAP32[i1 >> 2] = _fgetc(HEAP32[i3 >> 2] | 0) | 0;
+ i8 = 1;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function _lua_isnumber(i4, i6) {
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ i5 = HEAP32[i4 + 16 >> 2] | 0;
+ do {
+ if ((i6 | 0) <= 0) {
+ if (!((i6 | 0) < -1000999)) {
+ i3 = (HEAP32[i4 + 8 >> 2] | 0) + (i6 << 4) | 0;
+ break;
+ }
+ if ((i6 | 0) == -1001e3) {
+ i3 = (HEAP32[i4 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i4 = -1001e3 - i6 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i4 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i5 >> 2] | 0) + (i6 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i4 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ if ((HEAP32[i3 + 8 >> 2] | 0) == 3) {
+ i6 = 1;
+ i6 = i6 & 1;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ i6 = (_luaV_tonumber(i3, i2) | 0) != 0;
+ i6 = i6 & 1;
+ STACKTOP = i1;
+ return i6 | 0;
+}
+function ___shgetc(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i7 = i3 + 104 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ if (!((i6 | 0) != 0 ? (HEAP32[i3 + 108 >> 2] | 0) >= (i6 | 0) : 0)) {
+ i8 = 3;
+ }
+ if ((i8 | 0) == 3 ? (i1 = ___uflow(i3) | 0, (i1 | 0) >= 0) : 0) {
+ i7 = HEAP32[i7 >> 2] | 0;
+ i6 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((i7 | 0) != 0 ? (i4 = HEAP32[i3 + 4 >> 2] | 0, i5 = i7 - (HEAP32[i3 + 108 >> 2] | 0) + -1 | 0, (i6 - i4 | 0) > (i5 | 0)) : 0) {
+ HEAP32[i3 + 100 >> 2] = i4 + i5;
+ } else {
+ HEAP32[i3 + 100 >> 2] = i6;
+ }
+ i4 = HEAP32[i3 + 4 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i8 = i3 + 108 | 0;
+ HEAP32[i8 >> 2] = i6 + 1 - i4 + (HEAP32[i8 >> 2] | 0);
+ }
+ i3 = i4 + -1 | 0;
+ if ((HEAPU8[i3] | 0 | 0) == (i1 | 0)) {
+ i8 = i1;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ HEAP8[i3] = i1;
+ i8 = i1;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ HEAP32[i3 + 100 >> 2] = 0;
+ i8 = -1;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function _lua_type(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i2 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i2 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i2 = -1001e3 - i4 | 0;
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP32[i3 + 8 >> 2] | 0) == 22) {
+ i4 = -1;
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((i2 | 0) > (HEAPU8[i3 + 6 | 0] | 0 | 0)) {
+ i4 = -1;
+ STACKTOP = i1;
+ return i4 | 0;
+ } else {
+ i2 = i3 + (i2 + -1 << 4) + 16 | 0;
+ break;
+ }
+ } else {
+ i3 = (HEAP32[i3 >> 2] | 0) + (i4 << 4) | 0;
+ i2 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ if ((i2 | 0) == 5192) {
+ i4 = -1;
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i4 = HEAP32[i2 + 8 >> 2] & 15;
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _g_iofile(i4, i1, i5) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((_lua_type(i4, 1) | 0) < 1) {
+ _lua_getfield(i4, -1001e3, i1);
+ STACKTOP = i2;
+ return;
+ }
+ i6 = _lua_tolstring(i4, 1, 0) | 0;
+ if ((i6 | 0) != 0) {
+ i7 = _lua_newuserdata(i4, 8) | 0;
+ i8 = i7 + 4 | 0;
+ HEAP32[i8 >> 2] = 0;
+ _luaL_setmetatable(i4, 2832);
+ HEAP32[i7 >> 2] = 0;
+ HEAP32[i8 >> 2] = 156;
+ i5 = _fopen(i6 | 0, i5 | 0) | 0;
+ HEAP32[i7 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ i8 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
+ HEAP32[i3 >> 2] = i6;
+ HEAP32[i3 + 4 >> 2] = i8;
+ _luaL_error(i4, 3520, i3) | 0;
+ }
+ } else {
+ if ((HEAP32[(_luaL_checkudata(i4, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
+ _luaL_error(i4, 3080, i3) | 0;
+ }
+ _lua_pushvalue(i4, 1);
+ }
+ _lua_setfield(i4, -1001e3, i1);
+ _lua_getfield(i4, -1001e3, i1);
+ STACKTOP = i2;
+ return;
+}
+function _lua_getlocal(i4, i5, i2) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ if ((i5 | 0) == 0) {
+ i3 = HEAP32[i4 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + -8 >> 2] | 0) != 70) {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i5 = _luaF_getlocalname(HEAP32[(HEAP32[i3 + -16 >> 2] | 0) + 12 >> 2] | 0, i2, 0) | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else {
+ HEAP32[i3 >> 2] = 0;
+ i2 = _findlocal(i4, HEAP32[i5 + 96 >> 2] | 0, i2, i3) | 0;
+ if ((i2 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ i5 = i4 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i8 = i3;
+ i7 = HEAP32[i8 + 4 >> 2] | 0;
+ i6 = i4;
+ HEAP32[i6 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i6 + 4 >> 2] = i7;
+ HEAP32[i4 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
+ i5 = i2;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _lua_checkstack(i7, i4) {
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i8 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ HEAP32[i3 >> 2] = i4;
+ i2 = HEAP32[i7 + 16 >> 2] | 0;
+ i5 = i7 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i8 = i6;
+ do {
+ if (((HEAP32[i7 + 24 >> 2] | 0) - i8 >> 4 | 0) <= (i4 | 0)) {
+ if (((i8 - (HEAP32[i7 + 28 >> 2] | 0) >> 4) + 5 | 0) > (1e6 - i4 | 0)) {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ i6 = (_luaD_rawrunprotected(i7, 2, i3) | 0) == 0;
+ if (i6) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ i3 = i6 & 1;
+ break;
+ } else {
+ i8 = 0;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ } else {
+ i5 = i6;
+ i3 = 1;
+ }
+ } while (0);
+ i2 = i2 + 4 | 0;
+ i4 = i5 + (i4 << 4) | 0;
+ if (!((HEAP32[i2 >> 2] | 0) >>> 0 < i4 >>> 0)) {
+ i8 = i3;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ HEAP32[i2 >> 2] = i4;
+ i8 = i3;
+ STACKTOP = i1;
+ return i8 | 0;
+}
+function _luaK_exp2nextreg(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ _luaK_dischargevars(i1, i3);
+ if (((HEAP32[i3 >> 2] | 0) == 6 ? (i4 = HEAP32[i3 + 8 >> 2] | 0, (i4 & 256 | 0) == 0) : 0) ? (HEAPU8[i1 + 46 | 0] | 0 | 0) <= (i4 | 0) : 0) {
+ i7 = i1 + 48 | 0;
+ HEAP8[i7] = (HEAP8[i7] | 0) + -1 << 24 >> 24;
+ }
+ i4 = i1 + 48 | 0;
+ i5 = HEAP8[i4] | 0;
+ i6 = (i5 & 255) + 1 | 0;
+ i7 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
+ if (!(i6 >>> 0 > (HEAPU8[i7] | 0) >>> 0)) {
+ i7 = i5;
+ i7 = i7 & 255;
+ i7 = i7 + 1 | 0;
+ i6 = i7 & 255;
+ HEAP8[i4] = i6;
+ i7 = i7 & 255;
+ i7 = i7 + -1 | 0;
+ _exp2reg(i1, i3, i7);
+ STACKTOP = i2;
+ return;
+ }
+ if (i6 >>> 0 > 249) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
+ }
+ HEAP8[i7] = i6;
+ i7 = HEAP8[i4] | 0;
+ i7 = i7 & 255;
+ i7 = i7 + 1 | 0;
+ i6 = i7 & 255;
+ HEAP8[i4] = i6;
+ i7 = i7 & 255;
+ i7 = i7 + -1 | 0;
+ _exp2reg(i1, i3, i7);
+ STACKTOP = i2;
+ return;
+}
+function _lua_next(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i5 = HEAP32[i2 + 16 >> 2] | 0;
+ do {
+ if ((i4 | 0) <= 0) {
+ if (!((i4 | 0) < -1000999)) {
+ i4 = (HEAP32[i2 + 8 >> 2] | 0) + (i4 << 4) | 0;
+ break;
+ }
+ if ((i4 | 0) == -1001e3) {
+ i4 = (HEAP32[i2 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i4 = -1001e3 - i4 | 0;
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i5 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i5 >> 2] | 0, (i4 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i4 = i3 + (i4 + -1 << 4) + 16 | 0;
+ } else {
+ i4 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i5 >> 2] | 0) + (i4 << 4) | 0;
+ i4 = i3 >>> 0 < (HEAP32[i2 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i3 = i2 + 8 | 0;
+ i2 = _luaH_next(i2, HEAP32[i4 >> 2] | 0, (HEAP32[i3 >> 2] | 0) + -16 | 0) | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = (i2 | 0) == 0 ? i4 + -16 | 0 : i4 + 16 | 0;
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _inclinenumber(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 >> 2] | 0;
+ i3 = i1 + 56 | 0;
+ i5 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i6 + -1;
+ if ((i6 | 0) == 0) {
+ i5 = _luaZ_fill(i5) | 0;
+ } else {
+ i6 = i5 + 4 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i5 + 1;
+ i5 = HEAPU8[i5] | 0;
+ }
+ HEAP32[i1 >> 2] = i5;
+ if ((i5 | 0) == 13 | (i5 | 0) == 10 ? (i5 | 0) != (i4 | 0) : 0) {
+ i3 = HEAP32[i3 >> 2] | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i6 + -1;
+ if ((i6 | 0) == 0) {
+ i3 = _luaZ_fill(i3) | 0;
+ } else {
+ i6 = i3 + 4 | 0;
+ i3 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i3 + 1;
+ i3 = HEAPU8[i3] | 0;
+ }
+ HEAP32[i1 >> 2] = i3;
+ }
+ i5 = i1 + 4 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i6 + 1;
+ if ((i6 | 0) > 2147483643) {
+ _luaX_syntaxerror(i1, 12560);
+ } else {
+ STACKTOP = i2;
+ return;
+ }
+}
+function _lua_yieldk(i5, i6, i1, i7) {
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = HEAP32[i5 + 16 >> 2] | 0;
+ if ((HEAP16[i5 + 36 >> 1] | 0) != 0) {
+ if ((HEAP32[(HEAP32[i5 + 12 >> 2] | 0) + 172 >> 2] | 0) == (i5 | 0)) {
+ _luaG_runerror(i5, 2312, i4);
+ } else {
+ _luaG_runerror(i5, 2264, i4);
+ }
+ }
+ HEAP8[i5 + 6 | 0] = 1;
+ HEAP32[i3 + 20 >> 2] = (HEAP32[i3 >> 2] | 0) - (HEAP32[i5 + 28 >> 2] | 0);
+ if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
+ STACKTOP = i2;
+ return 0;
+ }
+ HEAP32[i3 + 28 >> 2] = i7;
+ if ((i7 | 0) == 0) {
+ i4 = i5 + 8 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ i7 = ~i6;
+ i7 = i4 + (i7 << 4) | 0;
+ HEAP32[i3 >> 2] = i7;
+ _luaD_throw(i5, 1);
+ }
+ HEAP32[i3 + 24 >> 2] = i1;
+ i4 = i5 + 8 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ i7 = ~i6;
+ i7 = i4 + (i7 << 4) | 0;
+ HEAP32[i3 >> 2] = i7;
+ _luaD_throw(i5, 1);
+ return 0;
+}
+function _luaH_getint(i4, i6) {
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, d3 = 0.0, i5 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i1;
+ i7 = i6 + -1 | 0;
+ if (i7 >>> 0 < (HEAP32[i4 + 28 >> 2] | 0) >>> 0) {
+ i7 = (HEAP32[i4 + 12 >> 2] | 0) + (i7 << 4) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ d3 = +(i6 | 0);
+ HEAPF64[i5 >> 3] = d3 + 1.0;
+ i5 = (HEAP32[i5 + 4 >> 2] | 0) + (HEAP32[i5 >> 2] | 0) | 0;
+ if ((i5 | 0) < 0) {
+ i6 = 0 - i5 | 0;
+ i5 = (i5 | 0) == (i6 | 0) ? 0 : i6;
+ }
+ i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((i5 | 0) % ((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 | 1 | 0) | 0) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i4 + 24 >> 2] | 0) == 3 ? +HEAPF64[i4 + 16 >> 3] == d3 : 0) {
+ break;
+ }
+ i4 = HEAP32[i4 + 28 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i4 = 5192;
+ i2 = 10;
+ break;
+ }
+ }
+ if ((i2 | 0) == 10) {
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i7 = i4;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _luaL_checkversion_(i1, d4) {
+ i1 = i1 | 0;
+ d4 = +d4;
+ var i2 = 0, i3 = 0, i5 = 0, d6 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i5 = _lua_version(i1) | 0;
+ if ((i5 | 0) == (_lua_version(0) | 0)) {
+ d6 = +HEAPF64[i5 >> 3];
+ if (d6 != d4) {
+ HEAPF64[tempDoublePtr >> 3] = d4;
+ HEAP32[i3 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i5 = i3 + 8 | 0;
+ HEAPF64[tempDoublePtr >> 3] = d6;
+ HEAP32[i5 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i5 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ _luaL_error(i1, 1528, i3) | 0;
+ }
+ } else {
+ _luaL_error(i1, 1496, i3) | 0;
+ }
+ _lua_pushnumber(i1, -4660.0);
+ if ((_lua_tointegerx(i1, -1, 0) | 0) == -4660 ? (_lua_tounsignedx(i1, -1, 0) | 0) == -4660 : 0) {
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return;
+ }
+ _luaL_error(i1, 1584, i3) | 0;
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return;
+}
+function _math_random(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0, i4 = 0, i5 = 0, d6 = 0.0, d7 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ d3 = +((_rand() | 0) % 2147483647 | 0 | 0) / 2147483647.0;
+ i5 = _lua_gettop(i1) | 0;
+ if ((i5 | 0) == 0) {
+ _lua_pushnumber(i1, d3);
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else if ((i5 | 0) == 1) {
+ d6 = +_luaL_checknumber(i1, 1);
+ if (!(d6 >= 1.0)) {
+ _luaL_argerror(i1, 1, 4056) | 0;
+ }
+ _lua_pushnumber(i1, +Math_floor(+(d3 * d6)) + 1.0);
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else if ((i5 | 0) == 2) {
+ d6 = +_luaL_checknumber(i1, 1);
+ d7 = +_luaL_checknumber(i1, 2);
+ if (!(d6 <= d7)) {
+ _luaL_argerror(i1, 2, 4056) | 0;
+ }
+ _lua_pushnumber(i1, d6 + +Math_floor(+(d3 * (d7 - d6 + 1.0))));
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else {
+ i5 = _luaL_error(i1, 4080, i4) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _push_onecapture(i2, i3, i4, i6) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i5 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i1;
+ if ((HEAP32[i2 + 20 >> 2] | 0) <= (i3 | 0)) {
+ i2 = HEAP32[i2 + 16 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ _lua_pushlstring(i2, i4, i6 - i4 | 0) | 0;
+ STACKTOP = i1;
+ return;
+ } else {
+ _luaL_error(i2, 7224, i5) | 0;
+ STACKTOP = i1;
+ return;
+ }
+ }
+ i4 = HEAP32[i2 + (i3 << 3) + 28 >> 2] | 0;
+ if (!((i4 | 0) == -1)) {
+ i5 = HEAP32[i2 + 16 >> 2] | 0;
+ i3 = HEAP32[i2 + (i3 << 3) + 24 >> 2] | 0;
+ if ((i4 | 0) == -2) {
+ _lua_pushinteger(i5, i3 + 1 - (HEAP32[i2 + 4 >> 2] | 0) | 0);
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ i6 = i2 + 16 | 0;
+ _luaL_error(HEAP32[i6 >> 2] | 0, 7248, i5) | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i3 = HEAP32[i2 + (i3 << 3) + 24 >> 2] | 0;
+ }
+ _lua_pushlstring(i5, i3, i4) | 0;
+ STACKTOP = i1;
+ return;
+}
+function _luaK_nil(i7, i6, i5) {
+ i7 = i7 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ i9 = i5 + i6 | 0;
+ i1 = i9 + -1 | 0;
+ i10 = HEAP32[i7 + 20 >> 2] | 0;
+ do {
+ if ((i10 | 0) > (HEAP32[i7 + 24 >> 2] | 0) ? (i4 = (HEAP32[(HEAP32[i7 >> 2] | 0) + 12 >> 2] | 0) + (i10 + -1 << 2) | 0, i3 = HEAP32[i4 >> 2] | 0, (i3 & 63 | 0) == 4) : 0) {
+ i11 = i3 >>> 6 & 255;
+ i10 = i11 + (i3 >>> 23) | 0;
+ if (!((i11 | 0) <= (i6 | 0) ? (i10 + 1 | 0) >= (i6 | 0) : 0)) {
+ i8 = 5;
+ }
+ if ((i8 | 0) == 5 ? (i11 | 0) < (i6 | 0) | (i11 | 0) > (i9 | 0) : 0) {
+ break;
+ }
+ i5 = (i11 | 0) < (i6 | 0) ? i11 : i6;
+ HEAP32[i4 >> 2] = ((i10 | 0) > (i1 | 0) ? i10 : i1) - i5 << 23 | i5 << 6 & 16320 | i3 & 8372287;
+ STACKTOP = i2;
+ return;
+ }
+ } while (0);
+ _luaK_code(i7, i6 << 6 | (i5 << 23) + -8388608 | 4) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _lua_settable(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i5 = i1 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ _luaV_settable(i1, i3, i4 + -32 | 0, i4 + -16 | 0);
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + -32;
+ STACKTOP = i2;
+ return;
+}
+function _luaL_findtable(i3, i6, i5, i4) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i7 = 0;
+ i2 = STACKTOP;
+ if ((i6 | 0) != 0) {
+ _lua_pushvalue(i3, i6);
+ }
+ while (1) {
+ i6 = _strchr(i5, 46) | 0;
+ if ((i6 | 0) == 0) {
+ i6 = i5 + (_strlen(i5 | 0) | 0) | 0;
+ }
+ i7 = i6 - i5 | 0;
+ _lua_pushlstring(i3, i5, i7) | 0;
+ _lua_rawget(i3, -2);
+ if ((_lua_type(i3, -1) | 0) != 0) {
+ if ((_lua_type(i3, -1) | 0) != 5) {
+ break;
+ }
+ } else {
+ _lua_settop(i3, -2);
+ _lua_createtable(i3, 0, (HEAP8[i6] | 0) == 46 ? 1 : i4);
+ _lua_pushlstring(i3, i5, i7) | 0;
+ _lua_pushvalue(i3, -2);
+ _lua_settable(i3, -4);
+ }
+ _lua_remove(i3, -2);
+ if ((HEAP8[i6] | 0) == 46) {
+ i5 = i6 + 1 | 0;
+ } else {
+ i3 = 0;
+ i1 = 10;
+ break;
+ }
+ }
+ if ((i1 | 0) == 10) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _lua_settop(i3, -3);
+ i7 = i5;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _luaD_call(i1, i4, i5, i8) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i8 = i8 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i7 = i3;
+ i2 = i1 + 38 | 0;
+ i6 = (HEAP16[i2 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP16[i2 >> 1] = i6;
+ if ((i6 & 65535) > 199) {
+ if (i6 << 16 >> 16 == 200) {
+ _luaG_runerror(i1, 2240, i7);
+ }
+ if ((i6 & 65535) > 224) {
+ _luaD_throw(i1, 6);
+ }
+ }
+ i6 = (i8 | 0) != 0;
+ if (!i6) {
+ i8 = i1 + 36 | 0;
+ HEAP16[i8 >> 1] = (HEAP16[i8 >> 1] | 0) + 1 << 16 >> 16;
+ }
+ if ((_luaD_precall(i1, i4, i5) | 0) == 0) {
+ _luaV_execute(i1);
+ }
+ if (i6) {
+ i8 = HEAP16[i2 >> 1] | 0;
+ i8 = i8 + -1 << 16 >> 16;
+ HEAP16[i2 >> 1] = i8;
+ STACKTOP = i3;
+ return;
+ }
+ i8 = i1 + 36 | 0;
+ HEAP16[i8 >> 1] = (HEAP16[i8 >> 1] | 0) + -1 << 16 >> 16;
+ i8 = HEAP16[i2 >> 1] | 0;
+ i8 = i8 + -1 << 16 >> 16;
+ HEAP16[i2 >> 1] = i8;
+ STACKTOP = i3;
+ return;
+}
+function _pushline(i6, i1) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 528 | 0;
+ i4 = i2;
+ i3 = i2 + 8 | 0;
+ i7 = (i1 | 0) != 0;
+ _lua_getglobal(i6, i7 ? 288 : 296);
+ i8 = _lua_tolstring(i6, -1, 0) | 0;
+ if ((i8 | 0) == 0) {
+ i8 = i7 ? 312 : 320;
+ }
+ i7 = HEAP32[_stdout >> 2] | 0;
+ _fputs(i8 | 0, i7 | 0) | 0;
+ _fflush(i7 | 0) | 0;
+ i8 = (_fgets(i3 | 0, 512, HEAP32[_stdin >> 2] | 0) | 0) == 0;
+ _lua_settop(i6, -2);
+ if (i8) {
+ i8 = 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ i7 = _strlen(i3 | 0) | 0;
+ if ((i7 | 0) != 0 ? (i5 = i3 + (i7 + -1) | 0, (HEAP8[i5] | 0) == 10) : 0) {
+ HEAP8[i5] = 0;
+ }
+ if ((i1 | 0) != 0 ? (HEAP8[i3] | 0) == 61 : 0) {
+ HEAP32[i4 >> 2] = i3 + 1;
+ _lua_pushfstring(i6, 272, i4) | 0;
+ i8 = 1;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ _lua_pushstring(i6, i3) | 0;
+ i8 = 1;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function _db_getlocal(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i2;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i3 = _lua_tothread(i1, 1) | 0;
+ i6 = 1;
+ } else {
+ i3 = i1;
+ i6 = 0;
+ }
+ i5 = _luaL_checkinteger(i1, i6 | 2) | 0;
+ i6 = i6 + 1 | 0;
+ if ((_lua_type(i1, i6) | 0) == 6) {
+ _lua_pushvalue(i1, i6);
+ _lua_pushstring(i1, _lua_getlocal(i1, 0, i5) | 0) | 0;
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ if ((_lua_getstack(i3, _luaL_checkinteger(i1, i6) | 0, i4) | 0) == 0) {
+ i6 = _luaL_argerror(i1, i6, 11560) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i4 = _lua_getlocal(i3, i4, i5) | 0;
+ if ((i4 | 0) == 0) {
+ _lua_pushnil(i1);
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ _lua_xmove(i3, i1, 1);
+ _lua_pushstring(i1, i4) | 0;
+ _lua_pushvalue(i1, -2);
+ i6 = 2;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ return 0;
+}
+function _luaB_print(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i3;
+ i4 = i3 + 4 | 0;
+ i6 = _lua_gettop(i1) | 0;
+ _lua_getglobal(i1, 9584);
+ i5 = HEAP32[_stdout >> 2] | 0;
+ L1 : do {
+ if ((i6 | 0) >= 1) {
+ i7 = 1;
+ while (1) {
+ _lua_pushvalue(i1, -1);
+ _lua_pushvalue(i1, i7);
+ _lua_callk(i1, 1, 1, 0, 0);
+ i8 = _lua_tolstring(i1, -1, i4) | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ }
+ if ((i7 | 0) > 1) {
+ _fputc(9, i5 | 0) | 0;
+ }
+ _fwrite(i8 | 0, 1, HEAP32[i4 >> 2] | 0, i5 | 0) | 0;
+ _lua_settop(i1, -2);
+ if ((i7 | 0) < (i6 | 0)) {
+ i7 = i7 + 1 | 0;
+ } else {
+ break L1;
+ }
+ }
+ i8 = _luaL_error(i1, 9816, i2) | 0;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ } while (0);
+ _fputc(10, i5 | 0) | 0;
+ _fflush(i5 | 0) | 0;
+ i8 = 0;
+ STACKTOP = i3;
+ return i8 | 0;
+}
+function _luaB_load(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i2;
+ i6 = _lua_tolstring(i1, 1, i5) | 0;
+ i4 = _luaL_optlstring(i1, 3, 9872, 0) | 0;
+ i3 = (_lua_type(i1, 4) | 0) != -1;
+ if ((i6 | 0) == 0) {
+ i6 = _luaL_optlstring(i1, 2, 9880, 0) | 0;
+ _luaL_checktype(i1, 1, 6);
+ _lua_settop(i1, 5);
+ i4 = _lua_load(i1, 3, 0, i6, i4) | 0;
+ } else {
+ i7 = _luaL_optlstring(i1, 2, i6, 0) | 0;
+ i4 = _luaL_loadbufferx(i1, i6, HEAP32[i5 >> 2] | 0, i7, i4) | 0;
+ }
+ if ((i4 | 0) != 0) {
+ _lua_pushnil(i1);
+ _lua_insert(i1, -2);
+ i7 = 2;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ if (!i3) {
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ _lua_pushvalue(i1, i3 ? 4 : 0);
+ if ((_lua_setupvalue(i1, -2, 1) | 0) != 0) {
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ _lua_settop(i1, -2);
+ i7 = 1;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _db_debug(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 256 | 0;
+ i6 = i1;
+ i4 = i1 + 4 | 0;
+ i3 = HEAP32[_stderr >> 2] | 0;
+ _fwrite(12040, 11, 1, i3 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ i5 = HEAP32[_stdin >> 2] | 0;
+ if ((_fgets(i4 | 0, 250, i5 | 0) | 0) == 0) {
+ STACKTOP = i1;
+ return 0;
+ }
+ while (1) {
+ if ((_strcmp(i4, 12056) | 0) == 0) {
+ i2 = 7;
+ break;
+ }
+ if (!((_luaL_loadbufferx(i2, i4, _strlen(i4 | 0) | 0, 12064, 0) | 0) == 0 ? (_lua_pcallk(i2, 0, 0, 0, 0, 0) | 0) == 0 : 0)) {
+ HEAP32[i6 >> 2] = _lua_tolstring(i2, -1, 0) | 0;
+ _fprintf(i3 | 0, 12088, i6 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ }
+ _lua_settop(i2, 0);
+ _fwrite(12040, 11, 1, i3 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ if ((_fgets(i4 | 0, 250, i5 | 0) | 0) == 0) {
+ i2 = 7;
+ break;
+ }
+ }
+ if ((i2 | 0) == 7) {
+ STACKTOP = i1;
+ return 0;
+ }
+ return 0;
+}
+function _luaL_prepbuffsize(i2, i7) {
+ i2 = i2 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i1 = HEAP32[i2 + 12 >> 2] | 0;
+ i4 = i2 + 4 | 0;
+ i8 = HEAP32[i4 >> 2] | 0;
+ i5 = i2 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ if (!((i8 - i6 | 0) >>> 0 < i7 >>> 0)) {
+ i7 = HEAP32[i2 >> 2] | 0;
+ i8 = i6;
+ i8 = i7 + i8 | 0;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ i8 = i8 << 1;
+ i8 = (i8 - i6 | 0) >>> 0 < i7 >>> 0 ? i6 + i7 | 0 : i8;
+ if (i8 >>> 0 < i6 >>> 0 | (i8 - i6 | 0) >>> 0 < i7 >>> 0) {
+ _luaL_error(i1, 1272, i3) | 0;
+ }
+ i6 = _lua_newuserdata(i1, i8) | 0;
+ _memcpy(i6 | 0, HEAP32[i2 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ if ((HEAP32[i2 >> 2] | 0) != (i2 + 16 | 0)) {
+ _lua_remove(i1, -2);
+ }
+ HEAP32[i2 >> 2] = i6;
+ HEAP32[i4 >> 2] = i8;
+ i7 = i6;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i8 = i7 + i8 | 0;
+ STACKTOP = i3;
+ return i8 | 0;
+}
+function _luaG_runerror(i1, i5, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 96 | 0;
+ i2 = i6;
+ i3 = i6 + 32 | 0;
+ i6 = i6 + 16 | 0;
+ HEAP32[i6 >> 2] = i4;
+ i4 = _luaO_pushvfstring(i1, i5, i6) | 0;
+ i6 = HEAP32[i1 + 16 >> 2] | 0;
+ if ((HEAP8[i6 + 18 | 0] & 1) == 0) {
+ _luaG_errormsg(i1);
+ }
+ i5 = HEAP32[(HEAP32[HEAP32[i6 >> 2] >> 2] | 0) + 12 >> 2] | 0;
+ i7 = HEAP32[i5 + 20 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = HEAP32[i7 + (((HEAP32[i6 + 28 >> 2] | 0) - (HEAP32[i5 + 12 >> 2] | 0) >> 2) + -1 << 2) >> 2] | 0;
+ }
+ i5 = HEAP32[i5 + 36 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ HEAP8[i3] = 63;
+ HEAP8[i3 + 1 | 0] = 0;
+ } else {
+ _luaO_chunkid(i3, i5 + 16 | 0, 60);
+ }
+ HEAP32[i2 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i6;
+ HEAP32[i2 + 8 >> 2] = i4;
+ _luaO_pushfstring(i1, 2024, i2) | 0;
+ _luaG_errormsg(i1);
+}
+function _db_upvaluejoin(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i3;
+ i2 = _luaL_checkinteger(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 6);
+ _lua_pushvalue(i1, 1);
+ _lua_getinfo(i1, 11728, i4) | 0;
+ if (!((i2 | 0) > 0 ? (i2 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
+ _luaL_argerror(i1, 2, 11736) | 0;
+ }
+ i5 = _luaL_checkinteger(i1, 4) | 0;
+ _luaL_checktype(i1, 3, 6);
+ _lua_pushvalue(i1, 3);
+ _lua_getinfo(i1, 11728, i4) | 0;
+ if (!((i5 | 0) > 0 ? (i5 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
+ _luaL_argerror(i1, 4, 11736) | 0;
+ }
+ if ((_lua_iscfunction(i1, 1) | 0) != 0) {
+ _luaL_argerror(i1, 1, 11760) | 0;
+ }
+ if ((_lua_iscfunction(i1, 3) | 0) == 0) {
+ _lua_upvaluejoin(i1, 1, i2, 3, i5);
+ STACKTOP = i3;
+ return 0;
+ }
+ _luaL_argerror(i1, 3, 11760) | 0;
+ _lua_upvaluejoin(i1, 1, i2, 3, i5);
+ STACKTOP = i3;
+ return 0;
+}
+function _luaK_jump(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i3 = STACKTOP;
+ i2 = i1 + 28 | 0;
+ i7 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i2 >> 2] = -1;
+ i2 = _luaK_code(i1, 2147450903) | 0;
+ if ((i7 | 0) == -1) {
+ i9 = i2;
+ STACKTOP = i3;
+ return i9 | 0;
+ }
+ if ((i2 | 0) == -1) {
+ i9 = i7;
+ STACKTOP = i3;
+ return i9 | 0;
+ }
+ i6 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ i8 = i2;
+ while (1) {
+ i5 = i6 + (i8 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i9 = (i4 >>> 14) + -131071 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ }
+ i9 = i8 + 1 + i9 | 0;
+ if ((i9 | 0) == -1) {
+ break;
+ } else {
+ i8 = i9;
+ }
+ }
+ i6 = i7 + ~i8 | 0;
+ if ((((i6 | 0) > -1 ? i6 : 0 - i6 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i5 >> 2] = (i6 << 14) + 2147467264 | i4 & 16383;
+ i9 = i2;
+ STACKTOP = i3;
+ return i9 | 0;
+}
+function _findfield(i2, i3, i4) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ L1 : do {
+ if (((i4 | 0) != 0 ? (_lua_type(i2, -1) | 0) == 5 : 0) ? (_lua_pushnil(i2), (_lua_next(i2, -2) | 0) != 0) : 0) {
+ i4 = i4 + -1 | 0;
+ while (1) {
+ if ((_lua_type(i2, -2) | 0) == 4) {
+ if ((_lua_rawequal(i2, i3, -1) | 0) != 0) {
+ i3 = 7;
+ break;
+ }
+ if ((_findfield(i2, i3, i4) | 0) != 0) {
+ i3 = 9;
+ break;
+ }
+ }
+ _lua_settop(i2, -2);
+ if ((_lua_next(i2, -2) | 0) == 0) {
+ i2 = 0;
+ break L1;
+ }
+ }
+ if ((i3 | 0) == 7) {
+ _lua_settop(i2, -2);
+ i2 = 1;
+ break;
+ } else if ((i3 | 0) == 9) {
+ _lua_remove(i2, -2);
+ _lua_pushlstring(i2, 1776, 1) | 0;
+ _lua_insert(i2, -2);
+ _lua_concat(i2, 3);
+ i2 = 1;
+ break;
+ }
+ } else {
+ i2 = 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _db_gethook(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i3;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i4 = _lua_tothread(i1, 1) | 0;
+ } else {
+ i4 = i1;
+ }
+ i5 = _lua_gethookmask(i4) | 0;
+ i6 = _lua_gethook(i4) | 0;
+ if ((i6 | 0) != 0 & (i6 | 0) != 9) {
+ _lua_pushlstring(i1, 12024, 13) | 0;
+ } else {
+ _luaL_getsubtable(i1, -1001e3, 11584) | 0;
+ _lua_pushthread(i4) | 0;
+ _lua_xmove(i4, i1, 1);
+ _lua_rawget(i1, -2);
+ _lua_remove(i1, -2);
+ }
+ if ((i5 & 1 | 0) == 0) {
+ i6 = 0;
+ } else {
+ HEAP8[i2] = 99;
+ i6 = 1;
+ }
+ if ((i5 & 2 | 0) != 0) {
+ HEAP8[i2 + i6 | 0] = 114;
+ i6 = i6 + 1 | 0;
+ }
+ if ((i5 & 4 | 0) != 0) {
+ HEAP8[i2 + i6 | 0] = 108;
+ i6 = i6 + 1 | 0;
+ }
+ HEAP8[i2 + i6 | 0] = 0;
+ _lua_pushstring(i1, i2) | 0;
+ _lua_pushinteger(i1, _lua_gethookcount(i4) | 0);
+ STACKTOP = i3;
+ return 3;
+}
+function _lua_tothread(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i2 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i2 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ if ((HEAP32[i2 + 8 >> 2] | 0) != 72) {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i5 = HEAP32[i2 >> 2] | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _luaD_throw(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i3 = i1 + 64 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ if ((i4 | 0) != 0) {
+ HEAP32[i4 + 160 >> 2] = i2;
+ _longjmp((HEAP32[i3 >> 2] | 0) + 4 | 0, 1);
+ }
+ HEAP8[i1 + 6 | 0] = i2;
+ i4 = i1 + 12 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[i3 + 172 >> 2] | 0;
+ if ((HEAP32[i5 + 64 >> 2] | 0) != 0) {
+ i6 = HEAP32[i1 + 8 >> 2] | 0;
+ i9 = i5 + 8 | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i5 + 16;
+ i9 = i6 + -16 | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i5;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
+ _luaD_throw(HEAP32[(HEAP32[i4 >> 2] | 0) + 172 >> 2] | 0, i2);
+ }
+ i2 = HEAP32[i3 + 168 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ _abort();
+ }
+ FUNCTION_TABLE_ii[i2 & 255](i1) | 0;
+ _abort();
+}
+function _lua_len(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i5 = i1 + 8 | 0;
+ _luaV_objlen(i1, HEAP32[i5 >> 2] | 0, i3);
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return;
+}
+function _read_line(i4, i5, i1) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 1040 | 0;
+ i2 = i3;
+ _luaL_buffinit(i4, i2);
+ i7 = _luaL_prepbuffsize(i2, 1024) | 0;
+ L1 : do {
+ if ((_fgets(i7 | 0, 1024, i5 | 0) | 0) != 0) {
+ i6 = i2 + 8 | 0;
+ while (1) {
+ i8 = _strlen(i7 | 0) | 0;
+ if ((i8 | 0) != 0 ? (HEAP8[i7 + (i8 + -1) | 0] | 0) == 10 : 0) {
+ break;
+ }
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i8;
+ i7 = _luaL_prepbuffsize(i2, 1024) | 0;
+ if ((_fgets(i7 | 0, 1024, i5 | 0) | 0) == 0) {
+ break L1;
+ }
+ }
+ HEAP32[i6 >> 2] = i8 - i1 + (HEAP32[i6 >> 2] | 0);
+ _luaL_pushresult(i2);
+ i8 = 1;
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ } while (0);
+ _luaL_pushresult(i2);
+ i8 = (_lua_rawlen(i4, -1) | 0) != 0 | 0;
+ STACKTOP = i3;
+ return i8 | 0;
+}
+function _luaL_tolstring(i1, i5, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ do {
+ if ((_luaL_callmeta(i1, i5, 1384) | 0) == 0) {
+ i6 = _lua_type(i1, i5) | 0;
+ if ((i6 | 0) == 0) {
+ _lua_pushlstring(i1, 1416, 3) | 0;
+ break;
+ } else if ((i6 | 0) == 1) {
+ i6 = (_lua_toboolean(i1, i5) | 0) != 0;
+ _lua_pushstring(i1, i6 ? 1400 : 1408) | 0;
+ break;
+ } else if ((i6 | 0) == 4 | (i6 | 0) == 3) {
+ _lua_pushvalue(i1, i5);
+ break;
+ } else {
+ i7 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
+ i6 = _lua_topointer(i1, i5) | 0;
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i3 + 4 >> 2] = i6;
+ _lua_pushfstring(i1, 1424, i3) | 0;
+ break;
+ }
+ }
+ } while (0);
+ i7 = _lua_tolstring(i1, -1, i4) | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _save(i7, i1) {
+ i7 = i7 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i7 + 60 >> 2] | 0;
+ i3 = i4 + 4 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ i6 = i4 + 8 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if (!((i8 + 1 | 0) >>> 0 > i5 >>> 0)) {
+ i6 = HEAP32[i4 >> 2] | 0;
+ i7 = i1 & 255;
+ i5 = i8 + 1 | 0;
+ HEAP32[i3 >> 2] = i5;
+ i8 = i6 + i8 | 0;
+ HEAP8[i8] = i7;
+ STACKTOP = i2;
+ return;
+ }
+ if (i5 >>> 0 > 2147483645) {
+ _lexerror(i7, 12368, 0);
+ }
+ i8 = i5 << 1;
+ i7 = HEAP32[i7 + 52 >> 2] | 0;
+ if ((i8 | 0) == -2) {
+ _luaM_toobig(i7);
+ }
+ i7 = _luaM_realloc_(i7, HEAP32[i4 >> 2] | 0, i5, i8) | 0;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i6 >> 2] = i8;
+ i8 = HEAP32[i3 >> 2] | 0;
+ i6 = i7;
+ i7 = i1 & 255;
+ i5 = i8 + 1 | 0;
+ HEAP32[i3 >> 2] = i5;
+ i8 = i6 + i8 | 0;
+ HEAP8[i8] = i7;
+ STACKTOP = i2;
+ return;
+}
+function _luaK_patchtohere(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 24 >> 2] = HEAP32[i1 + 20 >> 2];
+ i4 = i1 + 28 | 0;
+ if ((i3 | 0) == -1) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == -1) {
+ HEAP32[i4 >> 2] = i3;
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i6 = i4 + (i7 << 2) | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i8 = (i5 >>> 14) + -131071 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ }
+ i8 = i7 + 1 + i8 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ } else {
+ i7 = i8;
+ }
+ }
+ i3 = ~i7 + i3 | 0;
+ if ((((i3 | 0) > -1 ? i3 : 0 - i3 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i6 >> 2] = (i3 << 14) + 2147467264 | i5 & 16383;
+ STACKTOP = i2;
+ return;
+}
+function _tinsert(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i7 = i2;
+ _luaL_checktype(i1, 1, 5);
+ i4 = _luaL_len(i1, 1) | 0;
+ i3 = i4 + 1 | 0;
+ i6 = _lua_gettop(i1) | 0;
+ if ((i6 | 0) == 3) {
+ i5 = 2;
+ } else if ((i6 | 0) != 2) {
+ i7 = _luaL_error(i1, 8320, i7) | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ if ((i5 | 0) == 2) {
+ i5 = _luaL_checkinteger(i1, 2) | 0;
+ if ((i5 | 0) < 1 | (i5 | 0) > (i3 | 0)) {
+ _luaL_argerror(i1, 2, 8256) | 0;
+ }
+ if ((i4 | 0) < (i5 | 0)) {
+ i3 = i5;
+ } else {
+ while (1) {
+ i4 = i3 + -1 | 0;
+ _lua_rawgeti(i1, 1, i4);
+ _lua_rawseti(i1, 1, i3);
+ if ((i4 | 0) > (i5 | 0)) {
+ i3 = i4;
+ } else {
+ i3 = i5;
+ break;
+ }
+ }
+ }
+ }
+ _lua_rawseti(i1, 1, i3);
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _lua_iscfunction(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i2 = (HEAP32[i3 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i2 = (HEAP32[i3 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i3 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i2 = HEAP32[i4 >> 2] | 0, (i3 | 0) <= (HEAPU8[i2 + 6 | 0] | 0 | 0)) : 0) {
+ i2 = i2 + (i3 + -1 << 4) + 16 | 0;
+ } else {
+ i2 = 5192;
+ }
+ } else {
+ i2 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i2 = i2 >>> 0 < (HEAP32[i3 + 8 >> 2] | 0) >>> 0 ? i2 : 5192;
+ }
+ } while (0);
+ i5 = HEAP32[i2 + 8 >> 2] | 0;
+ STACKTOP = i1;
+ return ((i5 | 0) == 22 | (i5 | 0) == 102) & 1 | 0;
+}
+function _lua_gettable(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) <= 0) {
+ if (!((i5 | 0) < -1000999)) {
+ i3 = (HEAP32[i1 + 8 >> 2] | 0) + (i5 << 4) | 0;
+ break;
+ }
+ if ((i5 | 0) == -1001e3) {
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 40 | 0;
+ break;
+ }
+ i5 = -1001e3 - i5 | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 22 ? (i3 = HEAP32[i4 >> 2] | 0, (i5 | 0) <= (HEAPU8[i3 + 6 | 0] | 0 | 0)) : 0) {
+ i3 = i3 + (i5 + -1 << 4) + 16 | 0;
+ } else {
+ i3 = 5192;
+ }
+ } else {
+ i3 = (HEAP32[i4 >> 2] | 0) + (i5 << 4) | 0;
+ i3 = i3 >>> 0 < (HEAP32[i1 + 8 >> 2] | 0) >>> 0 ? i3 : 5192;
+ }
+ } while (0);
+ i5 = (HEAP32[i1 + 8 >> 2] | 0) + -16 | 0;
+ _luaV_gettable(i1, i3, i5, i5);
+ STACKTOP = i2;
+ return;
+}
+function _luaG_errormsg(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = HEAP32[i1 + 68 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ _luaD_throw(i1, 2);
+ }
+ i4 = HEAP32[i1 + 28 >> 2] | 0;
+ i3 = i4 + (i2 + 8) | 0;
+ if ((HEAP32[i3 >> 2] & 15 | 0) != 6) {
+ _luaD_throw(i1, 6);
+ }
+ i5 = i1 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i9 = i6 + -16 | 0;
+ i8 = HEAP32[i9 + 4 >> 2] | 0;
+ i7 = i6;
+ HEAP32[i7 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i7 + 4 >> 2] = i8;
+ HEAP32[i6 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
+ i6 = HEAP32[i5 >> 2] | 0;
+ i7 = i4 + i2 | 0;
+ i2 = HEAP32[i7 + 4 >> 2] | 0;
+ i4 = i6 + -16 | 0;
+ HEAP32[i4 >> 2] = HEAP32[i7 >> 2];
+ HEAP32[i4 + 4 >> 2] = i2;
+ HEAP32[i6 + -8 >> 2] = HEAP32[i3 >> 2];
+ i4 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i4 + 16;
+ _luaD_call(i1, i4 + -16 | 0, 1, 0);
+ _luaD_throw(i1, 2);
+}
+function _luaB_costatus(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i3 = i4;
+ i2 = _lua_tothread(i1, 1) | 0;
+ if ((i2 | 0) == 0) {
+ _luaL_argerror(i1, 1, 10856) | 0;
+ }
+ do {
+ if ((i2 | 0) != (i1 | 0)) {
+ i5 = _lua_status(i2) | 0;
+ if ((i5 | 0) == 0) {
+ if ((_lua_getstack(i2, 0, i3) | 0) > 0) {
+ _lua_pushlstring(i1, 10896, 6) | 0;
+ break;
+ }
+ if ((_lua_gettop(i2) | 0) == 0) {
+ _lua_pushlstring(i1, 10904, 4) | 0;
+ break;
+ } else {
+ _lua_pushlstring(i1, 10880, 9) | 0;
+ break;
+ }
+ } else if ((i5 | 0) == 1) {
+ _lua_pushlstring(i1, 10880, 9) | 0;
+ break;
+ } else {
+ _lua_pushlstring(i1, 10904, 4) | 0;
+ break;
+ }
+ } else {
+ _lua_pushlstring(i1, 10728, 7) | 0;
+ }
+ } while (0);
+ STACKTOP = i4;
+ return 1;
+}
+function _searcher_Lua(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i4 = _luaL_checklstring(i1, 1, 0) | 0;
+ _lua_getfield(i1, -1001001, 4256);
+ i5 = _lua_tolstring(i1, -1, 0) | 0;
+ if ((i5 | 0) == 0) {
+ HEAP32[i3 >> 2] = 4256;
+ _luaL_error(i1, 5032, i3) | 0;
+ }
+ i4 = _searchpath(i1, i4, i5, 4936, 4848) | 0;
+ if ((i4 | 0) == 0) {
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ if ((_luaL_loadfilex(i1, i4, 0) | 0) == 0) {
+ _lua_pushstring(i1, i4) | 0;
+ i5 = 2;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else {
+ i6 = _lua_tolstring(i1, 1, 0) | 0;
+ i5 = _lua_tolstring(i1, -1, 0) | 0;
+ HEAP32[i3 >> 2] = i6;
+ HEAP32[i3 + 4 >> 2] = i4;
+ HEAP32[i3 + 8 >> 2] = i5;
+ i5 = _luaL_error(i1, 4888, i3) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _str_sub(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ i2 = _luaL_checklstring(i1, 1, i4) | 0;
+ i5 = _luaL_checkinteger(i1, 2) | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ if (!((i5 | 0) > -1)) {
+ if (i6 >>> 0 < (0 - i5 | 0) >>> 0) {
+ i5 = 0;
+ } else {
+ i5 = i5 + 1 + i6 | 0;
+ }
+ }
+ i6 = _luaL_optinteger(i1, 3, -1) | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if (!((i6 | 0) > -1)) {
+ if (i4 >>> 0 < (0 - i6 | 0) >>> 0) {
+ i6 = 0;
+ } else {
+ i6 = i6 + 1 + i4 | 0;
+ }
+ }
+ i5 = (i5 | 0) == 0 ? 1 : i5;
+ i4 = i6 >>> 0 > i4 >>> 0 ? i4 : i6;
+ if (i5 >>> 0 > i4 >>> 0) {
+ _lua_pushlstring(i1, 7040, 0) | 0;
+ STACKTOP = i3;
+ return 1;
+ } else {
+ _lua_pushlstring(i1, i2 + (i5 + -1) | 0, 1 - i5 + i4 | 0) | 0;
+ STACKTOP = i3;
+ return 1;
+ }
+ return 0;
+}
+function _searcher_C(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i4 = _luaL_checklstring(i1, 1, 0) | 0;
+ _lua_getfield(i1, -1001001, 4440);
+ i5 = _lua_tolstring(i1, -1, 0) | 0;
+ if ((i5 | 0) == 0) {
+ HEAP32[i3 >> 2] = 4440;
+ _luaL_error(i1, 5032, i3) | 0;
+ }
+ i5 = _searchpath(i1, i4, i5, 4936, 4848) | 0;
+ if ((i5 | 0) == 0) {
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ if ((_loadfunc(i1, i5, i4) | 0) == 0) {
+ _lua_pushstring(i1, i5) | 0;
+ i5 = 2;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else {
+ i6 = _lua_tolstring(i1, 1, 0) | 0;
+ i4 = _lua_tolstring(i1, -1, 0) | 0;
+ HEAP32[i3 >> 2] = i6;
+ HEAP32[i3 + 4 >> 2] = i5;
+ HEAP32[i3 + 8 >> 2] = i4;
+ i5 = _luaL_error(i1, 4888, i3) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _io_open(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i5 = STACKTOP;
+ i2 = _luaL_checklstring(i1, 1, 0) | 0;
+ i3 = _luaL_optlstring(i1, 2, 3480, 0) | 0;
+ i4 = _lua_newuserdata(i1, 8) | 0;
+ i6 = i4 + 4 | 0;
+ HEAP32[i6 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i4 >> 2] = 0;
+ HEAP32[i6 >> 2] = 156;
+ i6 = HEAP8[i3] | 0;
+ if (!((!(i6 << 24 >> 24 == 0) ? (i7 = i3 + 1 | 0, (_memchr(3552, i6 << 24 >> 24, 4) | 0) != 0) : 0) ? (i6 = (HEAP8[i7] | 0) == 43 ? i3 + 2 | 0 : i7, (HEAP8[(HEAP8[i6] | 0) == 98 ? i6 + 1 | 0 : i6] | 0) == 0) : 0)) {
+ _luaL_argerror(i1, 2, 3560) | 0;
+ }
+ i7 = _fopen(i2 | 0, i3 | 0) | 0;
+ HEAP32[i4 >> 2] = i7;
+ if ((i7 | 0) != 0) {
+ i7 = 1;
+ STACKTOP = i5;
+ return i7 | 0;
+ }
+ i7 = _luaL_fileresult(i1, 0, i2) | 0;
+ STACKTOP = i5;
+ return i7 | 0;
+}
+function _unpack(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i6 = i1;
+ _luaL_checktype(i2, 1, 5);
+ i5 = _luaL_optinteger(i2, 2, 1) | 0;
+ if ((_lua_type(i2, 3) | 0) < 1) {
+ i3 = _luaL_len(i2, 1) | 0;
+ } else {
+ i3 = _luaL_checkinteger(i2, 3) | 0;
+ }
+ if ((i5 | 0) > (i3 | 0)) {
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ i7 = i3 - i5 | 0;
+ i4 = i7 + 1 | 0;
+ if ((i7 | 0) >= 0 ? (_lua_checkstack(i2, i4) | 0) != 0 : 0) {
+ _lua_rawgeti(i2, 1, i5);
+ if ((i5 | 0) >= (i3 | 0)) {
+ i7 = i4;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ do {
+ i5 = i5 + 1 | 0;
+ _lua_rawgeti(i2, 1, i5);
+ } while ((i5 | 0) != (i3 | 0));
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i7 = _luaL_error(i2, 8280, i6) | 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _luaF_getlocalname(i4, i6, i2) {
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i4 + 60 >> 2] | 0;
+ if ((i3 | 0) <= 0) {
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ i4 = HEAP32[i4 + 24 >> 2] | 0;
+ i5 = 0;
+ while (1) {
+ if ((HEAP32[i4 + (i5 * 12 | 0) + 4 >> 2] | 0) > (i2 | 0)) {
+ i3 = 0;
+ i2 = 8;
+ break;
+ }
+ if ((HEAP32[i4 + (i5 * 12 | 0) + 8 >> 2] | 0) > (i2 | 0)) {
+ i6 = i6 + -1 | 0;
+ if ((i6 | 0) == 0) {
+ i2 = 6;
+ break;
+ }
+ }
+ i5 = i5 + 1 | 0;
+ if ((i5 | 0) >= (i3 | 0)) {
+ i3 = 0;
+ i2 = 8;
+ break;
+ }
+ }
+ if ((i2 | 0) == 6) {
+ i6 = (HEAP32[i4 + (i5 * 12 | 0) >> 2] | 0) + 16 | 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ } else if ((i2 | 0) == 8) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _luaK_concat(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) == -1) {
+ STACKTOP = i2;
+ return;
+ }
+ i7 = HEAP32[i4 >> 2] | 0;
+ if ((i7 | 0) == -1) {
+ HEAP32[i4 >> 2] = i3;
+ STACKTOP = i2;
+ return;
+ }
+ i4 = HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0;
+ while (1) {
+ i6 = i4 + (i7 << 2) | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i8 = (i5 >>> 14) + -131071 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ }
+ i8 = i7 + 1 + i8 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ } else {
+ i7 = i8;
+ }
+ }
+ i3 = ~i7 + i3 | 0;
+ if ((((i3 | 0) > -1 ? i3 : 0 - i3 | 0) | 0) > 131071) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10624);
+ }
+ HEAP32[i6 >> 2] = i5 & 16383 | (i3 << 14) + 2147467264;
+ STACKTOP = i2;
+ return;
+}
+function _scalbn(d3, i2) {
+ d3 = +d3;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0;
+ i1 = STACKTOP;
+ if ((i2 | 0) > 1023) {
+ d3 = d3 * 8.98846567431158e+307;
+ i4 = i2 + -1023 | 0;
+ if ((i4 | 0) > 1023) {
+ i2 = i2 + -2046 | 0;
+ i2 = (i2 | 0) > 1023 ? 1023 : i2;
+ d3 = d3 * 8.98846567431158e+307;
+ } else {
+ i2 = i4;
+ }
+ } else {
+ if ((i2 | 0) < -1022) {
+ d3 = d3 * 2.2250738585072014e-308;
+ i4 = i2 + 1022 | 0;
+ if ((i4 | 0) < -1022) {
+ i2 = i2 + 2044 | 0;
+ i2 = (i2 | 0) < -1022 ? -1022 : i2;
+ d3 = d3 * 2.2250738585072014e-308;
+ } else {
+ i2 = i4;
+ }
+ }
+ }
+ i2 = _bitshift64Shl(i2 + 1023 | 0, 0, 52) | 0;
+ i4 = tempRet0;
+ HEAP32[tempDoublePtr >> 2] = i2;
+ HEAP32[tempDoublePtr + 4 >> 2] = i4;
+ d3 = d3 * +HEAPF64[tempDoublePtr >> 3];
+ STACKTOP = i1;
+ return +d3;
+}
+function _luaK_numberK(i1, d6) {
+ i1 = i1 | 0;
+ d6 = +d6;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i4 = i2 + 16 | 0;
+ i3 = i2;
+ HEAPF64[i4 >> 3] = d6;
+ i5 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 52 >> 2] | 0;
+ HEAPF64[i3 >> 3] = d6;
+ HEAP32[i3 + 8 >> 2] = 3;
+ if (d6 != d6 | 0.0 != 0.0 | d6 == 0.0) {
+ i7 = i5 + 8 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i8 + 16;
+ i5 = _luaS_newlstr(i5, i4, 8) | 0;
+ HEAP32[i8 >> 2] = i5;
+ HEAP32[i8 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
+ i5 = _addk(i1, (HEAP32[i7 >> 2] | 0) + -16 | 0, i3) | 0;
+ HEAP32[i7 >> 2] = (HEAP32[i7 >> 2] | 0) + -16;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else {
+ i8 = _addk(i1, i3, i3) | 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ return 0;
+}
+function _auxresume(i2, i3, i4) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ do {
+ if ((_lua_checkstack(i3, i4) | 0) != 0) {
+ if ((_lua_status(i3) | 0) == 0 ? (_lua_gettop(i3) | 0) == 0 : 0) {
+ _lua_pushlstring(i2, 10792, 28) | 0;
+ i4 = -1;
+ break;
+ }
+ _lua_xmove(i2, i3, i4);
+ if (!((_lua_resume(i3, i2, i4) | 0) >>> 0 < 2)) {
+ _lua_xmove(i3, i2, 1);
+ i4 = -1;
+ break;
+ }
+ i4 = _lua_gettop(i3) | 0;
+ if ((_lua_checkstack(i2, i4 + 1 | 0) | 0) == 0) {
+ _lua_settop(i3, ~i4);
+ _lua_pushlstring(i2, 10824, 26) | 0;
+ i4 = -1;
+ break;
+ } else {
+ _lua_xmove(i3, i2, i4);
+ break;
+ }
+ } else {
+ _lua_pushlstring(i2, 10760, 28) | 0;
+ i4 = -1;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _luaX_setinput(i2, i1, i4, i3, i5) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i6 = 0, i7 = 0;
+ i6 = STACKTOP;
+ HEAP8[i1 + 76 | 0] = 46;
+ i7 = i1 + 52 | 0;
+ HEAP32[i7 >> 2] = i2;
+ HEAP32[i1 >> 2] = i5;
+ HEAP32[i1 + 32 >> 2] = 286;
+ HEAP32[i1 + 56 >> 2] = i4;
+ HEAP32[i1 + 48 >> 2] = 0;
+ HEAP32[i1 + 4 >> 2] = 1;
+ HEAP32[i1 + 8 >> 2] = 1;
+ HEAP32[i1 + 68 >> 2] = i3;
+ i5 = _luaS_new(i2, 12264) | 0;
+ HEAP32[i1 + 72 >> 2] = i5;
+ i5 = i5 + 5 | 0;
+ HEAP8[i5] = HEAPU8[i5] | 0 | 32;
+ i5 = i1 + 60 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i4 = _luaM_realloc_(HEAP32[i7 >> 2] | 0, HEAP32[i4 >> 2] | 0, HEAP32[i4 + 8 >> 2] | 0, 32) | 0;
+ HEAP32[HEAP32[i5 >> 2] >> 2] = i4;
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] = 32;
+ STACKTOP = i6;
+ return;
+}
+function _luaL_optlstring(i2, i4, i6, i5) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ if ((_lua_type(i2, i4) | 0) >= 1) {
+ i5 = _lua_tolstring(i2, i4, i5) | 0;
+ if ((i5 | 0) != 0) {
+ i6 = i5;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ i5 = _lua_typename(i2, 4) | 0;
+ i6 = _lua_typename(i2, _lua_type(i2, i4) | 0) | 0;
+ HEAP32[i3 >> 2] = i5;
+ HEAP32[i3 + 4 >> 2] = i6;
+ _luaL_argerror(i2, i4, _lua_pushfstring(i2, 1744, i3) | 0) | 0;
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ if ((i5 | 0) == 0) {
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ if ((i6 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = _strlen(i6 | 0) | 0;
+ }
+ HEAP32[i5 >> 2] = i2;
+ STACKTOP = i1;
+ return i6 | 0;
+}
+function _lua_xmove(i3, i4, i1) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) == (i4 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i3 + 8 | 0;
+ i5 = (HEAP32[i3 >> 2] | 0) + (0 - i1 << 4) | 0;
+ HEAP32[i3 >> 2] = i5;
+ if ((i1 | 0) <= 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i4 = i4 + 8 | 0;
+ i6 = 0;
+ while (1) {
+ i7 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i7 + 16;
+ i10 = i5 + (i6 << 4) | 0;
+ i9 = HEAP32[i10 + 4 >> 2] | 0;
+ i8 = i7;
+ HEAP32[i8 >> 2] = HEAP32[i10 >> 2];
+ HEAP32[i8 + 4 >> 2] = i9;
+ HEAP32[i7 + 8 >> 2] = HEAP32[i5 + (i6 << 4) + 8 >> 2];
+ i6 = i6 + 1 | 0;
+ if ((i6 | 0) == (i1 | 0)) {
+ break;
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ }
+ STACKTOP = i2;
+ return;
+}
+function _luaM_realloc_(i7, i10, i3, i2) {
+ i7 = i7 | 0;
+ i10 = i10 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0;
+ i5 = STACKTOP;
+ i6 = HEAP32[i7 + 12 >> 2] | 0;
+ i4 = (i10 | 0) != 0;
+ i9 = i6 + 4 | 0;
+ i8 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i9 >> 2] | 0, i10, i3, i2) | 0;
+ if (!((i8 | 0) != 0 | (i2 | 0) == 0)) {
+ if ((HEAP8[i6 + 63 | 0] | 0) == 0) {
+ _luaD_throw(i7, 4);
+ }
+ _luaC_fullgc(i7, 1);
+ i8 = FUNCTION_TABLE_iiiii[HEAP32[i6 >> 2] & 3](HEAP32[i9 >> 2] | 0, i10, i3, i2) | 0;
+ if ((i8 | 0) == 0) {
+ _luaD_throw(i7, 4);
+ } else {
+ i1 = i8;
+ }
+ } else {
+ i1 = i8;
+ }
+ i6 = i6 + 12 | 0;
+ HEAP32[i6 >> 2] = (i4 ? 0 - i3 | 0 : 0) + i2 + (HEAP32[i6 >> 2] | 0);
+ STACKTOP = i5;
+ return i1 | 0;
+}
+function _realloc(i2, i3) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i5 = 0;
+ i1 = STACKTOP;
+ do {
+ if ((i2 | 0) != 0) {
+ if (i3 >>> 0 > 4294967231) {
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i4 = 0;
+ break;
+ }
+ if (i3 >>> 0 < 11) {
+ i4 = 16;
+ } else {
+ i4 = i3 + 11 & -8;
+ }
+ i4 = _try_realloc_chunk(i2 + -8 | 0, i4) | 0;
+ if ((i4 | 0) != 0) {
+ i4 = i4 + 8 | 0;
+ break;
+ }
+ i4 = _malloc(i3) | 0;
+ if ((i4 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i5 = HEAP32[i2 + -4 >> 2] | 0;
+ i5 = (i5 & -8) - ((i5 & 3 | 0) == 0 ? 8 : 4) | 0;
+ _memcpy(i4 | 0, i2 | 0, (i5 >>> 0 < i3 >>> 0 ? i5 : i3) | 0) | 0;
+ _free(i2);
+ }
+ } else {
+ i4 = _malloc(i3) | 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _lua_setlocal(i3, i5, i4) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ HEAP32[i2 >> 2] = 0;
+ i4 = _findlocal(i3, HEAP32[i5 + 96 >> 2] | 0, i4, i2) | 0;
+ i3 = i3 + 8 | 0;
+ if ((i4 | 0) == 0) {
+ i5 = HEAP32[i3 >> 2] | 0;
+ i5 = i5 + -16 | 0;
+ HEAP32[i3 >> 2] = i5;
+ STACKTOP = i1;
+ return i4 | 0;
+ }
+ i6 = HEAP32[i3 >> 2] | 0;
+ i5 = HEAP32[i2 >> 2] | 0;
+ i8 = i6 + -16 | 0;
+ i7 = HEAP32[i8 + 4 >> 2] | 0;
+ i2 = i5;
+ HEAP32[i2 >> 2] = HEAP32[i8 >> 2];
+ HEAP32[i2 + 4 >> 2] = i7;
+ HEAP32[i5 + 8 >> 2] = HEAP32[i6 + -8 >> 2];
+ i5 = HEAP32[i3 >> 2] | 0;
+ i5 = i5 + -16 | 0;
+ HEAP32[i3 >> 2] = i5;
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function ___remdi3(i1, i4, i5, i6) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 8 | 0;
+ i2 = i3 | 0;
+ i7 = i4 >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
+ i8 = ((i4 | 0) < 0 ? -1 : 0) >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
+ i9 = i6 >> 31 | ((i6 | 0) < 0 ? -1 : 0) << 1;
+ i10 = ((i6 | 0) < 0 ? -1 : 0) >> 31 | ((i6 | 0) < 0 ? -1 : 0) << 1;
+ i1 = _i64Subtract(i7 ^ i1, i8 ^ i4, i7, i8) | 0;
+ i4 = tempRet0;
+ ___udivmoddi4(i1, i4, _i64Subtract(i9 ^ i5, i10 ^ i6, i9, i10) | 0, tempRet0, i2) | 0;
+ i9 = _i64Subtract(HEAP32[i2 >> 2] ^ i7, HEAP32[i2 + 4 >> 2] ^ i8, i7, i8) | 0;
+ i8 = tempRet0;
+ STACKTOP = i3;
+ return (tempRet0 = i8, i9) | 0;
+}
+function _luaC_barrierproto_(i3, i4, i2) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i5 = 0;
+ i1 = STACKTOP;
+ if ((HEAP32[i4 + 32 >> 2] | 0) != 0) {
+ i5 = HEAP32[i3 + 12 >> 2] | 0;
+ i3 = i4 + 5 | 0;
+ HEAP8[i3] = HEAP8[i3] & 251;
+ i5 = i5 + 88 | 0;
+ HEAP32[i4 + 72 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i5 >> 2] = i4;
+ STACKTOP = i1;
+ return;
+ }
+ if ((HEAP8[i2 + 5 | 0] & 3) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i5 = i4 + 5 | 0;
+ i4 = HEAP8[i5] | 0;
+ if ((i4 & 4) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = HEAP32[i3 + 12 >> 2] | 0;
+ if ((HEAPU8[i3 + 61 | 0] | 0) < 2) {
+ _reallymarkobject(i3, i2);
+ STACKTOP = i1;
+ return;
+ } else {
+ HEAP8[i5] = HEAP8[i3 + 60 | 0] & 3 | i4 & 184;
+ STACKTOP = i1;
+ return;
+ }
+}
+function _luaL_openlibs(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_requiref(i1, 2592, 144, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2600, 145, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2608, 146, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2624, 147, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2632, 148, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2640, 149, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2648, 150, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2656, 151, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2664, 152, 1);
+ _lua_settop(i1, -2);
+ _luaL_requiref(i1, 2672, 153, 1);
+ _lua_settop(i1, -2);
+ _luaL_getsubtable(i1, -1001e3, 2576) | 0;
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return;
+}
+function _luaX_token2str(i4, i3) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i5 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ if ((i3 | 0) >= 257) {
+ i5 = HEAP32[12096 + (i3 + -257 << 2) >> 2] | 0;
+ if ((i3 | 0) >= 286) {
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i4 = HEAP32[i4 + 52 >> 2] | 0;
+ HEAP32[i2 >> 2] = i5;
+ i5 = _luaO_pushfstring(i4, 12256, i2) | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i4 = HEAP32[i4 + 52 >> 2] | 0;
+ if ((HEAP8[i3 + 10913 | 0] & 4) == 0) {
+ HEAP32[i2 >> 2] = i3;
+ i5 = _luaO_pushfstring(i4, 12240, i2) | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ } else {
+ HEAP32[i2 >> 2] = i3;
+ i5 = _luaO_pushfstring(i4, 12232, i2) | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _luaL_buffinitsize(i6, i1, i7) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 12 >> 2] = i6;
+ i3 = i1 + 16 | 0;
+ HEAP32[i1 >> 2] = i3;
+ i5 = i1 + 8 | 0;
+ HEAP32[i5 >> 2] = 0;
+ i4 = i1 + 4 | 0;
+ HEAP32[i4 >> 2] = 1024;
+ if (!(i7 >>> 0 > 1024)) {
+ i7 = i3;
+ i8 = 0;
+ i8 = i7 + i8 | 0;
+ STACKTOP = i2;
+ return i8 | 0;
+ }
+ i8 = i7 >>> 0 > 2048 ? i7 : 2048;
+ i7 = _lua_newuserdata(i6, i8) | 0;
+ _memcpy(i7 | 0, HEAP32[i1 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+ if ((HEAP32[i1 >> 2] | 0) != (i3 | 0)) {
+ _lua_remove(i6, -2);
+ }
+ HEAP32[i1 >> 2] = i7;
+ HEAP32[i4 >> 2] = i8;
+ i8 = HEAP32[i5 >> 2] | 0;
+ i8 = i7 + i8 | 0;
+ STACKTOP = i2;
+ return i8 | 0;
+}
+function _luaE_freethread(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ i4 = i3 + 28 | 0;
+ _luaF_close(i3, HEAP32[i4 >> 2] | 0);
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ _luaM_realloc_(i1, i3, 112, 0) | 0;
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i3 + 16 >> 2] = i3 + 72;
+ i7 = i3 + 84 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = 0;
+ if ((i6 | 0) != 0) {
+ while (1) {
+ i5 = HEAP32[i6 + 12 >> 2] | 0;
+ _luaM_realloc_(i3, i6, 40, 0) | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ } else {
+ i6 = i5;
+ }
+ }
+ i5 = HEAP32[i4 >> 2] | 0;
+ }
+ _luaM_realloc_(i3, i5, HEAP32[i3 + 32 >> 2] << 4, 0) | 0;
+ _luaM_realloc_(i1, i3, 112, 0) | 0;
+ STACKTOP = i2;
+ return;
+}
+function ___toread(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ i4 = i1 + 74 | 0;
+ i2 = HEAP8[i4] | 0;
+ HEAP8[i4] = i2 + 255 | i2;
+ i4 = i1 + 20 | 0;
+ i2 = i1 + 44 | 0;
+ if ((HEAP32[i4 >> 2] | 0) >>> 0 > (HEAP32[i2 >> 2] | 0) >>> 0) {
+ FUNCTION_TABLE_iiii[HEAP32[i1 + 36 >> 2] & 3](i1, 0, 0) | 0;
+ }
+ HEAP32[i1 + 16 >> 2] = 0;
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i4 >> 2] = 0;
+ i4 = HEAP32[i1 >> 2] | 0;
+ if ((i4 & 20 | 0) == 0) {
+ i4 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i1 + 8 >> 2] = i4;
+ HEAP32[i1 + 4 >> 2] = i4;
+ i4 = 0;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ if ((i4 & 4 | 0) == 0) {
+ i4 = -1;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ HEAP32[i1 >> 2] = i4 | 32;
+ i4 = -1;
+ STACKTOP = i3;
+ return i4 | 0;
+}
+function _lua_callk(i3, i7, i4, i6, i5) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i8 = 0;
+ i1 = STACKTOP;
+ i2 = i3 + 8 | 0;
+ i7 = (HEAP32[i2 >> 2] | 0) + (~i7 << 4) | 0;
+ if ((i5 | 0) != 0 ? (HEAP16[i3 + 36 >> 1] | 0) == 0 : 0) {
+ i8 = i3 + 16 | 0;
+ HEAP32[(HEAP32[i8 >> 2] | 0) + 28 >> 2] = i5;
+ HEAP32[(HEAP32[i8 >> 2] | 0) + 24 >> 2] = i6;
+ _luaD_call(i3, i7, i4, 1);
+ } else {
+ _luaD_call(i3, i7, i4, 0);
+ }
+ if (!((i4 | 0) == -1)) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = (HEAP32[i3 + 16 >> 2] | 0) + 4 | 0;
+ i2 = HEAP32[i2 >> 2] | 0;
+ if (!((HEAP32[i3 >> 2] | 0) >>> 0 < i2 >>> 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[i3 >> 2] = i2;
+ STACKTOP = i1;
+ return;
+}
+function _luaX_newstring(i3, i5, i4) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i6 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i3 + 52 >> 2] | 0;
+ i5 = _luaS_newlstr(i2, i5, i4) | 0;
+ i4 = i2 + 8 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i6 + 16;
+ HEAP32[i6 >> 2] = i5;
+ HEAP32[i6 + 8 >> 2] = HEAPU8[i5 + 4 | 0] | 0 | 64;
+ i6 = _luaH_set(i2, HEAP32[(HEAP32[i3 + 48 >> 2] | 0) + 4 >> 2] | 0, (HEAP32[i4 >> 2] | 0) + -16 | 0) | 0;
+ i3 = i6 + 8 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 0 ? (HEAP32[i6 >> 2] = 1, HEAP32[i3 >> 2] = 1, (HEAP32[(HEAP32[i2 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) : 0) {
+ _luaC_step(i2);
+ }
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -16;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _strtod(i3, i2) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0, d5 = 0.0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i1;
+ i7 = i4 + 0 | 0;
+ i6 = i7 + 112 | 0;
+ do {
+ HEAP32[i7 >> 2] = 0;
+ i7 = i7 + 4 | 0;
+ } while ((i7 | 0) < (i6 | 0));
+ i6 = i4 + 4 | 0;
+ HEAP32[i6 >> 2] = i3;
+ i7 = i4 + 8 | 0;
+ HEAP32[i7 >> 2] = -1;
+ HEAP32[i4 + 44 >> 2] = i3;
+ HEAP32[i4 + 76 >> 2] = -1;
+ ___shlim(i4, 0);
+ d5 = +___floatscan(i4, 1, 1);
+ i4 = (HEAP32[i6 >> 2] | 0) - (HEAP32[i7 >> 2] | 0) + (HEAP32[i4 + 108 >> 2] | 0) | 0;
+ if ((i2 | 0) == 0) {
+ STACKTOP = i1;
+ return +d5;
+ }
+ if ((i4 | 0) != 0) {
+ i3 = i3 + i4 | 0;
+ }
+ HEAP32[i2 >> 2] = i3;
+ STACKTOP = i1;
+ return +d5;
+}
+function _f_seek(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, d6 = 0.0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ i5 = _luaL_checkoption(i1, 2, 3208, 3184) | 0;
+ d6 = +_luaL_optnumber(i1, 3, 0.0);
+ i4 = ~~d6;
+ if (!(+(i4 | 0) == d6)) {
+ _luaL_argerror(i1, 3, 3224) | 0;
+ }
+ if ((_fseek(i3 | 0, i4 | 0, HEAP32[3168 + (i5 << 2) >> 2] | 0) | 0) == 0) {
+ _lua_pushnumber(i1, +(_ftell(i3 | 0) | 0));
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ } else {
+ i5 = _luaL_fileresult(i1, 0, 0) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _setpath(i1, i4, i8, i7, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i8 = i8 | 0;
+ i7 = i7 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i8 = _getenv(i8 | 0) | 0;
+ if ((i8 | 0) == 0) {
+ i7 = _getenv(i7 | 0) | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = 3;
+ }
+ } else {
+ i5 = i8;
+ i6 = 3;
+ }
+ if ((i6 | 0) == 3 ? (_lua_getfield(i1, -1001e3, 4832), i8 = _lua_toboolean(i1, -1) | 0, _lua_settop(i1, -2), (i8 | 0) == 0) : 0) {
+ _luaL_gsub(i1, _luaL_gsub(i1, i5, 4808, 4816) | 0, 4824, i3) | 0;
+ _lua_remove(i1, -2);
+ _lua_setfield(i1, -2, i4);
+ STACKTOP = i2;
+ return;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_setfield(i1, -2, i4);
+ STACKTOP = i2;
+ return;
+}
+function _luaU_header(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ HEAP8[i1] = 1635077147;
+ HEAP8[i1 + 1 | 0] = 6387020;
+ HEAP8[i1 + 2 | 0] = 24949;
+ HEAP8[i1 + 3 | 0] = 97;
+ HEAP8[i1 + 4 | 0] = 82;
+ HEAP8[i1 + 5 | 0] = 0;
+ HEAP8[i1 + 6 | 0] = 1;
+ HEAP8[i1 + 7 | 0] = 4;
+ HEAP8[i1 + 8 | 0] = 4;
+ HEAP8[i1 + 9 | 0] = 4;
+ HEAP8[i1 + 10 | 0] = 8;
+ i3 = i1 + 12 | 0;
+ HEAP8[i1 + 11 | 0] = 0;
+ HEAP8[i3 + 0 | 0] = HEAP8[8816 | 0] | 0;
+ HEAP8[i3 + 1 | 0] = HEAP8[8817 | 0] | 0;
+ HEAP8[i3 + 2 | 0] = HEAP8[8818 | 0] | 0;
+ HEAP8[i3 + 3 | 0] = HEAP8[8819 | 0] | 0;
+ HEAP8[i3 + 4 | 0] = HEAP8[8820 | 0] | 0;
+ HEAP8[i3 + 5 | 0] = HEAP8[8821 | 0] | 0;
+ STACKTOP = i2;
+ return;
+}
+function _db_setlocal(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i3 = i2;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i5 = _lua_tothread(i1, 1) | 0;
+ i4 = 1;
+ } else {
+ i5 = i1;
+ i4 = 0;
+ }
+ i6 = i4 + 1 | 0;
+ if ((_lua_getstack(i5, _luaL_checkinteger(i1, i6) | 0, i3) | 0) == 0) {
+ i6 = _luaL_argerror(i1, i6, 11560) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ i6 = i4 + 3 | 0;
+ _luaL_checkany(i1, i6);
+ _lua_settop(i1, i6);
+ _lua_xmove(i1, i5, 1);
+ _lua_pushstring(i1, _lua_setlocal(i5, i3, _luaL_checkinteger(i1, i4 | 2) | 0) | 0) | 0;
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ return 0;
+}
+function _tremove(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ i3 = _luaL_len(i1, 1) | 0;
+ i4 = _luaL_optinteger(i1, 2, i3) | 0;
+ if ((i4 | 0) != (i3 | 0) ? (i4 | 0) < 1 | (i4 | 0) > (i3 + 1 | 0) : 0) {
+ _luaL_argerror(i1, 1, 8256) | 0;
+ }
+ _lua_rawgeti(i1, 1, i4);
+ if ((i4 | 0) >= (i3 | 0)) {
+ i5 = i4;
+ _lua_pushnil(i1);
+ _lua_rawseti(i1, 1, i5);
+ STACKTOP = i2;
+ return 1;
+ }
+ while (1) {
+ i5 = i4 + 1 | 0;
+ _lua_rawgeti(i1, 1, i5);
+ _lua_rawseti(i1, 1, i4);
+ if ((i5 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i5;
+ }
+ }
+ _lua_pushnil(i1);
+ _lua_rawseti(i1, 1, i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaL_checkudata(i1, i7, i5) {
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = _lua_touserdata(i1, i7) | 0;
+ if (((i3 | 0) != 0 ? (_lua_getmetatable(i1, i7) | 0) != 0 : 0) ? (_lua_getfield(i1, -1001e3, i5), i6 = (_lua_rawequal(i1, -1, -2) | 0) == 0, i6 = i6 ? 0 : i3, _lua_settop(i1, -3), (i6 | 0) != 0) : 0) {
+ i7 = i6;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ i6 = _lua_typename(i1, _lua_type(i1, i7) | 0) | 0;
+ HEAP32[i4 >> 2] = i5;
+ HEAP32[i4 + 4 >> 2] = i6;
+ _luaL_argerror(i1, i7, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
+ i7 = 0;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _luaL_error(i1, i5, i7) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 128 | 0;
+ i3 = i4;
+ i2 = i4 + 24 | 0;
+ i4 = i4 + 8 | 0;
+ HEAP32[i4 >> 2] = i7;
+ if ((_lua_getstack(i1, 1, i2) | 0) != 0 ? (_lua_getinfo(i1, 1152, i2) | 0, i6 = HEAP32[i2 + 20 >> 2] | 0, (i6 | 0) > 0) : 0) {
+ HEAP32[i3 >> 2] = i2 + 36;
+ HEAP32[i3 + 4 >> 2] = i6;
+ _lua_pushfstring(i1, 1160, i3) | 0;
+ _lua_pushvfstring(i1, i5, i4) | 0;
+ _lua_concat(i1, 2);
+ _lua_error(i1) | 0;
+ }
+ _lua_pushlstring(i1, 1168, 0) | 0;
+ _lua_pushvfstring(i1, i5, i4) | 0;
+ _lua_concat(i1, 2);
+ _lua_error(i1) | 0;
+ return 0;
+}
+function _luaK_infix(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ L1 : do {
+ switch (i4 | 0) {
+ case 6:
+ {
+ _luaK_exp2nextreg(i1, i3);
+ break;
+ }
+ case 5:
+ case 4:
+ case 3:
+ case 2:
+ case 1:
+ case 0:
+ {
+ if (((HEAP32[i3 >> 2] | 0) == 5 ? (HEAP32[i3 + 16 >> 2] | 0) == -1 : 0) ? (HEAP32[i3 + 20 >> 2] | 0) == -1 : 0) {
+ break L1;
+ }
+ _luaK_exp2RK(i1, i3) | 0;
+ break;
+ }
+ case 13:
+ {
+ _luaK_goiftrue(i1, i3);
+ break;
+ }
+ case 14:
+ {
+ _luaK_goiffalse(i1, i3);
+ break;
+ }
+ default:
+ {
+ _luaK_exp2RK(i1, i3) | 0;
+ }
+ }
+ } while (0);
+ STACKTOP = i2;
+ return;
+}
+function _luaD_shrinkstack(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i1 + 8 >> 2] | 0;
+ i3 = HEAP32[i1 + 16 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ do {
+ i5 = HEAP32[i3 + 4 >> 2] | 0;
+ i4 = i4 >>> 0 < i5 >>> 0 ? i5 : i4;
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ } while ((i3 | 0) != 0);
+ }
+ i3 = i4 - (HEAP32[i1 + 28 >> 2] | 0) | 0;
+ i4 = (i3 >> 4) + 1 | 0;
+ i4 = ((i4 | 0) / 8 | 0) + 10 + i4 | 0;
+ i4 = (i4 | 0) > 1e6 ? 1e6 : i4;
+ if ((i3 | 0) > 15999984) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i4 | 0) >= (HEAP32[i1 + 32 >> 2] | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaD_reallocstack(i1, i4);
+ STACKTOP = i2;
+ return;
+}
+function _luaF_newproto(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _luaC_newobj(i1, 9, 80, 0, 0) | 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i1 + 44 >> 2] = 0;
+ HEAP32[i1 + 16 >> 2] = 0;
+ HEAP32[i1 + 56 >> 2] = 0;
+ HEAP32[i1 + 12 >> 2] = 0;
+ HEAP32[i1 + 32 >> 2] = 0;
+ HEAP32[i1 + 48 >> 2] = 0;
+ HEAP32[i1 + 20 >> 2] = 0;
+ HEAP32[i1 + 52 >> 2] = 0;
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i1 + 40 >> 2] = 0;
+ HEAP8[i1 + 76 | 0] = 0;
+ HEAP8[i1 + 77 | 0] = 0;
+ HEAP8[i1 + 78 | 0] = 0;
+ HEAP32[i1 + 24 >> 2] = 0;
+ HEAP32[i1 + 60 >> 2] = 0;
+ HEAP32[i1 + 64 >> 2] = 0;
+ HEAP32[i1 + 68 >> 2] = 0;
+ HEAP32[i1 + 36 >> 2] = 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaF_freeproto(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ _luaM_realloc_(i2, HEAP32[i1 + 12 >> 2] | 0, HEAP32[i1 + 48 >> 2] << 2, 0) | 0;
+ _luaM_realloc_(i2, HEAP32[i1 + 16 >> 2] | 0, HEAP32[i1 + 56 >> 2] << 2, 0) | 0;
+ _luaM_realloc_(i2, HEAP32[i1 + 8 >> 2] | 0, HEAP32[i1 + 44 >> 2] << 4, 0) | 0;
+ _luaM_realloc_(i2, HEAP32[i1 + 20 >> 2] | 0, HEAP32[i1 + 52 >> 2] << 2, 0) | 0;
+ _luaM_realloc_(i2, HEAP32[i1 + 24 >> 2] | 0, (HEAP32[i1 + 60 >> 2] | 0) * 12 | 0, 0) | 0;
+ _luaM_realloc_(i2, HEAP32[i1 + 28 >> 2] | 0, HEAP32[i1 + 40 >> 2] << 3, 0) | 0;
+ _luaM_realloc_(i2, i1, 80, 0) | 0;
+ STACKTOP = i3;
+ return;
+}
+function _luaK_patchclose(i3, i7, i4) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i5 = 0, i6 = 0, i8 = 0;
+ i2 = STACKTOP;
+ if ((i7 | 0) == -1) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = HEAP32[(HEAP32[i3 >> 2] | 0) + 12 >> 2] | 0;
+ i4 = (i4 << 6) + 64 & 16320;
+ while (1) {
+ i6 = i3 + (i7 << 2) | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ i8 = (i5 >>> 14) + -131071 | 0;
+ if ((i8 | 0) == -1) {
+ break;
+ }
+ i7 = i7 + 1 + i8 | 0;
+ HEAP32[i6 >> 2] = i5 & -16321 | i4;
+ if ((i7 | 0) == -1) {
+ i1 = 6;
+ break;
+ }
+ }
+ if ((i1 | 0) == 6) {
+ STACKTOP = i2;
+ return;
+ }
+ HEAP32[i6 >> 2] = i5 & -16321 | i4;
+ STACKTOP = i2;
+ return;
+}
+function _loadfunc(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i6 = _luaL_gsub(i1, i5, 4936, 4944) | 0;
+ i5 = _strchr(i6, 45) | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ HEAP32[i3 >> 2] = _lua_pushlstring(i1, i6, i5 - i6 | 0) | 0;
+ i6 = _ll_loadfunc(i1, i4, _lua_pushfstring(i1, 4952, i3) | 0) | 0;
+ if ((i6 | 0) == 2) {
+ i6 = i5 + 1 | 0;
+ break;
+ } else {
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ }
+ } while (0);
+ HEAP32[i3 >> 2] = i6;
+ i6 = _ll_loadfunc(i1, i4, _lua_pushfstring(i1, 4952, i3) | 0) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _luaK_setlist(i1, i3, i4, i5) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i4 = ((i4 + -1 | 0) / 50 | 0) + 1 | 0;
+ i5 = (i5 | 0) == -1 ? 0 : i5;
+ if ((i4 | 0) < 512) {
+ _luaK_code(i1, i3 << 6 | i5 << 23 | i4 << 14 | 36) | 0;
+ i4 = i3 + 1 | 0;
+ i4 = i4 & 255;
+ i5 = i1 + 48 | 0;
+ HEAP8[i5] = i4;
+ STACKTOP = i2;
+ return;
+ }
+ if ((i4 | 0) >= 67108864) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10576);
+ }
+ _luaK_code(i1, i3 << 6 | i5 << 23 | 36) | 0;
+ _luaK_code(i1, i4 << 6 | 39) | 0;
+ i4 = i3 + 1 | 0;
+ i4 = i4 & 255;
+ i5 = i1 + 48 | 0;
+ HEAP8[i5] = i4;
+ STACKTOP = i2;
+ return;
+}
+function _lua_getstack(i2, i6, i3) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i5 = 0;
+ i1 = STACKTOP;
+ L1 : do {
+ if ((i6 | 0) >= 0) {
+ i5 = HEAP32[i2 + 16 >> 2] | 0;
+ if ((i6 | 0) > 0) {
+ i4 = i2 + 72 | 0;
+ do {
+ if ((i5 | 0) == (i4 | 0)) {
+ i2 = 0;
+ break L1;
+ }
+ i6 = i6 + -1 | 0;
+ i5 = HEAP32[i5 + 8 >> 2] | 0;
+ } while ((i6 | 0) > 0);
+ if ((i6 | 0) != 0) {
+ i2 = 0;
+ break;
+ }
+ }
+ if ((i5 | 0) != (i2 + 72 | 0)) {
+ HEAP32[i3 + 96 >> 2] = i5;
+ i2 = 1;
+ } else {
+ i2 = 0;
+ }
+ } else {
+ i2 = 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaC_checkupvalcolor(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = i5 + 5 | 0;
+ i3 = HEAPU8[i4] | 0;
+ if ((i3 & 7 | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP8[i1 + 62 | 0] | 0) != 2 ? (HEAPU8[i1 + 61 | 0] | 0) >= 2 : 0) {
+ HEAP8[i4] = HEAP8[i1 + 60 | 0] & 3 | i3 & 184;
+ STACKTOP = i2;
+ return;
+ }
+ HEAP8[i4] = i3 & 187 | 4;
+ i3 = HEAP32[i5 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + 8 >> 2] & 64 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ if ((HEAP8[i3 + 5 | 0] & 3) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _reallymarkobject(i1, i3);
+ STACKTOP = i2;
+ return;
+}
+function _luaB_collectgarbage(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[10160 + ((_luaL_checkoption(i1, 1, 10040, 9976) | 0) << 2) >> 2] | 0;
+ i3 = _lua_gc(i1, i4, _luaL_optinteger(i1, 2, 0) | 0) | 0;
+ if ((i4 | 0) == 3) {
+ i4 = _lua_gc(i1, 4, 0) | 0;
+ _lua_pushnumber(i1, +(i3 | 0) + +(i4 | 0) * .0009765625);
+ _lua_pushinteger(i1, i4);
+ i4 = 2;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else if ((i4 | 0) == 9 | (i4 | 0) == 5) {
+ _lua_pushboolean(i1, i3);
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ _lua_pushinteger(i1, i3);
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _maxn(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0, d4 = 0.0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ _lua_pushnil(i1);
+ L1 : do {
+ if ((_lua_next(i1, 1) | 0) == 0) {
+ d3 = 0.0;
+ } else {
+ d4 = 0.0;
+ while (1) {
+ while (1) {
+ _lua_settop(i1, -2);
+ if ((_lua_type(i1, -1) | 0) == 3 ? (d3 = +_lua_tonumberx(i1, -1, 0), d3 > d4) : 0) {
+ break;
+ }
+ if ((_lua_next(i1, 1) | 0) == 0) {
+ d3 = d4;
+ break L1;
+ }
+ }
+ if ((_lua_next(i1, 1) | 0) == 0) {
+ break;
+ } else {
+ d4 = d3;
+ }
+ }
+ }
+ } while (0);
+ _lua_pushnumber(i1, d3);
+ STACKTOP = i2;
+ return 1;
+}
+function _str_char(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1040 | 0;
+ i4 = i2;
+ i3 = _lua_gettop(i1) | 0;
+ i5 = _luaL_buffinitsize(i1, i4, i3) | 0;
+ if ((i3 | 0) < 1) {
+ _luaL_pushresultsize(i4, i3);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i6 = 1;
+ }
+ while (1) {
+ i7 = _luaL_checkinteger(i1, i6) | 0;
+ if ((i7 & 255 | 0) != (i7 | 0)) {
+ _luaL_argerror(i1, i6, 7920) | 0;
+ }
+ HEAP8[i5 + (i6 + -1) | 0] = i7;
+ if ((i6 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i6 = i6 + 1 | 0;
+ }
+ }
+ _luaL_pushresultsize(i4, i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _luaK_exp2val(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i2 = STACKTOP;
+ i3 = i5 + 16 | 0;
+ i4 = i5 + 20 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == (HEAP32[i4 >> 2] | 0)) {
+ _luaK_dischargevars(i1, i5);
+ STACKTOP = i2;
+ return;
+ }
+ _luaK_dischargevars(i1, i5);
+ if ((HEAP32[i5 >> 2] | 0) == 6) {
+ i6 = HEAP32[i5 + 8 >> 2] | 0;
+ if ((HEAP32[i3 >> 2] | 0) == (HEAP32[i4 >> 2] | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i6 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i1, i5, i6);
+ STACKTOP = i2;
+ return;
+ }
+ }
+ _luaK_exp2nextreg(i1, i5);
+ STACKTOP = i2;
+ return;
+}
+function _str_reverse(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i4 = i2 + 1040 | 0;
+ i1 = i2;
+ i3 = _luaL_checklstring(i5, 1, i4) | 0;
+ i5 = _luaL_buffinitsize(i5, i1, HEAP32[i4 >> 2] | 0) | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ i7 = 0;
+ _luaL_pushresultsize(i1, i7);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i7 = 0;
+ }
+ do {
+ HEAP8[i5 + i7 | 0] = HEAP8[i3 + (i6 + ~i7) | 0] | 0;
+ i7 = i7 + 1 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ } while (i7 >>> 0 < i6 >>> 0);
+ _luaL_pushresultsize(i1, i6);
+ STACKTOP = i2;
+ return 1;
+}
+function _str_upper(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i4 = i1 + 1040 | 0;
+ i2 = i1;
+ i3 = _luaL_checklstring(i5, 1, i4) | 0;
+ i5 = _luaL_buffinitsize(i5, i2, HEAP32[i4 >> 2] | 0) | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ i7 = 0;
+ _luaL_pushresultsize(i2, i7);
+ STACKTOP = i1;
+ return 1;
+ } else {
+ i6 = 0;
+ }
+ do {
+ HEAP8[i5 + i6 | 0] = _toupper(HEAPU8[i3 + i6 | 0] | 0 | 0) | 0;
+ i6 = i6 + 1 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ } while (i6 >>> 0 < i7 >>> 0);
+ _luaL_pushresultsize(i2, i7);
+ STACKTOP = i1;
+ return 1;
+}
+function _str_lower(i5) {
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i4 = i1 + 1040 | 0;
+ i2 = i1;
+ i3 = _luaL_checklstring(i5, 1, i4) | 0;
+ i5 = _luaL_buffinitsize(i5, i2, HEAP32[i4 >> 2] | 0) | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ i7 = 0;
+ _luaL_pushresultsize(i2, i7);
+ STACKTOP = i1;
+ return 1;
+ } else {
+ i6 = 0;
+ }
+ do {
+ HEAP8[i5 + i6 | 0] = _tolower(HEAPU8[i3 + i6 | 0] | 0 | 0) | 0;
+ i6 = i6 + 1 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ } while (i6 >>> 0 < i7 >>> 0);
+ _luaL_pushresultsize(i2, i7);
+ STACKTOP = i1;
+ return 1;
+}
+function ___divdi3(i1, i2, i3, i4) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i5 = 0, i6 = 0, i7 = 0, i8 = 0;
+ i5 = i2 >> 31 | ((i2 | 0) < 0 ? -1 : 0) << 1;
+ i6 = ((i2 | 0) < 0 ? -1 : 0) >> 31 | ((i2 | 0) < 0 ? -1 : 0) << 1;
+ i7 = i4 >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
+ i8 = ((i4 | 0) < 0 ? -1 : 0) >> 31 | ((i4 | 0) < 0 ? -1 : 0) << 1;
+ i1 = _i64Subtract(i5 ^ i1, i6 ^ i2, i5, i6) | 0;
+ i2 = tempRet0;
+ i5 = i7 ^ i5;
+ i6 = i8 ^ i6;
+ i7 = _i64Subtract((___udivmoddi4(i1, i2, _i64Subtract(i7 ^ i3, i8 ^ i4, i7, i8) | 0, tempRet0, 0) | 0) ^ i5, tempRet0 ^ i6, i5, i6) | 0;
+ return i7 | 0;
+}
+function _luaK_setoneret(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 13) {
+ i3 = (HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 + 8 >> 2] << 2) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & 8388607 | 16777216;
+ HEAP32[i4 >> 2] = 11;
+ STACKTOP = i2;
+ return;
+ } else if ((i3 | 0) == 12) {
+ HEAP32[i4 >> 2] = 6;
+ i4 = i4 + 8 | 0;
+ HEAP32[i4 >> 2] = (HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] | 0) + (HEAP32[i4 >> 2] << 2) >> 2] | 0) >>> 6 & 255;
+ STACKTOP = i2;
+ return;
+ } else {
+ STACKTOP = i2;
+ return;
+ }
+}
+function _luaV_tostring(i6, i1) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i3 = i2;
+ i4 = i2 + 8 | 0;
+ i5 = i1 + 8 | 0;
+ if ((HEAP32[i5 >> 2] | 0) != 3) {
+ i6 = 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ HEAPF64[tempDoublePtr >> 3] = +HEAPF64[i1 >> 3];
+ HEAP32[i3 >> 2] = HEAP32[tempDoublePtr >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[tempDoublePtr + 4 >> 2];
+ i6 = _luaS_newlstr(i6, i4, _sprintf(i4 | 0, 8936, i3 | 0) | 0) | 0;
+ HEAP32[i1 >> 2] = i6;
+ HEAP32[i5 >> 2] = HEAPU8[i6 + 4 | 0] | 0 | 64;
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _strcmp(i4, i2) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i5 = HEAP8[i4] | 0;
+ i3 = HEAP8[i2] | 0;
+ if (i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0) {
+ i4 = i5;
+ i5 = i3;
+ i4 = i4 & 255;
+ i5 = i5 & 255;
+ i5 = i4 - i5 | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ do {
+ i4 = i4 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i5 = HEAP8[i4] | 0;
+ i3 = HEAP8[i2] | 0;
+ } while (!(i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0));
+ i4 = i5 & 255;
+ i5 = i3 & 255;
+ i5 = i4 - i5 | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _lua_pushstring(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) == 0) {
+ i3 = i1 + 8 | 0;
+ i1 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i3 >> 2] = i1 + 16;
+ i3 = 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i3 = _luaS_new(i1, i3) | 0;
+ i1 = i1 + 8 | 0;
+ i4 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i4 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
+ HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 16;
+ i3 = i3 + 16 | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _luaK_exp2anyreg(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ _luaK_dischargevars(i1, i3);
+ if ((HEAP32[i3 >> 2] | 0) == 6) {
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if ((HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0)) {
+ i5 = i4;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ if ((i4 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i1, i3, i4);
+ i5 = HEAP32[i5 >> 2] | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ } else {
+ i5 = i3 + 8 | 0;
+ }
+ _luaK_exp2nextreg(i1, i3);
+ i5 = HEAP32[i5 >> 2] | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _check_match(i1, i4, i5, i6) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((HEAP32[i1 + 16 >> 2] | 0) == (i4 | 0)) {
+ _luaX_next(i1);
+ STACKTOP = i2;
+ return;
+ }
+ if ((HEAP32[i1 + 4 >> 2] | 0) == (i6 | 0)) {
+ _error_expected(i1, i4);
+ } else {
+ i2 = HEAP32[i1 + 52 >> 2] | 0;
+ i4 = _luaX_token2str(i1, i4) | 0;
+ i5 = _luaX_token2str(i1, i5) | 0;
+ HEAP32[i3 >> 2] = i4;
+ HEAP32[i3 + 4 >> 2] = i5;
+ HEAP32[i3 + 8 >> 2] = i6;
+ _luaX_syntaxerror(i1, _luaO_pushfstring(i2, 6840, i3) | 0);
+ }
+}
+function _fieldsel(i1, i6) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i2;
+ i5 = i1 + 48 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ _luaK_exp2anyregup(i4, i6);
+ _luaX_next(i1);
+ if ((HEAP32[i1 + 16 >> 2] | 0) == 288) {
+ i7 = HEAP32[i1 + 24 >> 2] | 0;
+ _luaX_next(i1);
+ i5 = _luaK_stringK(HEAP32[i5 >> 2] | 0, i7) | 0;
+ HEAP32[i3 + 16 >> 2] = -1;
+ HEAP32[i3 + 20 >> 2] = -1;
+ HEAP32[i3 >> 2] = 4;
+ HEAP32[i3 + 8 >> 2] = i5;
+ _luaK_indexed(i4, i6, i3);
+ STACKTOP = i2;
+ return;
+ } else {
+ _error_expected(i1, 288);
+ }
+}
+function _luaK_exp2anyregup(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i3 >> 2] | 0) == 8 ? (HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0) : 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaK_dischargevars(i1, i3);
+ if ((HEAP32[i3 >> 2] | 0) == 6) {
+ i4 = HEAP32[i3 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + 16 >> 2] | 0) == (HEAP32[i3 + 20 >> 2] | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i4 | 0) >= (HEAPU8[i1 + 46 | 0] | 0 | 0)) {
+ _exp2reg(i1, i3, i4);
+ STACKTOP = i2;
+ return;
+ }
+ }
+ _luaK_exp2nextreg(i1, i3);
+ STACKTOP = i2;
+ return;
+}
+function _lua_settop(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ if (!((i5 | 0) > -1)) {
+ i4 = i3 + 8 | 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + (i5 + 1 << 4);
+ STACKTOP = i1;
+ return;
+ }
+ i2 = i3 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ i3 = (HEAP32[HEAP32[i3 + 16 >> 2] >> 2] | 0) + (i5 + 1 << 4) | 0;
+ if (i4 >>> 0 < i3 >>> 0) {
+ while (1) {
+ i5 = i4 + 16 | 0;
+ HEAP32[i4 + 8 >> 2] = 0;
+ if (i5 >>> 0 < i3 >>> 0) {
+ i4 = i5;
+ } else {
+ break;
+ }
+ }
+ HEAP32[i2 >> 2] = i5;
+ }
+ HEAP32[i2 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+}
+function _luaL_fileresult(i1, i6, i5) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = HEAP32[(___errno_location() | 0) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ _lua_pushboolean(i1, 1);
+ i6 = 1;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ _lua_pushnil(i1);
+ i6 = _strerror(i3 | 0) | 0;
+ if ((i5 | 0) == 0) {
+ _lua_pushstring(i1, i6) | 0;
+ } else {
+ HEAP32[i4 >> 2] = i5;
+ HEAP32[i4 + 4 >> 2] = i6;
+ _lua_pushfstring(i1, 1176, i4) | 0;
+ }
+ _lua_pushinteger(i1, i3);
+ i6 = 3;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _luaL_pushmodule(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ _luaL_findtable(i1, -1001e3, 1432, 1) | 0;
+ _lua_getfield(i1, -1, i4);
+ if ((_lua_type(i1, -1) | 0) == 5) {
+ _lua_remove(i1, -2);
+ STACKTOP = i2;
+ return;
+ }
+ _lua_settop(i1, -2);
+ _lua_rawgeti(i1, -1001e3, 2);
+ if ((_luaL_findtable(i1, 0, i4, i5) | 0) != 0) {
+ HEAP32[i3 >> 2] = i4;
+ _luaL_error(i1, 1440, i3) | 0;
+ }
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -3, i4);
+ _lua_remove(i1, -2);
+ STACKTOP = i2;
+ return;
+}
+function _b_replace(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkunsigned(i1, 1) | 0;
+ i5 = _luaL_checkunsigned(i1, 2) | 0;
+ i4 = _luaL_checkinteger(i1, 3) | 0;
+ i2 = _luaL_optinteger(i1, 4, 1) | 0;
+ if (!((i4 | 0) > -1)) {
+ _luaL_argerror(i1, 3, 10440) | 0;
+ }
+ if ((i2 | 0) <= 0) {
+ _luaL_argerror(i1, 4, 10472) | 0;
+ }
+ if ((i2 + i4 | 0) > 32) {
+ _luaL_error(i1, 10496, i6) | 0;
+ }
+ i2 = ~(-2 << i2 + -1);
+ _lua_pushunsigned(i1, i3 & ~(i2 << i4) | (i5 & i2) << i4);
+ STACKTOP = i6;
+ return 1;
+}
+function _luaT_gettmbyobj(i1, i5, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i5 + 8 >> 2] & 15;
+ if ((i4 | 0) == 5) {
+ i4 = HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] | 0;
+ } else if ((i4 | 0) == 7) {
+ i4 = HEAP32[(HEAP32[i5 >> 2] | 0) + 8 >> 2] | 0;
+ } else {
+ i4 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i4 << 2) + 252 >> 2] | 0;
+ }
+ if ((i4 | 0) == 0) {
+ i5 = 5192;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ i5 = _luaH_getstr(i4, HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + (i3 << 2) + 184 >> 2] | 0) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _luaS_eqstr(i2, i3) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i4 = HEAP8[i2 + 4 | 0] | 0;
+ do {
+ if (i4 << 24 >> 24 == (HEAP8[i3 + 4 | 0] | 0)) {
+ if (i4 << 24 >> 24 == 4) {
+ i2 = (i2 | 0) == (i3 | 0);
+ break;
+ }
+ i4 = HEAP32[i2 + 12 >> 2] | 0;
+ if ((i2 | 0) != (i3 | 0)) {
+ if ((i4 | 0) == (HEAP32[i3 + 12 >> 2] | 0)) {
+ i2 = (_memcmp(i2 + 16 | 0, i3 + 16 | 0, i4) | 0) == 0;
+ } else {
+ i2 = 0;
+ }
+ } else {
+ i2 = 1;
+ }
+ } else {
+ i2 = 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 & 1 | 0;
+}
+function _lua_concat(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) > 1) {
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ _luaV_concat(i1, i3);
+ STACKTOP = i2;
+ return;
+ } else {
+ if ((i3 | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i1 + 8 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ i1 = _luaS_newlstr(i1, 936, 0) | 0;
+ HEAP32[i4 >> 2] = i1;
+ HEAP32[i4 + 8 >> 2] = HEAPU8[i1 + 4 | 0] | 0 | 64;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _ll_loadfunc(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_getfield(i1, -1001e3, 4184);
+ _lua_getfield(i1, -1, i4);
+ i4 = _lua_touserdata(i1, -1) | 0;
+ _lua_settop(i1, -3);
+ if ((i4 | 0) == 0) {
+ _lua_pushlstring(i1, 4968, 58) | 0;
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ if ((HEAP8[i3] | 0) == 42) {
+ _lua_pushboolean(i1, 1);
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ _lua_pushlstring(i1, 4968, 58) | 0;
+ i4 = 2;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function _luaD_growstack(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = HEAP32[i1 + 32 >> 2] | 0;
+ if ((i4 | 0) > 1e6) {
+ _luaD_throw(i1, 6);
+ }
+ i3 = i3 + 5 + ((HEAP32[i1 + 8 >> 2] | 0) - (HEAP32[i1 + 28 >> 2] | 0) >> 4) | 0;
+ i4 = i4 << 1;
+ i4 = (i4 | 0) > 1e6 ? 1e6 : i4;
+ i3 = (i4 | 0) < (i3 | 0) ? i3 : i4;
+ if ((i3 | 0) > 1e6) {
+ _luaD_reallocstack(i1, 1000200);
+ _luaG_runerror(i1, 2224, i2);
+ } else {
+ _luaD_reallocstack(i1, i3);
+ STACKTOP = i2;
+ return;
+ }
+}
+function _luaL_callmeta(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i4 = _lua_absindex(i1, i4) | 0;
+ if ((_lua_getmetatable(i1, i4) | 0) == 0) {
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_rawget(i1, -2);
+ if ((_lua_type(i1, -1) | 0) == 0) {
+ _lua_settop(i1, -3);
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ _lua_remove(i1, -2);
+ _lua_pushvalue(i1, i4);
+ _lua_callk(i1, 1, 1, 0, 0);
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _luaK_reserveregs(i8, i7) {
+ i8 = i8 | 0;
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i2 = i8 + 48 | 0;
+ i6 = HEAP8[i2] | 0;
+ i4 = (i6 & 255) + i7 | 0;
+ i5 = (HEAP32[i8 >> 2] | 0) + 78 | 0;
+ do {
+ if ((i4 | 0) > (HEAPU8[i5] | 0 | 0)) {
+ if ((i4 | 0) > 249) {
+ _luaX_syntaxerror(HEAP32[i8 + 12 >> 2] | 0, 10536);
+ } else {
+ HEAP8[i5] = i4;
+ i1 = HEAP8[i2] | 0;
+ break;
+ }
+ } else {
+ i1 = i6;
+ }
+ } while (0);
+ HEAP8[i2] = (i1 & 255) + i7;
+ STACKTOP = i3;
+ return;
+}
+function _aux_lines(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i4 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ i2 = i3 + -1 | 0;
+ if ((i3 | 0) >= 19) {
+ _luaL_argerror(i1, 17, 3320) | 0;
+ }
+ _lua_pushvalue(i1, 1);
+ _lua_pushinteger(i1, i2);
+ _lua_pushboolean(i1, i5);
+ if ((i3 | 0) >= 2) {
+ i5 = 1;
+ while (1) {
+ i6 = i5 + 1 | 0;
+ _lua_pushvalue(i1, i6);
+ if ((i5 | 0) < (i2 | 0)) {
+ i5 = i6;
+ } else {
+ break;
+ }
+ }
+ }
+ _lua_pushcclosure(i1, 155, i3 + 2 | 0);
+ STACKTOP = i4;
+ return;
+}
+function _memcmp(i2, i4, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0, i6 = 0;
+ i1 = STACKTOP;
+ L1 : do {
+ if ((i3 | 0) == 0) {
+ i2 = 0;
+ } else {
+ while (1) {
+ i6 = HEAP8[i2] | 0;
+ i5 = HEAP8[i4] | 0;
+ if (!(i6 << 24 >> 24 == i5 << 24 >> 24)) {
+ break;
+ }
+ i3 = i3 + -1 | 0;
+ if ((i3 | 0) == 0) {
+ i2 = 0;
+ break L1;
+ } else {
+ i2 = i2 + 1 | 0;
+ i4 = i4 + 1 | 0;
+ }
+ }
+ i2 = (i6 & 255) - (i5 & 255) | 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _b_arshift(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkunsigned(i1, 1) | 0;
+ i4 = _luaL_checkinteger(i1, 2) | 0;
+ if ((i4 | 0) > -1 & (i3 | 0) < 0) {
+ if ((i4 | 0) > 31) {
+ i3 = -1;
+ } else {
+ i3 = i3 >>> i4 | ~(-1 >>> i4);
+ }
+ _lua_pushunsigned(i1, i3);
+ STACKTOP = i2;
+ return 1;
+ }
+ i5 = 0 - i4 | 0;
+ if ((i4 | 0) > 0) {
+ i3 = (i4 | 0) > 31 ? 0 : i3 >>> i4;
+ } else {
+ i3 = (i5 | 0) > 31 ? 0 : i3 << i5;
+ }
+ _lua_pushunsigned(i1, i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaL_checkunsigned(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ i6 = i3 + 8 | 0;
+ i2 = _lua_tounsignedx(i1, i5, i6) | 0;
+ if ((HEAP32[i6 >> 2] | 0) != 0) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ i7 = _lua_typename(i1, 3) | 0;
+ i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i4 + 4 >> 2] = i6;
+ _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _luaB_loadfile(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i1 = STACKTOP;
+ i4 = _luaL_optlstring(i2, 1, 0, 0) | 0;
+ i5 = _luaL_optlstring(i2, 2, 0, 0) | 0;
+ i3 = (_lua_type(i2, 3) | 0) != -1;
+ i6 = i3 ? 3 : 0;
+ if ((_luaL_loadfilex(i2, i4, i5) | 0) == 0) {
+ if (i3 ? (_lua_pushvalue(i2, i6), (_lua_setupvalue(i2, -2, 1) | 0) == 0) : 0) {
+ _lua_settop(i2, -2);
+ i2 = 1;
+ } else {
+ i2 = 1;
+ }
+ } else {
+ _lua_pushnil(i2);
+ _lua_insert(i2, -2);
+ i2 = 2;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaL_checkinteger(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ i6 = i3 + 8 | 0;
+ i2 = _lua_tointegerx(i1, i5, i6) | 0;
+ if ((HEAP32[i6 >> 2] | 0) != 0) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ i7 = _lua_typename(i1, 3) | 0;
+ i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i4 + 4 >> 2] = i6;
+ _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _luaB_select(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ i2 = _lua_gettop(i1) | 0;
+ if ((_lua_type(i1, 1) | 0) == 4 ? (HEAP8[_lua_tolstring(i1, 1, 0) | 0] | 0) == 35 : 0) {
+ _lua_pushinteger(i1, i2 + -1 | 0);
+ i4 = 1;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ i4 = _luaL_checkinteger(i1, 1) | 0;
+ if ((i4 | 0) < 0) {
+ i4 = i4 + i2 | 0;
+ } else {
+ i4 = (i4 | 0) > (i2 | 0) ? i2 : i4;
+ }
+ if ((i4 | 0) <= 0) {
+ _luaL_argerror(i1, 1, 9760) | 0;
+ }
+ i4 = i2 - i4 | 0;
+ STACKTOP = i3;
+ return i4 | 0;
+}
+function _luaX_next(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 8 >> 2] = HEAP32[i1 + 4 >> 2];
+ i3 = i1 + 32 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 286) {
+ HEAP32[i1 + 16 >> 2] = _llex(i1, i1 + 24 | 0) | 0;
+ STACKTOP = i2;
+ return;
+ } else {
+ i1 = i1 + 16 | 0;
+ HEAP32[i1 + 0 >> 2] = HEAP32[i3 + 0 >> 2];
+ HEAP32[i1 + 4 >> 2] = HEAP32[i3 + 4 >> 2];
+ HEAP32[i1 + 8 >> 2] = HEAP32[i3 + 8 >> 2];
+ HEAP32[i1 + 12 >> 2] = HEAP32[i3 + 12 >> 2];
+ HEAP32[i3 >> 2] = 286;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _lua_setglobal(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i5 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
+ i4 = i1 + 8 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = i6 + 16;
+ i2 = _luaS_new(i1, i2) | 0;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i6 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
+ i2 = HEAP32[i4 >> 2] | 0;
+ _luaV_settable(i1, i5, i2 + -16 | 0, i2 + -32 | 0);
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + -32;
+ STACKTOP = i3;
+ return;
+}
+function _luaL_checknumber(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var d2 = 0.0, i3 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ i6 = i3 + 8 | 0;
+ d2 = +_lua_tonumberx(i1, i5, i6);
+ if ((HEAP32[i6 >> 2] | 0) != 0) {
+ STACKTOP = i3;
+ return +d2;
+ }
+ i7 = _lua_typename(i1, 3) | 0;
+ i6 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i4 + 4 >> 2] = i6;
+ _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i4) | 0) | 0;
+ STACKTOP = i3;
+ return +d2;
+}
+function _luaZ_fill(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = FUNCTION_TABLE_iiii[HEAP32[i1 + 8 >> 2] & 3](HEAP32[i1 + 16 >> 2] | 0, HEAP32[i1 + 12 >> 2] | 0, i4) | 0;
+ if ((i3 | 0) == 0) {
+ i4 = -1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i4 = -1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ HEAP32[i1 >> 2] = i4 + -1;
+ HEAP32[i1 + 4 >> 2] = i3 + 1;
+ i4 = HEAPU8[i3] | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _lua_createtable(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i5 = _luaH_new(i1) | 0;
+ i6 = i1 + 8 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i7 >> 2] = i5;
+ HEAP32[i7 + 8 >> 2] = 69;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + 16;
+ if (!((i3 | 0) > 0 | (i4 | 0) > 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ _luaH_resize(i1, i5, i3, i4);
+ STACKTOP = i2;
+ return;
+}
+function _generic_reader(i1, i3, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ _luaL_checkstack(i1, 2, 9888);
+ _lua_pushvalue(i1, 1);
+ _lua_callk(i1, 0, 1, 0, 0);
+ if ((_lua_type(i1, -1) | 0) == 0) {
+ _lua_settop(i1, -2);
+ HEAP32[i2 >> 2] = 0;
+ i2 = 0;
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ if ((_lua_isstring(i1, -1) | 0) == 0) {
+ _luaL_error(i1, 9920, i3) | 0;
+ }
+ _lua_replace(i1, 5);
+ i2 = _lua_tolstring(i1, 5, i2) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _luaZ_openspace(i5, i1, i6) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = i1 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (!(i3 >>> 0 < i6 >>> 0)) {
+ i6 = HEAP32[i1 >> 2] | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i6 = i6 >>> 0 < 32 ? 32 : i6;
+ if ((i6 + 1 | 0) >>> 0 > 4294967293) {
+ _luaM_toobig(i5);
+ }
+ i5 = _luaM_realloc_(i5, HEAP32[i1 >> 2] | 0, i3, i6) | 0;
+ HEAP32[i1 >> 2] = i5;
+ HEAP32[i4 >> 2] = i6;
+ i6 = i5;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _luaH_getstr(i4, i3) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0;
+ i2 = STACKTOP;
+ i4 = (HEAP32[i4 + 16 >> 2] | 0) + (((1 << (HEAPU8[i4 + 7 | 0] | 0)) + -1 & HEAP32[i3 + 8 >> 2]) << 5) | 0;
+ while (1) {
+ if ((HEAP32[i4 + 24 >> 2] | 0) == 68 ? (HEAP32[i4 + 16 >> 2] | 0) == (i3 | 0) : 0) {
+ break;
+ }
+ i4 = HEAP32[i4 + 28 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i3 = 5192;
+ i1 = 6;
+ break;
+ }
+ }
+ if ((i1 | 0) == 6) {
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _b_extract(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = _luaL_checkunsigned(i1, 1) | 0;
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ i4 = _luaL_optinteger(i1, 3, 1) | 0;
+ if (!((i3 | 0) > -1)) {
+ _luaL_argerror(i1, 2, 10440) | 0;
+ }
+ if ((i4 | 0) <= 0) {
+ _luaL_argerror(i1, 3, 10472) | 0;
+ }
+ if ((i4 + i3 | 0) > 32) {
+ _luaL_error(i1, 10496, i5) | 0;
+ }
+ _lua_pushunsigned(i1, i2 >>> i3 & ~(-2 << i4 + -1));
+ STACKTOP = i5;
+ return 1;
+}
+function _luaL_checklstring(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i6 = 0, i7 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i5 = _lua_tolstring(i1, i4, i5) | 0;
+ if ((i5 | 0) != 0) {
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ i7 = _lua_typename(i1, 4) | 0;
+ i6 = _lua_typename(i1, _lua_type(i1, i4) | 0) | 0;
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i3 + 4 >> 2] = i6;
+ _luaL_argerror(i1, i4, _lua_pushfstring(i1, 1744, i3) | 0) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _db_traceback(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, 1) | 0) == 8) {
+ i3 = _lua_tothread(i1, 1) | 0;
+ i4 = 1;
+ } else {
+ i3 = i1;
+ i4 = 0;
+ }
+ i5 = i4 + 1 | 0;
+ i6 = _lua_tolstring(i1, i5, 0) | 0;
+ if ((i6 | 0) == 0 ? (_lua_type(i1, i5) | 0) >= 1 : 0) {
+ _lua_pushvalue(i1, i5);
+ STACKTOP = i2;
+ return 1;
+ }
+ _luaL_traceback(i1, i3, i6, _luaL_optinteger(i1, i4 | 2, (i3 | 0) == (i1 | 0) | 0) | 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _f_setvbuf(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i5 = HEAP32[i3 >> 2] | 0;
+ i4 = _luaL_checkoption(i1, 2, 0, 3128) | 0;
+ i3 = _luaL_optinteger(i1, 3, 1024) | 0;
+ i3 = _luaL_fileresult(i1, (_setvbuf(i5 | 0, 0, HEAP32[3112 + (i4 << 2) >> 2] | 0, i3 | 0) | 0) == 0 | 0, 0) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _luaU_dump(i3, i1, i4, i2, i5) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i6 = 0, i7 = 0, i8 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 48 | 0;
+ i8 = i6 + 20 | 0;
+ i7 = i6;
+ HEAP32[i7 >> 2] = i3;
+ HEAP32[i7 + 4 >> 2] = i4;
+ HEAP32[i7 + 8 >> 2] = i2;
+ HEAP32[i7 + 12 >> 2] = i5;
+ i5 = i7 + 16 | 0;
+ _luaU_header(i8);
+ HEAP32[i5 >> 2] = FUNCTION_TABLE_iiiii[i4 & 3](i3, i8, 18, i2) | 0;
+ _DumpFunction(i1, i7);
+ STACKTOP = i6;
+ return HEAP32[i5 >> 2] | 0;
+}
+function _luaB_setmetatable(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _lua_type(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 5);
+ if (!((i3 | 0) == 0 | (i3 | 0) == 5)) {
+ _luaL_argerror(i1, 2, 9680) | 0;
+ }
+ if ((_luaL_getmetafield(i1, 1, 9704) | 0) == 0) {
+ _lua_settop(i1, 2);
+ _lua_setmetatable(i1, 1) | 0;
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ i3 = _luaL_error(i1, 9720, i2) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _getF(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ i3 = STACKTOP;
+ i4 = HEAP32[i2 >> 2] | 0;
+ if ((i4 | 0) > 0) {
+ HEAP32[i1 >> 2] = i4;
+ HEAP32[i2 >> 2] = 0;
+ i4 = i2 + 8 | 0;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ i4 = i2 + 4 | 0;
+ if ((_feof(HEAP32[i4 >> 2] | 0) | 0) != 0) {
+ i4 = 0;
+ STACKTOP = i3;
+ return i4 | 0;
+ }
+ i2 = i2 + 8 | 0;
+ HEAP32[i1 >> 2] = _fread(i2 | 0, 1, 1024, HEAP32[i4 >> 2] | 0) | 0;
+ i4 = i2;
+ STACKTOP = i3;
+ return i4 | 0;
+}
+function _luaL_where(i1, i6) {
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i3 = i4;
+ i2 = i4 + 8 | 0;
+ if ((_lua_getstack(i1, i6, i2) | 0) != 0 ? (_lua_getinfo(i1, 1152, i2) | 0, i5 = HEAP32[i2 + 20 >> 2] | 0, (i5 | 0) > 0) : 0) {
+ HEAP32[i3 >> 2] = i2 + 36;
+ HEAP32[i3 + 4 >> 2] = i5;
+ _lua_pushfstring(i1, 1160, i3) | 0;
+ STACKTOP = i4;
+ return;
+ }
+ _lua_pushlstring(i1, 1168, 0) | 0;
+ STACKTOP = i4;
+ return;
+}
+function _hookf(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_getsubtable(i1, -1001e3, 11584) | 0;
+ _lua_pushthread(i1) | 0;
+ _lua_rawget(i1, -2);
+ if ((_lua_type(i1, -1) | 0) != 6) {
+ STACKTOP = i2;
+ return;
+ }
+ _lua_pushstring(i1, HEAP32[11608 + (HEAP32[i3 >> 2] << 2) >> 2] | 0) | 0;
+ i3 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i3 | 0) > -1) {
+ _lua_pushinteger(i1, i3);
+ } else {
+ _lua_pushnil(i1);
+ }
+ _lua_callk(i1, 2, 0, 0, 0);
+ STACKTOP = i2;
+ return;
+}
+function _luaV_tonumber(i5, i2) {
+ i5 = i5 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ i4 = HEAP32[i5 + 8 >> 2] | 0;
+ if ((i4 | 0) != 3) {
+ if ((i4 & 15 | 0) == 4 ? (i5 = HEAP32[i5 >> 2] | 0, (_luaO_str2d(i5 + 16 | 0, HEAP32[i5 + 12 >> 2] | 0, i3) | 0) != 0) : 0) {
+ HEAPF64[i2 >> 3] = +HEAPF64[i3 >> 3];
+ HEAP32[i2 + 8 >> 2] = 3;
+ } else {
+ i2 = 0;
+ }
+ } else {
+ i2 = i5;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaO_arith(i3, d1, d2) {
+ i3 = i3 | 0;
+ d1 = +d1;
+ d2 = +d2;
+ switch (i3 | 0) {
+ case 4:
+ {
+ d1 = d1 - +Math_floor(+(d1 / d2)) * d2;
+ break;
+ }
+ case 6:
+ {
+ d1 = -d1;
+ break;
+ }
+ case 0:
+ {
+ d1 = d1 + d2;
+ break;
+ }
+ case 1:
+ {
+ d1 = d1 - d2;
+ break;
+ }
+ case 5:
+ {
+ d1 = +Math_pow(+d1, +d2);
+ break;
+ }
+ case 3:
+ {
+ d1 = d1 / d2;
+ break;
+ }
+ case 2:
+ {
+ d1 = d1 * d2;
+ break;
+ }
+ default:
+ {
+ d1 = 0.0;
+ }
+ }
+ return +d1;
+}
+function _luaB_coresume(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_tothread(i1, 1) | 0;
+ if ((i3 | 0) == 0) {
+ _luaL_argerror(i1, 1, 10856) | 0;
+ }
+ i3 = _auxresume(i1, i3, (_lua_gettop(i1) | 0) + -1 | 0) | 0;
+ if ((i3 | 0) < 0) {
+ _lua_pushboolean(i1, 0);
+ _lua_insert(i1, -2);
+ i3 = 2;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ _lua_pushboolean(i1, 1);
+ _lua_insert(i1, ~i3);
+ i3 = i3 + 1 | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _pairsmeta(i1, i5, i4, i3) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_luaL_getmetafield(i1, 1, i5) | 0) != 0) {
+ _lua_pushvalue(i1, 1);
+ _lua_callk(i1, 1, 3, 0, 0);
+ STACKTOP = i2;
+ return;
+ }
+ _luaL_checktype(i1, 1, 5);
+ _lua_pushcclosure(i1, i3, 0);
+ _lua_pushvalue(i1, 1);
+ if ((i4 | 0) == 0) {
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return;
+ } else {
+ _lua_pushinteger(i1, 0);
+ STACKTOP = i2;
+ return;
+ }
+}
+function _io_close(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ if ((_lua_type(i1, 1) | 0) == -1) {
+ _lua_getfield(i1, -1001e3, 2800);
+ }
+ if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i4 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = 0;
+ i1 = FUNCTION_TABLE_ii[i3 & 255](i1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _pack(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ _lua_createtable(i1, i3, 1);
+ _lua_pushinteger(i1, i3);
+ _lua_setfield(i1, -2, 8312);
+ if ((i3 | 0) <= 0) {
+ STACKTOP = i2;
+ return 1;
+ }
+ _lua_pushvalue(i1, 1);
+ _lua_rawseti(i1, -2, 1);
+ _lua_replace(i1, 1);
+ if ((i3 | 0) <= 1) {
+ STACKTOP = i2;
+ return 1;
+ }
+ do {
+ _lua_rawseti(i1, 1, i3);
+ i3 = i3 + -1 | 0;
+ } while ((i3 | 0) > 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaL_execresult(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) == -1) {
+ i3 = HEAP32[(___errno_location() | 0) >> 2] | 0;
+ _lua_pushnil(i1);
+ _lua_pushstring(i1, _strerror(i3 | 0) | 0) | 0;
+ _lua_pushinteger(i1, i3);
+ STACKTOP = i2;
+ return 3;
+ } else if ((i3 | 0) == 0) {
+ _lua_pushboolean(i1, 1);
+ } else {
+ _lua_pushnil(i1);
+ }
+ _lua_pushstring(i1, 1184) | 0;
+ _lua_pushinteger(i1, i3);
+ STACKTOP = i2;
+ return 3;
+}
+function _lua_getglobal(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i3 = STACKTOP;
+ i4 = _luaH_getint(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 40 >> 2] | 0, 2) | 0;
+ i5 = i1 + 8 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i6 + 16;
+ i2 = _luaS_new(i1, i2) | 0;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i6 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
+ i2 = (HEAP32[i5 >> 2] | 0) + -16 | 0;
+ _luaV_gettable(i1, i4, i2, i2);
+ STACKTOP = i3;
+ return;
+}
+function _luaL_checktype(i1, i5, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((_lua_type(i1, i5) | 0) == (i4 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i6 = _lua_typename(i1, i4) | 0;
+ i4 = _lua_typename(i1, _lua_type(i1, i5) | 0) | 0;
+ HEAP32[i3 >> 2] = i6;
+ HEAP32[i3 + 4 >> 2] = i4;
+ _luaL_argerror(i1, i5, _lua_pushfstring(i1, 1744, i3) | 0) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _luaC_newobj(i7, i4, i6, i5, i1) {
+ i7 = i7 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i7 + 12 >> 2] | 0;
+ i7 = _luaM_realloc_(i7, 0, i4 & 15, i6) | 0;
+ i6 = i7 + i1 | 0;
+ i5 = (i5 | 0) == 0 ? i3 + 68 | 0 : i5;
+ HEAP8[i7 + (i1 + 5) | 0] = HEAP8[i3 + 60 | 0] & 3;
+ HEAP8[i7 + (i1 + 4) | 0] = i4;
+ HEAP32[i6 >> 2] = HEAP32[i5 >> 2];
+ HEAP32[i5 >> 2] = i6;
+ STACKTOP = i2;
+ return i6 | 0;
+}
+function _luaL_requiref(i1, i3, i5, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushcclosure(i1, i5, 0);
+ _lua_pushstring(i1, i3) | 0;
+ _lua_callk(i1, 1, 1, 0, 0);
+ _luaL_getsubtable(i1, -1001e3, 1432) | 0;
+ _lua_pushvalue(i1, -2);
+ _lua_setfield(i1, -2, i3);
+ _lua_settop(i1, -2);
+ if ((i4 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ _lua_pushvalue(i1, -1);
+ _lua_setglobal(i1, i3);
+ STACKTOP = i2;
+ return;
+}
+function _luaG_ordererror(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = HEAP32[8528 + ((HEAP32[i3 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
+ i4 = HEAP32[8528 + ((HEAP32[i4 + 8 >> 2] & 15) + 1 << 2) >> 2] | 0;
+ if ((i3 | 0) == (i4 | 0)) {
+ HEAP32[i2 >> 2] = i3;
+ _luaG_runerror(i1, 1952, i2);
+ } else {
+ HEAP32[i2 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i4;
+ _luaG_runerror(i1, 1992, i2);
+ }
+}
+function _io_popen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ _luaL_optlstring(i1, 2, 3480, 0) | 0;
+ i5 = _lua_newuserdata(i1, 8) | 0;
+ i4 = i5 + 4 | 0;
+ HEAP32[i4 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ _luaL_error(i1, 3488, i2) | 0;
+ HEAP32[i5 >> 2] = 0;
+ HEAP32[i4 >> 2] = 157;
+ i1 = _luaL_fileresult(i1, 0, i3) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _sort_comp(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, 2) | 0) == 0) {
+ i4 = _lua_compare(i1, i3, i4, 1) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ _lua_pushvalue(i1, 2);
+ _lua_pushvalue(i1, i3 + -1 | 0);
+ _lua_pushvalue(i1, i4 + -2 | 0);
+ _lua_callk(i1, 2, 1, 0, 0);
+ i4 = _lua_toboolean(i1, -1) | 0;
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _db_upvalueid(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 112 | 0;
+ i4 = i3;
+ i2 = _luaL_checkinteger(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 6);
+ _lua_pushvalue(i1, 1);
+ _lua_getinfo(i1, 11728, i4) | 0;
+ if (!((i2 | 0) > 0 ? (i2 | 0) <= (HEAPU8[i4 + 32 | 0] | 0 | 0) : 0)) {
+ _luaL_argerror(i1, 2, 11736) | 0;
+ }
+ _lua_pushlightuserdata(i1, _lua_upvalueid(i1, 1, i2) | 0);
+ STACKTOP = i3;
+ return 1;
+}
+function _luaL_getmetafield(i2, i4, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ do {
+ if ((_lua_getmetatable(i2, i4) | 0) != 0) {
+ _lua_pushstring(i2, i3) | 0;
+ _lua_rawget(i2, -2);
+ if ((_lua_type(i2, -1) | 0) == 0) {
+ _lua_settop(i2, -3);
+ i2 = 0;
+ break;
+ } else {
+ _lua_remove(i2, -2);
+ i2 = 1;
+ break;
+ }
+ } else {
+ i2 = 0;
+ }
+ } while (0);
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaF_freeupval(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i3 + 8 >> 2] | 0) == (i3 + 16 | 0)) {
+ _luaM_realloc_(i1, i3, 32, 0) | 0;
+ STACKTOP = i2;
+ return;
+ }
+ i4 = i3 + 16 | 0;
+ i5 = i4 + 4 | 0;
+ HEAP32[(HEAP32[i5 >> 2] | 0) + 16 >> 2] = HEAP32[i4 >> 2];
+ HEAP32[(HEAP32[i4 >> 2] | 0) + 20 >> 2] = HEAP32[i5 >> 2];
+ _luaM_realloc_(i1, i3, 32, 0) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _luaL_addvalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i5 = HEAP32[i1 + 12 >> 2] | 0;
+ i3 = _lua_tolstring(i5, -1, i4) | 0;
+ i6 = i1 + 16 | 0;
+ if ((HEAP32[i1 >> 2] | 0) != (i6 | 0)) {
+ _lua_insert(i5, -2);
+ }
+ _luaL_addlstring(i1, i3, HEAP32[i4 >> 2] | 0);
+ _lua_remove(i5, (HEAP32[i1 >> 2] | 0) != (i6 | 0) ? -2 : -1);
+ STACKTOP = i2;
+ return;
+}
+function _escerror(i1, i4, i3, i2) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i5 = 0, i6 = 0;
+ HEAP32[(HEAP32[i1 + 60 >> 2] | 0) + 4 >> 2] = 0;
+ _save(i1, 92);
+ L1 : do {
+ if ((i3 | 0) > 0) {
+ i5 = 0;
+ do {
+ i6 = HEAP32[i4 + (i5 << 2) >> 2] | 0;
+ if ((i6 | 0) == -1) {
+ break L1;
+ }
+ _save(i1, i6);
+ i5 = i5 + 1 | 0;
+ } while ((i5 | 0) < (i3 | 0));
+ }
+ } while (0);
+ _lexerror(i1, i2, 289);
+}
+function _pushglobalfuncname(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ _lua_getinfo(i1, 1768, i4) | 0;
+ _lua_rawgeti(i1, -1001e3, 2);
+ i4 = i3 + 1 | 0;
+ if ((_findfield(i1, i4, 2) | 0) == 0) {
+ _lua_settop(i1, i3);
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ _lua_copy(i1, -1, i4);
+ _lua_settop(i1, -3);
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function _lua_pushlstring(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i4 = _luaS_newlstr(i1, i3, i4) | 0;
+ i3 = i1 + 8 | 0;
+ i1 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i1 >> 2] = i4;
+ HEAP32[i1 + 8 >> 2] = HEAPU8[i4 + 4 | 0] | 0 | 64;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return i4 + 16 | 0;
+}
+function _ll_searchpath(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i5 = _luaL_checklstring(i1, 1, 0) | 0;
+ i4 = _luaL_checklstring(i1, 2, 0) | 0;
+ i3 = _luaL_optlstring(i1, 3, 4936, 0) | 0;
+ if ((_searchpath(i1, i5, i4, i3, _luaL_optlstring(i1, 4, 4848, 0) | 0) | 0) != 0) {
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ _lua_pushnil(i1);
+ _lua_insert(i1, -2);
+ i5 = 2;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _math_log(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0, d4 = 0.0;
+ i2 = STACKTOP;
+ d3 = +_luaL_checknumber(i1, 1);
+ do {
+ if ((_lua_type(i1, 2) | 0) >= 1) {
+ d4 = +_luaL_checknumber(i1, 2);
+ if (d4 == 10.0) {
+ d3 = +_log10(+d3);
+ break;
+ } else {
+ d3 = +Math_log(+d3) / +Math_log(+d4);
+ break;
+ }
+ } else {
+ d3 = +Math_log(+d3);
+ }
+ } while (0);
+ _lua_pushnumber(i1, d3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaT_init(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = i1 + 12 | 0;
+ i4 = 0;
+ do {
+ i5 = _luaS_new(i1, HEAP32[8576 + (i4 << 2) >> 2] | 0) | 0;
+ HEAP32[(HEAP32[i3 >> 2] | 0) + (i4 << 2) + 184 >> 2] = i5;
+ i5 = (HEAP32[(HEAP32[i3 >> 2] | 0) + (i4 << 2) + 184 >> 2] | 0) + 5 | 0;
+ HEAP8[i5] = HEAPU8[i5] | 0 | 32;
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) != 17);
+ STACKTOP = i2;
+ return;
+}
+function _f_gc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ STACKTOP = i2;
+ return 0;
+ }
+ if ((HEAP32[i3 >> 2] | 0) == 0) {
+ STACKTOP = i2;
+ return 0;
+ }
+ i4 = (_luaL_checkudata(i1, 1, 2832) | 0) + 4 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = 0;
+ FUNCTION_TABLE_ii[i3 & 255](i1) | 0;
+ STACKTOP = i2;
+ return 0;
+}
+function ___shlim(i1, i5) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i6 = 0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 104 >> 2] = i5;
+ i4 = HEAP32[i1 + 8 >> 2] | 0;
+ i3 = HEAP32[i1 + 4 >> 2] | 0;
+ i6 = i4 - i3 | 0;
+ HEAP32[i1 + 108 >> 2] = i6;
+ if ((i5 | 0) != 0 & (i6 | 0) > (i5 | 0)) {
+ HEAP32[i1 + 100 >> 2] = i3 + i5;
+ STACKTOP = i2;
+ return;
+ } else {
+ HEAP32[i1 + 100 >> 2] = i4;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _lua_sethook(i4, i6, i1, i5) {
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = (i6 | 0) == 0 | (i1 | 0) == 0;
+ i3 = HEAP32[i4 + 16 >> 2] | 0;
+ if (!((HEAP8[i3 + 18 | 0] & 1) == 0)) {
+ HEAP32[i4 + 20 >> 2] = HEAP32[i3 + 28 >> 2];
+ }
+ HEAP32[i4 + 52 >> 2] = i2 ? 0 : i6;
+ HEAP32[i4 + 44 >> 2] = i5;
+ HEAP32[i4 + 48 >> 2] = i5;
+ HEAP8[i4 + 40 | 0] = i2 ? 0 : i1 & 255;
+ return 1;
+}
+function _io_tmpfile(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = _lua_newuserdata(i1, 8) | 0;
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 0;
+ _luaL_setmetatable(i1, 2832);
+ HEAP32[i4 >> 2] = 0;
+ HEAP32[i3 >> 2] = 156;
+ i3 = _tmpfile() | 0;
+ HEAP32[i4 >> 2] = i3;
+ if ((i3 | 0) != 0) {
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ i4 = _luaL_fileresult(i1, 0, 0) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _luaL_checkstack(i1, i5, i4) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((_lua_checkstack(i1, i5 + 20 | 0) | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i4 | 0) == 0) {
+ _luaL_error(i1, 1240, i3) | 0;
+ STACKTOP = i2;
+ return;
+ } else {
+ HEAP32[i3 >> 2] = i4;
+ _luaL_error(i1, 1216, i3) | 0;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _b_rshift(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i4 = _luaL_checkunsigned(i1, 1) | 0;
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ i5 = 0 - i3 | 0;
+ if ((i3 | 0) > 0) {
+ i5 = (i3 | 0) > 31 ? 0 : i4 >>> i3;
+ _lua_pushunsigned(i1, i5);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i5 = (i5 | 0) > 31 ? 0 : i4 << i5;
+ _lua_pushunsigned(i1, i5);
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _b_lshift(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkunsigned(i1, 1) | 0;
+ i4 = _luaL_checkinteger(i1, 2) | 0;
+ if ((i4 | 0) < 0) {
+ i4 = 0 - i4 | 0;
+ i4 = (i4 | 0) > 31 ? 0 : i3 >>> i4;
+ _lua_pushunsigned(i1, i4);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ i4 = (i4 | 0) > 31 ? 0 : i3 << i4;
+ _lua_pushunsigned(i1, i4);
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _math_min(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ d5 = +_luaL_checknumber(i1, 1);
+ if ((i3 | 0) >= 2) {
+ i4 = 2;
+ while (1) {
+ d6 = +_luaL_checknumber(i1, i4);
+ d5 = d6 < d5 ? d6 : d5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ _lua_pushnumber(i1, d5);
+ STACKTOP = i2;
+ return 1;
+}
+function _math_max(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, d5 = 0.0, d6 = 0.0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ d5 = +_luaL_checknumber(i1, 1);
+ if ((i3 | 0) >= 2) {
+ i4 = 2;
+ while (1) {
+ d6 = +_luaL_checknumber(i1, i4);
+ d5 = d6 > d5 ? d6 : d5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ _lua_pushnumber(i1, d5);
+ STACKTOP = i2;
+ return 1;
+}
+function _io_type(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ i3 = _luaL_testudata(i1, 1, 2832) | 0;
+ if ((i3 | 0) == 0) {
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return 1;
+ }
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _lua_pushlstring(i1, 3456, 11) | 0;
+ STACKTOP = i2;
+ return 1;
+ } else {
+ _lua_pushlstring(i1, 3472, 4) | 0;
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _luaF_newLclosure(i3, i2) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i3 = _luaC_newobj(i3, 6, (i2 << 2) + 16 | 0, 0, 0) | 0;
+ HEAP32[i3 + 12 >> 2] = 0;
+ HEAP8[i3 + 6 | 0] = i2;
+ if ((i2 | 0) == 0) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ i4 = i3 + 16 | 0;
+ do {
+ i2 = i2 + -1 | 0;
+ HEAP32[i4 + (i2 << 2) >> 2] = 0;
+ } while ((i2 | 0) != 0);
+ STACKTOP = i1;
+ return i3 | 0;
+}
+function _io_flush(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ _lua_getfield(i1, -1001e3, 2800);
+ i3 = _lua_touserdata(i1, -1) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 2804;
+ _luaL_error(i1, 3424, i4) | 0;
+ }
+ i4 = _luaL_fileresult(i1, (_fflush(HEAP32[i3 >> 2] | 0) | 0) == 0 | 0, 0) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _b_test(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ if ((i3 | 0) < 1) {
+ i3 = 1;
+ } else {
+ i4 = 1;
+ i5 = -1;
+ while (1) {
+ i5 = (_luaL_checkunsigned(i1, i4) | 0) & i5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ i3 = (i5 | 0) != 0;
+ }
+ _lua_pushboolean(i1, i3 & 1);
+ STACKTOP = i2;
+ return 1;
+}
+function ___muldsi3(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0, i4 = 0, i5 = 0, i6 = 0;
+ i6 = i2 & 65535;
+ i4 = i1 & 65535;
+ i3 = Math_imul(i4, i6) | 0;
+ i5 = i2 >>> 16;
+ i4 = (i3 >>> 16) + (Math_imul(i4, i5) | 0) | 0;
+ i1 = i1 >>> 16;
+ i2 = Math_imul(i1, i6) | 0;
+ return (tempRet0 = (i4 >>> 16) + (Math_imul(i1, i5) | 0) + (((i4 & 65535) + i2 | 0) >>> 16) | 0, i4 + i2 << 16 | i3 & 65535 | 0) | 0;
+}
+function _str_dump(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 1056 | 0;
+ i3 = i2 + 8 | 0;
+ _luaL_checktype(i1, 1, 6);
+ _lua_settop(i1, 1);
+ _luaL_buffinit(i1, i3);
+ if ((_lua_dump(i1, 2, i3) | 0) == 0) {
+ _luaL_pushresult(i3);
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ i3 = _luaL_error(i1, 7888, i2) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function ___memrchr(i2, i3, i5) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i3 = i3 & 255;
+ while (1) {
+ i4 = i5 + -1 | 0;
+ if ((i5 | 0) == 0) {
+ i5 = 0;
+ i2 = 4;
+ break;
+ }
+ i5 = i2 + i4 | 0;
+ if ((HEAP8[i5] | 0) == i3 << 24 >> 24) {
+ i2 = 4;
+ break;
+ } else {
+ i5 = i4;
+ }
+ }
+ if ((i2 | 0) == 4) {
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ return 0;
+}
+function _luaL_getsubtable(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_getfield(i1, i3, i4);
+ if ((_lua_type(i1, -1) | 0) == 5) {
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ _lua_settop(i1, -2);
+ i3 = _lua_absindex(i1, i3) | 0;
+ _lua_createtable(i1, 0, 0);
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, i3, i4);
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _luaE_freeCI(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = (HEAP32[i1 + 16 >> 2] | 0) + 12 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ HEAP32[i4 >> 2] = 0;
+ if ((i3 | 0) == 0) {
+ STACKTOP = i2;
+ return;
+ }
+ while (1) {
+ i4 = HEAP32[i3 + 12 >> 2] | 0;
+ _luaM_realloc_(i1, i3, 40, 0) | 0;
+ if ((i4 | 0) == 0) {
+ break;
+ } else {
+ i3 = i4;
+ }
+ }
+ STACKTOP = i2;
+ return;
+}
+function _f_tostring(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ i4 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i4 + 4 >> 2] | 0) == 0) {
+ _lua_pushlstring(i1, 3040, 13) | 0;
+ STACKTOP = i2;
+ return 1;
+ } else {
+ HEAP32[i3 >> 2] = HEAP32[i4 >> 2];
+ _lua_pushfstring(i1, 3056, i3) | 0;
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _lua_newuserdata(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i3 = _luaS_newudata(i1, i3, 0) | 0;
+ i1 = i1 + 8 | 0;
+ i4 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i4 >> 2] = i3;
+ HEAP32[i4 + 8 >> 2] = 71;
+ HEAP32[i1 >> 2] = (HEAP32[i1 >> 2] | 0) + 16;
+ STACKTOP = i2;
+ return i3 + 24 | 0;
+}
+function _luaL_pushresultsize(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i5 = i1 + 8 | 0;
+ i4 = (HEAP32[i5 >> 2] | 0) + i3 | 0;
+ HEAP32[i5 >> 2] = i4;
+ i3 = HEAP32[i1 + 12 >> 2] | 0;
+ _lua_pushlstring(i3, HEAP32[i1 >> 2] | 0, i4) | 0;
+ if ((HEAP32[i1 >> 2] | 0) == (i1 + 16 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ _lua_remove(i3, -2);
+ STACKTOP = i2;
+ return;
+}
+function _luaL_testudata(i2, i5, i4) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = _lua_touserdata(i2, i5) | 0;
+ if ((i3 | 0) != 0 ? (_lua_getmetatable(i2, i5) | 0) != 0 : 0) {
+ _lua_getfield(i2, -1001e3, i4);
+ i5 = (_lua_rawequal(i2, -1, -2) | 0) == 0;
+ _lua_settop(i2, -3);
+ i2 = i5 ? 0 : i3;
+ } else {
+ i2 = 0;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _finishpcall(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_lua_checkstack(i1, 1) | 0) == 0) {
+ _lua_settop(i1, 0);
+ _lua_pushboolean(i1, 0);
+ _lua_pushstring(i1, 9632) | 0;
+ i3 = 2;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ _lua_pushboolean(i1, i3);
+ _lua_replace(i1, 1);
+ i3 = _lua_gettop(i1) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _searcher_preload(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ _lua_getfield(i1, -1001e3, 4592);
+ _lua_getfield(i1, -1, i3);
+ if ((_lua_type(i1, -1) | 0) != 0) {
+ STACKTOP = i2;
+ return 1;
+ }
+ HEAP32[i4 >> 2] = i3;
+ _lua_pushfstring(i1, 5096, i4) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_auxwrap(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i3 = STACKTOP;
+ i2 = _lua_tothread(i1, -1001001) | 0;
+ i2 = _auxresume(i1, i2, _lua_gettop(i1) | 0) | 0;
+ if ((i2 | 0) >= 0) {
+ STACKTOP = i3;
+ return i2 | 0;
+ }
+ if ((_lua_isstring(i1, -1) | 0) == 0) {
+ _lua_error(i1) | 0;
+ }
+ _luaL_where(i1, 1);
+ _lua_insert(i1, -2);
+ _lua_concat(i1, 2);
+ _lua_error(i1) | 0;
+ return 0;
+}
+function _ll_loadlib(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ i3 = _ll_loadfunc(i1, i3, _luaL_checklstring(i1, 2, 0) | 0) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _lua_pushnil(i1);
+ _lua_insert(i1, -2);
+ _lua_pushstring(i1, (i3 | 0) == 1 ? 5176 : 5184) | 0;
+ i3 = 3;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _luaS_hash(i2, i4, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i5 = i3 ^ i4;
+ i3 = (i4 >>> 5) + 1 | 0;
+ if (i3 >>> 0 > i4 >>> 0) {
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ do {
+ i5 = (i5 << 5) + (i5 >>> 2) + (HEAPU8[i2 + (i4 + -1) | 0] | 0) ^ i5;
+ i4 = i4 - i3 | 0;
+ } while (!(i4 >>> 0 < i3 >>> 0));
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _b_and(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ if ((i3 | 0) < 1) {
+ i5 = -1;
+ } else {
+ i4 = 1;
+ i5 = -1;
+ while (1) {
+ i5 = (_luaL_checkunsigned(i1, i4) | 0) & i5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ _lua_pushunsigned(i1, i5);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaopen_string(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 14);
+ _luaL_setfuncs(i1, 6920, 0);
+ _lua_createtable(i1, 0, 1);
+ _lua_pushlstring(i1, 7040, 0) | 0;
+ _lua_pushvalue(i1, -2);
+ _lua_setmetatable(i1, -2) | 0;
+ _lua_settop(i1, -2);
+ _lua_pushvalue(i1, -2);
+ _lua_setfield(i1, -2, 7048);
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return 1;
+}
+function _b_xor(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ if ((i3 | 0) < 1) {
+ i5 = 0;
+ } else {
+ i4 = 1;
+ i5 = 0;
+ while (1) {
+ i5 = (_luaL_checkunsigned(i1, i4) | 0) ^ i5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ _lua_pushunsigned(i1, i5);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_assert(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((_lua_toboolean(i1, 1) | 0) == 0) {
+ HEAP32[i3 >> 2] = _luaL_optlstring(i1, 2, 10216, 0) | 0;
+ i3 = _luaL_error(i1, 10208, i3) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ i3 = _lua_gettop(i1) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _b_or(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ if ((i3 | 0) < 1) {
+ i5 = 0;
+ } else {
+ i4 = 1;
+ i5 = 0;
+ while (1) {
+ i5 = _luaL_checkunsigned(i1, i4) | 0 | i5;
+ if ((i4 | 0) == (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ _lua_pushunsigned(i1, i5);
+ STACKTOP = i2;
+ return 1;
+}
+function _io_write(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ _lua_getfield(i1, -1001e3, 2800);
+ i3 = _lua_touserdata(i1, -1) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 2804;
+ _luaL_error(i1, 3424, i4) | 0;
+ }
+ i4 = _g_write(i1, HEAP32[i3 >> 2] | 0, 1) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _luaK_checkstack(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i3 = (HEAPU8[i1 + 48 | 0] | 0) + i3 | 0;
+ i4 = (HEAP32[i1 >> 2] | 0) + 78 | 0;
+ if ((i3 | 0) <= (HEAPU8[i4] | 0 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ if ((i3 | 0) > 249) {
+ _luaX_syntaxerror(HEAP32[i1 + 12 >> 2] | 0, 10536);
+ }
+ HEAP8[i4] = i3;
+ STACKTOP = i2;
+ return;
+}
+function _io_read(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ _lua_getfield(i1, -1001e3, 2776);
+ i3 = _lua_touserdata(i1, -1) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 2780;
+ _luaL_error(i1, 3424, i4) | 0;
+ }
+ i4 = _g_read(i1, HEAP32[i3 >> 2] | 0, 1) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _db_setupvalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 3);
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 6);
+ i3 = _lua_setupvalue(i1, 1, i3) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_insert(i1, -1);
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function ___uflow(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i1;
+ if ((HEAP32[i2 + 8 >> 2] | 0) == 0 ? (___toread(i2) | 0) != 0 : 0) {
+ i2 = -1;
+ } else {
+ if ((FUNCTION_TABLE_iiii[HEAP32[i2 + 32 >> 2] & 3](i2, i3, 1) | 0) == 1) {
+ i2 = HEAPU8[i3] | 0;
+ } else {
+ i2 = -1;
+ }
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _llvm_cttz_i32(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = HEAP8[cttz_i8 + (i1 & 255) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 | 0;
+ i2 = HEAP8[cttz_i8 + (i1 >> 8 & 255) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 + 8 | 0;
+ i2 = HEAP8[cttz_i8 + (i1 >> 16 & 255) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 + 16 | 0;
+ return (HEAP8[cttz_i8 + (i1 >>> 24) | 0] | 0) + 24 | 0;
+}
+function _llvm_ctlz_i32(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = HEAP8[ctlz_i8 + (i1 >>> 24) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 | 0;
+ i2 = HEAP8[ctlz_i8 + (i1 >> 16 & 255) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 + 8 | 0;
+ i2 = HEAP8[ctlz_i8 + (i1 >> 8 & 255) | 0] | 0;
+ if ((i2 | 0) < 8) return i2 + 16 | 0;
+ return (HEAP8[ctlz_i8 + (i1 & 255) | 0] | 0) + 24 | 0;
+}
+function _luaO_ceillog2(i2) {
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i4 = 0;
+ i1 = STACKTOP;
+ i2 = i2 + -1 | 0;
+ if (i2 >>> 0 > 255) {
+ i3 = 0;
+ while (1) {
+ i3 = i3 + 8 | 0;
+ i4 = i2 >>> 8;
+ if (i2 >>> 0 > 65535) {
+ i2 = i4;
+ } else {
+ i2 = i4;
+ break;
+ }
+ }
+ } else {
+ i3 = 0;
+ }
+ STACKTOP = i1;
+ return (HEAPU8[5208 + i2 | 0] | 0) + i3 | 0;
+}
+function _os_exit(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, 1) | 0) == 1) {
+ i3 = (_lua_toboolean(i1, 1) | 0) == 0 | 0;
+ } else {
+ i3 = _luaL_optinteger(i1, 1, 0) | 0;
+ }
+ if ((_lua_toboolean(i1, 2) | 0) != 0) {
+ _lua_close(i1);
+ }
+ if ((i1 | 0) == 0) {
+ STACKTOP = i2;
+ return 0;
+ } else {
+ _exit(i3 | 0);
+ }
+ return 0;
+}
+function _luaL_newmetatable(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_getfield(i1, -1001e3, i3);
+ if ((_lua_type(i1, -1) | 0) != 0) {
+ i3 = 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _lua_settop(i1, -2);
+ _lua_createtable(i1, 0, 0);
+ _lua_pushvalue(i1, -1);
+ _lua_setfield(i1, -1001e3, i3);
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _luaH_free(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i4 + 16 >> 2] | 0;
+ if ((i3 | 0) != 8016) {
+ _luaM_realloc_(i1, i3, 32 << (HEAPU8[i4 + 7 | 0] | 0), 0) | 0;
+ }
+ _luaM_realloc_(i1, HEAP32[i4 + 12 >> 2] | 0, HEAP32[i4 + 28 >> 2] << 4, 0) | 0;
+ _luaM_realloc_(i1, i4, 32, 0) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _luaO_int2fb(i3) {
+ i3 = i3 | 0;
+ var i1 = 0, i2 = 0, i4 = 0;
+ i1 = STACKTOP;
+ if (i3 >>> 0 < 8) {
+ STACKTOP = i1;
+ return i3 | 0;
+ }
+ if (i3 >>> 0 > 15) {
+ i2 = 1;
+ do {
+ i4 = i3 + 1 | 0;
+ i3 = i4 >>> 1;
+ i2 = i2 + 1 | 0;
+ } while (i4 >>> 0 > 31);
+ i2 = i2 << 3;
+ } else {
+ i2 = 8;
+ }
+ i4 = i2 | i3 + -8;
+ STACKTOP = i1;
+ return i4 | 0;
+}
+function _luaK_codek(i3, i4, i1) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i4 = i4 << 6;
+ if ((i1 | 0) < 262144) {
+ i4 = _luaK_code(i3, i4 | i1 << 14 | 1) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ i4 = _luaK_code(i3, i4 | 2) | 0;
+ _luaK_code(i3, i1 << 6 | 39) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _luaB_xpcall(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_gettop(i1) | 0;
+ if ((i3 | 0) <= 1) {
+ _luaL_argerror(i1, 2, 9616) | 0;
+ }
+ _lua_pushvalue(i1, 1);
+ _lua_copy(i1, 2, 1);
+ _lua_replace(i1, 2);
+ i3 = _finishpcall(i1, (_lua_pcallk(i1, i3 + -2 | 0, -1, 1, 0, 166) | 0) == 0 | 0) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _luaS_newudata(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if (i3 >>> 0 > 4294967269) {
+ _luaM_toobig(i1);
+ } else {
+ i1 = _luaC_newobj(i1, 7, i3 + 24 | 0, 0, 0) | 0;
+ HEAP32[i1 + 16 >> 2] = i3;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i1 + 12 >> 2] = i4;
+ STACKTOP = i2;
+ return i1 | 0;
+ }
+ return 0;
+}
+function _lua_dump(i1, i4, i5) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i1 + 8 >> 2] | 0;
+ if ((HEAP32[i3 + -8 >> 2] | 0) != 70) {
+ i5 = 1;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ i5 = _luaU_dump(i1, HEAP32[(HEAP32[i3 + -16 >> 2] | 0) + 12 >> 2] | 0, i4, i5, 0) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _luaS_eqlngstr(i2, i4) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = HEAP32[i2 + 12 >> 2] | 0;
+ if ((i2 | 0) != (i4 | 0)) {
+ if ((i3 | 0) == (HEAP32[i4 + 12 >> 2] | 0)) {
+ i2 = (_memcmp(i2 + 16 | 0, i4 + 16 | 0, i3) | 0) == 0;
+ } else {
+ i2 = 0;
+ }
+ } else {
+ i2 = 1;
+ }
+ STACKTOP = i1;
+ return i2 & 1 | 0;
+}
+function _luaC_barrier_(i4, i3, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i4 = HEAP32[i4 + 12 >> 2] | 0;
+ if ((HEAPU8[i4 + 61 | 0] | 0) < 2) {
+ _reallymarkobject(i4, i1);
+ STACKTOP = i2;
+ return;
+ } else {
+ i3 = i3 + 5 | 0;
+ HEAP8[i3] = HEAP8[i4 + 60 | 0] & 3 | HEAP8[i3] & 184;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _db_getupvalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 6);
+ i3 = _lua_getupvalue(i1, 1, i3) | 0;
+ if ((i3 | 0) == 0) {
+ i3 = 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ _lua_pushstring(i1, i3) | 0;
+ _lua_insert(i1, -2);
+ i3 = 2;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _os_execute(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i4 = _luaL_optlstring(i1, 1, 0, 0) | 0;
+ i3 = _system(i4 | 0) | 0;
+ if ((i4 | 0) == 0) {
+ _lua_pushboolean(i1, i3);
+ i4 = 1;
+ STACKTOP = i2;
+ return i4 | 0;
+ } else {
+ i4 = _luaL_execresult(i1, i3) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ return 0;
+}
+function _lua_pushfstring(i4, i5, i1) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ if ((HEAP32[(HEAP32[i4 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i4);
+ }
+ HEAP32[i3 >> 2] = i1;
+ i5 = _luaO_pushvfstring(i4, i5, i3) | 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _luaB_dofile(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_optlstring(i1, 1, 0, 0) | 0;
+ _lua_settop(i1, 1);
+ if ((_luaL_loadfilex(i1, i3, 0) | 0) == 0) {
+ _lua_callk(i1, 0, -1, 0, 164);
+ i3 = (_lua_gettop(i1) | 0) + -1 | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ _lua_error(i1) | 0;
+ }
+ return 0;
+}
+function _f_write(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i3 = HEAP32[i3 >> 2] | 0;
+ _lua_pushvalue(i1, 1);
+ i3 = _g_write(i1, i3, 2) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _lua_getctx(i3, i1) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i3 + 16 >> 2] | 0;
+ if ((HEAP8[i3 + 18 | 0] & 8) == 0) {
+ i3 = 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ if ((i1 | 0) != 0) {
+ HEAP32[i1 >> 2] = HEAP32[i3 + 24 >> 2];
+ }
+ i3 = HEAPU8[i3 + 37 | 0] | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _f_flush(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i3 = _luaL_fileresult(i1, (_fflush(HEAP32[i3 >> 2] | 0) | 0) == 0 | 0, 0) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _os_tmpname(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i3 = i2 + 4 | 0;
+ if ((_tmpnam(i3 | 0) | 0) == 0) {
+ i3 = _luaL_error(i1, 5824, i2) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+ } else {
+ _lua_pushstring(i1, i3) | 0;
+ i3 = 1;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ return 0;
+}
+function _traceback(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_tolstring(i1, 1, 0) | 0;
+ if ((i3 | 0) == 0) {
+ if ((_lua_type(i1, 1) | 0) >= 1 ? (_luaL_callmeta(i1, 1, 216) | 0) == 0 : 0) {
+ _lua_pushlstring(i1, 232, 18) | 0;
+ }
+ } else {
+ _luaL_traceback(i1, i1, i3, 1);
+ }
+ STACKTOP = i2;
+ return 1;
+}
+function _luaH_new(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _luaC_newobj(i1, 5, 32, 0, 0) | 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP8[i1 + 6 | 0] = -1;
+ HEAP32[i1 + 12 >> 2] = 0;
+ HEAP32[i1 + 28 >> 2] = 0;
+ HEAP32[i1 + 16 >> 2] = 8016;
+ HEAP8[i1 + 7 | 0] = 0;
+ HEAP32[i1 + 20 >> 2] = 8016;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaL_len(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2 + 4 | 0;
+ _lua_len(i1, i3);
+ i3 = _lua_tointegerx(i1, -1, i4) | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 1352, i2) | 0;
+ }
+ _lua_settop(i1, -2);
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _getS(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0, i5 = 0;
+ i3 = STACKTOP;
+ i5 = i2 + 4 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i3;
+ return i5 | 0;
+ }
+ HEAP32[i1 >> 2] = i4;
+ HEAP32[i5 >> 2] = 0;
+ i5 = HEAP32[i2 >> 2] | 0;
+ STACKTOP = i3;
+ return i5 | 0;
+}
+function _luaC_runtilstate(i1, i4) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = (HEAP32[i1 + 12 >> 2] | 0) + 61 | 0;
+ if ((1 << (HEAPU8[i3] | 0) & i4 | 0) != 0) {
+ STACKTOP = i2;
+ return;
+ }
+ do {
+ _singlestep(i1) | 0;
+ } while ((1 << (HEAPU8[i3] | 0) & i4 | 0) == 0);
+ STACKTOP = i2;
+ return;
+}
+function _luaX_init(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ i3 = 0;
+ do {
+ i4 = _luaS_new(i1, HEAP32[12096 + (i3 << 2) >> 2] | 0) | 0;
+ i5 = i4 + 5 | 0;
+ HEAP8[i5] = HEAPU8[i5] | 0 | 32;
+ i3 = i3 + 1 | 0;
+ HEAP8[i4 + 6 | 0] = i3;
+ } while ((i3 | 0) != 22);
+ STACKTOP = i2;
+ return;
+}
+function _luaK_indexed(i5, i1, i4) {
+ i5 = i5 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i3 = 0;
+ i3 = STACKTOP;
+ i2 = i1 + 8 | 0;
+ HEAP8[i2 + 2 | 0] = HEAP32[i2 >> 2];
+ HEAP16[i2 >> 1] = _luaK_exp2RK(i5, i4) | 0;
+ HEAP8[i2 + 3 | 0] = (HEAP32[i1 >> 2] | 0) == 8 ? 8 : 7;
+ HEAP32[i1 >> 2] = 9;
+ STACKTOP = i3;
+ return;
+}
+function _db_setuservalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, 1) | 0) == 2) {
+ _luaL_argerror(i1, 1, 11680) | 0;
+ }
+ _luaL_checktype(i1, 1, 7);
+ if ((_lua_type(i1, 2) | 0) >= 1) {
+ _luaL_checktype(i1, 2, 5);
+ }
+ _lua_settop(i1, 2);
+ _lua_setuservalue(i1, 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _ll_seeall(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ if ((_lua_getmetatable(i1, 1) | 0) == 0) {
+ _lua_createtable(i1, 0, 1);
+ _lua_pushvalue(i1, -1);
+ _lua_setmetatable(i1, 1) | 0;
+ }
+ _lua_rawgeti(i1, -1001e3, 2);
+ _lua_setfield(i1, -2, 5168);
+ STACKTOP = i2;
+ return 0;
+}
+function _luaL_loadbufferx(i3, i5, i4, i2, i1) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i6 = 0, i7 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i7 = i6;
+ HEAP32[i7 >> 2] = i5;
+ HEAP32[i7 + 4 >> 2] = i4;
+ i5 = _lua_load(i3, 2, i7, i2, i1) | 0;
+ STACKTOP = i6;
+ return i5 | 0;
+}
+function _luaT_gettm(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i4 = _luaH_getstr(i1, i4) | 0;
+ if ((HEAP32[i4 + 8 >> 2] | 0) != 0) {
+ STACKTOP = i2;
+ return i4 | 0;
+ }
+ i4 = i1 + 6 | 0;
+ HEAP8[i4] = HEAPU8[i4] | 0 | 1 << i3;
+ i4 = 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _luaL_pushresult(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i1 + 12 >> 2] | 0;
+ _lua_pushlstring(i3, HEAP32[i1 >> 2] | 0, HEAP32[i1 + 8 >> 2] | 0) | 0;
+ if ((HEAP32[i1 >> 2] | 0) == (i1 + 16 | 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ _lua_remove(i3, -2);
+ STACKTOP = i2;
+ return;
+}
+function _resume_error(i1, i3, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ var i4 = 0;
+ i4 = i1 + 8 | 0;
+ HEAP32[i4 >> 2] = i2;
+ i3 = _luaS_new(i1, i3) | 0;
+ HEAP32[i2 >> 2] = i3;
+ HEAP32[i2 + 8 >> 2] = HEAPU8[i3 + 4 | 0] | 0 | 64;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + 16;
+ _luaD_throw(i1, -1);
+}
+function _lua_absindex(i3, i1) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((i1 + 1000999 | 0) >>> 0 > 1000999) {
+ i3 = i1;
+ STACKTOP = i2;
+ return i3 | 0;
+ }
+ i3 = ((HEAP32[i3 + 8 >> 2] | 0) - (HEAP32[HEAP32[i3 + 16 >> 2] >> 2] | 0) >> 4) + i1 | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function ___uremdi3(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i5 = 0, i6 = 0;
+ i6 = STACKTOP;
+ STACKTOP = STACKTOP + 8 | 0;
+ i5 = i6 | 0;
+ ___udivmoddi4(i4, i3, i2, i1, i5) | 0;
+ STACKTOP = i6;
+ return (tempRet0 = HEAP32[i5 + 4 >> 2] | 0, HEAP32[i5 >> 2] | 0) | 0;
+}
+function _f_read(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = _luaL_checkudata(i1, 1, 2832) | 0;
+ if ((HEAP32[i3 + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ i3 = _g_read(i1, HEAP32[i3 >> 2] | 0, 2) | 0;
+ STACKTOP = i2;
+ return i3 | 0;
+}
+function _sort(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ i3 = _luaL_len(i1, 1) | 0;
+ _luaL_checkstack(i1, 40, 8208);
+ if ((_lua_type(i1, 2) | 0) >= 1) {
+ _luaL_checktype(i1, 2, 6);
+ }
+ _lua_settop(i1, 2);
+ _auxsort(i1, 1, i3);
+ STACKTOP = i2;
+ return 0;
+}
+function _luaB_error(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = _luaL_optinteger(i1, 2, 1) | 0;
+ _lua_settop(i1, 1);
+ if (!((_lua_isstring(i1, 1) | 0) != 0 & (i2 | 0) > 0)) {
+ _lua_error(i1) | 0;
+ }
+ _luaL_where(i1, i2);
+ _lua_pushvalue(i1, 1);
+ _lua_concat(i1, 2);
+ _lua_error(i1) | 0;
+ return 0;
+}
+function _error(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i3 >> 2] = HEAP32[i1 + 12 >> 2];
+ HEAP32[i3 + 4 >> 2] = i2;
+ _luaO_pushfstring(i4, 8840, i3) | 0;
+ _luaD_throw(HEAP32[i1 >> 2] | 0, 3);
+}
+function _ipairsaux(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ _luaL_checktype(i1, 1, 5);
+ i3 = i3 + 1 | 0;
+ _lua_pushinteger(i1, i3);
+ _lua_rawgeti(i1, 1, i3);
+ i1 = (_lua_type(i1, -1) | 0) == 0;
+ STACKTOP = i2;
+ return (i1 ? 1 : 2) | 0;
+}
+function _panic(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ i3 = HEAP32[_stderr >> 2] | 0;
+ HEAP32[i4 >> 2] = _lua_tolstring(i1, -1, 0) | 0;
+ _fprintf(i3 | 0, 1656, i4 | 0) | 0;
+ _fflush(i3 | 0) | 0;
+ STACKTOP = i2;
+ return 0;
+}
+function _testSetjmp(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0;
+ while ((i3 | 0) < 20) {
+ i4 = HEAP32[i2 + (i3 << 2) >> 2] | 0;
+ if ((i4 | 0) == 0) break;
+ if ((i4 | 0) == (i1 | 0)) {
+ return HEAP32[i2 + ((i3 << 2) + 4) >> 2] | 0;
+ }
+ i3 = i3 + 2 | 0;
+ }
+ return 0;
+}
+function _luaopen_math(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 28);
+ _luaL_setfuncs(i1, 3576, 0);
+ _lua_pushnumber(i1, 3.141592653589793);
+ _lua_setfield(i1, -2, 3808);
+ _lua_pushnumber(i1, inf);
+ _lua_setfield(i1, -2, 3816);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaopen_base(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_rawgeti(i1, -1001e3, 2);
+ _lua_rawgeti(i1, -1001e3, 2);
+ _lua_setfield(i1, -2, 9144);
+ _luaL_setfuncs(i1, 9152, 0);
+ _lua_pushlstring(i1, 9344, 7) | 0;
+ _lua_setfield(i1, -2, 9352);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaE_extendCI(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i3 = STACKTOP;
+ i2 = _luaM_realloc_(i1, 0, 0, 40) | 0;
+ i1 = i1 + 16 | 0;
+ HEAP32[(HEAP32[i1 >> 2] | 0) + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = HEAP32[i1 >> 2];
+ HEAP32[i2 + 12 >> 2] = 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _luaB_getmetatable(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ if ((_lua_getmetatable(i1, 1) | 0) == 0) {
+ _lua_pushnil(i1);
+ STACKTOP = i2;
+ return 1;
+ } else {
+ _luaL_getmetafield(i1, 1, 9704) | 0;
+ STACKTOP = i2;
+ return 1;
+ }
+ return 0;
+}
+function _lua_pushunsigned(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var d3 = 0.0;
+ if ((i2 | 0) > -1) {
+ d3 = +(i2 | 0);
+ } else {
+ d3 = +(i2 >>> 0);
+ }
+ i2 = i1 + 8 | 0;
+ i1 = HEAP32[i2 >> 2] | 0;
+ HEAPF64[i1 >> 3] = d3;
+ HEAP32[i1 + 8 >> 2] = 3;
+ HEAP32[i2 >> 2] = i1 + 16;
+ return;
+}
+function _lua_pushthread(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = i1 + 8 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i3 >> 2] = i1;
+ HEAP32[i3 + 8 >> 2] = 72;
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + 16;
+ return (HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 172 >> 2] | 0) == (i1 | 0) | 0;
+}
+function _gctm(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_len(i1, 1) | 0;
+ if ((i3 | 0) <= 0) {
+ STACKTOP = i2;
+ return 0;
+ }
+ do {
+ _lua_rawgeti(i1, 1, i3);
+ _lua_settop(i1, -2);
+ i3 = i3 + -1 | 0;
+ } while ((i3 | 0) > 0);
+ STACKTOP = i2;
+ return 0;
+}
+function ___muldi3(i4, i2, i3, i1) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0, i6 = 0;
+ i5 = i4;
+ i6 = i3;
+ i4 = ___muldsi3(i5, i6) | 0;
+ i3 = tempRet0;
+ return (tempRet0 = (Math_imul(i2, i6) | 0) + (Math_imul(i1, i5) | 0) + i3 | i3 & 0, i4 | 0 | 0) | 0;
+}
+function _luaH_resizearray(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i5 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[i3 + 16 >> 2] | 0) == 8016) {
+ i5 = 0;
+ } else {
+ i5 = 1 << (HEAPU8[i3 + 7 | 0] | 0);
+ }
+ _luaH_resize(i1, i3, i4, i5);
+ STACKTOP = i2;
+ return;
+}
+function _luaK_stringK(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i3;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i4 + 8 >> 2] = HEAPU8[i2 + 4 | 0] | 0 | 64;
+ i2 = _addk(i1, i4, i4) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _math_modf(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i2;
+ d3 = +_modf(+(+_luaL_checknumber(i1, 1)), i4 | 0);
+ _lua_pushnumber(i1, +HEAPF64[i4 >> 3]);
+ _lua_pushnumber(i1, d3);
+ STACKTOP = i2;
+ return 2;
+}
+function _os_setlocale(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_optlstring(i1, 1, 0, 0) | 0;
+ _lua_pushstring(i1, _setlocale(HEAP32[5960 + ((_luaL_checkoption(i1, 2, 6016, 5984) | 0) << 2) >> 2] | 0, i3 | 0) | 0) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_pcall(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ _lua_pushnil(i1);
+ _lua_insert(i1, 1);
+ i1 = _finishpcall(i1, (_lua_pcallk(i1, (_lua_gettop(i1) | 0) + -2 | 0, -1, 0, 0, 166) | 0) == 0 | 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _error_expected(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0, i4 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = HEAP32[i1 + 52 >> 2] | 0;
+ HEAP32[i3 >> 2] = _luaX_token2str(i1, i2) | 0;
+ _luaX_syntaxerror(i1, _luaO_pushfstring(i4, 6328, i3) | 0);
+}
+function _lua_pushvfstring(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 12 >> 2] | 0) > 0) {
+ _luaC_step(i1);
+ }
+ i4 = _luaO_pushvfstring(i1, i3, i4) | 0;
+ STACKTOP = i2;
+ return i4 | 0;
+}
+function _db_setmetatable(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _lua_type(i1, 2) | 0;
+ if (!((i3 | 0) == 0 | (i3 | 0) == 5)) {
+ _luaL_argerror(i1, 2, 11536) | 0;
+ }
+ _lua_settop(i1, 2);
+ _lua_setmetatable(i1, 1) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function _b_rrot(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i3 = 0 - (_luaL_checkinteger(i1, 2) | 0) | 0;
+ i4 = _luaL_checkunsigned(i1, 1) | 0;
+ i3 = i3 & 31;
+ _lua_pushunsigned(i1, i4 >>> (32 - i3 | 0) | i4 << i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaC_step(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = HEAP32[i1 + 12 >> 2] | 0;
+ if ((HEAP8[i3 + 63 | 0] | 0) == 0) {
+ _luaE_setdebt(i3, -1600);
+ STACKTOP = i2;
+ return;
+ } else {
+ _luaC_forcestep(i1);
+ STACKTOP = i2;
+ return;
+ }
+}
+function _math_frexp(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ _lua_pushnumber(i1, +_frexp(+(+_luaL_checknumber(i1, 1)), i3 | 0));
+ _lua_pushinteger(i1, HEAP32[i3 >> 2] | 0);
+ STACKTOP = i2;
+ return 2;
+}
+function _luaO_pushfstring(i2, i1, i3) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i4 = 0, i5 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i5 = i4;
+ HEAP32[i5 >> 2] = i3;
+ i3 = _luaO_pushvfstring(i2, i1, i5) | 0;
+ STACKTOP = i4;
+ return i3 | 0;
+}
+function _luaO_hexavalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((HEAP8[i1 + 10913 | 0] & 2) == 0) {
+ i1 = (i1 | 32) + -87 | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+ } else {
+ i1 = i1 + -48 | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+ }
+ return 0;
+}
+function _b_lrot(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checkinteger(i1, 2) | 0;
+ i4 = _luaL_checkunsigned(i1, 1) | 0;
+ i3 = i3 & 31;
+ _lua_pushunsigned(i1, i4 >>> (32 - i3 | 0) | i4 << i3);
+ STACKTOP = i2;
+ return 1;
+}
+function _f_lines(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ if ((HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] | 0) == 0) {
+ _luaL_error(i1, 3080, i2) | 0;
+ }
+ _aux_lines(i1, 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaC_barrierback_(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i2 = HEAP32[i2 + 12 >> 2] | 0;
+ i3 = i1 + 5 | 0;
+ HEAP8[i3] = HEAP8[i3] & 251;
+ i2 = i2 + 88 | 0;
+ HEAP32[i1 + 24 >> 2] = HEAP32[i2 >> 2];
+ HEAP32[i2 >> 2] = i1;
+ return;
+}
+function _os_rename(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ i1 = _luaL_fileresult(i1, (_rename(i3 | 0, _luaL_checklstring(i1, 2, 0) | 0) | 0) == 0 | 0, 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _bitshift64Ashr(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ if ((i1 | 0) < 32) {
+ tempRet0 = i2 >> i1;
+ return i3 >>> i1 | (i2 & (1 << i1) - 1) << 32 - i1;
+ }
+ tempRet0 = (i2 | 0) < 0 ? -1 : 0;
+ return i2 >> i1 - 32 | 0;
+}
+function _luaB_cowrap(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 6);
+ i3 = _lua_newthread(i1) | 0;
+ _lua_pushvalue(i1, 1);
+ _lua_xmove(i1, i3, 1);
+ _lua_pushcclosure(i1, 167, 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _gmatch(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checklstring(i1, 1, 0) | 0;
+ _luaL_checklstring(i1, 2, 0) | 0;
+ _lua_settop(i1, 2);
+ _lua_pushinteger(i1, 0);
+ _lua_pushcclosure(i1, 163, 3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_next(i2) {
+ i2 = i2 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ _luaL_checktype(i2, 1, 5);
+ _lua_settop(i2, 2);
+ if ((_lua_next(i2, 1) | 0) == 0) {
+ _lua_pushnil(i2);
+ i2 = 1;
+ } else {
+ i2 = 2;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _luaK_codeABC(i5, i3, i4, i2, i1) {
+ i5 = i5 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i6 = 0;
+ i6 = STACKTOP;
+ i5 = _luaK_code(i5, i4 << 6 | i3 | i2 << 23 | i1 << 14) | 0;
+ STACKTOP = i6;
+ return i5 | 0;
+}
+function _luaH_set(i2, i4, i5) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0;
+ i1 = STACKTOP;
+ i3 = _luaH_get(i4, i5) | 0;
+ if ((i3 | 0) == 5192) {
+ i3 = _luaH_newkey(i2, i4, i5) | 0;
+ }
+ STACKTOP = i1;
+ return i3 | 0;
+}
+function _luaZ_init(i4, i1, i3, i2) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ HEAP32[i1 + 16 >> 2] = i4;
+ HEAP32[i1 + 8 >> 2] = i3;
+ HEAP32[i1 + 12 >> 2] = i2;
+ HEAP32[i1 >> 2] = 0;
+ HEAP32[i1 + 4 >> 2] = 0;
+ return;
+}
+function _lua_pushlightuserdata(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i2 = i2 + 8 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i3 >> 2] = i1;
+ HEAP32[i3 + 8 >> 2] = 2;
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + 16;
+ return;
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function _bitshift64Shl(i2, i3, i1) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ if ((i1 | 0) < 32) {
+ tempRet0 = i3 << i1 | (i2 & (1 << i1) - 1 << 32 - i1) >>> 32 - i1;
+ return i2 << i1;
+ }
+ tempRet0 = i2 << i1 - 32;
+ return 0;
+}
+function _luaB_rawlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if (((_lua_type(i1, 1) | 0) & -2 | 0) != 4) {
+ _luaL_argerror(i1, 1, 9784) | 0;
+ }
+ _lua_pushinteger(i1, _lua_rawlen(i1, 1) | 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _l_alloc(i3, i1, i4, i2) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i3 = STACKTOP;
+ if ((i2 | 0) == 0) {
+ _free(i1);
+ i1 = 0;
+ } else {
+ i1 = _realloc(i1, i2) | 0;
+ }
+ STACKTOP = i3;
+ return i1 | 0;
+}
+function _bitshift64Lshr(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ if ((i1 | 0) < 32) {
+ tempRet0 = i2 >>> i1;
+ return i3 >>> i1 | (i2 & (1 << i1) - 1) << 32 - i1;
+ }
+ tempRet0 = 0;
+ return i2 >>> i1 - 32 | 0;
+}
+function _luaG_aritherror(i3, i1, i2) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i4 = 0;
+ i4 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = (_luaV_tonumber(i1, i4) | 0) == 0;
+ _luaG_typeerror(i3, i4 ? i1 : i2, 1928);
+}
+function _str_len(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i3 = i2;
+ _luaL_checklstring(i1, 1, i3) | 0;
+ _lua_pushinteger(i1, HEAP32[i3 >> 2] | 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaL_optinteger(i3, i4, i2) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0;
+ i1 = STACKTOP;
+ if ((_lua_type(i3, i4) | 0) >= 1) {
+ i2 = _luaL_checkinteger(i3, i4) | 0;
+ }
+ STACKTOP = i1;
+ return i2 | 0;
+}
+function _os_difftime(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = ~~+_luaL_checknumber(i1, 1);
+ _lua_pushnumber(i1, +_difftime(i3 | 0, ~~+_luaL_optnumber(i1, 2, 0.0) | 0));
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_pushboolean(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i2 = i2 + 8 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i3 >> 2] = (i1 | 0) != 0;
+ HEAP32[i3 + 8 >> 2] = 1;
+ HEAP32[i2 >> 2] = i3 + 16;
+ return;
+}
+function _os_remove(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = _luaL_checklstring(i1, 1, 0) | 0;
+ i1 = _luaL_fileresult(i1, (_remove(i3 | 0) | 0) == 0 | 0, i3) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaopen_table(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 7);
+ _luaL_setfuncs(i1, 8088, 0);
+ _lua_getfield(i1, -1, 8152);
+ _lua_setglobal(i1, 8152);
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_pushinteger(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i2 = i2 + 8 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ HEAPF64[i3 >> 3] = +(i1 | 0);
+ HEAP32[i3 + 8 >> 2] = 3;
+ HEAP32[i2 >> 2] = i3 + 16;
+ return;
+}
+function _luaB_rawset(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ _luaL_checkany(i1, 2);
+ _luaL_checkany(i1, 3);
+ _lua_settop(i1, 3);
+ _lua_rawset(i1, 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaE_setdebt(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = i2 + 12 | 0;
+ i2 = i2 + 8 | 0;
+ HEAP32[i2 >> 2] = (HEAP32[i3 >> 2] | 0) - i1 + (HEAP32[i2 >> 2] | 0);
+ HEAP32[i3 >> 2] = i1;
+ return;
+}
+function _luaB_cocreate(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 6);
+ i3 = _lua_newthread(i1) | 0;
+ _lua_pushvalue(i1, 1);
+ _lua_xmove(i1, i3, 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _io_noclose(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) + 4 >> 2] = 154;
+ _lua_pushnil(i1);
+ _lua_pushlstring(i1, 2840, 26) | 0;
+ STACKTOP = i2;
+ return 2;
+}
+function _io_fclose(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _luaL_fileresult(i1, (_fclose(HEAP32[(_luaL_checkudata(i1, 1, 2832) | 0) >> 2] | 0) | 0) == 0 | 0, 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaL_optnumber(i3, i4, d2) {
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ d2 = +d2;
+ var i1 = 0;
+ i1 = STACKTOP;
+ if ((_lua_type(i3, i4) | 0) >= 1) {
+ d2 = +_luaL_checknumber(i3, i4);
+ }
+ STACKTOP = i1;
+ return +d2;
+}
+function _math_atan2(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0;
+ i2 = STACKTOP;
+ d3 = +_luaL_checknumber(i1, 1);
+ _lua_pushnumber(i1, +Math_atan2(+d3, +(+_luaL_checknumber(i1, 2))));
+ STACKTOP = i2;
+ return 1;
+}
+function _luaK_codeABx(i4, i2, i3, i1) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ i4 = _luaK_code(i4, i3 << 6 | i2 | i1 << 14) | 0;
+ STACKTOP = i5;
+ return i4 | 0;
+}
+function _luaF_newCclosure(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i2 = _luaC_newobj(i2, 38, (i1 << 4) + 16 | 0, 0, 0) | 0;
+ HEAP8[i2 + 6 | 0] = i1;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _math_pow(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0;
+ i2 = STACKTOP;
+ d3 = +_luaL_checknumber(i1, 1);
+ _lua_pushnumber(i1, +Math_pow(+d3, +(+_luaL_checknumber(i1, 2))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_ldexp(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0;
+ i2 = STACKTOP;
+ d3 = +_luaL_checknumber(i1, 1);
+ _lua_pushnumber(i1, +_ldexp(d3, _luaL_checkinteger(i1, 2) | 0));
+ STACKTOP = i2;
+ return 1;
+}
+function _luaF_newupval(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _luaC_newobj(i1, 10, 32, 0, 0) | 0;
+ HEAP32[i1 + 8 >> 2] = i1 + 16;
+ HEAP32[i1 + 24 >> 2] = 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _lua_pushnumber(i2, d1) {
+ i2 = i2 | 0;
+ d1 = +d1;
+ var i3 = 0;
+ i2 = i2 + 8 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ HEAPF64[i3 >> 3] = d1;
+ HEAP32[i3 + 8 >> 2] = 3;
+ HEAP32[i2 >> 2] = i3 + 16;
+ return;
+}
+function _math_fmod(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, d3 = 0.0;
+ i2 = STACKTOP;
+ d3 = +_luaL_checknumber(i1, 1);
+ _lua_pushnumber(i1, +_fmod(+d3, +(+_luaL_checknumber(i1, 2))));
+ STACKTOP = i2;
+ return 1;
+}
+function _luaG_concaterror(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ i4 = HEAP32[i2 + 8 >> 2] | 0;
+ _luaG_typeerror(i3, (i4 & 15 | 0) == 4 | (i4 | 0) == 3 ? i1 : i2, 1912);
+}
+function _luaB_rawequal(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ _luaL_checkany(i1, 2);
+ _lua_pushboolean(i1, _lua_rawequal(i1, 1, 2) | 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _db_getuservalue(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, 1) | 0) == 7) {
+ _lua_getuservalue(i1, 1);
+ } else {
+ _lua_pushnil(i1);
+ }
+ STACKTOP = i2;
+ return 1;
+}
+function _strchr(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i2 = ___strchrnul(i2, i1) | 0;
+ STACKTOP = i3;
+ return ((HEAP8[i2] | 0) == (i1 & 255) << 24 >> 24 ? i2 : 0) | 0;
+}
+function runPostSets() {}
+function _rand_r(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = (Math_imul(HEAP32[i1 >> 2] | 0, 31010991) | 0) + 1735287159 & 2147483647;
+ HEAP32[i1 >> 2] = i2;
+ return i2 | 0;
+}
+function _luaL_checkany(i1, i3) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ if ((_lua_type(i1, i3) | 0) == -1) {
+ _luaL_argerror(i1, i3, 1256) | 0;
+ }
+ STACKTOP = i2;
+ return;
+}
+function _i64Subtract(i2, i4, i1, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 - i3 - (i1 >>> 0 > i2 >>> 0 | 0) >>> 0;
+ return (tempRet0 = i4, i2 - i1 >>> 0 | 0) | 0;
+}
+function _db_getmetatable(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ if ((_lua_getmetatable(i1, 1) | 0) == 0) {
+ _lua_pushnil(i1);
+ }
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_rawget(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checktype(i1, 1, 5);
+ _luaL_checkany(i1, 2);
+ _lua_settop(i1, 2);
+ _lua_rawget(i1, 1);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_type(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ _lua_pushstring(i1, _lua_typename(i1, _lua_type(i1, 1) | 0) | 0) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function dynCall_iiiii(i5, i4, i3, i2, i1) {
+ i5 = i5 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iiiii[i5 & 3](i4 | 0, i3 | 0, i2 | 0, i1 | 0) | 0;
+}
+function _lstop(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ _lua_sethook(i1, 0, 0, 0) | 0;
+ _luaL_error(i1, 200, i2) | 0;
+ STACKTOP = i2;
+ return;
+}
+function _i64Add(i1, i3, i4, i2) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i4 = i1 + i4 >>> 0;
+ return (tempRet0 = i3 + i2 + (i4 >>> 0 < i1 >>> 0 | 0) >>> 0, i4 | 0) | 0;
+}
+function _luaK_ret(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ i4 = STACKTOP;
+ _luaK_code(i3, i2 << 6 | (i1 << 23) + 8388608 | 31) | 0;
+ STACKTOP = i4;
+ return;
+}
+function _strpbrk(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i1 = i2 + (_strcspn(i2, i1) | 0) | 0;
+ STACKTOP = i3;
+ return ((HEAP8[i1] | 0) != 0 ? i1 : 0) | 0;
+}
+function _luaL_setmetatable(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ _lua_getfield(i1, -1001e3, i2);
+ _lua_setmetatable(i1, -2) | 0;
+ STACKTOP = i3;
+ return;
+}
+function _lua_atpanic(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = (HEAP32[i2 + 12 >> 2] | 0) + 168 | 0;
+ i2 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i3 >> 2] = i1;
+ return i2 | 0;
+}
+function _luaL_newstate() {
+ var i1 = 0, i2 = 0;
+ i2 = STACKTOP;
+ i1 = _lua_newstate(1, 0) | 0;
+ if ((i1 | 0) != 0) {
+ _lua_atpanic(i1, 143) | 0;
+ }
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaL_buffinit(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ HEAP32[i1 + 12 >> 2] = i2;
+ HEAP32[i1 >> 2] = i1 + 16;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i1 + 4 >> 2] = 1024;
+ return;
+}
+function _strrchr(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i2 = ___memrchr(i1, i2, (_strlen(i1 | 0) | 0) + 1 | 0) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _luaK_fixline(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ HEAP32[(HEAP32[(HEAP32[i1 >> 2] | 0) + 20 >> 2] | 0) + ((HEAP32[i1 + 20 >> 2] | 0) + -1 << 2) >> 2] = i2;
+ return;
+}
+function _luaX_lookahead(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i3 = STACKTOP;
+ i2 = _llex(i1, i1 + 40 | 0) | 0;
+ HEAP32[i1 + 32 >> 2] = i2;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _f_call(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ _luaD_call(i2, HEAP32[i1 >> 2] | 0, HEAP32[i1 + 4 >> 2] | 0, 0);
+ STACKTOP = i3;
+ return;
+}
+function _io_pclose(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkudata(i1, 1, 2832) | 0;
+ i1 = _luaL_execresult(i1, -1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaS_new(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i2 = _luaS_newlstr(i2, i1, _strlen(i1 | 0) | 0) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _os_getenv(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushstring(i1, _getenv(_luaL_checklstring(i1, 1, 0) | 0) | 0) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function _math_rad(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_luaL_checknumber(i1, 1) * .017453292519943295);
+ STACKTOP = i2;
+ return 1;
+}
+function _math_deg(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_luaL_checknumber(i1, 1) / .017453292519943295);
+ STACKTOP = i2;
+ return 1;
+}
+function _writer(i4, i2, i1, i3) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = STACKTOP;
+ _luaL_addlstring(i3, i2, i1);
+ STACKTOP = i4;
+ return 0;
+}
+function _luaL_addstring(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ _luaL_addlstring(i2, i1, _strlen(i1 | 0) | 0);
+ STACKTOP = i3;
+ return;
+}
+function _pcallcont(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _finishpcall(i1, (_lua_getctx(i1, 0) | 0) == 1 | 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaopen_coroutine(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 6);
+ _luaL_setfuncs(i1, 10656, 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_version(i1) {
+ i1 = i1 | 0;
+ if ((i1 | 0) == 0) {
+ i1 = 920;
+ } else {
+ i1 = HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 176 >> 2] | 0;
+ }
+ return i1 | 0;
+}
+function _lua_pushnil(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i1 = i1 + 8 | 0;
+ i2 = HEAP32[i1 >> 2] | 0;
+ HEAP32[i2 + 8 >> 2] = 0;
+ HEAP32[i1 >> 2] = i2 + 16;
+ return;
+}
+function _math_floor(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_floor(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _laction(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _signal(i1 | 0, 0) | 0;
+ _lua_sethook(HEAP32[48] | 0, 1, 11, 1) | 0;
+ STACKTOP = i2;
+ return;
+}
+function dynCall_iiii(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iiii[i4 & 3](i3 | 0, i2 | 0, i1 | 0) | 0;
+}
+function _luaopen_debug(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 16);
+ _luaL_setfuncs(i1, 11176, 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaopen_bit32(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 12);
+ _luaL_setfuncs(i1, 10240, 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _math_sqrt(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_sqrt(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_ceil(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_ceil(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_atan(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_atan(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_asin(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_asin(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_acos(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_acos(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _lua_close(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _close_state(HEAP32[(HEAP32[i1 + 12 >> 2] | 0) + 172 >> 2] | 0);
+ STACKTOP = i2;
+ return;
+}
+function _dothecall(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i2 = STACKTOP;
+ _luaD_call(i1, (HEAP32[i1 + 8 >> 2] | 0) + -32 | 0, 0, 0);
+ STACKTOP = i2;
+ return;
+}
+function _math_tan(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_tan(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_sin(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_sin(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_log10(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_log10(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_exp(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_exp(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_cos(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_cos(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_abs(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +Math_abs(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_randomseed(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _srand(_luaL_checkunsigned(i1, 1) | 0);
+ _rand() | 0;
+ STACKTOP = i2;
+ return 0;
+}
+function _luaopen_os(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_createtable(i1, 0, 11);
+ _luaL_setfuncs(i1, 5624, 0);
+ STACKTOP = i2;
+ return 1;
+}
+function _math_tanh(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_tanh(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_sinh(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_sinh(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _math_cosh(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +_cosh(+(+_luaL_checknumber(i1, 1))));
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_yield(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _lua_yieldk(i1, _lua_gettop(i1) | 0, 0, 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaB_tostring(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _luaL_checkany(i1, 1);
+ _luaL_tolstring(i1, 1, 0) | 0;
+ STACKTOP = i2;
+ return 1;
+}
+function _growstack(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ _luaD_growstack(i2, HEAP32[i1 >> 2] | 0);
+ STACKTOP = i3;
+ return;
+}
+function ___udivdi3(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i4 = ___udivmoddi4(i4, i3, i2, i1, 0) | 0;
+ return i4 | 0;
+}
+function _b_not(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushunsigned(i1, ~(_luaL_checkunsigned(i1, 1) | 0));
+ STACKTOP = i2;
+ return 1;
+}
+function _luaO_fb2int(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1 >>> 3 & 31;
+ if ((i2 | 0) != 0) {
+ i1 = (i1 & 7 | 8) << i2 + -1;
+ }
+ return i1 | 0;
+}
+function _luaB_corunning(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushboolean(i1, _lua_pushthread(i1) | 0);
+ STACKTOP = i2;
+ return 2;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function _strcoll(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ i2 = _strcmp(i2, i1) | 0;
+ STACKTOP = i3;
+ return i2 | 0;
+}
+function _os_clock(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushnumber(i1, +(_clock() | 0) / 1.0e6);
+ STACKTOP = i2;
+ return 1;
+}
+function _dofilecont(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = (_lua_gettop(i1) | 0) + -1 | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _scalbnl(d2, i1) {
+ d2 = +d2;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ d2 = +_scalbn(d2, i1);
+ STACKTOP = i3;
+ return +d2;
+}
+function _tolower(i1) {
+ i1 = i1 | 0;
+ if ((i1 | 0) < 65) return i1 | 0;
+ if ((i1 | 0) > 90) return i1 | 0;
+ return i1 - 65 + 97 | 0;
+}
+function _lua_gettop(i1) {
+ i1 = i1 | 0;
+ return (HEAP32[i1 + 8 >> 2] | 0) - ((HEAP32[HEAP32[i1 + 16 >> 2] >> 2] | 0) + 16) >> 4 | 0;
+}
+function dynCall_iii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iii[i3 & 1](i2 | 0, i1 | 0) | 0;
+}
+function _str_match(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _str_find_aux(i1, 0) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _luaM_toobig(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ _luaG_runerror(i1, 4144, i2);
+}
+function _luaK_getlabel(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = HEAP32[i1 + 20 >> 2] | 0;
+ HEAP32[i1 + 24 >> 2] = i2;
+ return i2 | 0;
+}
+function _ldexp(d2, i1) {
+ d2 = +d2;
+ i1 = i1 | 0;
+ var i3 = 0;
+ i3 = STACKTOP;
+ d2 = +_scalbn(d2, i1);
+ STACKTOP = i3;
+ return +d2;
+}
+function _str_find(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ i1 = _str_find_aux(i1, 1) | 0;
+ STACKTOP = i2;
+ return i1 | 0;
+}
+function _db_getregistry(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _lua_pushvalue(i1, -1001e3);
+ STACKTOP = i2;
+ return 1;
+}
+function _luaB_ipairs(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _pairsmeta(i1, 9960, 1, 165);
+ STACKTOP = i2;
+ return 3;
+}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function _luaB_pairs(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _pairsmeta(i1, 9864, 0, 93);
+ STACKTOP = i2;
+ return 3;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function _io_output(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _g_iofile(i1, 2800, 3512);
+ STACKTOP = i2;
+ return 1;
+}
+function dynCall_vii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vii[i3 & 15](i2 | 0, i1 | 0);
+}
+function _io_input(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ _g_iofile(i1, 2776, 3480);
+ STACKTOP = i2;
+ return 1;
+}
+function _semerror(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ _luaX_syntaxerror(i2, i1);
+}
+function _luaX_syntaxerror(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ _lexerror(i1, i2, HEAP32[i1 + 16 >> 2] | 0);
+}
+function b4(i1, i2, i3, i4) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ abort(4);
+ return 0;
+}
+function _lua_typename(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return HEAP32[8528 + (i1 + 1 << 2) >> 2] | 0;
+}
+function dynCall_ii(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_ii[i2 & 255](i1 | 0) | 0;
+}
+function dynCall_vi(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vi[i2 & 1](i1 | 0);
+}
+function b0(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ abort(0);
+ return 0;
+}
+function _lua_gethookmask(i1) {
+ i1 = i1 | 0;
+ return HEAPU8[i1 + 40 | 0] | 0 | 0;
+}
+function _lua_gethookcount(i1) {
+ i1 = i1 | 0;
+ return HEAP32[i1 + 44 >> 2] | 0;
+}
+function _lua_status(i1) {
+ i1 = i1 | 0;
+ return HEAPU8[i1 + 6 | 0] | 0 | 0;
+}
+function _lua_gethook(i1) {
+ i1 = i1 | 0;
+ return HEAP32[i1 + 52 >> 2] | 0;
+}
+function b5(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(5);
+ return 0;
+}
+function _lua_error(i1) {
+ i1 = i1 | 0;
+ _luaG_errormsg(i1);
+ return 0;
+}
+function b2(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(2);
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function b3(i1) {
+ i1 = i1 | 0;
+ abort(3);
+ return 0;
+}
+function _rand() {
+ return _rand_r(___rand_seed) | 0;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+function b1(i1) {
+ i1 = i1 | 0;
+ abort(1);
+}
+
+// EMSCRIPTEN_END_FUNCS
+ var FUNCTION_TABLE_iiii = [b0,_getF,_getS,_generic_reader];
+ var FUNCTION_TABLE_vi = [b1,_laction];
+ var FUNCTION_TABLE_vii = [b2,_lstop,_growstack,_f_call,_resume,_unroll,_f_parser,_dothecall,_f_luaopen,_hookf,b2,b2,b2,b2,b2,b2];
+ var FUNCTION_TABLE_ii = [b3,_io_close,_io_flush,_io_input,_io_lines,_io_open,_io_output,_io_popen,_io_read,_io_tmpfile,_io_type,_io_write,_f_flush,_f_lines,_f_read,_f_seek,_f_setvbuf,_f_write,_f_gc,_f_tostring,_math_abs,_math_acos,_math_asin,_math_atan2,_math_atan,_math_ceil,_math_cosh,_math_cos,_math_deg
+ ,_math_exp,_math_floor,_math_fmod,_math_frexp,_math_ldexp,_math_log10,_math_log,_math_max,_math_min,_math_modf,_math_pow,_math_rad,_math_random,_math_randomseed,_math_sinh,_math_sin,_math_sqrt,_math_tanh,_math_tan,_ll_loadlib,_ll_searchpath,_ll_seeall,_ll_module,_ll_require,_os_clock,_os_date,_os_difftime,_os_execute,_os_exit,_os_getenv
+ ,_os_remove,_os_rename,_os_setlocale,_os_time,_os_tmpname,_str_byte,_str_char,_str_dump,_str_find,_str_format,_gmatch,_str_gsub,_str_len,_str_lower,_str_match,_str_rep,_str_reverse,_str_sub,_str_upper,_tconcat,_maxn,_tinsert,_pack,_unpack,_tremove,_sort,_luaB_assert,_luaB_collectgarbage,_luaB_dofile,_luaB_error
+ ,_luaB_getmetatable,_luaB_ipairs,_luaB_loadfile,_luaB_load,_luaB_next,_luaB_pairs,_luaB_pcall,_luaB_print,_luaB_rawequal,_luaB_rawlen,_luaB_rawget,_luaB_rawset,_luaB_select,_luaB_setmetatable,_luaB_tonumber,_luaB_tostring,_luaB_type,_luaB_xpcall,_b_arshift,_b_and,_b_not,_b_or,_b_xor,_b_test,_b_extract,_b_lrot,_b_lshift,_b_replace,_b_rrot,_b_rshift
+ ,_luaB_cocreate,_luaB_coresume,_luaB_corunning,_luaB_costatus,_luaB_cowrap,_luaB_yield,_db_debug,_db_getuservalue,_db_gethook,_db_getinfo,_db_getlocal,_db_getregistry,_db_getmetatable,_db_getupvalue,_db_upvaluejoin,_db_upvalueid,_db_setuservalue,_db_sethook,_db_setlocal,_db_setmetatable,_db_setupvalue,_db_traceback,_pmain,_traceback,_panic,_luaopen_base,_luaopen_package,_luaopen_coroutine,_luaopen_table,_luaopen_io
+ ,_luaopen_os,_luaopen_string,_luaopen_bit32,_luaopen_math,_luaopen_debug,_io_noclose,_io_readline,_io_fclose,_io_pclose,_gctm,_searcher_preload,_searcher_Lua,_searcher_C,_searcher_Croot,_gmatch_aux,_dofilecont,_ipairsaux,_pcallcont,_luaB_auxwrap,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
+ ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
+ ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3
+ ,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3,b3];
+ var FUNCTION_TABLE_iiiii = [b4,_l_alloc,_writer,b4];
+ var FUNCTION_TABLE_iii = [b5,_lua_newstate];
+
+ return { _testSetjmp: _testSetjmp, _i64Subtract: _i64Subtract, _free: _free, _main: _main, _rand_r: _rand_r, _realloc: _realloc, _i64Add: _i64Add, _tolower: _tolower, _saveSetjmp: _saveSetjmp, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, _strlen: _strlen, _rand: _rand, _bitshift64Shl: _bitshift64Shl, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9, dynCall_iiii: dynCall_iiii, dynCall_vi: dynCall_vi, dynCall_vii: dynCall_vii, dynCall_ii: dynCall_ii, dynCall_iiiii: dynCall_iiiii, dynCall_iii: dynCall_iii };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "invoke_iiii": invoke_iiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_ii": invoke_ii, "invoke_iiiii": invoke_iiiii, "invoke_iii": invoke_iii, "_isalnum": _isalnum, "_fabs": _fabs, "_frexp": _frexp, "_exp": _exp, "_fread": _fread, "__reallyNegative": __reallyNegative, "_longjmp": _longjmp, "__addDays": __addDays, "_fsync": _fsync, "_signal": _signal, "_rename": _rename, "_sbrk": _sbrk, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_sinh": _sinh, "_sysconf": _sysconf, "_close": _close, "_ferror": _ferror, "_clock": _clock, "_cos": _cos, "_tanh": _tanh, "_unlink": _unlink, "_write": _write, "__isLeapYear": __isLeapYear, "_ftell": _ftell, "_isupper": _isupper, "_gmtime_r": _gmtime_r, "_islower": _islower, "_tmpnam": _tmpnam, "_tmpfile": _tmpfile, "_send": _send, "_abort": _abort, "_setvbuf": _setvbuf, "_atan2": _atan2, "_setlocale": _setlocale, "_isgraph": _isgraph, "_modf": _modf, "_strerror_r": _strerror_r, "_fscanf": _fscanf, "___setErrNo": ___setErrNo, "_isalpha": _isalpha, "_srand": _srand, "_mktime": _mktime, "_putchar": _putchar, "_gmtime": _gmtime, "_localeconv": _localeconv, "_sprintf": _sprintf, "_localtime": _localtime, "_read": _read, "_fwrite": _fwrite, "_time": _time, "_fprintf": _fprintf, "_exit": _exit, "_freopen": _freopen, "_llvm_pow_f64": _llvm_pow_f64, "_fgetc": _fgetc, "_fmod": _fmod, "_lseek": _lseek, "_rmdir": _rmdir, "_asin": _asin, "_floor": _floor, "_pwrite": _pwrite, "_localtime_r": _localtime_r, "_tzset": _tzset, "_open": _open, "_remove": _remove, "_snprintf": _snprintf, "__scanString": __scanString, "_strftime": _strftime, "_fseek": _fseek, "_iscntrl": _iscntrl, "_isxdigit": _isxdigit, "_fclose": _fclose, "_log": _log, "_recv": _recv, "_tan": _tan, "_copysign": _copysign, "__getFloat": __getFloat, "_fputc": _fputc, "_ispunct": _ispunct, "_ceil": _ceil, "_isspace": _isspace, "_fopen": _fopen, "_sin": _sin, "_acos": _acos, "_cosh": _cosh, "___buildEnvironment": ___buildEnvironment, "_difftime": _difftime, "_ungetc": _ungetc, "_system": _system, "_fflush": _fflush, "_log10": _log10, "_fileno": _fileno, "__exit": __exit, "__arraySum": __arraySum, "_fgets": _fgets, "_atan": _atan, "_pread": _pread, "_mkport": _mkport, "_toupper": _toupper, "_feof": _feof, "___errno_location": ___errno_location, "_clearerr": _clearerr, "_getenv": _getenv, "_strerror": _strerror, "_emscripten_longjmp": _emscripten_longjmp, "__formatString": __formatString, "_fputs": _fputs, "_sqrt": _sqrt, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "cttz_i8": cttz_i8, "ctlz_i8": ctlz_i8, "___rand_seed": ___rand_seed, "NaN": NaN, "Infinity": Infinity, "_stderr": _stderr, "_stdin": _stdin, "_stdout": _stdout }, buffer);
+var _testSetjmp = Module["_testSetjmp"] = asm["_testSetjmp"];
+var _i64Subtract = Module["_i64Subtract"] = asm["_i64Subtract"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _rand_r = Module["_rand_r"] = asm["_rand_r"];
+var _realloc = Module["_realloc"] = asm["_realloc"];
+var _i64Add = Module["_i64Add"] = asm["_i64Add"];
+var _tolower = Module["_tolower"] = asm["_tolower"];
+var _saveSetjmp = Module["_saveSetjmp"] = asm["_saveSetjmp"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _rand = Module["_rand"] = asm["_rand"];
+var _bitshift64Shl = Module["_bitshift64Shl"] = asm["_bitshift64Shl"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
+var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
+var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
+var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
+var dynCall_iiiii = Module["dynCall_iiiii"] = asm["dynCall_iiiii"];
+var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// TODO: strip out parts of this we do not need
+
+//======= begin closure i64 code =======
+
+// Copyright 2009 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Defines a Long class for representing a 64-bit two's-complement
+ * integer value, which faithfully simulates the behavior of a Java "long". This
+ * implementation is derived from LongLib in GWT.
+ *
+ */
+
+var i64Math = (function() { // Emscripten wrapper
+ var goog = { math: {} };
+
+
+ /**
+ * Constructs a 64-bit two's-complement integer, given its low and high 32-bit
+ * values as *signed* integers. See the from* functions below for more
+ * convenient ways of constructing Longs.
+ *
+ * The internal representation of a long is the two given signed, 32-bit values.
+ * We use 32-bit pieces because these are the size of integers on which
+ * Javascript performs bit-operations. For operations like addition and
+ * multiplication, we split each number into 16-bit pieces, which can easily be
+ * multiplied within Javascript's floating-point representation without overflow
+ * or change in sign.
+ *
+ * In the algorithms below, we frequently reduce the negative case to the
+ * positive case by negating the input(s) and then post-processing the result.
+ * Note that we must ALWAYS check specially whether those values are MIN_VALUE
+ * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
+ * a positive number, it overflows back into a negative). Not handling this
+ * case would often result in infinite recursion.
+ *
+ * @param {number} low The low (signed) 32 bits of the long.
+ * @param {number} high The high (signed) 32 bits of the long.
+ * @constructor
+ */
+ goog.math.Long = function(low, high) {
+ /**
+ * @type {number}
+ * @private
+ */
+ this.low_ = low | 0; // force into 32 signed bits.
+
+ /**
+ * @type {number}
+ * @private
+ */
+ this.high_ = high | 0; // force into 32 signed bits.
+ };
+
+
+ // NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
+ // from* methods on which they depend.
+
+
+ /**
+ * A cache of the Long representations of small integer values.
+ * @type {!Object}
+ * @private
+ */
+ goog.math.Long.IntCache_ = {};
+
+
+ /**
+ * Returns a Long representing the given (32-bit) integer value.
+ * @param {number} value The 32-bit integer in question.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+ goog.math.Long.fromInt = function(value) {
+ if (-128 <= value && value < 128) {
+ var cachedObj = goog.math.Long.IntCache_[value];
+ if (cachedObj) {
+ return cachedObj;
+ }
+ }
+
+ var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0);
+ if (-128 <= value && value < 128) {
+ goog.math.Long.IntCache_[value] = obj;
+ }
+ return obj;
+ };
+
+
+ /**
+ * Returns a Long representing the given value, provided that it is a finite
+ * number. Otherwise, zero is returned.
+ * @param {number} value The number in question.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+ goog.math.Long.fromNumber = function(value) {
+ if (isNaN(value) || !isFinite(value)) {
+ return goog.math.Long.ZERO;
+ } else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) {
+ return goog.math.Long.MIN_VALUE;
+ } else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) {
+ return goog.math.Long.MAX_VALUE;
+ } else if (value < 0) {
+ return goog.math.Long.fromNumber(-value).negate();
+ } else {
+ return new goog.math.Long(
+ (value % goog.math.Long.TWO_PWR_32_DBL_) | 0,
+ (value / goog.math.Long.TWO_PWR_32_DBL_) | 0);
+ }
+ };
+
+
+ /**
+ * Returns a Long representing the 64-bit integer that comes by concatenating
+ * the given high and low bits. Each is assumed to use 32 bits.
+ * @param {number} lowBits The low 32-bits.
+ * @param {number} highBits The high 32-bits.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+ goog.math.Long.fromBits = function(lowBits, highBits) {
+ return new goog.math.Long(lowBits, highBits);
+ };
+
+
+ /**
+ * Returns a Long representation of the given string, written using the given
+ * radix.
+ * @param {string} str The textual representation of the Long.
+ * @param {number=} opt_radix The radix in which the text is written.
+ * @return {!goog.math.Long} The corresponding Long value.
+ */
+ goog.math.Long.fromString = function(str, opt_radix) {
+ if (str.length == 0) {
+ throw Error('number format error: empty string');
+ }
+
+ var radix = opt_radix || 10;
+ if (radix < 2 || 36 < radix) {
+ throw Error('radix out of range: ' + radix);
+ }
+
+ if (str.charAt(0) == '-') {
+ return goog.math.Long.fromString(str.substring(1), radix).negate();
+ } else if (str.indexOf('-') >= 0) {
+ throw Error('number format error: interior "-" character: ' + str);
+ }
+
+ // Do several (8) digits each time through the loop, so as to
+ // minimize the calls to the very expensive emulated div.
+ var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
+
+ var result = goog.math.Long.ZERO;
+ for (var i = 0; i < str.length; i += 8) {
+ var size = Math.min(8, str.length - i);
+ var value = parseInt(str.substring(i, i + size), radix);
+ if (size < 8) {
+ var power = goog.math.Long.fromNumber(Math.pow(radix, size));
+ result = result.multiply(power).add(goog.math.Long.fromNumber(value));
+ } else {
+ result = result.multiply(radixToPower);
+ result = result.add(goog.math.Long.fromNumber(value));
+ }
+ }
+ return result;
+ };
+
+
+ // NOTE: the compiler should inline these constant values below and then remove
+ // these variables, so there should be no runtime penalty for these.
+
+
+ /**
+ * Number used repeated below in calculations. This must appear before the
+ * first call to any from* function below.
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_32_DBL_ =
+ goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_31_DBL_ =
+ goog.math.Long.TWO_PWR_32_DBL_ / 2;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_48_DBL_ =
+ goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_64_DBL_ =
+ goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;
+
+
+ /**
+ * @type {number}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_63_DBL_ =
+ goog.math.Long.TWO_PWR_64_DBL_ / 2;
+
+
+ /** @type {!goog.math.Long} */
+ goog.math.Long.ZERO = goog.math.Long.fromInt(0);
+
+
+ /** @type {!goog.math.Long} */
+ goog.math.Long.ONE = goog.math.Long.fromInt(1);
+
+
+ /** @type {!goog.math.Long} */
+ goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);
+
+
+ /** @type {!goog.math.Long} */
+ goog.math.Long.MAX_VALUE =
+ goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);
+
+
+ /** @type {!goog.math.Long} */
+ goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0);
+
+
+ /**
+ * @type {!goog.math.Long}
+ * @private
+ */
+ goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);
+
+
+ /** @return {number} The value, assuming it is a 32-bit integer. */
+ goog.math.Long.prototype.toInt = function() {
+ return this.low_;
+ };
+
+
+ /** @return {number} The closest floating-point representation to this value. */
+ goog.math.Long.prototype.toNumber = function() {
+ return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +
+ this.getLowBitsUnsigned();
+ };
+
+
+ /**
+ * @param {number=} opt_radix The radix in which the text should be written.
+ * @return {string} The textual representation of this value.
+ */
+ goog.math.Long.prototype.toString = function(opt_radix) {
+ var radix = opt_radix || 10;
+ if (radix < 2 || 36 < radix) {
+ throw Error('radix out of range: ' + radix);
+ }
+
+ if (this.isZero()) {
+ return '0';
+ }
+
+ if (this.isNegative()) {
+ if (this.equals(goog.math.Long.MIN_VALUE)) {
+ // We need to change the Long value before it can be negated, so we remove
+ // the bottom-most digit in this base and then recurse to do the rest.
+ var radixLong = goog.math.Long.fromNumber(radix);
+ var div = this.div(radixLong);
+ var rem = div.multiply(radixLong).subtract(this);
+ return div.toString(radix) + rem.toInt().toString(radix);
+ } else {
+ return '-' + this.negate().toString(radix);
+ }
+ }
+
+ // Do several (6) digits each time through the loop, so as to
+ // minimize the calls to the very expensive emulated div.
+ var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
+
+ var rem = this;
+ var result = '';
+ while (true) {
+ var remDiv = rem.div(radixToPower);
+ var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
+ var digits = intval.toString(radix);
+
+ rem = remDiv;
+ if (rem.isZero()) {
+ return digits + result;
+ } else {
+ while (digits.length < 6) {
+ digits = '0' + digits;
+ }
+ result = '' + digits + result;
+ }
+ }
+ };
+
+
+ /** @return {number} The high 32-bits as a signed value. */
+ goog.math.Long.prototype.getHighBits = function() {
+ return this.high_;
+ };
+
+
+ /** @return {number} The low 32-bits as a signed value. */
+ goog.math.Long.prototype.getLowBits = function() {
+ return this.low_;
+ };
+
+
+ /** @return {number} The low 32-bits as an unsigned value. */
+ goog.math.Long.prototype.getLowBitsUnsigned = function() {
+ return (this.low_ >= 0) ?
+ this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;
+ };
+
+
+ /**
+ * @return {number} Returns the number of bits needed to represent the absolute
+ * value of this Long.
+ */
+ goog.math.Long.prototype.getNumBitsAbs = function() {
+ if (this.isNegative()) {
+ if (this.equals(goog.math.Long.MIN_VALUE)) {
+ return 64;
+ } else {
+ return this.negate().getNumBitsAbs();
+ }
+ } else {
+ var val = this.high_ != 0 ? this.high_ : this.low_;
+ for (var bit = 31; bit > 0; bit--) {
+ if ((val & (1 << bit)) != 0) {
+ break;
+ }
+ }
+ return this.high_ != 0 ? bit + 33 : bit + 1;
+ }
+ };
+
+
+ /** @return {boolean} Whether this value is zero. */
+ goog.math.Long.prototype.isZero = function() {
+ return this.high_ == 0 && this.low_ == 0;
+ };
+
+
+ /** @return {boolean} Whether this value is negative. */
+ goog.math.Long.prototype.isNegative = function() {
+ return this.high_ < 0;
+ };
+
+
+ /** @return {boolean} Whether this value is odd. */
+ goog.math.Long.prototype.isOdd = function() {
+ return (this.low_ & 1) == 1;
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long equals the other.
+ */
+ goog.math.Long.prototype.equals = function(other) {
+ return (this.high_ == other.high_) && (this.low_ == other.low_);
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long does not equal the other.
+ */
+ goog.math.Long.prototype.notEquals = function(other) {
+ return (this.high_ != other.high_) || (this.low_ != other.low_);
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is less than the other.
+ */
+ goog.math.Long.prototype.lessThan = function(other) {
+ return this.compare(other) < 0;
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is less than or equal to the other.
+ */
+ goog.math.Long.prototype.lessThanOrEqual = function(other) {
+ return this.compare(other) <= 0;
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is greater than the other.
+ */
+ goog.math.Long.prototype.greaterThan = function(other) {
+ return this.compare(other) > 0;
+ };
+
+
+ /**
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {boolean} Whether this Long is greater than or equal to the other.
+ */
+ goog.math.Long.prototype.greaterThanOrEqual = function(other) {
+ return this.compare(other) >= 0;
+ };
+
+
+ /**
+ * Compares this Long with the given one.
+ * @param {goog.math.Long} other Long to compare against.
+ * @return {number} 0 if they are the same, 1 if the this is greater, and -1
+ * if the given one is greater.
+ */
+ goog.math.Long.prototype.compare = function(other) {
+ if (this.equals(other)) {
+ return 0;
+ }
+
+ var thisNeg = this.isNegative();
+ var otherNeg = other.isNegative();
+ if (thisNeg && !otherNeg) {
+ return -1;
+ }
+ if (!thisNeg && otherNeg) {
+ return 1;
+ }
+
+ // at this point, the signs are the same, so subtraction will not overflow
+ if (this.subtract(other).isNegative()) {
+ return -1;
+ } else {
+ return 1;
+ }
+ };
+
+
+ /** @return {!goog.math.Long} The negation of this value. */
+ goog.math.Long.prototype.negate = function() {
+ if (this.equals(goog.math.Long.MIN_VALUE)) {
+ return goog.math.Long.MIN_VALUE;
+ } else {
+ return this.not().add(goog.math.Long.ONE);
+ }
+ };
+
+
+ /**
+ * Returns the sum of this and the given Long.
+ * @param {goog.math.Long} other Long to add to this one.
+ * @return {!goog.math.Long} The sum of this and the given Long.
+ */
+ goog.math.Long.prototype.add = function(other) {
+ // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
+
+ var a48 = this.high_ >>> 16;
+ var a32 = this.high_ & 0xFFFF;
+ var a16 = this.low_ >>> 16;
+ var a00 = this.low_ & 0xFFFF;
+
+ var b48 = other.high_ >>> 16;
+ var b32 = other.high_ & 0xFFFF;
+ var b16 = other.low_ >>> 16;
+ var b00 = other.low_ & 0xFFFF;
+
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 + b00;
+ c16 += c00 >>> 16;
+ c00 &= 0xFFFF;
+ c16 += a16 + b16;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c32 += a32 + b32;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c48 += a48 + b48;
+ c48 &= 0xFFFF;
+ return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+ };
+
+
+ /**
+ * Returns the difference of this and the given Long.
+ * @param {goog.math.Long} other Long to subtract from this.
+ * @return {!goog.math.Long} The difference of this and the given Long.
+ */
+ goog.math.Long.prototype.subtract = function(other) {
+ return this.add(other.negate());
+ };
+
+
+ /**
+ * Returns the product of this and the given long.
+ * @param {goog.math.Long} other Long to multiply with this.
+ * @return {!goog.math.Long} The product of this and the other.
+ */
+ goog.math.Long.prototype.multiply = function(other) {
+ if (this.isZero()) {
+ return goog.math.Long.ZERO;
+ } else if (other.isZero()) {
+ return goog.math.Long.ZERO;
+ }
+
+ if (this.equals(goog.math.Long.MIN_VALUE)) {
+ return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
+ } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+ return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;
+ }
+
+ if (this.isNegative()) {
+ if (other.isNegative()) {
+ return this.negate().multiply(other.negate());
+ } else {
+ return this.negate().multiply(other).negate();
+ }
+ } else if (other.isNegative()) {
+ return this.multiply(other.negate()).negate();
+ }
+
+ // If both longs are small, use float multiplication
+ if (this.lessThan(goog.math.Long.TWO_PWR_24_) &&
+ other.lessThan(goog.math.Long.TWO_PWR_24_)) {
+ return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
+ }
+
+ // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
+ // We can skip products that would overflow.
+
+ var a48 = this.high_ >>> 16;
+ var a32 = this.high_ & 0xFFFF;
+ var a16 = this.low_ >>> 16;
+ var a00 = this.low_ & 0xFFFF;
+
+ var b48 = other.high_ >>> 16;
+ var b32 = other.high_ & 0xFFFF;
+ var b16 = other.low_ >>> 16;
+ var b00 = other.low_ & 0xFFFF;
+
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 * b00;
+ c16 += c00 >>> 16;
+ c00 &= 0xFFFF;
+ c16 += a16 * b00;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c16 += a00 * b16;
+ c32 += c16 >>> 16;
+ c16 &= 0xFFFF;
+ c32 += a32 * b00;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c32 += a16 * b16;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c32 += a00 * b32;
+ c48 += c32 >>> 16;
+ c32 &= 0xFFFF;
+ c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+ c48 &= 0xFFFF;
+ return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
+ };
+
+
+ /**
+ * Returns this Long divided by the given one.
+ * @param {goog.math.Long} other Long by which to divide.
+ * @return {!goog.math.Long} This Long divided by the given one.
+ */
+ goog.math.Long.prototype.div = function(other) {
+ if (other.isZero()) {
+ throw Error('division by zero');
+ } else if (this.isZero()) {
+ return goog.math.Long.ZERO;
+ }
+
+ if (this.equals(goog.math.Long.MIN_VALUE)) {
+ if (other.equals(goog.math.Long.ONE) ||
+ other.equals(goog.math.Long.NEG_ONE)) {
+ return goog.math.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
+ } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+ return goog.math.Long.ONE;
+ } else {
+ // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
+ var halfThis = this.shiftRight(1);
+ var approx = halfThis.div(other).shiftLeft(1);
+ if (approx.equals(goog.math.Long.ZERO)) {
+ return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;
+ } else {
+ var rem = this.subtract(other.multiply(approx));
+ var result = approx.add(rem.div(other));
+ return result;
+ }
+ }
+ } else if (other.equals(goog.math.Long.MIN_VALUE)) {
+ return goog.math.Long.ZERO;
+ }
+
+ if (this.isNegative()) {
+ if (other.isNegative()) {
+ return this.negate().div(other.negate());
+ } else {
+ return this.negate().div(other).negate();
+ }
+ } else if (other.isNegative()) {
+ return this.div(other.negate()).negate();
+ }
+
+ // Repeat the following until the remainder is less than other: find a
+ // floating-point that approximates remainder / other *from below*, add this
+ // into the result, and subtract it from the remainder. It is critical that
+ // the approximate value is less than or equal to the real value so that the
+ // remainder never becomes negative.
+ var res = goog.math.Long.ZERO;
+ var rem = this;
+ while (rem.greaterThanOrEqual(other)) {
+ // Approximate the result of division. This may be a little greater or
+ // smaller than the actual value.
+ var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
+
+ // We will tweak the approximate result by changing it in the 48-th digit or
+ // the smallest non-fractional digit, whichever is larger.
+ var log2 = Math.ceil(Math.log(approx) / Math.LN2);
+ var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);
+
+ // Decrease the approximation until it is smaller than the remainder. Note
+ // that if it is too large, the product overflows and is negative.
+ var approxRes = goog.math.Long.fromNumber(approx);
+ var approxRem = approxRes.multiply(other);
+ while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
+ approx -= delta;
+ approxRes = goog.math.Long.fromNumber(approx);
+ approxRem = approxRes.multiply(other);
+ }
+
+ // We know the answer can't be zero... and actually, zero would cause
+ // infinite recursion since we would make no progress.
+ if (approxRes.isZero()) {
+ approxRes = goog.math.Long.ONE;
+ }
+
+ res = res.add(approxRes);
+ rem = rem.subtract(approxRem);
+ }
+ return res;
+ };
+
+
+ /**
+ * Returns this Long modulo the given one.
+ * @param {goog.math.Long} other Long by which to mod.
+ * @return {!goog.math.Long} This Long modulo the given one.
+ */
+ goog.math.Long.prototype.modulo = function(other) {
+ return this.subtract(this.div(other).multiply(other));
+ };
+
+
+ /** @return {!goog.math.Long} The bitwise-NOT of this value. */
+ goog.math.Long.prototype.not = function() {
+ return goog.math.Long.fromBits(~this.low_, ~this.high_);
+ };
+
+
+ /**
+ * Returns the bitwise-AND of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to AND.
+ * @return {!goog.math.Long} The bitwise-AND of this and the other.
+ */
+ goog.math.Long.prototype.and = function(other) {
+ return goog.math.Long.fromBits(this.low_ & other.low_,
+ this.high_ & other.high_);
+ };
+
+
+ /**
+ * Returns the bitwise-OR of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to OR.
+ * @return {!goog.math.Long} The bitwise-OR of this and the other.
+ */
+ goog.math.Long.prototype.or = function(other) {
+ return goog.math.Long.fromBits(this.low_ | other.low_,
+ this.high_ | other.high_);
+ };
+
+
+ /**
+ * Returns the bitwise-XOR of this Long and the given one.
+ * @param {goog.math.Long} other The Long with which to XOR.
+ * @return {!goog.math.Long} The bitwise-XOR of this and the other.
+ */
+ goog.math.Long.prototype.xor = function(other) {
+ return goog.math.Long.fromBits(this.low_ ^ other.low_,
+ this.high_ ^ other.high_);
+ };
+
+
+ /**
+ * Returns this Long with bits shifted to the left by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the left by the given amount.
+ */
+ goog.math.Long.prototype.shiftLeft = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var low = this.low_;
+ if (numBits < 32) {
+ var high = this.high_;
+ return goog.math.Long.fromBits(
+ low << numBits,
+ (high << numBits) | (low >>> (32 - numBits)));
+ } else {
+ return goog.math.Long.fromBits(0, low << (numBits - 32));
+ }
+ }
+ };
+
+
+ /**
+ * Returns this Long with bits shifted to the right by the given amount.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the right by the given amount.
+ */
+ goog.math.Long.prototype.shiftRight = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var high = this.high_;
+ if (numBits < 32) {
+ var low = this.low_;
+ return goog.math.Long.fromBits(
+ (low >>> numBits) | (high << (32 - numBits)),
+ high >> numBits);
+ } else {
+ return goog.math.Long.fromBits(
+ high >> (numBits - 32),
+ high >= 0 ? 0 : -1);
+ }
+ }
+ };
+
+
+ /**
+ * Returns this Long with bits shifted to the right by the given amount, with
+ * the new top bits matching the current sign bit.
+ * @param {number} numBits The number of bits by which to shift.
+ * @return {!goog.math.Long} This shifted to the right by the given amount, with
+ * zeros placed into the new leading bits.
+ */
+ goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
+ numBits &= 63;
+ if (numBits == 0) {
+ return this;
+ } else {
+ var high = this.high_;
+ if (numBits < 32) {
+ var low = this.low_;
+ return goog.math.Long.fromBits(
+ (low >>> numBits) | (high << (32 - numBits)),
+ high >>> numBits);
+ } else if (numBits == 32) {
+ return goog.math.Long.fromBits(high, 0);
+ } else {
+ return goog.math.Long.fromBits(high >>> (numBits - 32), 0);
+ }
+ }
+ };
+
+ //======= begin jsbn =======
+
+ var navigator = { appName: 'Modern Browser' }; // polyfill a little
+
+ // Copyright (c) 2005 Tom Wu
+ // All Rights Reserved.
+ // http://www-cs-students.stanford.edu/~tjw/jsbn/
+
+ /*
+ * Copyright (c) 2003-2005 Tom Wu
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+ * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * In addition, the following condition applies:
+ *
+ * All redistributions must retain an intact copy of this copyright notice
+ * and disclaimer.
+ */
+
+ // Basic JavaScript BN library - subset useful for RSA encryption.
+
+ // Bits per digit
+ var dbits;
+
+ // JavaScript engine analysis
+ var canary = 0xdeadbeefcafe;
+ var j_lm = ((canary&0xffffff)==0xefcafe);
+
+ // (public) Constructor
+ function BigInteger(a,b,c) {
+ if(a != null)
+ if("number" == typeof a) this.fromNumber(a,b,c);
+ else if(b == null && "string" != typeof a) this.fromString(a,256);
+ else this.fromString(a,b);
+ }
+
+ // return new, unset BigInteger
+ function nbi() { return new BigInteger(null); }
+
+ // am: Compute w_j += (x*this_i), propagate carries,
+ // c is initial carry, returns final carry.
+ // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
+ // We need to select the fastest one that works in this environment.
+
+ // am1: use a single mult and divide to get the high bits,
+ // max digit bits should be 26 because
+ // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
+ function am1(i,x,w,j,c,n) {
+ while(--n >= 0) {
+ var v = x*this[i++]+w[j]+c;
+ c = Math.floor(v/0x4000000);
+ w[j++] = v&0x3ffffff;
+ }
+ return c;
+ }
+ // am2 avoids a big mult-and-extract completely.
+ // Max digit bits should be <= 30 because we do bitwise ops
+ // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
+ function am2(i,x,w,j,c,n) {
+ var xl = x&0x7fff, xh = x>>15;
+ while(--n >= 0) {
+ var l = this[i]&0x7fff;
+ var h = this[i++]>>15;
+ var m = xh*l+h*xl;
+ l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
+ c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
+ w[j++] = l&0x3fffffff;
+ }
+ return c;
+ }
+ // Alternately, set max digit bits to 28 since some
+ // browsers slow down when dealing with 32-bit numbers.
+ function am3(i,x,w,j,c,n) {
+ var xl = x&0x3fff, xh = x>>14;
+ while(--n >= 0) {
+ var l = this[i]&0x3fff;
+ var h = this[i++]>>14;
+ var m = xh*l+h*xl;
+ l = xl*l+((m&0x3fff)<<14)+w[j]+c;
+ c = (l>>28)+(m>>14)+xh*h;
+ w[j++] = l&0xfffffff;
+ }
+ return c;
+ }
+ if(j_lm && (navigator.appName == "Microsoft Internet Explorer")) {
+ BigInteger.prototype.am = am2;
+ dbits = 30;
+ }
+ else if(j_lm && (navigator.appName != "Netscape")) {
+ BigInteger.prototype.am = am1;
+ dbits = 26;
+ }
+ else { // Mozilla/Netscape seems to prefer am3
+ BigInteger.prototype.am = am3;
+ dbits = 28;
+ }
+
+ BigInteger.prototype.DB = dbits;
+ BigInteger.prototype.DM = ((1<<dbits)-1);
+ BigInteger.prototype.DV = (1<<dbits);
+
+ var BI_FP = 52;
+ BigInteger.prototype.FV = Math.pow(2,BI_FP);
+ BigInteger.prototype.F1 = BI_FP-dbits;
+ BigInteger.prototype.F2 = 2*dbits-BI_FP;
+
+ // Digit conversions
+ var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+ var BI_RC = new Array();
+ var rr,vv;
+ rr = "0".charCodeAt(0);
+ for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
+ rr = "a".charCodeAt(0);
+ for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+ rr = "A".charCodeAt(0);
+ for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+
+ function int2char(n) { return BI_RM.charAt(n); }
+ function intAt(s,i) {
+ var c = BI_RC[s.charCodeAt(i)];
+ return (c==null)?-1:c;
+ }
+
+ // (protected) copy this to r
+ function bnpCopyTo(r) {
+ for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
+ r.t = this.t;
+ r.s = this.s;
+ }
+
+ // (protected) set from integer value x, -DV <= x < DV
+ function bnpFromInt(x) {
+ this.t = 1;
+ this.s = (x<0)?-1:0;
+ if(x > 0) this[0] = x;
+ else if(x < -1) this[0] = x+DV;
+ else this.t = 0;
+ }
+
+ // return bigint initialized to value
+ function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
+
+ // (protected) set from string and radix
+ function bnpFromString(s,b) {
+ var k;
+ if(b == 16) k = 4;
+ else if(b == 8) k = 3;
+ else if(b == 256) k = 8; // byte array
+ else if(b == 2) k = 1;
+ else if(b == 32) k = 5;
+ else if(b == 4) k = 2;
+ else { this.fromRadix(s,b); return; }
+ this.t = 0;
+ this.s = 0;
+ var i = s.length, mi = false, sh = 0;
+ while(--i >= 0) {
+ var x = (k==8)?s[i]&0xff:intAt(s,i);
+ if(x < 0) {
+ if(s.charAt(i) == "-") mi = true;
+ continue;
+ }
+ mi = false;
+ if(sh == 0)
+ this[this.t++] = x;
+ else if(sh+k > this.DB) {
+ this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
+ this[this.t++] = (x>>(this.DB-sh));
+ }
+ else
+ this[this.t-1] |= x<<sh;
+ sh += k;
+ if(sh >= this.DB) sh -= this.DB;
+ }
+ if(k == 8 && (s[0]&0x80) != 0) {
+ this.s = -1;
+ if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
+ }
+ this.clamp();
+ if(mi) BigInteger.ZERO.subTo(this,this);
+ }
+
+ // (protected) clamp off excess high words
+ function bnpClamp() {
+ var c = this.s&this.DM;
+ while(this.t > 0 && this[this.t-1] == c) --this.t;
+ }
+
+ // (public) return string representation in given radix
+ function bnToString(b) {
+ if(this.s < 0) return "-"+this.negate().toString(b);
+ var k;
+ if(b == 16) k = 4;
+ else if(b == 8) k = 3;
+ else if(b == 2) k = 1;
+ else if(b == 32) k = 5;
+ else if(b == 4) k = 2;
+ else return this.toRadix(b);
+ var km = (1<<k)-1, d, m = false, r = "", i = this.t;
+ var p = this.DB-(i*this.DB)%k;
+ if(i-- > 0) {
+ if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
+ while(i >= 0) {
+ if(p < k) {
+ d = (this[i]&((1<<p)-1))<<(k-p);
+ d |= this[--i]>>(p+=this.DB-k);
+ }
+ else {
+ d = (this[i]>>(p-=k))&km;
+ if(p <= 0) { p += this.DB; --i; }
+ }
+ if(d > 0) m = true;
+ if(m) r += int2char(d);
+ }
+ }
+ return m?r:"0";
+ }
+
+ // (public) -this
+ function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
+
+ // (public) |this|
+ function bnAbs() { return (this.s<0)?this.negate():this; }
+
+ // (public) return + if this > a, - if this < a, 0 if equal
+ function bnCompareTo(a) {
+ var r = this.s-a.s;
+ if(r != 0) return r;
+ var i = this.t;
+ r = i-a.t;
+ if(r != 0) return (this.s<0)?-r:r;
+ while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
+ return 0;
+ }
+
+ // returns bit length of the integer x
+ function nbits(x) {
+ var r = 1, t;
+ if((t=x>>>16) != 0) { x = t; r += 16; }
+ if((t=x>>8) != 0) { x = t; r += 8; }
+ if((t=x>>4) != 0) { x = t; r += 4; }
+ if((t=x>>2) != 0) { x = t; r += 2; }
+ if((t=x>>1) != 0) { x = t; r += 1; }
+ return r;
+ }
+
+ // (public) return the number of bits in "this"
+ function bnBitLength() {
+ if(this.t <= 0) return 0;
+ return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
+ }
+
+ // (protected) r = this << n*DB
+ function bnpDLShiftTo(n,r) {
+ var i;
+ for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
+ for(i = n-1; i >= 0; --i) r[i] = 0;
+ r.t = this.t+n;
+ r.s = this.s;
+ }
+
+ // (protected) r = this >> n*DB
+ function bnpDRShiftTo(n,r) {
+ for(var i = n; i < this.t; ++i) r[i-n] = this[i];
+ r.t = Math.max(this.t-n,0);
+ r.s = this.s;
+ }
+
+ // (protected) r = this << n
+ function bnpLShiftTo(n,r) {
+ var bs = n%this.DB;
+ var cbs = this.DB-bs;
+ var bm = (1<<cbs)-1;
+ var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
+ for(i = this.t-1; i >= 0; --i) {
+ r[i+ds+1] = (this[i]>>cbs)|c;
+ c = (this[i]&bm)<<bs;
+ }
+ for(i = ds-1; i >= 0; --i) r[i] = 0;
+ r[ds] = c;
+ r.t = this.t+ds+1;
+ r.s = this.s;
+ r.clamp();
+ }
+
+ // (protected) r = this >> n
+ function bnpRShiftTo(n,r) {
+ r.s = this.s;
+ var ds = Math.floor(n/this.DB);
+ if(ds >= this.t) { r.t = 0; return; }
+ var bs = n%this.DB;
+ var cbs = this.DB-bs;
+ var bm = (1<<bs)-1;
+ r[0] = this[ds]>>bs;
+ for(var i = ds+1; i < this.t; ++i) {
+ r[i-ds-1] |= (this[i]&bm)<<cbs;
+ r[i-ds] = this[i]>>bs;
+ }
+ if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
+ r.t = this.t-ds;
+ r.clamp();
+ }
+
+ // (protected) r = this - a
+ function bnpSubTo(a,r) {
+ var i = 0, c = 0, m = Math.min(a.t,this.t);
+ while(i < m) {
+ c += this[i]-a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ if(a.t < this.t) {
+ c -= a.s;
+ while(i < this.t) {
+ c += this[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += this.s;
+ }
+ else {
+ c += this.s;
+ while(i < a.t) {
+ c -= a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c -= a.s;
+ }
+ r.s = (c<0)?-1:0;
+ if(c < -1) r[i++] = this.DV+c;
+ else if(c > 0) r[i++] = c;
+ r.t = i;
+ r.clamp();
+ }
+
+ // (protected) r = this * a, r != this,a (HAC 14.12)
+ // "this" should be the larger one if appropriate.
+ function bnpMultiplyTo(a,r) {
+ var x = this.abs(), y = a.abs();
+ var i = x.t;
+ r.t = i+y.t;
+ while(--i >= 0) r[i] = 0;
+ for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
+ r.s = 0;
+ r.clamp();
+ if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
+ }
+
+ // (protected) r = this^2, r != this (HAC 14.16)
+ function bnpSquareTo(r) {
+ var x = this.abs();
+ var i = r.t = 2*x.t;
+ while(--i >= 0) r[i] = 0;
+ for(i = 0; i < x.t-1; ++i) {
+ var c = x.am(i,x[i],r,2*i,0,1);
+ if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
+ r[i+x.t] -= x.DV;
+ r[i+x.t+1] = 1;
+ }
+ }
+ if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
+ r.s = 0;
+ r.clamp();
+ }
+
+ // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
+ // r != q, this != m. q or r may be null.
+ function bnpDivRemTo(m,q,r) {
+ var pm = m.abs();
+ if(pm.t <= 0) return;
+ var pt = this.abs();
+ if(pt.t < pm.t) {
+ if(q != null) q.fromInt(0);
+ if(r != null) this.copyTo(r);
+ return;
+ }
+ if(r == null) r = nbi();
+ var y = nbi(), ts = this.s, ms = m.s;
+ var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus
+ if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
+ else { pm.copyTo(y); pt.copyTo(r); }
+ var ys = y.t;
+ var y0 = y[ys-1];
+ if(y0 == 0) return;
+ var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
+ var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
+ var i = r.t, j = i-ys, t = (q==null)?nbi():q;
+ y.dlShiftTo(j,t);
+ if(r.compareTo(t) >= 0) {
+ r[r.t++] = 1;
+ r.subTo(t,r);
+ }
+ BigInteger.ONE.dlShiftTo(ys,t);
+ t.subTo(y,y); // "negative" y so we can replace sub with am later
+ while(y.t < ys) y[y.t++] = 0;
+ while(--j >= 0) {
+ // Estimate quotient digit
+ var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
+ if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out
+ y.dlShiftTo(j,t);
+ r.subTo(t,r);
+ while(r[i] < --qd) r.subTo(t,r);
+ }
+ }
+ if(q != null) {
+ r.drShiftTo(ys,q);
+ if(ts != ms) BigInteger.ZERO.subTo(q,q);
+ }
+ r.t = ys;
+ r.clamp();
+ if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
+ if(ts < 0) BigInteger.ZERO.subTo(r,r);
+ }
+
+ // (public) this mod a
+ function bnMod(a) {
+ var r = nbi();
+ this.abs().divRemTo(a,null,r);
+ if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
+ return r;
+ }
+
+ // Modular reduction using "classic" algorithm
+ function Classic(m) { this.m = m; }
+ function cConvert(x) {
+ if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
+ else return x;
+ }
+ function cRevert(x) { return x; }
+ function cReduce(x) { x.divRemTo(this.m,null,x); }
+ function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+ function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+ Classic.prototype.convert = cConvert;
+ Classic.prototype.revert = cRevert;
+ Classic.prototype.reduce = cReduce;
+ Classic.prototype.mulTo = cMulTo;
+ Classic.prototype.sqrTo = cSqrTo;
+
+ // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
+ // justification:
+ // xy == 1 (mod m)
+ // xy = 1+km
+ // xy(2-xy) = (1+km)(1-km)
+ // x[y(2-xy)] = 1-k^2m^2
+ // x[y(2-xy)] == 1 (mod m^2)
+ // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
+ // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
+ // JS multiply "overflows" differently from C/C++, so care is needed here.
+ function bnpInvDigit() {
+ if(this.t < 1) return 0;
+ var x = this[0];
+ if((x&1) == 0) return 0;
+ var y = x&3; // y == 1/x mod 2^2
+ y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
+ y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8
+ y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16
+ // last step - calculate inverse mod DV directly;
+ // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
+ y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits
+ // we really want the negative inverse, and -DV < y < DV
+ return (y>0)?this.DV-y:-y;
+ }
+
+ // Montgomery reduction
+ function Montgomery(m) {
+ this.m = m;
+ this.mp = m.invDigit();
+ this.mpl = this.mp&0x7fff;
+ this.mph = this.mp>>15;
+ this.um = (1<<(m.DB-15))-1;
+ this.mt2 = 2*m.t;
+ }
+
+ // xR mod m
+ function montConvert(x) {
+ var r = nbi();
+ x.abs().dlShiftTo(this.m.t,r);
+ r.divRemTo(this.m,null,r);
+ if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
+ return r;
+ }
+
+ // x/R mod m
+ function montRevert(x) {
+ var r = nbi();
+ x.copyTo(r);
+ this.reduce(r);
+ return r;
+ }
+
+ // x = x/R mod m (HAC 14.32)
+ function montReduce(x) {
+ while(x.t <= this.mt2) // pad x so am has enough room later
+ x[x.t++] = 0;
+ for(var i = 0; i < this.m.t; ++i) {
+ // faster way of calculating u0 = x[i]*mp mod DV
+ var j = x[i]&0x7fff;
+ var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
+ // use am to combine the multiply-shift-add into one call
+ j = i+this.m.t;
+ x[j] += this.m.am(0,u0,x,i,0,this.m.t);
+ // propagate carry
+ while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
+ }
+ x.clamp();
+ x.drShiftTo(this.m.t,x);
+ if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+ }
+
+ // r = "x^2/R mod m"; x != r
+ function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+ // r = "xy/R mod m"; x,y != r
+ function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+ Montgomery.prototype.convert = montConvert;
+ Montgomery.prototype.revert = montRevert;
+ Montgomery.prototype.reduce = montReduce;
+ Montgomery.prototype.mulTo = montMulTo;
+ Montgomery.prototype.sqrTo = montSqrTo;
+
+ // (protected) true iff this is even
+ function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
+
+ // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
+ function bnpExp(e,z) {
+ if(e > 0xffffffff || e < 1) return BigInteger.ONE;
+ var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
+ g.copyTo(r);
+ while(--i >= 0) {
+ z.sqrTo(r,r2);
+ if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
+ else { var t = r; r = r2; r2 = t; }
+ }
+ return z.revert(r);
+ }
+
+ // (public) this^e % m, 0 <= e < 2^32
+ function bnModPowInt(e,m) {
+ var z;
+ if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
+ return this.exp(e,z);
+ }
+
+ // protected
+ BigInteger.prototype.copyTo = bnpCopyTo;
+ BigInteger.prototype.fromInt = bnpFromInt;
+ BigInteger.prototype.fromString = bnpFromString;
+ BigInteger.prototype.clamp = bnpClamp;
+ BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
+ BigInteger.prototype.drShiftTo = bnpDRShiftTo;
+ BigInteger.prototype.lShiftTo = bnpLShiftTo;
+ BigInteger.prototype.rShiftTo = bnpRShiftTo;
+ BigInteger.prototype.subTo = bnpSubTo;
+ BigInteger.prototype.multiplyTo = bnpMultiplyTo;
+ BigInteger.prototype.squareTo = bnpSquareTo;
+ BigInteger.prototype.divRemTo = bnpDivRemTo;
+ BigInteger.prototype.invDigit = bnpInvDigit;
+ BigInteger.prototype.isEven = bnpIsEven;
+ BigInteger.prototype.exp = bnpExp;
+
+ // public
+ BigInteger.prototype.toString = bnToString;
+ BigInteger.prototype.negate = bnNegate;
+ BigInteger.prototype.abs = bnAbs;
+ BigInteger.prototype.compareTo = bnCompareTo;
+ BigInteger.prototype.bitLength = bnBitLength;
+ BigInteger.prototype.mod = bnMod;
+ BigInteger.prototype.modPowInt = bnModPowInt;
+
+ // "constants"
+ BigInteger.ZERO = nbv(0);
+ BigInteger.ONE = nbv(1);
+
+ // jsbn2 stuff
+
+ // (protected) convert from radix string
+ function bnpFromRadix(s,b) {
+ this.fromInt(0);
+ if(b == null) b = 10;
+ var cs = this.chunkSize(b);
+ var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
+ for(var i = 0; i < s.length; ++i) {
+ var x = intAt(s,i);
+ if(x < 0) {
+ if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
+ continue;
+ }
+ w = b*w+x;
+ if(++j >= cs) {
+ this.dMultiply(d);
+ this.dAddOffset(w,0);
+ j = 0;
+ w = 0;
+ }
+ }
+ if(j > 0) {
+ this.dMultiply(Math.pow(b,j));
+ this.dAddOffset(w,0);
+ }
+ if(mi) BigInteger.ZERO.subTo(this,this);
+ }
+
+ // (protected) return x s.t. r^x < DV
+ function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
+
+ // (public) 0 if this == 0, 1 if this > 0
+ function bnSigNum() {
+ if(this.s < 0) return -1;
+ else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
+ else return 1;
+ }
+
+ // (protected) this *= n, this >= 0, 1 < n < DV
+ function bnpDMultiply(n) {
+ this[this.t] = this.am(0,n-1,this,0,0,this.t);
+ ++this.t;
+ this.clamp();
+ }
+
+ // (protected) this += n << w words, this >= 0
+ function bnpDAddOffset(n,w) {
+ if(n == 0) return;
+ while(this.t <= w) this[this.t++] = 0;
+ this[w] += n;
+ while(this[w] >= this.DV) {
+ this[w] -= this.DV;
+ if(++w >= this.t) this[this.t++] = 0;
+ ++this[w];
+ }
+ }
+
+ // (protected) convert to radix string
+ function bnpToRadix(b) {
+ if(b == null) b = 10;
+ if(this.signum() == 0 || b < 2 || b > 36) return "0";
+ var cs = this.chunkSize(b);
+ var a = Math.pow(b,cs);
+ var d = nbv(a), y = nbi(), z = nbi(), r = "";
+ this.divRemTo(d,y,z);
+ while(y.signum() > 0) {
+ r = (a+z.intValue()).toString(b).substr(1) + r;
+ y.divRemTo(d,y,z);
+ }
+ return z.intValue().toString(b) + r;
+ }
+
+ // (public) return value as integer
+ function bnIntValue() {
+ if(this.s < 0) {
+ if(this.t == 1) return this[0]-this.DV;
+ else if(this.t == 0) return -1;
+ }
+ else if(this.t == 1) return this[0];
+ else if(this.t == 0) return 0;
+ // assumes 16 < DB < 32
+ return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];
+ }
+
+ // (protected) r = this + a
+ function bnpAddTo(a,r) {
+ var i = 0, c = 0, m = Math.min(a.t,this.t);
+ while(i < m) {
+ c += this[i]+a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ if(a.t < this.t) {
+ c += a.s;
+ while(i < this.t) {
+ c += this[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += this.s;
+ }
+ else {
+ c += this.s;
+ while(i < a.t) {
+ c += a[i];
+ r[i++] = c&this.DM;
+ c >>= this.DB;
+ }
+ c += a.s;
+ }
+ r.s = (c<0)?-1:0;
+ if(c > 0) r[i++] = c;
+ else if(c < -1) r[i++] = this.DV+c;
+ r.t = i;
+ r.clamp();
+ }
+
+ BigInteger.prototype.fromRadix = bnpFromRadix;
+ BigInteger.prototype.chunkSize = bnpChunkSize;
+ BigInteger.prototype.signum = bnSigNum;
+ BigInteger.prototype.dMultiply = bnpDMultiply;
+ BigInteger.prototype.dAddOffset = bnpDAddOffset;
+ BigInteger.prototype.toRadix = bnpToRadix;
+ BigInteger.prototype.intValue = bnIntValue;
+ BigInteger.prototype.addTo = bnpAddTo;
+
+ //======= end jsbn =======
+
+ // Emscripten wrapper
+ var Wrapper = {
+ abs: function(l, h) {
+ var x = new goog.math.Long(l, h);
+ var ret;
+ if (x.isNegative()) {
+ ret = x.negate();
+ } else {
+ ret = x;
+ }
+ HEAP32[tempDoublePtr>>2] = ret.low_;
+ HEAP32[tempDoublePtr+4>>2] = ret.high_;
+ },
+ ensureTemps: function() {
+ if (Wrapper.ensuredTemps) return;
+ Wrapper.ensuredTemps = true;
+ Wrapper.two32 = new BigInteger();
+ Wrapper.two32.fromString('4294967296', 10);
+ Wrapper.two64 = new BigInteger();
+ Wrapper.two64.fromString('18446744073709551616', 10);
+ Wrapper.temp1 = new BigInteger();
+ Wrapper.temp2 = new BigInteger();
+ },
+ lh2bignum: function(l, h) {
+ var a = new BigInteger();
+ a.fromString(h.toString(), 10);
+ var b = new BigInteger();
+ a.multiplyTo(Wrapper.two32, b);
+ var c = new BigInteger();
+ c.fromString(l.toString(), 10);
+ var d = new BigInteger();
+ c.addTo(b, d);
+ return d;
+ },
+ stringify: function(l, h, unsigned) {
+ var ret = new goog.math.Long(l, h).toString();
+ if (unsigned && ret[0] == '-') {
+ // unsign slowly using jsbn bignums
+ Wrapper.ensureTemps();
+ var bignum = new BigInteger();
+ bignum.fromString(ret, 10);
+ ret = new BigInteger();
+ Wrapper.two64.addTo(bignum, ret);
+ ret = ret.toString(10);
+ }
+ return ret;
+ },
+ fromString: function(str, base, min, max, unsigned) {
+ Wrapper.ensureTemps();
+ var bignum = new BigInteger();
+ bignum.fromString(str, base);
+ var bigmin = new BigInteger();
+ bigmin.fromString(min, 10);
+ var bigmax = new BigInteger();
+ bigmax.fromString(max, 10);
+ if (unsigned && bignum.compareTo(BigInteger.ZERO) < 0) {
+ var temp = new BigInteger();
+ bignum.addTo(Wrapper.two64, temp);
+ bignum = temp;
+ }
+ var error = false;
+ if (bignum.compareTo(bigmin) < 0) {
+ bignum = bigmin;
+ error = true;
+ } else if (bignum.compareTo(bigmax) > 0) {
+ bignum = bigmax;
+ error = true;
+ }
+ var ret = goog.math.Long.fromString(bignum.toString()); // min-max checks should have clamped this to a range goog.math.Long can handle well
+ HEAP32[tempDoublePtr>>2] = ret.low_;
+ HEAP32[tempDoublePtr+4>>2] = ret.high_;
+ if (error) throw 'range error';
+ }
+ };
+ return Wrapper;
+})();
+
+//======= end closure i64 code =======
+
+
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run(['binarytrees.lua'].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run(['binarytrees.lua'].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT = 'final: 840.\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(531);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([101,114,114,111,114,58,32,37,100,10,0,0,0,0,0,0,102,105,110,97,108,58,32,37,100,46,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+ function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+
+ Module["_memset"] = _memset;
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+ function _abort() {
+ Module['abort']();
+ }
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var _fflush=env._fflush;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _printf=env._printf;
+ var _send=env._send;
+ var _pwrite=env._pwrite;
+ var _abort=env._abort;
+ var ___setErrNo=env.___setErrNo;
+ var _fwrite=env._fwrite;
+ var _sbrk=env._sbrk;
+ var _time=env._time;
+ var _mkport=env._mkport;
+ var __reallyNegative=env.__reallyNegative;
+ var __formatString=env.__formatString;
+ var _fileno=env._fileno;
+ var _write=env._write;
+ var _fprintf=env._fprintf;
+ var _sysconf=env._sysconf;
+ var ___errno_location=env.___errno_location;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[10] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 80 + (i5 << 2) | 0;
+ i5 = 80 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[10] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[48 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 80 + (i7 << 2) | 0;
+ i7 = 80 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[10] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[48 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[60 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 80 + (i9 << 2) | 0;
+ i7 = HEAP32[10] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 80 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[10] = i7 | i8;
+ i28 = 80 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[48 >> 2] = i4;
+ HEAP32[60 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[44 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[344 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[56 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 344 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[44 >> 2] = HEAP32[44 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[48 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[60 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 80 + (i9 << 2) | 0;
+ i7 = HEAP32[10] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 80 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[10] = i7 | i8;
+ i25 = 80 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[48 >> 2] = i2;
+ HEAP32[60 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[44 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[344 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[344 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[48 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[56 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 344 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[44 >> 2] = HEAP32[44 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 80 + (i6 << 2) | 0;
+ i5 = HEAP32[10] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 80 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[10] = i5 | i4;
+ i21 = 80 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 344 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[44 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[44 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[56 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[48 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[60 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[60 >> 2] = i2 + i12;
+ HEAP32[48 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[48 >> 2] = 0;
+ HEAP32[60 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[52 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[52 >> 2] = i31;
+ i32 = HEAP32[64 >> 2] | 0;
+ HEAP32[64 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[128] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[520 >> 2] = i18;
+ HEAP32[516 >> 2] = i18;
+ HEAP32[524 >> 2] = -1;
+ HEAP32[528 >> 2] = -1;
+ HEAP32[532 >> 2] = 0;
+ HEAP32[484 >> 2] = 0;
+ HEAP32[128] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[520 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[480 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[472 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[484 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[64 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 488 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[52 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[516 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[472 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[480 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[520 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[484 >> 2] = HEAP32[484 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[472 >> 2] | 0) + i14 | 0;
+ HEAP32[472 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[476 >> 2] | 0) >>> 0) {
+ HEAP32[476 >> 2] = i15;
+ }
+ i15 = HEAP32[64 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 488 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[52 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[64 >> 2] = i15 + i3;
+ HEAP32[52 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[68 >> 2] = HEAP32[528 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ HEAP32[56 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 488 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[64 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[60 >> 2] | 0)) {
+ i32 = (HEAP32[48 >> 2] | 0) + i10 | 0;
+ HEAP32[48 >> 2] = i32;
+ HEAP32[60 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 344 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[44 >> 2] = HEAP32[44 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 80 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[10] = HEAP32[10] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 80 + (i10 << 2) | 0;
+ i9 = HEAP32[10] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 80 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[10] = i9 | i5;
+ i3 = 80 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 344 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[44 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[44 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L444 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L444;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[56 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[52 >> 2] | 0) + i10 | 0;
+ HEAP32[52 >> 2] = i32;
+ HEAP32[64 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 488 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[64 >> 2] = i17 + i4;
+ HEAP32[52 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[68 >> 2] = HEAP32[528 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[488 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[492 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[496 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[500 >> 2];
+ HEAP32[488 >> 2] = i17;
+ HEAP32[492 >> 2] = i14;
+ HEAP32[500 >> 2] = 0;
+ HEAP32[496 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 80 + (i4 << 2) | 0;
+ i5 = HEAP32[10] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 80 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[10] = i5 | i3;
+ i7 = 80 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 344 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[44 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[44 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[56 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[56 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[56 >> 2] = i17;
+ }
+ HEAP32[488 >> 2] = i17;
+ HEAP32[492 >> 2] = i14;
+ HEAP32[500 >> 2] = 0;
+ HEAP32[76 >> 2] = HEAP32[128];
+ HEAP32[72 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 80 + (i32 << 2) | 0;
+ HEAP32[80 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[80 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[64 >> 2] = i17 + i2;
+ HEAP32[52 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[68 >> 2] = HEAP32[528 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[52 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[52 >> 2] = i31;
+ i32 = HEAP32[64 >> 2] | 0;
+ HEAP32[64 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[56 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[60 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[48 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 80 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[10] = HEAP32[10] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 344 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[44 >> 2] = HEAP32[44 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[64 >> 2] | 0)) {
+ i21 = (HEAP32[52 >> 2] | 0) + i11 | 0;
+ HEAP32[52 >> 2] = i21;
+ HEAP32[64 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[60 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[60 >> 2] = 0;
+ HEAP32[48 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[60 >> 2] | 0)) {
+ i21 = (HEAP32[48 >> 2] | 0) + i11 | 0;
+ HEAP32[48 >> 2] = i21;
+ HEAP32[60 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 344 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[44 >> 2] = HEAP32[44 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 80 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[10] = HEAP32[10] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[60 >> 2] | 0)) {
+ HEAP32[48 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 80 + (i7 << 2) | 0;
+ i8 = HEAP32[10] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 80 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[10] = i8 | i6;
+ i4 = 80 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 344 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[44 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L205 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L205;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[56 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[56 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[44 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[72 >> 2] | 0) + -1 | 0;
+ HEAP32[72 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 496 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[72 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function _main(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i3 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i3 | 0) {
+ case 50:
+ {
+ i3 = 400;
+ break L1;
+ }
+ case 51:
+ {
+ i4 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 4e3;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 8e3;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 55;
+ break L1;
+ }
+ case 48:
+ {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ default:
+ {
+ HEAP32[i2 >> 2] = i3 + -48;
+ _printf(8, i2 | 0) | 0;
+ i7 = -1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ }
+ } else {
+ i4 = 4;
+ }
+ } while (0);
+ if ((i4 | 0) == 4) {
+ i3 = 800;
+ }
+ i5 = _malloc(1048576) | 0;
+ i6 = 0;
+ i4 = 0;
+ do {
+ i7 = 0;
+ while (1) {
+ HEAP8[i5 + i7 | 0] = i7 + i6;
+ i7 = i7 + 1 | 0;
+ if ((i7 | 0) == 1048576) {
+ i7 = 0;
+ break;
+ }
+ }
+ do {
+ i6 = (HEAP8[i5 + i7 | 0] & 1) + i6 | 0;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != 1048576);
+ i6 = (i6 | 0) % 1e3 | 0;
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) < (i3 | 0));
+ HEAP32[i2 >> 2] = i6;
+ _printf(24, i2 | 0) | 0;
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function runPostSets() {}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+
+
+ return { _strlen: _strlen, _free: _free, _main: _main, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9 };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "_fflush": _fflush, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_printf": _printf, "_send": _send, "_pwrite": _pwrite, "_abort": _abort, "___setErrNo": ___setErrNo, "_fwrite": _fwrite, "_sbrk": _sbrk, "_time": _time, "_mkport": _mkport, "__reallyNegative": __reallyNegative, "__formatString": __formatString, "_fileno": _fileno, "_write": _write, "_fprintf": _fprintf, "_sysconf": _sysconf, "___errno_location": ___errno_location, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT = 'lastprime: 387677.\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(35);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([101,114,114,111,114,58,32,37,100,92,110,0,0,0,0,0,108,97,115,116,112,114,105,109,101,58,32,37,100,46,10,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+ function _malloc(bytes) {
+ /* Over-allocate to make sure it is byte-aligned by 8.
+ * This will leak memory, but this is only the dummy
+ * implementation (replaced by dlmalloc normally) so
+ * not an issue.
+ */
+ var ptr = Runtime.dynamicAlloc(bytes + 8);
+ return (ptr+8) & 0xFFFFFFF8;
+ }
+ Module["_malloc"] = _malloc;
+
+
+ Module["_memset"] = _memset;
+
+ function _free() {
+ }
+ Module["_free"] = _free;
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+
+
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+ var _sqrtf=Math_sqrt;
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var _free=env._free;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _printf=env._printf;
+ var _send=env._send;
+ var _pwrite=env._pwrite;
+ var _sqrtf=env._sqrtf;
+ var __reallyNegative=env.__reallyNegative;
+ var _fwrite=env._fwrite;
+ var _malloc=env._malloc;
+ var _mkport=env._mkport;
+ var _fprintf=env._fprintf;
+ var ___setErrNo=env.___setErrNo;
+ var __formatString=env.__formatString;
+ var _fileno=env._fileno;
+ var _fflush=env._fflush;
+ var _write=env._write;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _main(i3, i5) {
+ i3 = i3 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i6 = 0, i7 = 0, d8 = 0.0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ L1 : do {
+ if ((i3 | 0) > 1) {
+ i3 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i3 | 0) {
+ case 50:
+ {
+ i3 = 13e4;
+ break L1;
+ }
+ case 51:
+ {
+ i4 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i3 = 61e4;
+ break L1;
+ }
+ case 53:
+ {
+ i3 = 101e4;
+ break L1;
+ }
+ case 49:
+ {
+ i3 = 33e3;
+ break L1;
+ }
+ case 48:
+ {
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ default:
+ {
+ HEAP32[i2 >> 2] = i3 + -48;
+ _printf(8, i2 | 0) | 0;
+ i7 = -1;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ }
+ } else {
+ i4 = 4;
+ }
+ } while (0);
+ if ((i4 | 0) == 4) {
+ i3 = 22e4;
+ }
+ i4 = 2;
+ i5 = 0;
+ while (1) {
+ d8 = +Math_sqrt(+(+(i4 | 0)));
+ L15 : do {
+ if (d8 > 2.0) {
+ i7 = 2;
+ while (1) {
+ i6 = i7 + 1 | 0;
+ if (((i4 | 0) % (i7 | 0) | 0 | 0) == 0) {
+ i6 = 0;
+ break L15;
+ }
+ if (+(i6 | 0) < d8) {
+ i7 = i6;
+ } else {
+ i6 = 1;
+ break;
+ }
+ }
+ } else {
+ i6 = 1;
+ }
+ } while (0);
+ i5 = i6 + i5 | 0;
+ if ((i5 | 0) >= (i3 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ HEAP32[i2 >> 2] = i4;
+ _printf(24, i2 | 0) | 0;
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function runPostSets() {}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+
+
+ return { _strlen: _strlen, _memcpy: _memcpy, _main: _main, _memset: _memset, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9 };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "_free": _free, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_printf": _printf, "_send": _send, "_pwrite": _pwrite, "_sqrtf": _sqrtf, "__reallyNegative": __reallyNegative, "_fwrite": _fwrite, "_malloc": _malloc, "_mkport": _mkport, "_fprintf": _fprintf, "___setErrNo": ___setErrNo, "__formatString": __formatString, "_fileno": _fileno, "_fflush": _fflush, "_write": _write, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+var EXPECTED_OUTPUT = 'sizes: 100000,25906\nok.\n';
+var Module = {
+ arguments: [1],
+ print: function(x) {Module.printBuffer += x + '\n';},
+ preRun: [function() {Module.printBuffer = ''}],
+ postRun: [function() {
+ assertEquals(EXPECTED_OUTPUT, Module.printBuffer);
+ }],
+};
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+ if (Module.hasOwnProperty(key)) {
+ moduleOverrides[key] = Module[key];
+ }
+}
+
+// The environment setup code below is customized to use Module.
+// *** Environment setup code ***
+var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
+var ENVIRONMENT_IS_WEB = typeof window === 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
+var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (ENVIRONMENT_IS_NODE) {
+ // Expose functionality in the same simple way that the shells work
+ // Note that we pollute the global namespace here, otherwise we break in node
+ if (!Module['print']) Module['print'] = function print(x) {
+ process['stdout'].write(x + '\n');
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ process['stderr'].write(x + '\n');
+ };
+
+ var nodeFS = require('fs');
+ var nodePath = require('path');
+
+ Module['read'] = function read(filename, binary) {
+ filename = nodePath['normalize'](filename);
+ var ret = nodeFS['readFileSync'](filename);
+ // The path is absolute if the normalized version is the same as the resolved.
+ if (!ret && filename != nodePath['resolve'](filename)) {
+ filename = path.join(__dirname, '..', 'src', filename);
+ ret = nodeFS['readFileSync'](filename);
+ }
+ if (ret && !binary) ret = ret.toString();
+ return ret;
+ };
+
+ Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) };
+
+ Module['load'] = function load(f) {
+ globalEval(read(f));
+ };
+
+ Module['arguments'] = process['argv'].slice(2);
+
+ module['exports'] = Module;
+}
+else if (ENVIRONMENT_IS_SHELL) {
+ if (!Module['print']) Module['print'] = print;
+ if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm
+
+ if (typeof read != 'undefined') {
+ Module['read'] = read;
+ } else {
+ Module['read'] = function read() { throw 'no read() available (jsc?)' };
+ }
+
+ Module['readBinary'] = function readBinary(f) {
+ return read(f, 'binary');
+ };
+
+ if (typeof scriptArgs != 'undefined') {
+ Module['arguments'] = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ this['Module'] = Module;
+
+ eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)
+}
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ Module['read'] = function read(url) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (typeof arguments != 'undefined') {
+ Module['arguments'] = arguments;
+ }
+
+ if (typeof console !== 'undefined') {
+ if (!Module['print']) Module['print'] = function print(x) {
+ console.log(x);
+ };
+ if (!Module['printErr']) Module['printErr'] = function printErr(x) {
+ console.log(x);
+ };
+ } else {
+ // Probably a worker, and without console.log. We can do very little here...
+ var TRY_USE_DUMP = false;
+ if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
+ dump(x);
+ }) : (function(x) {
+ // self.postMessage(x); // enable this if you want stdout to be sent as messages
+ }));
+ }
+
+ if (ENVIRONMENT_IS_WEB) {
+ window['Module'] = Module;
+ } else {
+ Module['load'] = importScripts;
+ }
+}
+else {
+ // Unreachable because SHELL is dependant on the others
+ throw 'Unknown runtime environment. Where are we?';
+}
+
+function globalEval(x) {
+ eval.call(null, x);
+}
+if (!Module['load'] == 'undefined' && Module['read']) {
+ Module['load'] = function load(f) {
+ globalEval(Module['read'](f));
+ };
+}
+if (!Module['print']) {
+ Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+ Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+ Module['arguments'] = [];
+}
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+ Module[key] = moduleOverrides[key];
+ }
+}
+
+
+
+// === Auto-generated preamble library stuff ===
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+ stackSave: function () {
+ return STACKTOP;
+ },
+ stackRestore: function (stackTop) {
+ STACKTOP = stackTop;
+ },
+ forceAlign: function (target, quantum) {
+ quantum = quantum || 4;
+ if (quantum == 1) return target;
+ if (isNumber(target) && isNumber(quantum)) {
+ return Math.ceil(target/quantum)*quantum;
+ } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
+ return '(((' +target + ')+' + (quantum-1) + ')&' + -quantum + ')';
+ }
+ return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
+ },
+ isNumberType: function (type) {
+ return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
+ },
+ isPointerType: function isPointerType(type) {
+ return type[type.length-1] == '*';
+},
+ isStructType: function isStructType(type) {
+ if (isPointerType(type)) return false;
+ if (isArrayType(type)) return true;
+ if (/<?\{ ?[^}]* ?\}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
+ // See comment in isStructPointerType()
+ return type[0] == '%';
+},
+ INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
+ FLOAT_TYPES: {"float":0,"double":0},
+ or64: function (x, y) {
+ var l = (x | 0) | (y | 0);
+ var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ and64: function (x, y) {
+ var l = (x | 0) & (y | 0);
+ var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ xor64: function (x, y) {
+ var l = (x | 0) ^ (y | 0);
+ var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
+ return l + h;
+ },
+ getNativeTypeSize: function (type) {
+ switch (type) {
+ case 'i1': case 'i8': return 1;
+ case 'i16': return 2;
+ case 'i32': return 4;
+ case 'i64': return 8;
+ case 'float': return 4;
+ case 'double': return 8;
+ default: {
+ if (type[type.length-1] === '*') {
+ return Runtime.QUANTUM_SIZE; // A pointer
+ } else if (type[0] === 'i') {
+ var bits = parseInt(type.substr(1));
+ assert(bits % 8 === 0);
+ return bits/8;
+ } else {
+ return 0;
+ }
+ }
+ }
+ },
+ getNativeFieldSize: function (type) {
+ return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+ },
+ dedup: function dedup(items, ident) {
+ var seen = {};
+ if (ident) {
+ return items.filter(function(item) {
+ if (seen[item[ident]]) return false;
+ seen[item[ident]] = true;
+ return true;
+ });
+ } else {
+ return items.filter(function(item) {
+ if (seen[item]) return false;
+ seen[item] = true;
+ return true;
+ });
+ }
+},
+ set: function set() {
+ var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
+ var ret = {};
+ for (var i = 0; i < args.length; i++) {
+ ret[args[i]] = 0;
+ }
+ return ret;
+},
+ STACK_ALIGN: 8,
+ getAlignSize: function (type, size, vararg) {
+ // we align i64s and doubles on 64-bit boundaries, unlike x86
+ if (!vararg && (type == 'i64' || type == 'double')) return 8;
+ if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+ return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+ },
+ calculateStructAlignment: function calculateStructAlignment(type) {
+ type.flatSize = 0;
+ type.alignSize = 0;
+ var diffs = [];
+ var prev = -1;
+ var index = 0;
+ type.flatIndexes = type.fields.map(function(field) {
+ index++;
+ var size, alignSize;
+ if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
+ size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
+ alignSize = Runtime.getAlignSize(field, size);
+ } else if (Runtime.isStructType(field)) {
+ if (field[1] === '0') {
+ // this is [0 x something]. When inside another structure like here, it must be at the end,
+ // and it adds no size
+ // XXX this happens in java-nbody for example... assert(index === type.fields.length, 'zero-length in the middle!');
+ size = 0;
+ if (Types.types[field]) {
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ } else {
+ alignSize = type.alignSize || QUANTUM_SIZE;
+ }
+ } else {
+ size = Types.types[field].flatSize;
+ alignSize = Runtime.getAlignSize(null, Types.types[field].alignSize);
+ }
+ } else if (field[0] == 'b') {
+ // bN, large number field, like a [N x i8]
+ size = field.substr(1)|0;
+ alignSize = 1;
+ } else if (field[0] === '<') {
+ // vector type
+ size = alignSize = Types.types[field].flatSize; // fully aligned
+ } else if (field[0] === 'i') {
+ // illegal integer field, that could not be legalized because it is an internal structure field
+ // it is ok to have such fields, if we just use them as markers of field size and nothing more complex
+ size = alignSize = parseInt(field.substr(1))/8;
+ assert(size % 1 === 0, 'cannot handle non-byte-size field ' + field);
+ } else {
+ assert(false, 'invalid type for calculateStructAlignment');
+ }
+ if (type.packed) alignSize = 1;
+ type.alignSize = Math.max(type.alignSize, alignSize);
+ var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
+ type.flatSize = curr + size;
+ if (prev >= 0) {
+ diffs.push(curr-prev);
+ }
+ prev = curr;
+ return curr;
+ });
+ if (type.name_ && type.name_[0] === '[') {
+ // arrays have 2 elements, so we get the proper difference. then we scale here. that way we avoid
+ // allocating a potentially huge array for [999999 x i8] etc.
+ type.flatSize = parseInt(type.name_.substr(1))*type.flatSize/2;
+ }
+ type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
+ if (diffs.length == 0) {
+ type.flatFactor = type.flatSize;
+ } else if (Runtime.dedup(diffs).length == 1) {
+ type.flatFactor = diffs[0];
+ }
+ type.needsFlattening = (type.flatFactor != 1);
+ return type.flatIndexes;
+ },
+ generateStructInfo: function (struct, typeName, offset) {
+ var type, alignment;
+ if (typeName) {
+ offset = offset || 0;
+ type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
+ if (!type) return null;
+ if (type.fields.length != struct.length) {
+ printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
+ return null;
+ }
+ alignment = type.flatIndexes;
+ } else {
+ var type = { fields: struct.map(function(item) { return item[0] }) };
+ alignment = Runtime.calculateStructAlignment(type);
+ }
+ var ret = {
+ __size__: type.flatSize
+ };
+ if (typeName) {
+ struct.forEach(function(item, i) {
+ if (typeof item === 'string') {
+ ret[item] = alignment[i] + offset;
+ } else {
+ // embedded struct
+ var key;
+ for (var k in item) key = k;
+ ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
+ }
+ });
+ } else {
+ struct.forEach(function(item, i) {
+ ret[item[1]] = alignment[i];
+ });
+ }
+ return ret;
+ },
+ dynCall: function (sig, ptr, args) {
+ if (args && args.length) {
+ if (!args.splice) args = Array.prototype.slice.call(args);
+ args.splice(0, 0, ptr);
+ return Module['dynCall_' + sig].apply(null, args);
+ } else {
+ return Module['dynCall_' + sig].call(null, ptr);
+ }
+ },
+ functionPointers: [],
+ addFunction: function (func) {
+ for (var i = 0; i < Runtime.functionPointers.length; i++) {
+ if (!Runtime.functionPointers[i]) {
+ Runtime.functionPointers[i] = func;
+ return 2*(1 + i);
+ }
+ }
+ throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+ },
+ removeFunction: function (index) {
+ Runtime.functionPointers[(index-2)/2] = null;
+ },
+ getAsmConst: function (code, numArgs) {
+ // code is a constant string on the heap, so we can cache these
+ if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
+ var func = Runtime.asmConstCache[code];
+ if (func) return func;
+ var args = [];
+ for (var i = 0; i < numArgs; i++) {
+ args.push(String.fromCharCode(36) + i); // $0, $1 etc
+ }
+ var source = Pointer_stringify(code);
+ if (source[0] === '"') {
+ // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
+ if (source.indexOf('"', 1) === source.length-1) {
+ source = source.substr(1, source.length-2);
+ } else {
+ // something invalid happened, e.g. EM_ASM("..code($0)..", input)
+ abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
+ }
+ }
+ try {
+ var evalled = eval('(function(' + args.join(',') + '){ ' + source + ' })'); // new Function does not allow upvars in node
+ } catch(e) {
+ Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
+ throw e;
+ }
+ return Runtime.asmConstCache[code] = evalled;
+ },
+ warnOnce: function (text) {
+ if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+ if (!Runtime.warnOnce.shown[text]) {
+ Runtime.warnOnce.shown[text] = 1;
+ Module.printErr(text);
+ }
+ },
+ funcWrappers: {},
+ getFuncWrapper: function (func, sig) {
+ assert(sig);
+ if (!Runtime.funcWrappers[func]) {
+ Runtime.funcWrappers[func] = function dynCall_wrapper() {
+ return Runtime.dynCall(sig, func, arguments);
+ };
+ }
+ return Runtime.funcWrappers[func];
+ },
+ UTF8Processor: function () {
+ var buffer = [];
+ var needed = 0;
+ this.processCChar = function (code) {
+ code = code & 0xFF;
+
+ if (buffer.length == 0) {
+ if ((code & 0x80) == 0x00) { // 0xxxxxxx
+ return String.fromCharCode(code);
+ }
+ buffer.push(code);
+ if ((code & 0xE0) == 0xC0) { // 110xxxxx
+ needed = 1;
+ } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
+ needed = 2;
+ } else { // 11110xxx
+ needed = 3;
+ }
+ return '';
+ }
+
+ if (needed) {
+ buffer.push(code);
+ needed--;
+ if (needed > 0) return '';
+ }
+
+ var c1 = buffer[0];
+ var c2 = buffer[1];
+ var c3 = buffer[2];
+ var c4 = buffer[3];
+ var ret;
+ if (buffer.length == 2) {
+ ret = String.fromCharCode(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+ } else if (buffer.length == 3) {
+ ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+ } else {
+ // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+ var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
+ ((c3 & 0x3F) << 6) | (c4 & 0x3F);
+ ret = String.fromCharCode(
+ Math.floor((codePoint - 0x10000) / 0x400) + 0xD800,
+ (codePoint - 0x10000) % 0x400 + 0xDC00);
+ }
+ buffer.length = 0;
+ return ret;
+ }
+ this.processJSString = function processJSString(string) {
+ /* TODO: use TextEncoder when present,
+ var encoder = new TextEncoder();
+ encoder['encoding'] = "utf-8";
+ var utf8Array = encoder['encode'](aMsg.data);
+ */
+ string = unescape(encodeURIComponent(string));
+ var ret = [];
+ for (var i = 0; i < string.length; i++) {
+ ret.push(string.charCodeAt(i));
+ }
+ return ret;
+ }
+ },
+ getCompilerSetting: function (name) {
+ throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+ },
+ stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+7)&-8); return ret; },
+ staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+7)&-8); return ret; },
+ dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+7)&-8); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
+ alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 8))*(quantum ? quantum : 8); return ret; },
+ makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; },
+ GLOBAL_BASE: 8,
+ QUANTUM_SIZE: 4,
+ __dummy__: 0
+}
+
+
+Module['Runtime'] = Runtime;
+
+
+
+
+
+
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var __THREW__ = 0; // Used in checking for thrown exceptions.
+
+var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+var undef = 0;
+// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
+// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
+var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD, tempDouble, tempFloat;
+var tempI64, tempI64b;
+var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;
+
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed: ' + text);
+ }
+}
+
+var globalScope = this;
+
+// C calling interface. A convenient way to call C functions (in C files, or
+// defined with extern "C").
+//
+// Note: LLVM optimizations can inline and remove functions, after which you will not be
+// able to call them. Closure can also do so. To avoid that, add your function to
+// the exports using something like
+//
+// -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
+//
+// @param ident The name of the C function (note that C++ functions will be name-mangled - use extern "C")
+// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
+// 'array' for JavaScript arrays and typed arrays; note that arrays are 8-bit).
+// @param argTypes An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
+// except that 'array' is not possible (there is no way for us to know the length of the array)
+// @param args An array of the arguments to the function, as native JS values (as in returnType)
+// Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
+// @return The return value, as a native JS value (as in returnType)
+function ccall(ident, returnType, argTypes, args) {
+ return ccallFunc(getCFunc(ident), returnType, argTypes, args);
+}
+Module["ccall"] = ccall;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+ try {
+ var func = Module['_' + ident]; // closure exported function
+ if (!func) func = eval('_' + ident); // explicit lookup
+ } catch(e) {
+ }
+ assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+ return func;
+}
+
+// Internal function that does a C call using a function, not an identifier
+function ccallFunc(func, returnType, argTypes, args) {
+ var stack = 0;
+ function toC(value, type) {
+ if (type == 'string') {
+ if (value === null || value === undefined || value === 0) return 0; // null string
+ value = intArrayFromString(value);
+ type = 'array';
+ }
+ if (type == 'array') {
+ if (!stack) stack = Runtime.stackSave();
+ var ret = Runtime.stackAlloc(value.length);
+ writeArrayToMemory(value, ret);
+ return ret;
+ }
+ return value;
+ }
+ function fromC(value, type) {
+ if (type == 'string') {
+ return Pointer_stringify(value);
+ }
+ assert(type != 'array');
+ return value;
+ }
+ var i = 0;
+ var cArgs = args ? args.map(function(arg) {
+ return toC(arg, argTypes[i++]);
+ }) : [];
+ var ret = fromC(func.apply(null, cArgs), returnType);
+ if (stack) Runtime.stackRestore(stack);
+ return ret;
+}
+
+// Returns a native JS wrapper for a C function. This is similar to ccall, but
+// returns a function you can call repeatedly in a normal way. For example:
+//
+// var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
+// alert(my_function(5, 22));
+// alert(my_function(99, 12));
+//
+function cwrap(ident, returnType, argTypes) {
+ var func = getCFunc(ident);
+ return function() {
+ return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
+ }
+}
+Module["cwrap"] = cwrap;
+
+// Sets a value in memory in a dynamic way at run-time. Uses the
+// type data. This is the same as makeSetValue, except that
+// makeSetValue is done at compile-time and generates the needed
+// code then, whereas this function picks the right code at
+// run-time.
+// Note that setValue and getValue only do *aligned* writes and reads!
+// Note that ccall uses JS types as for defining types, while setValue and
+// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
+function setValue(ptr, value, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': HEAP8[(ptr)]=value; break;
+ case 'i8': HEAP8[(ptr)]=value; break;
+ case 'i16': HEAP16[((ptr)>>1)]=value; break;
+ case 'i32': HEAP32[((ptr)>>2)]=value; break;
+ case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+ case 'float': HEAPF32[((ptr)>>2)]=value; break;
+ case 'double': HEAPF64[((ptr)>>3)]=value; break;
+ default: abort('invalid type for setValue: ' + type);
+ }
+}
+Module['setValue'] = setValue;
+
+// Parallel to setValue.
+function getValue(ptr, type, noSafe) {
+ type = type || 'i8';
+ if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+ switch(type) {
+ case 'i1': return HEAP8[(ptr)];
+ case 'i8': return HEAP8[(ptr)];
+ case 'i16': return HEAP16[((ptr)>>1)];
+ case 'i32': return HEAP32[((ptr)>>2)];
+ case 'i64': return HEAP32[((ptr)>>2)];
+ case 'float': return HEAPF32[((ptr)>>2)];
+ case 'double': return HEAPF64[((ptr)>>3)];
+ default: abort('invalid type for setValue: ' + type);
+ }
+ return null;
+}
+Module['getValue'] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
+Module['ALLOC_STACK'] = ALLOC_STACK;
+Module['ALLOC_STATIC'] = ALLOC_STATIC;
+Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC;
+Module['ALLOC_NONE'] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+// is a little tricky (see docs right below). The reason is that it is optimized
+// for multiple syntaxes to save space in generated code. So you should
+// normally not use allocate(), and instead allocate memory using _malloc(),
+// initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+// in *bytes* (note that this is sometimes confusing: the next parameter does not
+// affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+// or a single type which is used for the entire block. This only matters if there
+// is initial data - if @slab is a number, then this does not matter at all and is
+// ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+ var zeroinit, size;
+ if (typeof slab === 'number') {
+ zeroinit = true;
+ size = slab;
+ } else {
+ zeroinit = false;
+ size = slab.length;
+ }
+
+ var singleType = typeof types === 'string' ? types : null;
+
+ var ret;
+ if (allocator == ALLOC_NONE) {
+ ret = ptr;
+ } else {
+ ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+ }
+
+ if (zeroinit) {
+ var ptr = ret, stop;
+ assert((ret & 3) == 0);
+ stop = ret + (size & ~3);
+ for (; ptr < stop; ptr += 4) {
+ HEAP32[((ptr)>>2)]=0;
+ }
+ stop = ret + size;
+ while (ptr < stop) {
+ HEAP8[((ptr++)|0)]=0;
+ }
+ return ret;
+ }
+
+ if (singleType === 'i8') {
+ if (slab.subarray || slab.slice) {
+ HEAPU8.set(slab, ret);
+ } else {
+ HEAPU8.set(new Uint8Array(slab), ret);
+ }
+ return ret;
+ }
+
+ var i = 0, type, typeSize, previousType;
+ while (i < size) {
+ var curr = slab[i];
+
+ if (typeof curr === 'function') {
+ curr = Runtime.getFunctionIndex(curr);
+ }
+
+ type = singleType || types[i];
+ if (type === 0) {
+ i++;
+ continue;
+ }
+
+ if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+ setValue(ret+i, curr, type);
+
+ // no need to look up size unless type changes, so cache it
+ if (previousType !== type) {
+ typeSize = Runtime.getNativeTypeSize(type);
+ previousType = type;
+ }
+ i += typeSize;
+ }
+
+ return ret;
+}
+Module['allocate'] = allocate;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+ // TODO: use TextDecoder
+ // Find the length, and check for UTF while doing so
+ var hasUtf = false;
+ var t;
+ var i = 0;
+ while (1) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ if (t >= 128) hasUtf = true;
+ else if (t == 0 && !length) break;
+ i++;
+ if (length && i == length) break;
+ }
+ if (!length) length = i;
+
+ var ret = '';
+
+ if (!hasUtf) {
+ var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+ var curr;
+ while (length > 0) {
+ curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+ ret = ret ? ret + curr : curr;
+ ptr += MAX_CHUNK;
+ length -= MAX_CHUNK;
+ }
+ return ret;
+ }
+
+ var utf8 = new Runtime.UTF8Processor();
+ for (i = 0; i < length; i++) {
+ t = HEAPU8[(((ptr)+(i))|0)];
+ ret += utf8.processCChar(t);
+ }
+ return ret;
+}
+Module['Pointer_stringify'] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF16ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+ if (codeUnit == 0)
+ return str;
+ ++i;
+ // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+ str += String.fromCharCode(codeUnit);
+ }
+}
+Module['UTF16ToString'] = UTF16ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16LE form. The copy will require at most (str.length*2+1)*2 bytes of space in the HEAP.
+function stringToUTF16(str, outPtr) {
+ for(var i = 0; i < str.length; ++i) {
+ // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+ var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+ HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
+}
+Module['stringToUTF16'] = stringToUTF16;
+
+// Given a pointer 'ptr' to a null-terminated UTF32LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+function UTF32ToString(ptr) {
+ var i = 0;
+
+ var str = '';
+ while (1) {
+ var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+ if (utf32 == 0)
+ return str;
+ ++i;
+ // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+ if (utf32 >= 0x10000) {
+ var ch = utf32 - 0x10000;
+ str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+}
+Module['UTF32ToString'] = UTF32ToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32LE form. The copy will require at most (str.length+1)*4 bytes of space in the HEAP,
+// but can use less, since str.length does not return the number of characters in the string, but the number of UTF-16 code units in the string.
+function stringToUTF32(str, outPtr) {
+ var iChar = 0;
+ for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+ var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
+ if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+ var trailSurrogate = str.charCodeAt(++iCodeUnit);
+ codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+ }
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
+ ++iChar;
+ }
+ // Null-terminate the pointer to the HEAP.
+ HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
+}
+Module['stringToUTF32'] = stringToUTF32;
+
+function demangle(func) {
+ var i = 3;
+ // params, etc.
+ var basicTypes = {
+ 'v': 'void',
+ 'b': 'bool',
+ 'c': 'char',
+ 's': 'short',
+ 'i': 'int',
+ 'l': 'long',
+ 'f': 'float',
+ 'd': 'double',
+ 'w': 'wchar_t',
+ 'a': 'signed char',
+ 'h': 'unsigned char',
+ 't': 'unsigned short',
+ 'j': 'unsigned int',
+ 'm': 'unsigned long',
+ 'x': 'long long',
+ 'y': 'unsigned long long',
+ 'z': '...'
+ };
+ var subs = [];
+ var first = true;
+ function dump(x) {
+ //return;
+ if (x) Module.print(x);
+ Module.print(func);
+ var pre = '';
+ for (var a = 0; a < i; a++) pre += ' ';
+ Module.print (pre + '^');
+ }
+ function parseNested() {
+ i++;
+ if (func[i] === 'K') i++; // ignore const
+ var parts = [];
+ while (func[i] !== 'E') {
+ if (func[i] === 'S') { // substitution
+ i++;
+ var next = func.indexOf('_', i);
+ var num = func.substring(i, next) || 0;
+ parts.push(subs[num] || '?');
+ i = next+1;
+ continue;
+ }
+ if (func[i] === 'C') { // constructor
+ parts.push(parts[parts.length-1]);
+ i += 2;
+ continue;
+ }
+ var size = parseInt(func.substr(i));
+ var pre = size.toString().length;
+ if (!size || !pre) { i--; break; } // counter i++ below us
+ var curr = func.substr(i + pre, size);
+ parts.push(curr);
+ subs.push(curr);
+ i += pre + size;
+ }
+ i++; // skip E
+ return parts;
+ }
+ function parse(rawList, limit, allowVoid) { // main parser
+ limit = limit || Infinity;
+ var ret = '', list = [];
+ function flushList() {
+ return '(' + list.join(', ') + ')';
+ }
+ var name;
+ if (func[i] === 'N') {
+ // namespaced N-E
+ name = parseNested().join('::');
+ limit--;
+ if (limit === 0) return rawList ? [name] : name;
+ } else {
+ // not namespaced
+ if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L'
+ var size = parseInt(func.substr(i));
+ if (size) {
+ var pre = size.toString().length;
+ name = func.substr(i + pre, size);
+ i += pre + size;
+ }
+ }
+ first = false;
+ if (func[i] === 'I') {
+ i++;
+ var iList = parse(true);
+ var iRet = parse(true, 1, true);
+ ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>';
+ } else {
+ ret = name;
+ }
+ paramLoop: while (i < func.length && limit-- > 0) {
+ //dump('paramLoop');
+ var c = func[i++];
+ if (c in basicTypes) {
+ list.push(basicTypes[c]);
+ } else {
+ switch (c) {
+ case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer
+ case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference
+ case 'L': { // literal
+ i++; // skip basic type
+ var end = func.indexOf('E', i);
+ var size = end - i;
+ list.push(func.substr(i, size));
+ i += size + 2; // size + 'EE'
+ break;
+ }
+ case 'A': { // array
+ var size = parseInt(func.substr(i));
+ i += size.toString().length;
+ if (func[i] !== '_') throw '?';
+ i++; // skip _
+ list.push(parse(true, 1, true)[0] + ' [' + size + ']');
+ break;
+ }
+ case 'E': break paramLoop;
+ default: ret += '?' + c; break paramLoop;
+ }
+ }
+ }
+ if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void)
+ if (rawList) {
+ if (ret) {
+ list.push(ret + '?');
+ }
+ return list;
+ } else {
+ return ret + flushList();
+ }
+ }
+ try {
+ // Special-case the entry point, since its name differs from other name mangling.
+ if (func == 'Object._main' || func == '_main') {
+ return 'main()';
+ }
+ if (typeof func === 'number') func = Pointer_stringify(func);
+ if (func[0] !== '_') return func;
+ if (func[1] !== '_') return func; // C function
+ if (func[2] !== 'Z') return func;
+ switch (func[3]) {
+ case 'n': return 'operator new()';
+ case 'd': return 'operator delete()';
+ }
+ return parse();
+ } catch(e) {
+ return func;
+ }
+}
+
+function demangleAll(text) {
+ return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') });
+}
+
+function stackTrace() {
+ var stack = new Error().stack;
+ return stack ? demangleAll(stack) : '(no stack trace available)'; // Stack trace is not available at least on IE10 and Safari 6.
+}
+
+// Memory management
+
+var PAGE_SIZE = 4096;
+function alignMemoryPage(x) {
+ return (x+4095)&-4096;
+}
+
+var HEAP;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area
+var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area
+var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk
+
+function enlargeMemory() {
+ abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
+}
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728;
+var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;
+
+var totalMemory = 4096;
+while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
+ if (totalMemory < 16*1024*1024) {
+ totalMemory *= 2;
+ } else {
+ totalMemory += 16*1024*1024
+ }
+}
+if (totalMemory !== TOTAL_MEMORY) {
+ Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be more reasonable');
+ TOTAL_MEMORY = totalMemory;
+}
+
+// Initialize the runtime's memory
+// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
+assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
+ 'JS engine does not provide full typed array support');
+
+var buffer = new ArrayBuffer(TOTAL_MEMORY);
+HEAP8 = new Int8Array(buffer);
+HEAP16 = new Int16Array(buffer);
+HEAP32 = new Int32Array(buffer);
+HEAPU8 = new Uint8Array(buffer);
+HEAPU16 = new Uint16Array(buffer);
+HEAPU32 = new Uint32Array(buffer);
+HEAPF32 = new Float32Array(buffer);
+HEAPF64 = new Float64Array(buffer);
+
+// Endianness check (note: assumes compiler arch was little-endian)
+HEAP32[0] = 255;
+assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');
+
+Module['HEAP'] = HEAP;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+ while(callbacks.length > 0) {
+ var callback = callbacks.shift();
+ if (typeof callback == 'function') {
+ callback();
+ continue;
+ }
+ var func = callback.func;
+ if (typeof func === 'number') {
+ if (callback.arg === undefined) {
+ Runtime.dynCall('v', func);
+ } else {
+ Runtime.dynCall('vi', func, [callback.arg]);
+ }
+ } else {
+ func(callback.arg === undefined ? null : callback.arg);
+ }
+ }
+}
+
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+
+function preRun() {
+ // compatibility - merge in anything from Module['preRun'] at this time
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+ if (runtimeInitialized) return;
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ callRuntimeCallbacks(__ATEXIT__);
+}
+
+function postRun() {
+ // compatibility - merge in anything from Module['postRun'] at this time
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun;
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+Module['addOnInit'] = Module.addOnInit = addOnInit;
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain;
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+Module['addOnExit'] = Module.addOnExit = addOnExit;
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun;
+
+// Tools
+
+// This processes a JS string into a C-line array of numbers, 0-terminated.
+// For LLVM-originating strings, see parser.js:parseLLVMString function
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+ var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
+ if (length) {
+ ret.length = length;
+ }
+ if (!dontAddNull) {
+ ret.push(0);
+ }
+ return ret;
+}
+Module['intArrayFromString'] = intArrayFromString;
+
+function intArrayToString(array) {
+ var ret = [];
+ for (var i = 0; i < array.length; i++) {
+ var chr = array[i];
+ if (chr > 0xFF) {
+ chr &= 0xFF;
+ }
+ ret.push(String.fromCharCode(chr));
+ }
+ return ret.join('');
+}
+Module['intArrayToString'] = intArrayToString;
+
+// Write a Javascript array to somewhere in the heap
+function writeStringToMemory(string, buffer, dontAddNull) {
+ var array = intArrayFromString(string, dontAddNull);
+ var i = 0;
+ while (i < array.length) {
+ var chr = array[i];
+ HEAP8[(((buffer)+(i))|0)]=chr;
+ i = i + 1;
+ }
+}
+Module['writeStringToMemory'] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+ for (var i = 0; i < array.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=array[i];
+ }
+}
+Module['writeArrayToMemory'] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; i++) {
+ HEAP8[(((buffer)+(i))|0)]=str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[(((buffer)+(str.length))|0)]=0;
+}
+Module['writeAsciiToMemory'] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+ if (value >= 0) {
+ return value;
+ }
+ return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+ : Math.pow(2, bits) + value;
+}
+function reSign(value, bits, ignore) {
+ if (value <= 0) {
+ return value;
+ }
+ var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+ : Math.pow(2, bits-1);
+ if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+ // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+ // TODO: In i64 mode 1, resign the two parts separately and safely
+ value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+ }
+ return value;
+}
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+ var ah = a >>> 16;
+ var al = a & 0xffff;
+ var bh = b >>> 16;
+ var bl = b & 0xffff;
+ return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_min = Math.min;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+}
+Module['addRunDependency'] = addRunDependency;
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module['monitorRunDependencies']) {
+ Module['monitorRunDependencies'](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+Module['removeRunDependency'] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+var memoryInitializer = null;
+
+// === Body ===
+
+
+
+
+
+STATIC_BASE = 8;
+
+STATICTOP = STATIC_BASE + Runtime.alignMemory(14963);
+/* global initializers */ __ATINIT__.push();
+
+
+/* memory initializer */ allocate([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,115,105,122,101,115,58,32,37,100,44,37,100,10,0,0,0,100,101,99,111,109,112,114,101,115,115,101,100,83,105,122,101,32,61,61,32,115,105,122,101,0,0,0,0,0,0,0,0,47,116,109,112,47,101,109,115,99,114,105,112,116,101,110,95,116,101,109,112,47,122,108,105,98,46,99,0,0,0,0,0,100,111,105,116,0,0,0,0,115,116,114,99,109,112,40,98,117,102,102,101,114,44,32,98,117,102,102,101,114,51,41,32,61,61,32,48,0,0,0,0,101,114,114,111,114,58,32,37,100,92,110,0,0,0,0,0,111,107,46,0,0,0,0,0,49,46,50,46,53,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,4,0,4,0,8,0,4,0,2,0,0,0,4,0,5,0,16,0,8,0,2,0,0,0,4,0,6,0,32,0,32,0,2,0,0,0,4,0,4,0,16,0,16,0,3,0,0,0,8,0,16,0,32,0,32,0,3,0,0,0,8,0,16,0,128,0,128,0,3,0,0,0,8,0,32,0,128,0,0,1,3,0,0,0,32,0,128,0,2,1,0,4,3,0,0,0,32,0,2,1,2,1,0,16,3,0,0,0,0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,0,0,16,17,18,18,19,19,20,20,20,20,21,21,21,21,22,22,22,22,22,22,22,22,23,23,23,23,23,23,23,23,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,0,1,2,3,4,5,6,7,8,8,9,9,10,10,11,11,12,12,12,12,13,13,13,13,14,14,14,14,15,15,15,15,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,22,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,112,4,0,0,104,9,0,0,1,1,0,0,30,1,0,0,15,0,0,0,0,0,0,0,240,8,0,0,88,10,0,0,0,0,0,0,30,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,96,11,0,0,0,0,0,0,19,0,0,0,7,0,0,0,0,0,0,0,12,0,8,0,140,0,8,0,76,0,8,0,204,0,8,0,44,0,8,0,172,0,8,0,108,0,8,0,236,0,8,0,28,0,8,0,156,0,8,0,92,0,8,0,220,0,8,0,60,0,8,0,188,0,8,0,124,0,8,0,252,0,8,0,2,0,8,0,130,0,8,0,66,0,8,0,194,0,8,0,34,0,8,0,162,0,8,0,98,0,8,0,226,0,8,0,18,0,8,0,146,0,8,0,82,0,8,0,210,0,8,0,50,0,8,0,178,0,8,0,114,0,8,0,242,0,8,0,10,0,8,0,138,0,8,0,74,0,8,0,202,0,8,0,42,0,8,0,170,0,8,0,106,0,8,0,234,0,8,0,26,0,8,0,154,0,8,0,90,0,8,0,218,0,8,0,58,0,8,0,186,0,8,0,122,0,8,0,250,0,8,0,6,0,8,0,134,0,8,0,70,0,8,0,198,0,8,0,38,0,8,0,166,0,8,0,102,0,8,0,230,0,8,0,22,0,8,0,150,0,8,0,86,0,8,0,214,0,8,0,54,0,8,0,182,0,8,0,118,0,8,0,246,0,8,0,14,0,8,0,142,0,8,0,78,0,8,0,206,0,8,0,46,0,8,0,174,0,8,0,110,0,8,0,238,0,8,0,30,0,8,0,158,0,8,0,94,0,8,0,222,0,8,0,62,0,8,0,190,0,8,0,126,0,8,0,254,0,8,0,1,0,8,0,129,0,8,0,65,0,8,0,193,0,8,0,33,0,8,0,161,0,8,0,97,0,8,0,225,0,8,0,17,0,8,0,145,0,8,0,81,0,8,0,209,0,8,0,49,0,8,0,177,0,8,0,113,0,8,0,241,0,8,0,9,0,8,0,137,0,8,0,73,0,8,0,201,0,8,0,41,0,8,0,169,0,8,0,105,0,8,0,233,0,8,0,25,0,8,0,153,0,8,0,89,0,8,0,217,0,8,0,57,0,8,0,185,0,8,0,121,0,8,0,249,0,8,0,5,0,8,0,133,0,8,0,69,0,8,0,197,0,8,0,37,0,8,0,165,0,8,0,101,0,8,0,229,0,8,0,21,0,8,0,149,0,8,0,85,0,8,0,213,0,8,0,53,0,8,0,181,0,8,0,117,0,8,0,245,0,8,0,13,0,8,0,141,0,8,0,77,0,8,0,205,0,8,0,45,0,8,0,173,0,8,0,109,0,8,0,237,0,8,0,29,0,8,0,157,0,8,0,93,0,8,0,221,0,8,0,61,0,8,0,189,0,8,0,125,0,8,0,253,0,8,0,19,0,9,0,19,1,9,0,147,0,9,0,147,1,9,0,83,0,9,0,83,1,9,0,211,0,9,0,211,1,9,0,51,0,9,0,51,1,9,0,179,0,9,0,179,1,9,0,115,0,9,0,115,1,9,0,243,0,9,0,243,1,9,0,11,0,9,0,11,1,9,0,139,0,9,0,139,1,9,0,75,0,9,0,75,1,9,0,203,0,9,0,203,1,9,0,43,0,9,0,43,1,9,0,171,0,9,0,171,1,9,0,107,0,9,0,107,1,9,0,235,0,9,0,235,1,9,0,27,0,9,0,27,1,9,0,155,0,9,0,155,1,9,0,91,0,9,0,91,1,9,0,219,0,9,0,219,1,9,0,59,0,9,0,59,1,9,0,187,0,9,0,187,1,9,0,123,0,9,0,123,1,9,0,251,0,9,0,251,1,9,0,7,0,9,0,7,1,9,0,135,0,9,0,135,1,9,0,71,0,9,0,71,1,9,0,199,0,9,0,199,1,9,0,39,0,9,0,39,1,9,0,167,0,9,0,167,1,9,0,103,0,9,0,103,1,9,0,231,0,9,0,231,1,9,0,23,0,9,0,23,1,9,0,151,0,9,0,151,1,9,0,87,0,9,0,87,1,9,0,215,0,9,0,215,1,9,0,55,0,9,0,55,1,9,0,183,0,9,0,183,1,9,0,119,0,9,0,119,1,9,0,247,0,9,0,247,1,9,0,15,0,9,0,15,1,9,0,143,0,9,0,143,1,9,0,79,0,9,0,79,1,9,0,207,0,9,0,207,1,9,0,47,0,9,0,47,1,9,0,175,0,9,0,175,1,9,0,111,0,9,0,111,1,9,0,239,0,9,0,239,1,9,0,31,0,9,0,31,1,9,0,159,0,9,0,159,1,9,0,95,0,9,0,95,1,9,0,223,0,9,0,223,1,9,0,63,0,9,0,63,1,9,0,191,0,9,0,191,1,9,0,127,0,9,0,127,1,9,0,255,0,9,0,255,1,9,0,0,0,7,0,64,0,7,0,32,0,7,0,96,0,7,0,16,0,7,0,80,0,7,0,48,0,7,0,112,0,7,0,8,0,7,0,72,0,7,0,40,0,7,0,104,0,7,0,24,0,7,0,88,0,7,0,56,0,7,0,120,0,7,0,4,0,7,0,68,0,7,0,36,0,7,0,100,0,7,0,20,0,7,0,84,0,7,0,52,0,7,0,116,0,7,0,3,0,8,0,131,0,8,0,67,0,8,0,195,0,8,0,35,0,8,0,163,0,8,0,99,0,8,0,227,0,8,0,0,0,5,0,16,0,5,0,8,0,5,0,24,0,5,0,4,0,5,0,20,0,5,0,12,0,5,0,28,0,5,0,2,0,5,0,18,0,5,0,10,0,5,0,26,0,5,0,6,0,5,0,22,0,5,0,14,0,5,0,30,0,5,0,1,0,5,0,17,0,5,0,9,0,5,0,25,0,5,0,5,0,5,0,21,0,5,0,13,0,5,0,29,0,5,0,3,0,5,0,19,0,5,0,11,0,5,0,27,0,5,0,7,0,5,0,23,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,3,0,0,0,3,0,0,0,3,0,0,0,3,0,0,0,4,0,0,0,4,0,0,0,4,0,0,0,4,0,0,0,5,0,0,0,5,0,0,0,5,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,5,0,0,0,6,0,0,0,7,0,0,0,8,0,0,0,10,0,0,0,12,0,0,0,14,0,0,0,16,0,0,0,20,0,0,0,24,0,0,0,28,0,0,0,32,0,0,0,40,0,0,0,48,0,0,0,56,0,0,0,64,0,0,0,80,0,0,0,96,0,0,0,112,0,0,0,128,0,0,0,160,0,0,0,192,0,0,0,224,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,2,0,0,0,2,0,0,0,3,0,0,0,3,0,0,0,4,0,0,0,4,0,0,0,5,0,0,0,5,0,0,0,6,0,0,0,6,0,0,0,7,0,0,0,7,0,0,0,8,0,0,0,8,0,0,0,9,0,0,0,9,0,0,0,10,0,0,0,10,0,0,0,11,0,0,0,11,0,0,0,12,0,0,0,12,0,0,0,13,0,0,0,13,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,6,0,0,0,8,0,0,0,12,0,0,0,16,0,0,0,24,0,0,0,32,0,0,0,48,0,0,0,64,0,0,0,96,0,0,0,128,0,0,0,192,0,0,0,0,1,0,0,128,1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,6,0,0,0,8,0,0,0,12,0,0,0,16,0,0,0,24,0,0,0,32,0,0,0,48,0,0,0,64,0,0,0,96,0,0,16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,7,0,0,0,0,0,0,0,49,46,50,46,53,0,0,0,110,101,101,100,32,100,105,99,116,105,111,110,97,114,121,0,115,116,114,101,97,109,32,101,110,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,105,108,101,32,101,114,114,111,114,0,0,0,0,0,0,115,116,114,101,97,109,32,101,114,114,111,114,0,0,0,0,100,97,116,97,32,101,114,114,111,114,0,0,0,0,0,0,105,110,115,117,102,102,105,99,105,101,110,116,32,109,101,109,111,114,121,0,0,0,0,0,98,117,102,102,101,114,32,101,114,114,111,114,0,0,0,0,105,110,99,111,109,112,97,116,105,98,108,101,32,118,101,114,115,105,111,110,0,0,0,0,184,11,0,0,200,11,0,0,216,11,0,0,224,11,0,0,240,11,0,0,0,12,0,0,16,12,0,0,40,12,0,0,56,12,0,0,216,11,0,0,0,0,0,0,150,48,7,119,44,97,14,238,186,81,9,153,25,196,109,7,143,244,106,112,53,165,99,233,163,149,100,158,50,136,219,14,164,184,220,121,30,233,213,224,136,217,210,151,43,76,182,9,189,124,177,126,7,45,184,231,145,29,191,144,100,16,183,29,242,32,176,106,72,113,185,243,222,65,190,132,125,212,218,26,235,228,221,109,81,181,212,244,199,133,211,131,86,152,108,19,192,168,107,100,122,249,98,253,236,201,101,138,79,92,1,20,217,108,6,99,99,61,15,250,245,13,8,141,200,32,110,59,94,16,105,76,228,65,96,213,114,113,103,162,209,228,3,60,71,212,4,75,253,133,13,210,107,181,10,165,250,168,181,53,108,152,178,66,214,201,187,219,64,249,188,172,227,108,216,50,117,92,223,69,207,13,214,220,89,61,209,171,172,48,217,38,58,0,222,81,128,81,215,200,22,97,208,191,181,244,180,33,35,196,179,86,153,149,186,207,15,165,189,184,158,184,2,40,8,136,5,95,178,217,12,198,36,233,11,177,135,124,111,47,17,76,104,88,171,29,97,193,61,45,102,182,144,65,220,118,6,113,219,1,188,32,210,152,42,16,213,239,137,133,177,113,31,181,182,6,165,228,191,159,51,212,184,232,162,201,7,120,52,249,0,15,142,168,9,150,24,152,14,225,187,13,106,127,45,61,109,8,151,108,100,145,1,92,99,230,244,81,107,107,98,97,108,28,216,48,101,133,78,0,98,242,237,149,6,108,123,165,1,27,193,244,8,130,87,196,15,245,198,217,176,101,80,233,183,18,234,184,190,139,124,136,185,252,223,29,221,98,73,45,218,21,243,124,211,140,101,76,212,251,88,97,178,77,206,81,181,58,116,0,188,163,226,48,187,212,65,165,223,74,215,149,216,61,109,196,209,164,251,244,214,211,106,233,105,67,252,217,110,52,70,136,103,173,208,184,96,218,115,45,4,68,229,29,3,51,95,76,10,170,201,124,13,221,60,113,5,80,170,65,2,39,16,16,11,190,134,32,12,201,37,181,104,87,179,133,111,32,9,212,102,185,159,228,97,206,14,249,222,94,152,201,217,41,34,152,208,176,180,168,215,199,23,61,179,89,129,13,180,46,59,92,189,183,173,108,186,192,32,131,184,237,182,179,191,154,12,226,182,3,154,210,177,116,57,71,213,234,175,119,210,157,21,38,219,4,131,22,220,115,18,11,99,227,132,59,100,148,62,106,109,13,168,90,106,122,11,207,14,228,157,255,9,147,39,174,0,10,177,158,7,125,68,147,15,240,210,163,8,135,104,242,1,30,254,194,6,105,93,87,98,247,203,103,101,128,113,54,108,25,231,6,107,110,118,27,212,254,224,43,211,137,90,122,218,16,204,74,221,103,111,223,185,249,249,239,190,142,67,190,183,23,213,142,176,96,232,163,214,214,126,147,209,161,196,194,216,56,82,242,223,79,241,103,187,209,103,87,188,166,221,6,181,63,75,54,178,72,218,43,13,216,76,27,10,175,246,74,3,54,96,122,4,65,195,239,96,223,85,223,103,168,239,142,110,49,121,190,105,70,140,179,97,203,26,131,102,188,160,210,111,37,54,226,104,82,149,119,12,204,3,71,11,187,185,22,2,34,47,38,5,85,190,59,186,197,40,11,189,178,146,90,180,43,4,106,179,92,167,255,215,194,49,207,208,181,139,158,217,44,29,174,222,91,176,194,100,155,38,242,99,236,156,163,106,117,10,147,109,2,169,6,9,156,63,54,14,235,133,103,7,114,19,87,0,5,130,74,191,149,20,122,184,226,174,43,177,123,56,27,182,12,155,142,210,146,13,190,213,229,183,239,220,124,33,223,219,11,212,210,211,134,66,226,212,241,248,179,221,104,110,131,218,31,205,22,190,129,91,38,185,246,225,119,176,111,119,71,183,24,230,90,8,136,112,106,15,255,202,59,6,102,92,11,1,17,255,158,101,143,105,174,98,248,211,255,107,97,69,207,108,22,120,226,10,160,238,210,13,215,84,131,4,78,194,179,3,57,97,38,103,167,247,22,96,208,77,71,105,73,219,119,110,62,74,106,209,174,220,90,214,217,102,11,223,64,240,59,216,55,83,174,188,169,197,158,187,222,127,207,178,71,233,255,181,48,28,242,189,189,138,194,186,202,48,147,179,83,166,163,180,36,5,54,208,186,147,6,215,205,41,87,222,84,191,103,217,35,46,122,102,179,184,74,97,196,2,27,104,93,148,43,111,42,55,190,11,180,161,142,12,195,27,223,5,90,141,239,2,45,0,0,0,0,65,49,27,25,130,98,54,50,195,83,45,43,4,197,108,100,69,244,119,125,134,167,90,86,199,150,65,79,8,138,217,200,73,187,194,209,138,232,239,250,203,217,244,227,12,79,181,172,77,126,174,181,142,45,131,158,207,28,152,135,81,18,194,74,16,35,217,83,211,112,244,120,146,65,239,97,85,215,174,46,20,230,181,55,215,181,152,28,150,132,131,5,89,152,27,130,24,169,0,155,219,250,45,176,154,203,54,169,93,93,119,230,28,108,108,255,223,63,65,212,158,14,90,205,162,36,132,149,227,21,159,140,32,70,178,167,97,119,169,190,166,225,232,241,231,208,243,232,36,131,222,195,101,178,197,218,170,174,93,93,235,159,70,68,40,204,107,111,105,253,112,118,174,107,49,57,239,90,42,32,44,9,7,11,109,56,28,18,243,54,70,223,178,7,93,198,113,84,112,237,48,101,107,244,247,243,42,187,182,194,49,162,117,145,28,137,52,160,7,144,251,188,159,23,186,141,132,14,121,222,169,37,56,239,178,60,255,121,243,115,190,72,232,106,125,27,197,65,60,42,222,88,5,79,121,240,68,126,98,233,135,45,79,194,198,28,84,219,1,138,21,148,64,187,14,141,131,232,35,166,194,217,56,191,13,197,160,56,76,244,187,33,143,167,150,10,206,150,141,19,9,0,204,92,72,49,215,69,139,98,250,110,202,83,225,119,84,93,187,186,21,108,160,163,214,63,141,136,151,14,150,145,80,152,215,222,17,169,204,199,210,250,225,236,147,203,250,245,92,215,98,114,29,230,121,107,222,181,84,64,159,132,79,89,88,18,14,22,25,35,21,15,218,112,56,36,155,65,35,61,167,107,253,101,230,90,230,124,37,9,203,87,100,56,208,78,163,174,145,1,226,159,138,24,33,204,167,51,96,253,188,42,175,225,36,173,238,208,63,180,45,131,18,159,108,178,9,134,171,36,72,201,234,21,83,208,41,70,126,251,104,119,101,226,246,121,63,47,183,72,36,54,116,27,9,29,53,42,18,4,242,188,83,75,179,141,72,82,112,222,101,121,49,239,126,96,254,243,230,231,191,194,253,254,124,145,208,213,61,160,203,204,250,54,138,131,187,7,145,154,120,84,188,177,57,101,167,168,75,152,131,59,10,169,152,34,201,250,181,9,136,203,174,16,79,93,239,95,14,108,244,70,205,63,217,109,140,14,194,116,67,18,90,243,2,35,65,234,193,112,108,193,128,65,119,216,71,215,54,151,6,230,45,142,197,181,0,165,132,132,27,188,26,138,65,113,91,187,90,104,152,232,119,67,217,217,108,90,30,79,45,21,95,126,54,12,156,45,27,39,221,28,0,62,18,0,152,185,83,49,131,160,144,98,174,139,209,83,181,146,22,197,244,221,87,244,239,196,148,167,194,239,213,150,217,246,233,188,7,174,168,141,28,183,107,222,49,156,42,239,42,133,237,121,107,202,172,72,112,211,111,27,93,248,46,42,70,225,225,54,222,102,160,7,197,127,99,84,232,84,34,101,243,77,229,243,178,2,164,194,169,27,103,145,132,48,38,160,159,41,184,174,197,228,249,159,222,253,58,204,243,214,123,253,232,207,188,107,169,128,253,90,178,153,62,9,159,178,127,56,132,171,176,36,28,44,241,21,7,53,50,70,42,30,115,119,49,7,180,225,112,72,245,208,107,81,54,131,70,122,119,178,93,99,78,215,250,203,15,230,225,210,204,181,204,249,141,132,215,224,74,18,150,175,11,35,141,182,200,112,160,157,137,65,187,132,70,93,35,3,7,108,56,26,196,63,21,49,133,14,14,40,66,152,79,103,3,169,84,126,192,250,121,85,129,203,98,76,31,197,56,129,94,244,35,152,157,167,14,179,220,150,21,170,27,0,84,229,90,49,79,252,153,98,98,215,216,83,121,206,23,79,225,73,86,126,250,80,149,45,215,123,212,28,204,98,19,138,141,45,82,187,150,52,145,232,187,31,208,217,160,6,236,243,126,94,173,194,101,71,110,145,72,108,47,160,83,117,232,54,18,58,169,7,9,35,106,84,36,8,43,101,63,17,228,121,167,150,165,72,188,143,102,27,145,164,39,42,138,189,224,188,203,242,161,141,208,235,98,222,253,192,35,239,230,217,189,225,188,20,252,208,167,13,63,131,138,38,126,178,145,63,185,36,208,112,248,21,203,105,59,70,230,66,122,119,253,91,181,107,101,220,244,90,126,197,55,9,83,238,118,56,72,247,177,174,9,184,240,159,18,161,51,204,63,138,114,253,36,147,0,0,0,0,55,106,194,1,110,212,132,3,89,190,70,2,220,168,9,7,235,194,203,6,178,124,141,4,133,22,79,5,184,81,19,14,143,59,209,15,214,133,151,13,225,239,85,12,100,249,26,9,83,147,216,8,10,45,158,10,61,71,92,11,112,163,38,28,71,201,228,29,30,119,162,31,41,29,96,30,172,11,47,27,155,97,237,26,194,223,171,24,245,181,105,25,200,242,53,18,255,152,247,19,166,38,177,17,145,76,115,16,20,90,60,21,35,48,254,20,122,142,184,22,77,228,122,23,224,70,77,56,215,44,143,57,142,146,201,59,185,248,11,58,60,238,68,63,11,132,134,62,82,58,192,60,101,80,2,61,88,23,94,54,111,125,156,55,54,195,218,53,1,169,24,52,132,191,87,49,179,213,149,48,234,107,211,50,221,1,17,51,144,229,107,36,167,143,169,37,254,49,239,39,201,91,45,38,76,77,98,35,123,39,160,34,34,153,230,32,21,243,36,33,40,180,120,42,31,222,186,43,70,96,252,41,113,10,62,40,244,28,113,45,195,118,179,44,154,200,245,46,173,162,55,47,192,141,154,112,247,231,88,113,174,89,30,115,153,51,220,114,28,37,147,119,43,79,81,118,114,241,23,116,69,155,213,117,120,220,137,126,79,182,75,127,22,8,13,125,33,98,207,124,164,116,128,121,147,30,66,120,202,160,4,122,253,202,198,123,176,46,188,108,135,68,126,109,222,250,56,111,233,144,250,110,108,134,181,107,91,236,119,106,2,82,49,104,53,56,243,105,8,127,175,98,63,21,109,99,102,171,43,97,81,193,233,96,212,215,166,101,227,189,100,100,186,3,34,102,141,105,224,103,32,203,215,72,23,161,21,73,78,31,83,75,121,117,145,74,252,99,222,79,203,9,28,78,146,183,90,76,165,221,152,77,152,154,196,70,175,240,6,71,246,78,64,69,193,36,130,68,68,50,205,65,115,88,15,64,42,230,73,66,29,140,139,67,80,104,241,84,103,2,51,85,62,188,117,87,9,214,183,86,140,192,248,83,187,170,58,82,226,20,124,80,213,126,190,81,232,57,226,90,223,83,32,91,134,237,102,89,177,135,164,88,52,145,235,93,3,251,41,92,90,69,111,94,109,47,173,95,128,27,53,225,183,113,247,224,238,207,177,226,217,165,115,227,92,179,60,230,107,217,254,231,50,103,184,229,5,13,122,228,56,74,38,239,15,32,228,238,86,158,162,236,97,244,96,237,228,226,47,232,211,136,237,233,138,54,171,235,189,92,105,234,240,184,19,253,199,210,209,252,158,108,151,254,169,6,85,255,44,16,26,250,27,122,216,251,66,196,158,249,117,174,92,248,72,233,0,243,127,131,194,242,38,61,132,240,17,87,70,241,148,65,9,244,163,43,203,245,250,149,141,247,205,255,79,246,96,93,120,217,87,55,186,216,14,137,252,218,57,227,62,219,188,245,113,222,139,159,179,223,210,33,245,221,229,75,55,220,216,12,107,215,239,102,169,214,182,216,239,212,129,178,45,213,4,164,98,208,51,206,160,209,106,112,230,211,93,26,36,210,16,254,94,197,39,148,156,196,126,42,218,198,73,64,24,199,204,86,87,194,251,60,149,195,162,130,211,193,149,232,17,192,168,175,77,203,159,197,143,202,198,123,201,200,241,17,11,201,116,7,68,204,67,109,134,205,26,211,192,207,45,185,2,206,64,150,175,145,119,252,109,144,46,66,43,146,25,40,233,147,156,62,166,150,171,84,100,151,242,234,34,149,197,128,224,148,248,199,188,159,207,173,126,158,150,19,56,156,161,121,250,157,36,111,181,152,19,5,119,153,74,187,49,155,125,209,243,154,48,53,137,141,7,95,75,140,94,225,13,142,105,139,207,143,236,157,128,138,219,247,66,139,130,73,4,137,181,35,198,136,136,100,154,131,191,14,88,130,230,176,30,128,209,218,220,129,84,204,147,132,99,166,81,133,58,24,23,135,13,114,213,134,160,208,226,169,151,186,32,168,206,4,102,170,249,110,164,171,124,120,235,174,75,18,41,175,18,172,111,173,37,198,173,172,24,129,241,167,47,235,51,166,118,85,117,164,65,63,183,165,196,41,248,160,243,67,58,161,170,253,124,163,157,151,190,162,208,115,196,181,231,25,6,180,190,167,64,182,137,205,130,183,12,219,205,178,59,177,15,179,98,15,73,177,85,101,139,176,104,34,215,187,95,72,21,186,6,246,83,184,49,156,145,185,180,138,222,188,131,224,28,189,218,94,90,191,237,52,152,190,0,0,0,0,101,103,188,184,139,200,9,170,238,175,181,18,87,151,98,143,50,240,222,55,220,95,107,37,185,56,215,157,239,40,180,197,138,79,8,125,100,224,189,111,1,135,1,215,184,191,214,74,221,216,106,242,51,119,223,224,86,16,99,88,159,87,25,80,250,48,165,232,20,159,16,250,113,248,172,66,200,192,123,223,173,167,199,103,67,8,114,117,38,111,206,205,112,127,173,149,21,24,17,45,251,183,164,63,158,208,24,135,39,232,207,26,66,143,115,162,172,32,198,176,201,71,122,8,62,175,50,160,91,200,142,24,181,103,59,10,208,0,135,178,105,56,80,47,12,95,236,151,226,240,89,133,135,151,229,61,209,135,134,101,180,224,58,221,90,79,143,207,63,40,51,119,134,16,228,234,227,119,88,82,13,216,237,64,104,191,81,248,161,248,43,240,196,159,151,72,42,48,34,90,79,87,158,226,246,111,73,127,147,8,245,199,125,167,64,213,24,192,252,109,78,208,159,53,43,183,35,141,197,24,150,159,160,127,42,39,25,71,253,186,124,32,65,2,146,143,244,16,247,232,72,168,61,88,20,155,88,63,168,35,182,144,29,49,211,247,161,137,106,207,118,20,15,168,202,172,225,7,127,190,132,96,195,6,210,112,160,94,183,23,28,230,89,184,169,244,60,223,21,76,133,231,194,209,224,128,126,105,14,47,203,123,107,72,119,195,162,15,13,203,199,104,177,115,41,199,4,97,76,160,184,217,245,152,111,68,144,255,211,252,126,80,102,238,27,55,218,86,77,39,185,14,40,64,5,182,198,239,176,164,163,136,12,28,26,176,219,129,127,215,103,57,145,120,210,43,244,31,110,147,3,247,38,59,102,144,154,131,136,63,47,145,237,88,147,41,84,96,68,180,49,7,248,12,223,168,77,30,186,207,241,166,236,223,146,254,137,184,46,70,103,23,155,84,2,112,39,236,187,72,240,113,222,47,76,201,48,128,249,219,85,231,69,99,156,160,63,107,249,199,131,211,23,104,54,193,114,15,138,121,203,55,93,228,174,80,225,92,64,255,84,78,37,152,232,246,115,136,139,174,22,239,55,22,248,64,130,4,157,39,62,188,36,31,233,33,65,120,85,153,175,215,224,139,202,176,92,51,59,182,89,237,94,209,229,85,176,126,80,71,213,25,236,255,108,33,59,98,9,70,135,218,231,233,50,200,130,142,142,112,212,158,237,40,177,249,81,144,95,86,228,130,58,49,88,58,131,9,143,167,230,110,51,31,8,193,134,13,109,166,58,181,164,225,64,189,193,134,252,5,47,41,73,23,74,78,245,175,243,118,34,50,150,17,158,138,120,190,43,152,29,217,151,32,75,201,244,120,46,174,72,192,192,1,253,210,165,102,65,106,28,94,150,247,121,57,42,79,151,150,159,93,242,241,35,229,5,25,107,77,96,126,215,245,142,209,98,231,235,182,222,95,82,142,9,194,55,233,181,122,217,70,0,104,188,33,188,208,234,49,223,136,143,86,99,48,97,249,214,34,4,158,106,154,189,166,189,7,216,193,1,191,54,110,180,173,83,9,8,21,154,78,114,29,255,41,206,165,17,134,123,183,116,225,199,15,205,217,16,146,168,190,172,42,70,17,25,56,35,118,165,128,117,102,198,216,16,1,122,96,254,174,207,114,155,201,115,202,34,241,164,87,71,150,24,239,169,57,173,253,204,94,17,69,6,238,77,118,99,137,241,206,141,38,68,220,232,65,248,100,81,121,47,249,52,30,147,65,218,177,38,83,191,214,154,235,233,198,249,179,140,161,69,11,98,14,240,25,7,105,76,161,190,81,155,60,219,54,39,132,53,153,146,150,80,254,46,46,153,185,84,38,252,222,232,158,18,113,93,140,119,22,225,52,206,46,54,169,171,73,138,17,69,230,63,3,32,129,131,187,118,145,224,227,19,246,92,91,253,89,233,73,152,62,85,241,33,6,130,108,68,97,62,212,170,206,139,198,207,169,55,126,56,65,127,214,93,38,195,110,179,137,118,124,214,238,202,196,111,214,29,89,10,177,161,225,228,30,20,243,129,121,168,75,215,105,203,19,178,14,119,171,92,161,194,185,57,198,126,1,128,254,169,156,229,153,21,36,11,54,160,54,110,81,28,142,167,22,102,134,194,113,218,62,44,222,111,44,73,185,211,148,240,129,4,9,149,230,184,177,123,73,13,163,30,46,177,27,72,62,210,67,45,89,110,251,195,246,219,233,166,145,103,81,31,169,176,204,122,206,12,116,148,97,185,102,241,6,5,222,0,0,0,0,119,7,48,150,238,14,97,44,153,9,81,186,7,109,196,25,112,106,244,143,233,99,165,53,158,100,149,163,14,219,136,50,121,220,184,164,224,213,233,30,151,210,217,136,9,182,76,43,126,177,124,189,231,184,45,7,144,191,29,145,29,183,16,100,106,176,32,242,243,185,113,72,132,190,65,222,26,218,212,125,109,221,228,235,244,212,181,81,131,211,133,199,19,108,152,86,100,107,168,192,253,98,249,122,138,101,201,236,20,1,92,79,99,6,108,217,250,15,61,99,141,8,13,245,59,110,32,200,76,105,16,94,213,96,65,228,162,103,113,114,60,3,228,209,75,4,212,71,210,13,133,253,165,10,181,107,53,181,168,250,66,178,152,108,219,187,201,214,172,188,249,64,50,216,108,227,69,223,92,117,220,214,13,207,171,209,61,89,38,217,48,172,81,222,0,58,200,215,81,128,191,208,97,22,33,180,244,181,86,179,196,35,207,186,149,153,184,189,165,15,40,2,184,158,95,5,136,8,198,12,217,178,177,11,233,36,47,111,124,135,88,104,76,17,193,97,29,171,182,102,45,61,118,220,65,144,1,219,113,6,152,210,32,188,239,213,16,42,113,177,133,137,6,182,181,31,159,191,228,165,232,184,212,51,120,7,201,162,15,0,249,52,150,9,168,142,225,14,152,24,127,106,13,187,8,109,61,45,145,100,108,151,230,99,92,1,107,107,81,244,28,108,97,98,133,101,48,216,242,98,0,78,108,6,149,237,27,1,165,123,130,8,244,193,245,15,196,87,101,176,217,198,18,183,233,80,139,190,184,234,252,185,136,124,98,221,29,223,21,218,45,73,140,211,124,243,251,212,76,101,77,178,97,88,58,181,81,206,163,188,0,116,212,187,48,226,74,223,165,65,61,216,149,215,164,209,196,109,211,214,244,251,67,105,233,106,52,110,217,252,173,103,136,70,218,96,184,208,68,4,45,115,51,3,29,229,170,10,76,95,221,13,124,201,80,5,113,60,39,2,65,170,190,11,16,16,201,12,32,134,87,104,181,37,32,111,133,179,185,102,212,9,206,97,228,159,94,222,249,14,41,217,201,152,176,208,152,34,199,215,168,180,89,179,61,23,46,180,13,129,183,189,92,59,192,186,108,173,237,184,131,32,154,191,179,182,3,182,226,12,116,177,210,154,234,213,71,57,157,210,119,175,4,219,38,21,115,220,22,131,227,99,11,18,148,100,59,132,13,109,106,62,122,106,90,168,228,14,207,11,147,9,255,157,10,0,174,39,125,7,158,177,240,15,147,68,135,8,163,210,30,1,242,104,105,6,194,254,247,98,87,93,128,101,103,203,25,108,54,113,110,107,6,231,254,212,27,118,137,211,43,224,16,218,122,90,103,221,74,204,249,185,223,111,142,190,239,249,23,183,190,67,96,176,142,213,214,214,163,232,161,209,147,126,56,216,194,196,79,223,242,82,209,187,103,241,166,188,87,103,63,181,6,221,72,178,54,75,216,13,43,218,175,10,27,76,54,3,74,246,65,4,122,96,223,96,239,195,168,103,223,85,49,110,142,239,70,105,190,121,203,97,179,140,188,102,131,26,37,111,210,160,82,104,226,54,204,12,119,149,187,11,71,3,34,2,22,185,85,5,38,47,197,186,59,190,178,189,11,40,43,180,90,146,92,179,106,4,194,215,255,167,181,208,207,49,44,217,158,139,91,222,174,29,155,100,194,176,236,99,242,38,117,106,163,156,2,109,147,10,156,9,6,169,235,14,54,63,114,7,103,133,5,0,87,19,149,191,74,130,226,184,122,20,123,177,43,174,12,182,27,56,146,210,142,155,229,213,190,13,124,220,239,183,11,219,223,33,134,211,210,212,241,212,226,66,104,221,179,248,31,218,131,110,129,190,22,205,246,185,38,91,111,176,119,225,24,183,71,119,136,8,90,230,255,15,106,112,102,6,59,202,17,1,11,92,143,101,158,255,248,98,174,105,97,107,255,211,22,108,207,69,160,10,226,120,215,13,210,238,78,4,131,84,57,3,179,194,167,103,38,97,208,96,22,247,73,105,71,77,62,110,119,219,174,209,106,74,217,214,90,220,64,223,11,102,55,216,59,240,169,188,174,83,222,187,158,197,71,178,207,127,48,181,255,233,189,189,242,28,202,186,194,138,83,179,147,48,36,180,163,166,186,208,54,5,205,215,6,147,84,222,87,41,35,217,103,191,179,102,122,46,196,97,74,184,93,104,27,2,42,111,43,148,180,11,190,55,195,12,142,161,90,5,223,27,45,2,239,141,0,0,0,0,25,27,49,65,50,54,98,130,43,45,83,195,100,108,197,4,125,119,244,69,86,90,167,134,79,65,150,199,200,217,138,8,209,194,187,73,250,239,232,138,227,244,217,203,172,181,79,12,181,174,126,77,158,131,45,142,135,152,28,207,74,194,18,81,83,217,35,16,120,244,112,211,97,239,65,146,46,174,215,85,55,181,230,20,28,152,181,215,5,131,132,150,130,27,152,89,155,0,169,24,176,45,250,219,169,54,203,154,230,119,93,93,255,108,108,28,212,65,63,223,205,90,14,158,149,132,36,162,140,159,21,227,167,178,70,32,190,169,119,97,241,232,225,166,232,243,208,231,195,222,131,36,218,197,178,101,93,93,174,170,68,70,159,235,111,107,204,40,118,112,253,105,57,49,107,174,32,42,90,239,11,7,9,44,18,28,56,109,223,70,54,243,198,93,7,178,237,112,84,113,244,107,101,48,187,42,243,247,162,49,194,182,137,28,145,117,144,7,160,52,23,159,188,251,14,132,141,186,37,169,222,121,60,178,239,56,115,243,121,255,106,232,72,190,65,197,27,125,88,222,42,60,240,121,79,5,233,98,126,68,194,79,45,135,219,84,28,198,148,21,138,1,141,14,187,64,166,35,232,131,191,56,217,194,56,160,197,13,33,187,244,76,10,150,167,143,19,141,150,206,92,204,0,9,69,215,49,72,110,250,98,139,119,225,83,202,186,187,93,84,163,160,108,21,136,141,63,214,145,150,14,151,222,215,152,80,199,204,169,17,236,225,250,210,245,250,203,147,114,98,215,92,107,121,230,29,64,84,181,222,89,79,132,159,22,14,18,88,15,21,35,25,36,56,112,218,61,35,65,155,101,253,107,167,124,230,90,230,87,203,9,37,78,208,56,100,1,145,174,163,24,138,159,226,51,167,204,33,42,188,253,96,173,36,225,175,180,63,208,238,159,18,131,45,134,9,178,108,201,72,36,171,208,83,21,234,251,126,70,41,226,101,119,104,47,63,121,246,54,36,72,183,29,9,27,116,4,18,42,53,75,83,188,242,82,72,141,179,121,101,222,112,96,126,239,49,231,230,243,254,254,253,194,191,213,208,145,124,204,203,160,61,131,138,54,250,154,145,7,187,177,188,84,120,168,167,101,57,59,131,152,75,34,152,169,10,9,181,250,201,16,174,203,136,95,239,93,79,70,244,108,14,109,217,63,205,116,194,14,140,243,90,18,67,234,65,35,2,193,108,112,193,216,119,65,128,151,54,215,71,142,45,230,6,165,0,181,197,188,27,132,132,113,65,138,26,104,90,187,91,67,119,232,152,90,108,217,217,21,45,79,30,12,54,126,95,39,27,45,156,62,0,28,221,185,152,0,18,160,131,49,83,139,174,98,144,146,181,83,209,221,244,197,22,196,239,244,87,239,194,167,148,246,217,150,213,174,7,188,233,183,28,141,168,156,49,222,107,133,42,239,42,202,107,121,237,211,112,72,172,248,93,27,111,225,70,42,46,102,222,54,225,127,197,7,160,84,232,84,99,77,243,101,34,2,178,243,229,27,169,194,164,48,132,145,103,41,159,160,38,228,197,174,184,253,222,159,249,214,243,204,58,207,232,253,123,128,169,107,188,153,178,90,253,178,159,9,62,171,132,56,127,44,28,36,176,53,7,21,241,30,42,70,50,7,49,119,115,72,112,225,180,81,107,208,245,122,70,131,54,99,93,178,119,203,250,215,78,210,225,230,15,249,204,181,204,224,215,132,141,175,150,18,74,182,141,35,11,157,160,112,200,132,187,65,137,3,35,93,70,26,56,108,7,49,21,63,196,40,14,14,133,103,79,152,66,126,84,169,3,85,121,250,192,76,98,203,129,129,56,197,31,152,35,244,94,179,14,167,157,170,21,150,220,229,84,0,27,252,79,49,90,215,98,98,153,206,121,83,216,73,225,79,23,80,250,126,86,123,215,45,149,98,204,28,212,45,141,138,19,52,150,187,82,31,187,232,145,6,160,217,208,94,126,243,236,71,101,194,173,108,72,145,110,117,83,160,47,58,18,54,232,35,9,7,169,8,36,84,106,17,63,101,43,150,167,121,228,143,188,72,165,164,145,27,102,189,138,42,39,242,203,188,224,235,208,141,161,192,253,222,98,217,230,239,35,20,188,225,189,13,167,208,252,38,138,131,63,63,145,178,126,112,208,36,185,105,203,21,248,66,230,70,59,91,253,119,122,220,101,107,181,197,126,90,244,238,83,9,55,247,72,56,118,184,9,174,177,161,18,159,240,138,63,204,51,147,36,253,114,0,0,0,0,1,194,106,55,3,132,212,110,2,70,190,89,7,9,168,220,6,203,194,235,4,141,124,178,5,79,22,133,14,19,81,184,15,209,59,143,13,151,133,214,12,85,239,225,9,26,249,100,8,216,147,83,10,158,45,10,11,92,71,61,28,38,163,112,29,228,201,71,31,162,119,30,30,96,29,41,27,47,11,172,26,237,97,155,24,171,223,194,25,105,181,245,18,53,242,200,19,247,152,255,17,177,38,166,16,115,76,145,21,60,90,20,20,254,48,35,22,184,142,122,23,122,228,77,56,77,70,224,57,143,44,215,59,201,146,142,58,11,248,185,63,68,238,60,62,134,132,11,60,192,58,82,61,2,80,101,54,94,23,88,55,156,125,111,53,218,195,54,52,24,169,1,49,87,191,132,48,149,213,179,50,211,107,234,51,17,1,221,36,107,229,144,37,169,143,167,39,239,49,254,38,45,91,201,35,98,77,76,34,160,39,123,32,230,153,34,33,36,243,21,42,120,180,40,43,186,222,31,41,252,96,70,40,62,10,113,45,113,28,244,44,179,118,195,46,245,200,154,47,55,162,173,112,154,141,192,113,88,231,247,115,30,89,174,114,220,51,153,119,147,37,28,118,81,79,43,116,23,241,114,117,213,155,69,126,137,220,120,127,75,182,79,125,13,8,22,124,207,98,33,121,128,116,164,120,66,30,147,122,4,160,202,123,198,202,253,108,188,46,176,109,126,68,135,111,56,250,222,110,250,144,233,107,181,134,108,106,119,236,91,104,49,82,2,105,243,56,53,98,175,127,8,99,109,21,63,97,43,171,102,96,233,193,81,101,166,215,212,100,100,189,227,102,34,3,186,103,224,105,141,72,215,203,32,73,21,161,23,75,83,31,78,74,145,117,121,79,222,99,252,78,28,9,203,76,90,183,146,77,152,221,165,70,196,154,152,71,6,240,175,69,64,78,246,68,130,36,193,65,205,50,68,64,15,88,115,66,73,230,42,67,139,140,29,84,241,104,80,85,51,2,103,87,117,188,62,86,183,214,9,83,248,192,140,82,58,170,187,80,124,20,226,81,190,126,213,90,226,57,232,91,32,83,223,89,102,237,134,88,164,135,177,93,235,145,52,92,41,251,3,94,111,69,90,95,173,47,109,225,53,27,128,224,247,113,183,226,177,207,238,227,115,165,217,230,60,179,92,231,254,217,107,229,184,103,50,228,122,13,5,239,38,74,56,238,228,32,15,236,162,158,86,237,96,244,97,232,47,226,228,233,237,136,211,235,171,54,138,234,105,92,189,253,19,184,240,252,209,210,199,254,151,108,158,255,85,6,169,250,26,16,44,251,216,122,27,249,158,196,66,248,92,174,117,243,0,233,72,242,194,131,127,240,132,61,38,241,70,87,17,244,9,65,148,245,203,43,163,247,141,149,250,246,79,255,205,217,120,93,96,216,186,55,87,218,252,137,14,219,62,227,57,222,113,245,188,223,179,159,139,221,245,33,210,220,55,75,229,215,107,12,216,214,169,102,239,212,239,216,182,213,45,178,129,208,98,164,4,209,160,206,51,211,230,112,106,210,36,26,93,197,94,254,16,196,156,148,39,198,218,42,126,199,24,64,73,194,87,86,204,195,149,60,251,193,211,130,162,192,17,232,149,203,77,175,168,202,143,197,159,200,201,123,198,201,11,17,241,204,68,7,116,205,134,109,67,207,192,211,26,206,2,185,45,145,175,150,64,144,109,252,119,146,43,66,46,147,233,40,25,150,166,62,156,151,100,84,171,149,34,234,242,148,224,128,197,159,188,199,248,158,126,173,207,156,56,19,150,157,250,121,161,152,181,111,36,153,119,5,19,155,49,187,74,154,243,209,125,141,137,53,48,140,75,95,7,142,13,225,94,143,207,139,105,138,128,157,236,139,66,247,219,137,4,73,130,136,198,35,181,131,154,100,136,130,88,14,191,128,30,176,230,129,220,218,209,132,147,204,84,133,81,166,99,135,23,24,58,134,213,114,13,169,226,208,160,168,32,186,151,170,102,4,206,171,164,110,249], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);
+/* memory initializer */ allocate([174,235,120,124,175,41,18,75,173,111,172,18,172,173,198,37,167,241,129,24,166,51,235,47,164,117,85,118,165,183,63,65,160,248,41,196,161,58,67,243,163,124,253,170,162,190,151,157,181,196,115,208,180,6,25,231,182,64,167,190,183,130,205,137,178,205,219,12,179,15,177,59,177,73,15,98,176,139,101,85,187,215,34,104,186,21,72,95,184,83,246,6,185,145,156,49,188,222,138,180,189,28,224,131,191,90,94,218,190,152,52,237,0,0,0,0,184,188,103,101,170,9,200,139,18,181,175,238,143,98,151,87,55,222,240,50,37,107,95,220,157,215,56,185,197,180,40,239,125,8,79,138,111,189,224,100,215,1,135,1,74,214,191,184,242,106,216,221,224,223,119,51,88,99,16,86,80,25,87,159,232,165,48,250,250,16,159,20,66,172,248,113,223,123,192,200,103,199,167,173,117,114,8,67,205,206,111,38,149,173,127,112,45,17,24,21,63,164,183,251,135,24,208,158,26,207,232,39,162,115,143,66,176,198,32,172,8,122,71,201,160,50,175,62,24,142,200,91,10,59,103,181,178,135,0,208,47,80,56,105,151,236,95,12,133,89,240,226,61,229,151,135,101,134,135,209,221,58,224,180,207,143,79,90,119,51,40,63,234,228,16,134,82,88,119,227,64,237,216,13,248,81,191,104,240,43,248,161,72,151,159,196,90,34,48,42,226,158,87,79,127,73,111,246,199,245,8,147,213,64,167,125,109,252,192,24,53,159,208,78,141,35,183,43,159,150,24,197,39,42,127,160,186,253,71,25,2,65,32,124,16,244,143,146,168,72,232,247,155,20,88,61,35,168,63,88,49,29,144,182,137,161,247,211,20,118,207,106,172,202,168,15,190,127,7,225,6,195,96,132,94,160,112,210,230,28,23,183,244,169,184,89,76,21,223,60,209,194,231,133,105,126,128,224,123,203,47,14,195,119,72,107,203,13,15,162,115,177,104,199,97,4,199,41,217,184,160,76,68,111,152,245,252,211,255,144,238,102,80,126,86,218,55,27,14,185,39,77,182,5,64,40,164,176,239,198,28,12,136,163,129,219,176,26,57,103,215,127,43,210,120,145,147,110,31,244,59,38,247,3,131,154,144,102,145,47,63,136,41,147,88,237,180,68,96,84,12,248,7,49,30,77,168,223,166,241,207,186,254,146,223,236,70,46,184,137,84,155,23,103,236,39,112,2,113,240,72,187,201,76,47,222,219,249,128,48,99,69,231,85,107,63,160,156,211,131,199,249,193,54,104,23,121,138,15,114,228,93,55,203,92,225,80,174,78,84,255,64,246,232,152,37,174,139,136,115,22,55,239,22,4,130,64,248,188,62,39,157,33,233,31,36,153,85,120,65,139,224,215,175,51,92,176,202,237,89,182,59,85,229,209,94,71,80,126,176,255,236,25,213,98,59,33,108,218,135,70,9,200,50,233,231,112,142,142,130,40,237,158,212,144,81,249,177,130,228,86,95,58,88,49,58,167,143,9,131,31,51,110,230,13,134,193,8,181,58,166,109,189,64,225,164,5,252,134,193,23,73,41,47,175,245,78,74,50,34,118,243,138,158,17,150,152,43,190,120,32,151,217,29,120,244,201,75,192,72,174,46,210,253,1,192,106,65,102,165,247,150,94,28,79,42,57,121,93,159,150,151,229,35,241,242,77,107,25,5,245,215,126,96,231,98,209,142,95,222,182,235,194,9,142,82,122,181,233,55,104,0,70,217,208,188,33,188,136,223,49,234,48,99,86,143,34,214,249,97,154,106,158,4,7,189,166,189,191,1,193,216,173,180,110,54,21,8,9,83,29,114,78,154,165,206,41,255,183,123,134,17,15,199,225,116,146,16,217,205,42,172,190,168,56,25,17,70,128,165,118,35,216,198,102,117,96,122,1,16,114,207,174,254,202,115,201,155,87,164,241,34,239,24,150,71,253,173,57,169,69,17,94,204,118,77,238,6,206,241,137,99,220,68,38,141,100,248,65,232,249,47,121,81,65,147,30,52,83,38,177,218,235,154,214,191,179,249,198,233,11,69,161,140,25,240,14,98,161,76,105,7,60,155,81,190,132,39,54,219,150,146,153,53,46,46,254,80,38,84,185,153,158,232,222,252,140,93,113,18,52,225,22,119,169,54,46,206,17,138,73,171,3,63,230,69,187,131,129,32,227,224,145,118,91,92,246,19,73,233,89,253,241,85,62,152,108,130,6,33,212,62,97,68,198,139,206,170,126,55,169,207,214,127,65,56,110,195,38,93,124,118,137,179,196,202,238,214,89,29,214,111,225,161,177,10,243,20,30,228,75,168,121,129,19,203,105,215,171,119,14,178,185,194,161,92,1,126,198,57,156,169,254,128,36,21,153,229,54,160,54,11,142,28,81,110,134,102,22,167,62,218,113,194,44,111,222,44,148,211,185,73,9,4,129,240,177,184,230,149,163,13,73,123,27,177,46,30,67,210,62,72,251,110,89,45,233,219,246,195,81,103,145,166,204,176,169,31,116,12,206,122,102,185,97,148,222,5,6,241,16,0,17,0,18,0,0,0,8,0,7,0,9,0,6,0,10,0,5,0,11,0,4,0,12,0,3,0,13,0,2,0,14,0,1,0,15,0,0,0,105,110,99,111,114,114,101,99,116,32,104,101,97,100,101,114,32,99,104,101,99,107,0,0,117,110,107,110,111,119,110,32,99,111,109,112,114,101,115,115,105,111,110,32,109,101,116,104,111,100,0,0,0,0,0,0,105,110,118,97,108,105,100,32,119,105,110,100,111,119,32,115,105,122,101,0,0,0,0,0,117,110,107,110,111,119,110,32,104,101,97,100,101,114,32,102,108,97,103,115,32,115,101,116,0,0,0,0,0,0,0,0,104,101,97,100,101,114,32,99,114,99,32,109,105,115,109,97,116,99,104,0,0,0,0,0,105,110,118,97,108,105,100,32,98,108,111,99,107,32,116,121,112,101,0,0,0,0,0,0,105,110,118,97,108,105,100,32,115,116,111,114,101,100,32,98,108,111,99,107,32,108,101,110,103,116,104,115,0,0,0,0,116,111,111,32,109,97,110,121,32,108,101,110,103,116,104,32,111,114,32,100,105,115,116,97,110,99,101,32,115,121,109,98,111,108,115,0,0,0,0,0,105,110,118,97,108,105,100,32,99,111,100,101,32,108,101,110,103,116,104,115,32,115,101,116,0,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,98,105,116,32,108,101,110,103,116,104,32,114,101,112,101,97,116,0,0,0,0,0,0,0,105,110,118,97,108,105,100,32,99,111,100,101,32,45,45,32,109,105,115,115,105,110,103,32,101,110,100,45,111,102,45,98,108,111,99,107,0,0,0,0,105,110,118,97,108,105,100,32,108,105,116,101,114,97,108,47,108,101,110,103,116,104,115,32,115,101,116,0,0,0,0,0,105,110,118,97,108,105,100,32,100,105,115,116,97,110,99,101,115,32,115,101,116,0,0,0,105,110,118,97,108,105,100,32,108,105,116,101,114,97,108,47,108,101,110,103,116,104,32,99,111,100,101,0,0,0,0,0,105,110,118,97,108,105,100,32,100,105,115,116,97,110,99,101,32,99,111,100,101,0,0,0,105,110,118,97,108,105,100,32,100,105,115,116,97,110,99,101,32,116,111,111,32,102,97,114,32,98,97,99,107,0,0,0,105,110,99,111,114,114,101,99,116,32,100,97,116,97,32,99,104,101,99,107,0,0,0,0,105,110,99,111,114,114,101,99,116,32,108,101,110,103,116,104,32,99,104,101,99,107,0,0,96,7,0,0,0,8,80,0,0,8,16,0,20,8,115,0,18,7,31,0,0,8,112,0,0,8,48,0,0,9,192,0,16,7,10,0,0,8,96,0,0,8,32,0,0,9,160,0,0,8,0,0,0,8,128,0,0,8,64,0,0,9,224,0,16,7,6,0,0,8,88,0,0,8,24,0,0,9,144,0,19,7,59,0,0,8,120,0,0,8,56,0,0,9,208,0,17,7,17,0,0,8,104,0,0,8,40,0,0,9,176,0,0,8,8,0,0,8,136,0,0,8,72,0,0,9,240,0,16,7,4,0,0,8,84,0,0,8,20,0,21,8,227,0,19,7,43,0,0,8,116,0,0,8,52,0,0,9,200,0,17,7,13,0,0,8,100,0,0,8,36,0,0,9,168,0,0,8,4,0,0,8,132,0,0,8,68,0,0,9,232,0,16,7,8,0,0,8,92,0,0,8,28,0,0,9,152,0,20,7,83,0,0,8,124,0,0,8,60,0,0,9,216,0,18,7,23,0,0,8,108,0,0,8,44,0,0,9,184,0,0,8,12,0,0,8,140,0,0,8,76,0,0,9,248,0,16,7,3,0,0,8,82,0,0,8,18,0,21,8,163,0,19,7,35,0,0,8,114,0,0,8,50,0,0,9,196,0,17,7,11,0,0,8,98,0,0,8,34,0,0,9,164,0,0,8,2,0,0,8,130,0,0,8,66,0,0,9,228,0,16,7,7,0,0,8,90,0,0,8,26,0,0,9,148,0,20,7,67,0,0,8,122,0,0,8,58,0,0,9,212,0,18,7,19,0,0,8,106,0,0,8,42,0,0,9,180,0,0,8,10,0,0,8,138,0,0,8,74,0,0,9,244,0,16,7,5,0,0,8,86,0,0,8,22,0,64,8,0,0,19,7,51,0,0,8,118,0,0,8,54,0,0,9,204,0,17,7,15,0,0,8,102,0,0,8,38,0,0,9,172,0,0,8,6,0,0,8,134,0,0,8,70,0,0,9,236,0,16,7,9,0,0,8,94,0,0,8,30,0,0,9,156,0,20,7,99,0,0,8,126,0,0,8,62,0,0,9,220,0,18,7,27,0,0,8,110,0,0,8,46,0,0,9,188,0,0,8,14,0,0,8,142,0,0,8,78,0,0,9,252,0,96,7,0,0,0,8,81,0,0,8,17,0,21,8,131,0,18,7,31,0,0,8,113,0,0,8,49,0,0,9,194,0,16,7,10,0,0,8,97,0,0,8,33,0,0,9,162,0,0,8,1,0,0,8,129,0,0,8,65,0,0,9,226,0,16,7,6,0,0,8,89,0,0,8,25,0,0,9,146,0,19,7,59,0,0,8,121,0,0,8,57,0,0,9,210,0,17,7,17,0,0,8,105,0,0,8,41,0,0,9,178,0,0,8,9,0,0,8,137,0,0,8,73,0,0,9,242,0,16,7,4,0,0,8,85,0,0,8,21,0,16,8,2,1,19,7,43,0,0,8,117,0,0,8,53,0,0,9,202,0,17,7,13,0,0,8,101,0,0,8,37,0,0,9,170,0,0,8,5,0,0,8,133,0,0,8,69,0,0,9,234,0,16,7,8,0,0,8,93,0,0,8,29,0,0,9,154,0,20,7,83,0,0,8,125,0,0,8,61,0,0,9,218,0,18,7,23,0,0,8,109,0,0,8,45,0,0,9,186,0,0,8,13,0,0,8,141,0,0,8,77,0,0,9,250,0,16,7,3,0,0,8,83,0,0,8,19,0,21,8,195,0,19,7,35,0,0,8,115,0,0,8,51,0,0,9,198,0,17,7,11,0,0,8,99,0,0,8,35,0,0,9,166,0,0,8,3,0,0,8,131,0,0,8,67,0,0,9,230,0,16,7,7,0,0,8,91,0,0,8,27,0,0,9,150,0,20,7,67,0,0,8,123,0,0,8,59,0,0,9,214,0,18,7,19,0,0,8,107,0,0,8,43,0,0,9,182,0,0,8,11,0,0,8,139,0,0,8,75,0,0,9,246,0,16,7,5,0,0,8,87,0,0,8,23,0,64,8,0,0,19,7,51,0,0,8,119,0,0,8,55,0,0,9,206,0,17,7,15,0,0,8,103,0,0,8,39,0,0,9,174,0,0,8,7,0,0,8,135,0,0,8,71,0,0,9,238,0,16,7,9,0,0,8,95,0,0,8,31,0,0,9,158,0,20,7,99,0,0,8,127,0,0,8,63,0,0,9,222,0,18,7,27,0,0,8,111,0,0,8,47,0,0,9,190,0,0,8,15,0,0,8,143,0,0,8,79,0,0,9,254,0,96,7,0,0,0,8,80,0,0,8,16,0,20,8,115,0,18,7,31,0,0,8,112,0,0,8,48,0,0,9,193,0,16,7,10,0,0,8,96,0,0,8,32,0,0,9,161,0,0,8,0,0,0,8,128,0,0,8,64,0,0,9,225,0,16,7,6,0,0,8,88,0,0,8,24,0,0,9,145,0,19,7,59,0,0,8,120,0,0,8,56,0,0,9,209,0,17,7,17,0,0,8,104,0,0,8,40,0,0,9,177,0,0,8,8,0,0,8,136,0,0,8,72,0,0,9,241,0,16,7,4,0,0,8,84,0,0,8,20,0,21,8,227,0,19,7,43,0,0,8,116,0,0,8,52,0,0,9,201,0,17,7,13,0,0,8,100,0,0,8,36,0,0,9,169,0,0,8,4,0,0,8,132,0,0,8,68,0,0,9,233,0,16,7,8,0,0,8,92,0,0,8,28,0,0,9,153,0,20,7,83,0,0,8,124,0,0,8,60,0,0,9,217,0,18,7,23,0,0,8,108,0,0,8,44,0,0,9,185,0,0,8,12,0,0,8,140,0,0,8,76,0,0,9,249,0,16,7,3,0,0,8,82,0,0,8,18,0,21,8,163,0,19,7,35,0,0,8,114,0,0,8,50,0,0,9,197,0,17,7,11,0,0,8,98,0,0,8,34,0,0,9,165,0,0,8,2,0,0,8,130,0,0,8,66,0,0,9,229,0,16,7,7,0,0,8,90,0,0,8,26,0,0,9,149,0,20,7,67,0,0,8,122,0,0,8,58,0,0,9,213,0,18,7,19,0,0,8,106,0,0,8,42,0,0,9,181,0,0,8,10,0,0,8,138,0,0,8,74,0,0,9,245,0,16,7,5,0,0,8,86,0,0,8,22,0,64,8,0,0,19,7,51,0,0,8,118,0,0,8,54,0,0,9,205,0,17,7,15,0,0,8,102,0,0,8,38,0,0,9,173,0,0,8,6,0,0,8,134,0,0,8,70,0,0,9,237,0,16,7,9,0,0,8,94,0,0,8,30,0,0,9,157,0,20,7,99,0,0,8,126,0,0,8,62,0,0,9,221,0,18,7,27,0,0,8,110,0,0,8,46,0,0,9,189,0,0,8,14,0,0,8,142,0,0,8,78,0,0,9,253,0,96,7,0,0,0,8,81,0,0,8,17,0,21,8,131,0,18,7,31,0,0,8,113,0,0,8,49,0,0,9,195,0,16,7,10,0,0,8,97,0,0,8,33,0,0,9,163,0,0,8,1,0,0,8,129,0,0,8,65,0,0,9,227,0,16,7,6,0,0,8,89,0,0,8,25,0,0,9,147,0,19,7,59,0,0,8,121,0,0,8,57,0,0,9,211,0,17,7,17,0,0,8,105,0,0,8,41,0,0,9,179,0,0,8,9,0,0,8,137,0,0,8,73,0,0,9,243,0,16,7,4,0,0,8,85,0,0,8,21,0,16,8,2,1,19,7,43,0,0,8,117,0,0,8,53,0,0,9,203,0,17,7,13,0,0,8,101,0,0,8,37,0,0,9,171,0,0,8,5,0,0,8,133,0,0,8,69,0,0,9,235,0,16,7,8,0,0,8,93,0,0,8,29,0,0,9,155,0,20,7,83,0,0,8,125,0,0,8,61,0,0,9,219,0,18,7,23,0,0,8,109,0,0,8,45,0,0,9,187,0,0,8,13,0,0,8,141,0,0,8,77,0,0,9,251,0,16,7,3,0,0,8,83,0,0,8,19,0,21,8,195,0,19,7,35,0,0,8,115,0,0,8,51,0,0,9,199,0,17,7,11,0,0,8,99,0,0,8,35,0,0,9,167,0,0,8,3,0,0,8,131,0,0,8,67,0,0,9,231,0,16,7,7,0,0,8,91,0,0,8,27,0,0,9,151,0,20,7,67,0,0,8,123,0,0,8,59,0,0,9,215,0,18,7,19,0,0,8,107,0,0,8,43,0,0,9,183,0,0,8,11,0,0,8,139,0,0,8,75,0,0,9,247,0,16,7,5,0,0,8,87,0,0,8,23,0,64,8,0,0,19,7,51,0,0,8,119,0,0,8,55,0,0,9,207,0,17,7,15,0,0,8,103,0,0,8,39,0,0,9,175,0,0,8,7,0,0,8,135,0,0,8,71,0,0,9,239,0,16,7,9,0,0,8,95,0,0,8,31,0,0,9,159,0,20,7,99,0,0,8,127,0,0,8,63,0,0,9,223,0,18,7,27,0,0,8,111,0,0,8,47,0,0,9,191,0,0,8,15,0,0,8,143,0,0,8,79,0,0,9,255,0,16,5,1,0,23,5,1,1,19,5,17,0,27,5,1,16,17,5,5,0,25,5,1,4,21,5,65,0,29,5,1,64,16,5,3,0,24,5,1,2,20,5,33,0,28,5,1,32,18,5,9,0,26,5,1,8,22,5,129,0,64,5,0,0,16,5,2,0,23,5,129,1,19,5,25,0,27,5,1,24,17,5,7,0,25,5,1,6,21,5,97,0,29,5,1,96,16,5,4,0,24,5,1,3,20,5,49,0,28,5,1,48,18,5,13,0,26,5,1,12,22,5,193,0,64,5,0,0,3,0,4,0,5,0,6,0,7,0,8,0,9,0,10,0,11,0,13,0,15,0,17,0,19,0,23,0,27,0,31,0,35,0,43,0,51,0,59,0,67,0,83,0,99,0,115,0,131,0,163,0,195,0,227,0,2,1,0,0,0,0,0,0,16,0,16,0,16,0,16,0,16,0,16,0,16,0,16,0,17,0,17,0,17,0,17,0,18,0,18,0,18,0,18,0,19,0,19,0,19,0,19,0,20,0,20,0,20,0,20,0,21,0,21,0,21,0,21,0,16,0,73,0,195,0,0,0,1,0,2,0,3,0,4,0,5,0,7,0,9,0,13,0,17,0,25,0,33,0,49,0,65,0,97,0,129,0,193,0,1,1,129,1,1,2,1,3,1,4,1,6,1,8,1,12,1,16,1,24,1,32,1,48,1,64,1,96,0,0,0,0,16,0,16,0,16,0,16,0,17,0,17,0,18,0,18,0,19,0,19,0,20,0,20,0,21,0,21,0,22,0,22,0,23,0,23,0,24,0,24,0,25,0,25,0,26,0,26,0,27,0,27,0,28,0,28,0,29,0,29,0,64,0,64,0,105,110,118,97,108,105,100,32,100,105,115,116,97,110,99,101,32,116,111,111,32,102,97,114,32,98,97,99,107,0,0,0,105,110,118,97,108,105,100,32,100,105,115,116,97,110,99,101,32,99,111,100,101,0,0,0,105,110,118,97,108,105,100,32,108,105,116,101,114,97,108,47,108,101,110,103,116,104,32,99,111,100,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE+10240);
+
+
+
+
+var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8);
+
+assert(tempDoublePtr % 8 == 0);
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+ HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+ HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+ HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+ HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+ HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+ HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+ HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+ HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+
+
+
+
+
+ var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};
+
+ var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"Cross-device link",19:"No such device",20:"Not a directory",21:"Is a directory",22:"Invalid argument",23:"Too many open files in system",24:"Too many open files",25:"Not a typewriter",26:"Text file busy",27:"File too large",28:"No space left on device",29:"Illegal seek",30:"Read only file system",31:"Too many links",32:"Broken pipe",33:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",88:"Socket operation on non-socket",89:"Destination address required",90:"Message too long",91:"Protocol wrong type for socket",92:"Protocol not available",93:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"};
+
+
+ var ___errno_state=0;function ___setErrNo(value) {
+ // For convenient setting and returning of errno.
+ HEAP32[((___errno_state)>>2)]=value;
+ return value;
+ }
+
+ var PATH={splitPath:function (filename) {
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },normalizeArray:function (parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },normalize:function (path) {
+ var isAbsolute = path.charAt(0) === '/',
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ path = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+ return (isAbsolute ? '/' : '') + path;
+ },dirname:function (path) {
+ var result = PATH.splitPath(path),
+ root = result[0],
+ dir = result[1];
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },basename:function (path) {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash+1);
+ },extname:function (path) {
+ return PATH.splitPath(path)[3];
+ },join:function () {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return PATH.normalize(paths.join('/'));
+ },join2:function (l, r) {
+ return PATH.normalize(l + '/' + r);
+ },resolve:function () {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : FS.cwd();
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+ },relative:function (from, to) {
+ from = PATH.resolve(from).substr(1);
+ to = PATH.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }};
+
+ var TTY={ttys:[],init:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process['stdin']['setEncoding']('utf8');
+ // }
+ },shutdown:function () {
+ // https://github.com/kripken/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process['stdin']['pause']();
+ // }
+ },register:function (dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: ops };
+ FS.registerDevice(dev, TTY.stream_ops);
+ },stream_ops:{open:function (stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ stream.tty = tty;
+ stream.seekable = false;
+ },close:function (stream) {
+ // flush any pending line data
+ if (stream.tty.output.length) {
+ stream.tty.ops.put_char(stream.tty, 10);
+ }
+ },read:function (stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENXIO);
+ }
+ for (var i = 0; i < length; i++) {
+ try {
+ stream.tty.ops.put_char(stream.tty, buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }},default_tty_ops:{get_char:function (tty) {
+ if (!tty.input.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ result = process['stdin']['read']();
+ if (!result) {
+ if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
+ return null; // EOF
+ }
+ return undefined; // no data available
+ }
+ } else if (typeof window != 'undefined' &&
+ typeof window.prompt == 'function') {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ tty.input = intArrayFromString(result, true);
+ }
+ return tty.input.shift();
+ },put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['print'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }},default_tty1_ops:{put_char:function (tty, val) {
+ if (val === null || val === 10) {
+ Module['printErr'](tty.output.join(''));
+ tty.output = [];
+ } else {
+ tty.output.push(TTY.utf8.processCChar(val));
+ }
+ }}};
+
+ var MEMFS={ops_table:null,CONTENT_OWNING:1,CONTENT_FLEXIBLE:2,CONTENT_FIXED:3,mount:function (mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (!MEMFS.ops_table) {
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ },
+ };
+ }
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.contents = [];
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ }
+ return node;
+ },ensureFlexible:function (node) {
+ if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+ var contents = node.contents;
+ node.contents = Array.prototype.slice.call(contents);
+ node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+ }
+ },node_ops:{getattr:function (node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.contents.length;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },setattr:function (node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ if (attr.size < contents.length) contents.length = attr.size;
+ else while (attr.size > contents.length) contents.push(0);
+ }
+ },lookup:function (parent, name) {
+ throw FS.genericErrors[ERRNO_CODES.ENOENT];
+ },mknod:function (parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },rename:function (old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ }
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ old_node.parent = new_dir;
+ },unlink:function (parent, name) {
+ delete parent.contents[name];
+ },rmdir:function (parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ delete parent.contents[name];
+ },readdir:function (node) {
+ var entries = ['.', '..']
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },symlink:function (parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0);
+ node.link = oldpath;
+ return node;
+ },readlink:function (node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return node.link;
+ }},stream_ops:{read:function (stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) { // non-trivial, and typed array
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else
+ {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ }
+ return size;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ var node = stream.node;
+ node.timestamp = Date.now();
+ var contents = node.contents;
+ if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+ // just replace it with the new data
+ if (canOwn && offset === 0) {
+ node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+ node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
+ } else {
+ node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+ node.contentMode = MEMFS.CONTENT_FIXED;
+ }
+ return length;
+ }
+ MEMFS.ensureFlexible(node);
+ var contents = node.contents;
+ while (contents.length < position) contents.push(0);
+ for (var i = 0; i < length; i++) {
+ contents[position + i] = buffer[offset + i];
+ }
+ return length;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ position += stream.node.contents.length;
+ }
+ }
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ stream.ungotten = [];
+ stream.position = position;
+ return position;
+ },allocate:function (stream, offset, length) {
+ MEMFS.ensureFlexible(stream.node);
+ var contents = stream.node.contents;
+ var limit = offset + length;
+ while (limit > contents.length) contents.push(0);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ var ptr;
+ var allocated;
+ var contents = stream.node.contents;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if ( !(flags & 2) &&
+ (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+ // We can't emulate MAP_SHARED when the file is not backed by the buffer
+ // we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(contents, position, position + length);
+ }
+ }
+ allocated = true;
+ ptr = _malloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+ }
+ buffer.set(contents, ptr);
+ }
+ return { ptr: ptr, allocated: allocated };
+ }}};
+
+ var IDBFS={dbs:{},indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) {
+ // reuse all of the core MEMFS functionality
+ return MEMFS.mount.apply(null, arguments);
+ },syncfs:function (mount, populate, callback) {
+ IDBFS.getLocalSet(mount, function(err, local) {
+ if (err) return callback(err);
+
+ IDBFS.getRemoteSet(mount, function(err, remote) {
+ if (err) return callback(err);
+
+ var src = populate ? remote : local;
+ var dst = populate ? local : remote;
+
+ IDBFS.reconcile(src, dst, callback);
+ });
+ });
+ },getDB:function (name, callback) {
+ // check the cache first
+ var db = IDBFS.dbs[name];
+ if (db) {
+ return callback(null, db);
+ }
+
+ var req;
+ try {
+ req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+ } catch (e) {
+ return callback(e);
+ }
+ req.onupgradeneeded = function(e) {
+ var db = e.target.result;
+ var transaction = e.target.transaction;
+
+ var fileStore;
+
+ if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
+ fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ } else {
+ fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME);
+ }
+
+ fileStore.createIndex('timestamp', 'timestamp', { unique: false });
+ };
+ req.onsuccess = function() {
+ db = req.result;
+
+ // add to the cache
+ IDBFS.dbs[name] = db;
+ callback(null, db);
+ };
+ req.onerror = function() {
+ callback(this.error);
+ };
+ },getLocalSet:function (mount, callback) {
+ var entries = {};
+
+ function isRealDir(p) {
+ return p !== '.' && p !== '..';
+ };
+ function toAbsolute(root) {
+ return function(p) {
+ return PATH.join2(root, p);
+ }
+ };
+
+ var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
+
+ while (check.length) {
+ var path = check.pop();
+ var stat;
+
+ try {
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path)));
+ }
+
+ entries[path] = { timestamp: stat.mtime };
+ }
+
+ return callback(null, { type: 'local', entries: entries });
+ },getRemoteSet:function (mount, callback) {
+ var entries = {};
+
+ IDBFS.getDB(mount.mountpoint, function(err, db) {
+ if (err) return callback(err);
+
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+ transaction.onerror = function() { callback(this.error); };
+
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+ var index = store.index('timestamp');
+
+ index.openKeyCursor().onsuccess = function(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return callback(null, { type: 'remote', db: db, entries: entries });
+ }
+
+ entries[cursor.primaryKey] = { timestamp: cursor.key };
+
+ cursor.continue();
+ };
+ });
+ },loadLocalEntry:function (path, callback) {
+ var stat, node;
+
+ try {
+ var lookup = FS.lookupPath(path);
+ node = lookup.node;
+ stat = FS.stat(path);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (FS.isDir(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode });
+ } else if (FS.isFile(stat.mode)) {
+ return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+ },storeLocalEntry:function (path, entry, callback) {
+ try {
+ if (FS.isDir(entry.mode)) {
+ FS.mkdir(path, entry.mode);
+ } else if (FS.isFile(entry.mode)) {
+ FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true });
+ } else {
+ return callback(new Error('node type not supported'));
+ }
+
+ FS.utime(path, entry.timestamp, entry.timestamp);
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },removeLocalEntry:function (path, callback) {
+ try {
+ var lookup = FS.lookupPath(path);
+ var stat = FS.stat(path);
+
+ if (FS.isDir(stat.mode)) {
+ FS.rmdir(path);
+ } else if (FS.isFile(stat.mode)) {
+ FS.unlink(path);
+ }
+ } catch (e) {
+ return callback(e);
+ }
+
+ callback(null);
+ },loadRemoteEntry:function (store, path, callback) {
+ var req = store.get(path);
+ req.onsuccess = function(event) { callback(null, event.target.result); };
+ req.onerror = function() { callback(this.error); };
+ },storeRemoteEntry:function (store, path, entry, callback) {
+ var req = store.put(entry, path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },removeRemoteEntry:function (store, path, callback) {
+ var req = store.delete(path);
+ req.onsuccess = function() { callback(null); };
+ req.onerror = function() { callback(this.error); };
+ },reconcile:function (src, dst, callback) {
+ var total = 0;
+
+ var create = [];
+ Object.keys(src.entries).forEach(function (key) {
+ var e = src.entries[key];
+ var e2 = dst.entries[key];
+ if (!e2 || e.timestamp > e2.timestamp) {
+ create.push(key);
+ total++;
+ }
+ });
+
+ var remove = [];
+ Object.keys(dst.entries).forEach(function (key) {
+ var e = dst.entries[key];
+ var e2 = src.entries[key];
+ if (!e2) {
+ remove.push(key);
+ total++;
+ }
+ });
+
+ if (!total) {
+ return callback(null);
+ }
+
+ var errored = false;
+ var completed = 0;
+ var db = src.type === 'remote' ? src.db : dst.db;
+ var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+ var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= total) {
+ return callback(null);
+ }
+ };
+
+ transaction.onerror = function() { done(this.error); };
+
+ // sort paths in ascending order so directory entries are created
+ // before the files inside them
+ create.sort().forEach(function (path) {
+ if (dst.type === 'local') {
+ IDBFS.loadRemoteEntry(store, path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeLocalEntry(path, entry, done);
+ });
+ } else {
+ IDBFS.loadLocalEntry(path, function (err, entry) {
+ if (err) return done(err);
+ IDBFS.storeRemoteEntry(store, path, entry, done);
+ });
+ }
+ });
+
+ // sort paths in descending order so files are deleted before their
+ // parent directories
+ remove.sort().reverse().forEach(function(path) {
+ if (dst.type === 'local') {
+ IDBFS.removeLocalEntry(path, done);
+ } else {
+ IDBFS.removeRemoteEntry(store, path, done);
+ }
+ });
+ }};
+
+ var NODEFS={isWindows:false,staticInit:function () {
+ NODEFS.isWindows = !!process.platform.match(/^win/);
+ },mount:function (mount) {
+ assert(ENVIRONMENT_IS_NODE);
+ return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
+ },createNode:function (parent, name, mode, dev) {
+ if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node = FS.createNode(parent, name, mode);
+ node.node_ops = NODEFS.node_ops;
+ node.stream_ops = NODEFS.stream_ops;
+ return node;
+ },getMode:function (path) {
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ if (NODEFS.isWindows) {
+ // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so
+ // propagate write bits to execute bits.
+ stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return stat.mode;
+ },realPath:function (node) {
+ var parts = [];
+ while (node.parent !== node) {
+ parts.push(node.name);
+ node = node.parent;
+ }
+ parts.push(node.mount.opts.root);
+ parts.reverse();
+ return PATH.join.apply(null, parts);
+ },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) {
+ if (flags in NODEFS.flagsToPermissionStringMap) {
+ return NODEFS.flagsToPermissionStringMap[flags];
+ } else {
+ return flags;
+ }
+ },node_ops:{getattr:function (node) {
+ var path = NODEFS.realPath(node);
+ var stat;
+ try {
+ stat = fs.lstatSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+ // See http://support.microsoft.com/kb/140365
+ if (NODEFS.isWindows && !stat.blksize) {
+ stat.blksize = 4096;
+ }
+ if (NODEFS.isWindows && !stat.blocks) {
+ stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+ }
+ return {
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ nlink: stat.nlink,
+ uid: stat.uid,
+ gid: stat.gid,
+ rdev: stat.rdev,
+ size: stat.size,
+ atime: stat.atime,
+ mtime: stat.mtime,
+ ctime: stat.ctime,
+ blksize: stat.blksize,
+ blocks: stat.blocks
+ };
+ },setattr:function (node, attr) {
+ var path = NODEFS.realPath(node);
+ try {
+ if (attr.mode !== undefined) {
+ fs.chmodSync(path, attr.mode);
+ // update the common node structure mode as well
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ var date = new Date(attr.timestamp);
+ fs.utimesSync(path, date, date);
+ }
+ if (attr.size !== undefined) {
+ fs.truncateSync(path, attr.size);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },lookup:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ var mode = NODEFS.getMode(path);
+ return NODEFS.createNode(parent, name, mode);
+ },mknod:function (parent, name, mode, dev) {
+ var node = NODEFS.createNode(parent, name, mode, dev);
+ // create the backing node for this in the fs root as well
+ var path = NODEFS.realPath(node);
+ try {
+ if (FS.isDir(node.mode)) {
+ fs.mkdirSync(path, node.mode);
+ } else {
+ fs.writeFileSync(path, '', { mode: node.mode });
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return node;
+ },rename:function (oldNode, newDir, newName) {
+ var oldPath = NODEFS.realPath(oldNode);
+ var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+ try {
+ fs.renameSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },unlink:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.unlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },rmdir:function (parent, name) {
+ var path = PATH.join2(NODEFS.realPath(parent), name);
+ try {
+ fs.rmdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readdir:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readdirSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },symlink:function (parent, newName, oldPath) {
+ var newPath = PATH.join2(NODEFS.realPath(parent), newName);
+ try {
+ fs.symlinkSync(oldPath, newPath);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },readlink:function (node) {
+ var path = NODEFS.realPath(node);
+ try {
+ return fs.readlinkSync(path);
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }},stream_ops:{open:function (stream) {
+ var path = NODEFS.realPath(stream.node);
+ try {
+ if (FS.isFile(stream.node.mode)) {
+ stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },close:function (stream) {
+ try {
+ if (FS.isFile(stream.node.mode) && stream.nfd) {
+ fs.closeSync(stream.nfd);
+ }
+ } catch (e) {
+ if (!e.code) throw e;
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ },read:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(length);
+ var res;
+ try {
+ res = fs.readSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ if (res > 0) {
+ for (var i = 0; i < res; i++) {
+ buffer[offset + i] = nbuffer[i];
+ }
+ }
+ return res;
+ },write:function (stream, buffer, offset, length, position) {
+ // FIXME this is terrible.
+ var nbuffer = new Buffer(buffer.subarray(offset, offset + length));
+ var res;
+ try {
+ res = fs.writeSync(stream.nfd, nbuffer, 0, length, position);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ return res;
+ },llseek:function (stream, offset, whence) {
+ var position = offset;
+ if (whence === 1) { // SEEK_CUR.
+ position += stream.position;
+ } else if (whence === 2) { // SEEK_END.
+ if (FS.isFile(stream.node.mode)) {
+ try {
+ var stat = fs.fstatSync(stream.nfd);
+ position += stat.size;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+ }
+ }
+ }
+
+ if (position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ stream.position = position;
+ return position;
+ }}};
+
+ var _stdin=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stdout=allocate(1, "i32*", ALLOC_STATIC);
+
+ var _stderr=allocate(1, "i32*", ALLOC_STATIC);
+
+ function _fflush(stream) {
+ // int fflush(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html
+ // we don't currently perform any user-space buffering of data
+ }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:null,genericErrors:{},handleFSError:function (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace();
+ return ___setErrNo(e.errno);
+ },lookupPath:function (path, opts) {
+ path = PATH.resolve(FS.cwd(), path);
+ opts = opts || {};
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ for (var key in defaults) {
+ if (opts[key] === undefined) {
+ opts[key] = defaults[key];
+ }
+ }
+
+ if (opts.recurse_count > 8) { // max recursive lookup of 8
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+
+ // split the path
+ var parts = PATH.normalizeArray(path.split('/').filter(function(p) {
+ return !!p;
+ }), false);
+
+ // start at the root
+ var current = FS.root;
+ var current_path = '/';
+
+ for (var i = 0; i < parts.length; i++) {
+ var islast = (i === parts.length-1);
+ if (islast && opts.parent) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count });
+ current = lookup.node;
+
+ if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(ERRNO_CODES.ELOOP);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },getPath:function (node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path;
+ }
+ path = path ? node.name + '/' + path : node.name;
+ node = node.parent;
+ }
+ },hashName:function (parentid, name) {
+ var hash = 0;
+
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },hashAddNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },hashRemoveNode:function (node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },lookupNode:function (parent, name) {
+ var err = FS.mayLookup(parent);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },createNode:function (parent, name, mode, rdev) {
+ if (!FS.FSNode) {
+ FS.FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+
+ FS.FSNode.prototype = {};
+
+ // compatibility
+ var readMode = 292 | 73;
+ var writeMode = 146;
+
+ // NOTE we must use Object.defineProperties instead of individual calls to
+ // Object.defineProperty in order to make closure compiler happy
+ Object.defineProperties(FS.FSNode.prototype, {
+ read: {
+ get: function() { return (this.mode & readMode) === readMode; },
+ set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; }
+ },
+ write: {
+ get: function() { return (this.mode & writeMode) === writeMode; },
+ set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; }
+ },
+ isFolder: {
+ get: function() { return FS.isDir(this.mode); },
+ },
+ isDevice: {
+ get: function() { return FS.isChrdev(this.mode); },
+ },
+ });
+ }
+
+ var node = new FS.FSNode(parent, name, mode, rdev);
+
+ FS.hashAddNode(node);
+
+ return node;
+ },destroyNode:function (node) {
+ FS.hashRemoveNode(node);
+ },isRoot:function (node) {
+ return node === node.parent;
+ },isMountpoint:function (node) {
+ return !!node.mounted;
+ },isFile:function (mode) {
+ return (mode & 61440) === 32768;
+ },isDir:function (mode) {
+ return (mode & 61440) === 16384;
+ },isLink:function (mode) {
+ return (mode & 61440) === 40960;
+ },isChrdev:function (mode) {
+ return (mode & 61440) === 8192;
+ },isBlkdev:function (mode) {
+ return (mode & 61440) === 24576;
+ },isFIFO:function (mode) {
+ return (mode & 61440) === 4096;
+ },isSocket:function (mode) {
+ return (mode & 49152) === 49152;
+ },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) {
+ var flags = FS.flagModes[str];
+ if (typeof flags === 'undefined') {
+ throw new Error('Unknown file open mode: ' + str);
+ }
+ return flags;
+ },flagsToPermissionString:function (flag) {
+ var accmode = flag & 2097155;
+ var perms = ['r', 'w', 'rw'][accmode];
+ if ((flag & 512)) {
+ perms += 'w';
+ }
+ return perms;
+ },nodePermissions:function (node, perms) {
+ if (FS.ignorePermissions) {
+ return 0;
+ }
+ // return 0 if any user, group or owner bits are set.
+ if (perms.indexOf('r') !== -1 && !(node.mode & 292)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) {
+ return ERRNO_CODES.EACCES;
+ } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) {
+ return ERRNO_CODES.EACCES;
+ }
+ return 0;
+ },mayLookup:function (dir) {
+ return FS.nodePermissions(dir, 'x');
+ },mayCreate:function (dir, name) {
+ try {
+ var node = FS.lookupNode(dir, name);
+ return ERRNO_CODES.EEXIST;
+ } catch (e) {
+ }
+ return FS.nodePermissions(dir, 'wx');
+ },mayDelete:function (dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name);
+ } catch (e) {
+ return e.errno;
+ }
+ var err = FS.nodePermissions(dir, 'wx');
+ if (err) {
+ return err;
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return ERRNO_CODES.ENOTDIR;
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return ERRNO_CODES.EBUSY;
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return 0;
+ },mayOpen:function (node, flags) {
+ if (!node) {
+ return ERRNO_CODES.ENOENT;
+ }
+ if (FS.isLink(node.mode)) {
+ return ERRNO_CODES.ELOOP;
+ } else if (FS.isDir(node.mode)) {
+ if ((flags & 2097155) !== 0 || // opening for write
+ (flags & 512)) {
+ return ERRNO_CODES.EISDIR;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) {
+ fd_start = fd_start || 0;
+ fd_end = fd_end || FS.MAX_OPEN_FDS;
+ for (var fd = fd_start; fd <= fd_end; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(ERRNO_CODES.EMFILE);
+ },getStream:function (fd) {
+ return FS.streams[fd];
+ },createStream:function (stream, fd_start, fd_end) {
+ if (!FS.FSStream) {
+ FS.FSStream = function(){};
+ FS.FSStream.prototype = {};
+ // compatibility
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get: function() { return this.node; },
+ set: function(val) { this.node = val; }
+ },
+ isRead: {
+ get: function() { return (this.flags & 2097155) !== 1; }
+ },
+ isWrite: {
+ get: function() { return (this.flags & 2097155) !== 0; }
+ },
+ isAppend: {
+ get: function() { return (this.flags & 1024); }
+ }
+ });
+ }
+ if (0) {
+ // reuse the object
+ stream.__proto__ = FS.FSStream.prototype;
+ } else {
+ var newStream = new FS.FSStream();
+ for (var p in stream) {
+ newStream[p] = stream[p];
+ }
+ stream = newStream;
+ }
+ var fd = FS.nextfd(fd_start, fd_end);
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },closeStream:function (fd) {
+ FS.streams[fd] = null;
+ },getStreamFromPtr:function (ptr) {
+ return FS.streams[ptr - 1];
+ },getPtrForStream:function (stream) {
+ return stream ? stream.fd + 1 : 0;
+ },chrdev_stream_ops:{open:function (stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ },llseek:function () {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }},major:function (dev) {
+ return ((dev) >> 8);
+ },minor:function (dev) {
+ return ((dev) & 0xff);
+ },makedev:function (ma, mi) {
+ return ((ma) << 8 | (mi));
+ },registerDevice:function (dev, ops) {
+ FS.devices[dev] = { stream_ops: ops };
+ },getDevice:function (dev) {
+ return FS.devices[dev];
+ },getMounts:function (mount) {
+ var mounts = [];
+ var check = [mount];
+
+ while (check.length) {
+ var m = check.pop();
+
+ mounts.push(m);
+
+ check.push.apply(check, m.mounts);
+ }
+
+ return mounts;
+ },syncfs:function (populate, callback) {
+ if (typeof(populate) === 'function') {
+ callback = populate;
+ populate = false;
+ }
+
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function done(err) {
+ if (err) {
+ if (!done.errored) {
+ done.errored = true;
+ return callback(err);
+ }
+ return;
+ }
+ if (++completed >= mounts.length) {
+ callback(null);
+ }
+ };
+
+ // sync all mounts
+ mounts.forEach(function (mount) {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },mount:function (type, opts, mountpoint) {
+ var root = mountpoint === '/';
+ var pseudo = !mountpoint;
+ var node;
+
+ if (root && FS.root) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ mountpoint = lookup.path; // use the absolute path
+ node = lookup.node;
+
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ }
+
+ var mount = {
+ type: type,
+ opts: opts,
+ mountpoint: mountpoint,
+ mounts: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ if (node.mount) {
+ node.mount.mounts.push(mount);
+ }
+ }
+
+ return mountRoot;
+ },unmount:function (mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
+
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+
+ Object.keys(FS.nameTable).forEach(function (hash) {
+ var current = FS.nameTable[hash];
+
+ while (current) {
+ var next = current.name_next;
+
+ if (mounts.indexOf(current.mount) !== -1) {
+ FS.destroyNode(current);
+ }
+
+ current = next;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },lookup:function (parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },mknod:function (path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var err = FS.mayCreate(parent, name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },create:function (path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },mkdir:function (path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },mkdev:function (path, mode, dev) {
+ if (typeof(dev) === 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ mode |= 8192;
+ return FS.mknod(path, mode, dev);
+ },symlink:function (oldpath, newpath) {
+ var lookup = FS.lookupPath(newpath, { parent: true });
+ var parent = lookup.node;
+ var newname = PATH.basename(newpath);
+ var err = FS.mayCreate(parent, newname);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.symlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return parent.node_ops.symlink(parent, newname, oldpath);
+ },rename:function (old_path, new_path) {
+ var old_dirname = PATH.dirname(old_path);
+ var new_dirname = PATH.dirname(new_path);
+ var old_name = PATH.basename(old_path);
+ var new_name = PATH.basename(new_path);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+ try {
+ lookup = FS.lookupPath(old_path, { parent: true });
+ old_dir = lookup.node;
+ lookup = FS.lookupPath(new_path, { parent: true });
+ new_dir = lookup.node;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(ERRNO_CODES.EXDEV);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var err = FS.mayDelete(old_dir, old_name, isdir);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ err = new_node ?
+ FS.mayDelete(new_dir, new_name, isdir) :
+ FS.mayCreate(new_dir, new_name);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!old_dir.node_ops.rename) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ // if we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ err = FS.nodePermissions(old_dir, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },rmdir:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, true);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },readdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ return node.node_ops.readdir(node);
+ },unlink:function (path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var err = FS.mayDelete(parent, name, false);
+ if (err) {
+ // POSIX says unlink should set EPERM, not EISDIR
+ if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM;
+ throw new FS.ErrnoError(err);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBUSY);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },readlink:function (path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ return link.node_ops.readlink(link);
+ },stat:function (path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ return node.node_ops.getattr(node);
+ },lstat:function (path) {
+ return FS.stat(path, true);
+ },chmod:function (path, mode, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },lchmod:function (path, mode) {
+ FS.chmod(path, mode, true);
+ },fchmod:function (fd, mode) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chmod(stream.node, mode);
+ },chown:function (path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },lchown:function (path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },fchown:function (fd, uid, gid) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ FS.chown(stream.node, uid, gid);
+ },truncate:function (path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var node;
+ if (typeof path === 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var err = FS.nodePermissions(node, 'w');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },ftruncate:function (fd, len) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ FS.truncate(stream.node, len);
+ },utime:function (path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },open:function (path, flags, mode, fd_start, fd_end) {
+ flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags;
+ mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode;
+ if ((flags & 64)) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path === 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ if ((flags & 64)) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if ((flags & 128)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EEXIST);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // check permissions
+ var err = FS.mayOpen(node, flags);
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ // do truncation if necessary
+ if ((flags & 512)) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node: node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ }, fd_start, fd_end);
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ Module['printErr']('read file: ' + path);
+ }
+ }
+ return stream;
+ },close:function (stream) {
+ try {
+ if (stream.stream_ops.close) {
+ stream.stream_ops.close(stream);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ FS.closeStream(stream.fd);
+ }
+ },llseek:function (stream, offset, whence) {
+ if (!stream.seekable || !stream.stream_ops.llseek) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ return stream.stream_ops.llseek(stream, offset, whence);
+ },read:function (stream, buffer, offset, length, position) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.read) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+ if (!seeking) stream.position += bytesRead;
+ return bytesRead;
+ },write:function (stream, buffer, offset, length, position, canOwn) {
+ if (length < 0 || position < 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EISDIR);
+ }
+ if (!stream.stream_ops.write) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var seeking = true;
+ if (typeof position === 'undefined') {
+ position = stream.position;
+ seeking = false;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(ERRNO_CODES.ESPIPE);
+ }
+ if (stream.flags & 1024) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },allocate:function (stream, offset, length) {
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EBADF);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },mmap:function (stream, buffer, offset, length, position, prot, flags) {
+ // TODO if PROT is PROT_WRITE, make sure we have write access
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(ERRNO_CODES.EACCES);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+ }
+ return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags);
+ },ioctl:function (stream, cmd, arg) {
+ if (!stream.stream_ops.ioctl) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTTY);
+ }
+ return stream.stream_ops.ioctl(stream, cmd, arg);
+ },readFile:function (path, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'r';
+ opts.encoding = opts.encoding || 'binary';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = '';
+ var utf8 = new Runtime.UTF8Processor();
+ for (var i = 0; i < length; i++) {
+ ret += utf8.processCChar(buf[i]);
+ }
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },writeFile:function (path, data, opts) {
+ opts = opts || {};
+ opts.flags = opts.flags || 'w';
+ opts.encoding = opts.encoding || 'utf8';
+ if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') {
+ throw new Error('Invalid encoding type "' + opts.encoding + '"');
+ }
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (opts.encoding === 'utf8') {
+ var utf8 = new Runtime.UTF8Processor();
+ var buf = new Uint8Array(utf8.processJSString(data));
+ FS.write(stream, buf, 0, buf.length, 0, opts.canOwn);
+ } else if (opts.encoding === 'binary') {
+ FS.write(stream, data, 0, data.length, 0, opts.canOwn);
+ }
+ FS.close(stream);
+ },cwd:function () {
+ return FS.currentPath;
+ },chdir:function (path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR);
+ }
+ var err = FS.nodePermissions(lookup.node, 'x');
+ if (err) {
+ throw new FS.ErrnoError(err);
+ }
+ FS.currentPath = lookup.path;
+ },createDefaultDirectories:function () {
+ FS.mkdir('/tmp');
+ },createDefaultDevices:function () {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: function() { return 0; },
+ write: function() { return 0; }
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using Module['printErr']
+ // so we register a second tty just for it.
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev('/dev/tty', FS.makedev(5, 0));
+ FS.mkdev('/dev/tty1', FS.makedev(6, 0));
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },createStandardStreams:function () {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 'r');
+ HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
+ assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
+
+ var stdout = FS.open('/dev/stdout', 'w');
+ HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
+ assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
+
+ var stderr = FS.open('/dev/stderr', 'w');
+ HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
+ assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')');
+ },ensureErrnoError:function () {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno) {
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ this.message = ERRNO_MESSAGES[errno];
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [ERRNO_CODES.ENOENT].forEach(function(code) {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '<generic error, no stack>';
+ });
+ },staticInit:function () {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },init:function (input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },quit:function () {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },getMode:function (canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },joinPath:function (parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },absolutePath:function (relative, base) {
+ return PATH.resolve(base, relative);
+ },standardizePath:function (path) {
+ return PATH.normalize(path);
+ },findObject:function (path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },analyzePath:function (path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ path = lookup.path;
+ } catch (e) {
+ }
+ var ret = {
+ isRoot: false, exists: false, error: 0, name: null, path: null, object: null,
+ parentExists: false, parentPath: null, parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, { parent: true });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },createFolder:function (parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },createPath:function (parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },createFile:function (parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },createDevice:function (parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset+i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset+i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },createLink:function (parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },forceLoadFile:function (obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },createLazyFile:function (parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length-1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024*1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum+1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if(!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },indexedDB:function () {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },DB_NAME:function () {
+ return 'EM_FS_' + window.location.pathname;
+ },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() };
+ putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },loadFilesFromDB:function (paths, onload, onerror) {
+ onload = onload || function(){};
+ onerror = onerror || function(){};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch(e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0, fail = 0, total = paths.length;
+ function finish() {
+ if (fail == 0) onload(); else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }};
+
+
+
+
+ function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
+ return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },createSocket:function (family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },getSocket:function (fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },stream_ops:{poll:function (stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },ioctl:function (stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },read:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },write:function (stream, buffer, offset, length, position /* ignored */) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },close:function (stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }},nextname:function () {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },websocket_sock_ops:{createPeer:function (sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ // runtimeConfig gets set to true if WebSocket runtime configuration is available.
+ var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
+
+ // The default value is 'ws://' the replace is needed because the compiler replaces "//" comments with '#'
+ // comments without checking context, so we'd end up with ws:#, the replace swaps the "#" for "//" again.
+ var url = 'ws:#'.replace('#', '//');
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['url']) {
+ url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
+ }
+ }
+
+ if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
+ url = url + addr + ':' + port;
+ }
+
+ // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
+ var subProtocols = 'binary'; // The default value is 'binary'
+
+ if (runtimeConfig) {
+ if ('string' === typeof Module['websocket']['subprotocol']) {
+ subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
+ }
+ }
+
+ // The regex trims the string (removes spaces at the beginning and end, then splits the string by
+ // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
+ subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
+
+ // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
+ var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
+
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
+ ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },getPeer:function (sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },addPeer:function (sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },removePeer:function (sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },handlePeerEvents:function (sock, peer) {
+ var first = true;
+
+ var handleOpen = function () {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },poll:function (sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },ioctl:function (sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg)>>2)]=bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },close:function (sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {
+ }
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {
+ }
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },bind:function (sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },connect:function (sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },listen:function (sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },accept:function (listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },getname:function (sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return { addr: addr, port: port };
+ },sendmsg:function (sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },recvmsg:function (sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ }
+ else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }}};function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+ }
+
+ function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+ }
+
+ function _fileno(stream) {
+ // int fileno(FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
+ stream = FS.getStreamFromPtr(stream);
+ if (!stream) return -1;
+ return stream.fd;
+ }function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var fd = _fileno(stream);
+ var bytesWritten = _write(fd, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+ }
+
+
+
+ Module["_strlen"] = _strlen;
+
+ function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1/x) === -Infinity);
+ }function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs)+(argIndex))>>3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs)+(argIndex))>>2)],
+ HEAP32[(((varargs)+(argIndex+4))>>2)]];
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs)+(argIndex))>>2)];
+ }
+ argIndex += Runtime.getNativeFieldSize(type);
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while(1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex+1)|0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false, precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while(1) {
+ var precisionChr = HEAP8[((textIndex+1)|0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex+1)|0)];
+ }
+ if (precision < 0) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex+2)|0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex+1)|0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's': {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++)|0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c': {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n': {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr)>>2)]=ret.length;
+ break;
+ }
+ case '%': {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default: {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+ }function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+ }function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout)>>2)];
+ return _fprintf(stdout, format, varargs);
+ }
+
+
+ function _fputs(s, stream) {
+ // int fputs(const char *restrict s, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
+ var fd = _fileno(stream);
+ return _write(fd, s, _strlen(s));
+ }
+
+ function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret)|0)]=chr;
+ var fd = _fileno(stream);
+ var ret = _write(fd, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStreamFromPtr(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+ }function _puts(s) {
+ // int puts(const char *s);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/puts.html
+ // NOTE: puts() always writes an extra newline.
+ var stdout = HEAP32[((_stdout)>>2)];
+ var ret = _fputs(s, stdout);
+ if (ret < 0) {
+ return ret;
+ } else {
+ var newlineRet = _fputc(10, stdout);
+ return (newlineRet < 0) ? -1 : ret + 1;
+ }
+ }
+
+ function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch(name) {
+ case 30: return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0: return 2097152;
+ case 3: return 65536;
+ case 28: return 32768;
+ case 44: return 32767;
+ case 75: return 16384;
+ case 39: return 1000;
+ case 89: return 700;
+ case 71: return 256;
+ case 40: return 255;
+ case 2: return 100;
+ case 180: return 64;
+ case 25: return 20;
+ case 5: return 16;
+ case 6: return 6;
+ case 73: return 4;
+ case 84: return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+ }
+
+
+ Module["_memset"] = _memset;
+
+ function ___errno_location() {
+ return ___errno_state;
+ }
+
+ function _abort() {
+ Module['abort']();
+ }
+
+ var Browser={mainLoop:{scheduler:null,method:"",shouldPause:false,paused:false,queue:[],pause:function () {
+ Browser.mainLoop.shouldPause = true;
+ },resume:function () {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },updateStatus:function () {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch(e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+ }
+ } catch(e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+ } catch(e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits-6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar&3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar&0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+
+ // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+ // Module['forcedAspectRatio'] = 4 / 3;
+
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'] ||
+ canvas['msRequestPointerLock'] ||
+ function(){};
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ document['msExitPointerLock'] ||
+ function(){}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas ||
+ document['msPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+ document.addEventListener('mspointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ var errorInfo = '?';
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+ Browser.init();
+ }
+ return ctx;
+ },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ var canvasContainer = canvas.parentNode;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvasContainer) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'] ||
+ document['msExitFullscreen'] ||
+ document['exitFullscreen'] ||
+ function() {};
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else {
+
+ // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+ canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+ canvasContainer.parentNode.removeChild(canvasContainer);
+
+ if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ Browser.updateCanvasDimensions(canvas);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ document.addEventListener('MSFullscreenChange', fullScreenChange, false);
+ }
+
+ // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+ var canvasContainer = document.createElement("div");
+ canvas.parentNode.insertBefore(canvasContainer, canvas);
+ canvasContainer.appendChild(canvas);
+
+ // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+ canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] ||
+ canvasContainer['mozRequestFullScreen'] ||
+ canvasContainer['msRequestFullscreen'] ||
+ (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+ canvasContainer.requestFullScreen();
+ },requestAnimationFrame:function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000/60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },safeCallback:function (func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },safeRequestAnimationFrame:function (func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },safeSetTimeout:function (func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },safeSetInterval:function (func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },getMimetype:function (name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.')+1)];
+ },getUserMedia:function (func) {
+ if(!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },getMovementX:function (event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },getMovementY:function (event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },getMouseWheelDelta:function (event) {
+ return Math.max(-1, Math.min(1, event.type === 'DOMMouseScroll' ? event.detail : -event.wheelDelta));
+ },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },xhrLoad:function (url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },asyncLoad:function (url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },resizeListeners:[],updateResizeListeners:function () {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },setCanvasSize:function (width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ Browser.updateCanvasDimensions(canvas, width, height);
+ if (!noUpdates) Browser.updateResizeListeners();
+ },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },setWindowedCanvasSize:function () {
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+ }
+ Browser.updateResizeListeners();
+ },updateCanvasDimensions:function (canvas, wNative, hNative) {
+ if (wNative && hNative) {
+ canvas.widthNative = wNative;
+ canvas.heightNative = hNative;
+ } else {
+ wNative = canvas.widthNative;
+ hNative = canvas.heightNative;
+ }
+ var w = wNative;
+ var h = hNative;
+ if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+ if (w/h < Module['forcedAspectRatio']) {
+ w = Math.round(h * Module['forcedAspectRatio']);
+ } else {
+ h = Math.round(w / Module['forcedAspectRatio']);
+ }
+ }
+ if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement'] ||
+ document['msFullScreenElement'] || document['msFullscreenElement'] ||
+ document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+ var factor = Math.min(screen.width / w, screen.height / h);
+ w = Math.round(w * factor);
+ h = Math.round(h * factor);
+ }
+ if (Browser.resizeCanvas) {
+ if (canvas.width != w) canvas.width = w;
+ if (canvas.height != h) canvas.height = h;
+ if (typeof canvas.style != 'undefined') {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ } else {
+ if (canvas.width != wNative) canvas.width = wNative;
+ if (canvas.height != hNative) canvas.height = hNative;
+ if (typeof canvas.style != 'undefined') {
+ if (w != wNative || h != hNative) {
+ canvas.style.setProperty( "width", w + "px", "important");
+ canvas.style.setProperty("height", h + "px", "important");
+ } else {
+ canvas.style.removeProperty( "width");
+ canvas.style.removeProperty("height");
+ }
+ }
+ }
+ }};
+
+ function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+ }
+
+ function ___assert_fail(condition, filename, line, func) {
+ ABORT = true;
+ throw 'Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + stackTrace();
+ }
+
+ function _time(ptr) {
+ var ret = Math.floor(Date.now()/1000);
+ if (ptr) {
+ HEAP32[((ptr)>>2)]=ret;
+ }
+ return ret;
+ }
+
+ function _llvm_bswap_i32(x) {
+ return ((x&0xff)<<24) | (((x>>8)&0xff)<<16) | (((x>>16)&0xff)<<8) | (x>>>24);
+ }
+
+
+
+ function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+ return dest;
+ }
+ Module["_memcpy"] = _memcpy;
+FS.staticInit();__ATINIT__.unshift({ func: function() { if (!Module["noFSInit"] && !FS.init.initialized) FS.init() } });__ATMAIN__.push({ func: function() { FS.ignorePermissions = false } });__ATEXIT__.push({ func: function() { FS.quit() } });Module["FS_createFolder"] = FS.createFolder;Module["FS_createPath"] = FS.createPath;Module["FS_createDataFile"] = FS.createDataFile;Module["FS_createPreloadedFile"] = FS.createPreloadedFile;Module["FS_createLazyFile"] = FS.createLazyFile;Module["FS_createLink"] = FS.createLink;Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
+__ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } });TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
+__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
+ Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+ Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+ Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+ Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+ Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+function invoke_iiii(index,a1,a2,a3) {
+ try {
+ return Module["dynCall_iiii"](index,a1,a2,a3);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vii(index,a1,a2) {
+ try {
+ Module["dynCall_vii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iii(index,a1,a2) {
+ try {
+ return Module["dynCall_iii"](index,a1,a2);
+ } catch(e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y);// + ' ' + new Error().stack);
+}
+// EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ 'use asm';
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+
+ var STACKTOP=env.STACKTOP|0;
+ var STACK_MAX=env.STACK_MAX|0;
+ var tempDoublePtr=env.tempDoublePtr|0;
+ var ABORT=env.ABORT|0;
+
+ var __THREW__ = 0;
+ var threwValue = 0;
+ var setjmpId = 0;
+ var undef = 0;
+ var nan = +env.NaN, inf = +env.Infinity;
+ var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0;
+
+ var tempRet0 = 0;
+ var tempRet1 = 0;
+ var tempRet2 = 0;
+ var tempRet3 = 0;
+ var tempRet4 = 0;
+ var tempRet5 = 0;
+ var tempRet6 = 0;
+ var tempRet7 = 0;
+ var tempRet8 = 0;
+ var tempRet9 = 0;
+ var Math_floor=global.Math.floor;
+ var Math_abs=global.Math.abs;
+ var Math_sqrt=global.Math.sqrt;
+ var Math_pow=global.Math.pow;
+ var Math_cos=global.Math.cos;
+ var Math_sin=global.Math.sin;
+ var Math_tan=global.Math.tan;
+ var Math_acos=global.Math.acos;
+ var Math_asin=global.Math.asin;
+ var Math_atan=global.Math.atan;
+ var Math_atan2=global.Math.atan2;
+ var Math_exp=global.Math.exp;
+ var Math_log=global.Math.log;
+ var Math_ceil=global.Math.ceil;
+ var Math_imul=global.Math.imul;
+ var abort=env.abort;
+ var assert=env.assert;
+ var asmPrintInt=env.asmPrintInt;
+ var asmPrintFloat=env.asmPrintFloat;
+ var Math_min=env.min;
+ var invoke_iiii=env.invoke_iiii;
+ var invoke_vii=env.invoke_vii;
+ var invoke_iii=env.invoke_iii;
+ var _send=env._send;
+ var ___setErrNo=env.___setErrNo;
+ var ___assert_fail=env.___assert_fail;
+ var _fflush=env._fflush;
+ var _pwrite=env._pwrite;
+ var __reallyNegative=env.__reallyNegative;
+ var _sbrk=env._sbrk;
+ var ___errno_location=env.___errno_location;
+ var _emscripten_memcpy_big=env._emscripten_memcpy_big;
+ var _fileno=env._fileno;
+ var _sysconf=env._sysconf;
+ var _puts=env._puts;
+ var _mkport=env._mkport;
+ var _write=env._write;
+ var _llvm_bswap_i32=env._llvm_bswap_i32;
+ var _fputc=env._fputc;
+ var _abort=env._abort;
+ var _fwrite=env._fwrite;
+ var _time=env._time;
+ var _fprintf=env._fprintf;
+ var __formatString=env.__formatString;
+ var _fputs=env._fputs;
+ var _printf=env._printf;
+ var tempFloat = 0.0;
+
+// EMSCRIPTEN_START_FUNCS
+function _inflate(i2, i3) {
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0, i38 = 0, i39 = 0, i40 = 0, i41 = 0, i42 = 0, i43 = 0, i44 = 0, i45 = 0, i46 = 0, i47 = 0, i48 = 0, i49 = 0, i50 = 0, i51 = 0, i52 = 0, i53 = 0, i54 = 0, i55 = 0, i56 = 0, i57 = 0, i58 = 0, i59 = 0, i60 = 0, i61 = 0, i62 = 0, i63 = 0, i64 = 0, i65 = 0, i66 = 0, i67 = 0, i68 = 0, i69 = 0, i70 = 0, i71 = 0, i72 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i25 = i1;
+ if ((i2 | 0) == 0) {
+ i72 = -2;
+ STACKTOP = i1;
+ return i72 | 0;
+ }
+ i4 = HEAP32[i2 + 28 >> 2] | 0;
+ if ((i4 | 0) == 0) {
+ i72 = -2;
+ STACKTOP = i1;
+ return i72 | 0;
+ }
+ i8 = i2 + 12 | 0;
+ i19 = HEAP32[i8 >> 2] | 0;
+ if ((i19 | 0) == 0) {
+ i72 = -2;
+ STACKTOP = i1;
+ return i72 | 0;
+ }
+ i62 = HEAP32[i2 >> 2] | 0;
+ if ((i62 | 0) == 0 ? (HEAP32[i2 + 4 >> 2] | 0) != 0 : 0) {
+ i72 = -2;
+ STACKTOP = i1;
+ return i72 | 0;
+ }
+ i68 = HEAP32[i4 >> 2] | 0;
+ if ((i68 | 0) == 11) {
+ HEAP32[i4 >> 2] = 12;
+ i68 = 12;
+ i62 = HEAP32[i2 >> 2] | 0;
+ i19 = HEAP32[i8 >> 2] | 0;
+ }
+ i15 = i2 + 16 | 0;
+ i59 = HEAP32[i15 >> 2] | 0;
+ i16 = i2 + 4 | 0;
+ i5 = HEAP32[i16 >> 2] | 0;
+ i17 = i4 + 56 | 0;
+ i6 = i4 + 60 | 0;
+ i12 = i4 + 8 | 0;
+ i10 = i4 + 24 | 0;
+ i39 = i25 + 1 | 0;
+ i11 = i4 + 16 | 0;
+ i38 = i4 + 32 | 0;
+ i35 = i2 + 24 | 0;
+ i40 = i4 + 36 | 0;
+ i41 = i4 + 20 | 0;
+ i9 = i2 + 48 | 0;
+ i42 = i4 + 64 | 0;
+ i46 = i4 + 12 | 0;
+ i47 = (i3 + -5 | 0) >>> 0 < 2;
+ i7 = i4 + 4 | 0;
+ i48 = i4 + 76 | 0;
+ i49 = i4 + 84 | 0;
+ i50 = i4 + 80 | 0;
+ i51 = i4 + 88 | 0;
+ i43 = (i3 | 0) == 6;
+ i57 = i4 + 7108 | 0;
+ i37 = i4 + 72 | 0;
+ i58 = i4 + 7112 | 0;
+ i54 = i4 + 68 | 0;
+ i28 = i4 + 44 | 0;
+ i29 = i4 + 7104 | 0;
+ i30 = i4 + 48 | 0;
+ i31 = i4 + 52 | 0;
+ i18 = i4 + 40 | 0;
+ i13 = i2 + 20 | 0;
+ i14 = i4 + 28 | 0;
+ i32 = i4 + 96 | 0;
+ i33 = i4 + 100 | 0;
+ i34 = i4 + 92 | 0;
+ i36 = i4 + 104 | 0;
+ i52 = i4 + 1328 | 0;
+ i53 = i4 + 108 | 0;
+ i27 = i4 + 112 | 0;
+ i55 = i4 + 752 | 0;
+ i56 = i4 + 624 | 0;
+ i44 = i25 + 2 | 0;
+ i45 = i25 + 3 | 0;
+ i67 = HEAP32[i6 >> 2] | 0;
+ i65 = i5;
+ i64 = HEAP32[i17 >> 2] | 0;
+ i26 = i59;
+ i61 = 0;
+ L17 : while (1) {
+ L19 : do {
+ switch (i68 | 0) {
+ case 16:
+ {
+ if (i67 >>> 0 < 14) {
+ i63 = i67;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 14) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ } else {
+ i63 = i67;
+ }
+ i71 = (i64 & 31) + 257 | 0;
+ HEAP32[i32 >> 2] = i71;
+ i72 = (i64 >>> 5 & 31) + 1 | 0;
+ HEAP32[i33 >> 2] = i72;
+ HEAP32[i34 >> 2] = (i64 >>> 10 & 15) + 4;
+ i64 = i64 >>> 14;
+ i63 = i63 + -14 | 0;
+ if (i71 >>> 0 > 286 | i72 >>> 0 > 30) {
+ HEAP32[i35 >> 2] = 11616;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break L19;
+ } else {
+ HEAP32[i36 >> 2] = 0;
+ HEAP32[i4 >> 2] = 17;
+ i66 = 0;
+ i60 = 154;
+ break L19;
+ }
+ }
+ case 2:
+ {
+ if (i67 >>> 0 < 32) {
+ i63 = i67;
+ i60 = 47;
+ } else {
+ i60 = 49;
+ }
+ break;
+ }
+ case 23:
+ {
+ i66 = HEAP32[i37 >> 2] | 0;
+ i63 = i67;
+ i60 = 240;
+ break;
+ }
+ case 18:
+ {
+ i63 = HEAP32[i36 >> 2] | 0;
+ i69 = i65;
+ i60 = 164;
+ break;
+ }
+ case 1:
+ {
+ if (i67 >>> 0 < 16) {
+ i63 = i67;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 16) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ } else {
+ i63 = i67;
+ }
+ HEAP32[i11 >> 2] = i64;
+ if ((i64 & 255 | 0) != 8) {
+ HEAP32[i35 >> 2] = 11448;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break L19;
+ }
+ if ((i64 & 57344 | 0) != 0) {
+ HEAP32[i35 >> 2] = 11504;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break L19;
+ }
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) == 0) {
+ i60 = i64;
+ } else {
+ HEAP32[i60 >> 2] = i64 >>> 8 & 1;
+ i60 = HEAP32[i11 >> 2] | 0;
+ }
+ if ((i60 & 512 | 0) != 0) {
+ HEAP8[i25] = i64;
+ HEAP8[i39] = i64 >>> 8;
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i25, 2) | 0;
+ }
+ HEAP32[i4 >> 2] = 2;
+ i63 = 0;
+ i64 = 0;
+ i60 = 47;
+ break;
+ }
+ case 8:
+ {
+ i63 = i67;
+ i60 = 109;
+ break;
+ }
+ case 22:
+ {
+ i63 = i67;
+ i60 = 228;
+ break;
+ }
+ case 24:
+ {
+ i63 = i67;
+ i60 = 246;
+ break;
+ }
+ case 19:
+ {
+ i63 = i67;
+ i60 = 201;
+ break;
+ }
+ case 20:
+ {
+ i63 = i67;
+ i60 = 202;
+ break;
+ }
+ case 21:
+ {
+ i66 = HEAP32[i37 >> 2] | 0;
+ i63 = i67;
+ i60 = 221;
+ break;
+ }
+ case 10:
+ {
+ i63 = i67;
+ i60 = 121;
+ break;
+ }
+ case 11:
+ {
+ i63 = i67;
+ i60 = 124;
+ break;
+ }
+ case 12:
+ {
+ i63 = i67;
+ i60 = 125;
+ break;
+ }
+ case 5:
+ {
+ i63 = i67;
+ i60 = 73;
+ break;
+ }
+ case 4:
+ {
+ i63 = i67;
+ i60 = 62;
+ break;
+ }
+ case 0:
+ {
+ i66 = HEAP32[i12 >> 2] | 0;
+ if ((i66 | 0) == 0) {
+ HEAP32[i4 >> 2] = 12;
+ i63 = i67;
+ i66 = i26;
+ break L19;
+ }
+ if (i67 >>> 0 < 16) {
+ i63 = i67;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i67 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 16) {
+ i62 = i67;
+ } else {
+ i62 = i67;
+ break;
+ }
+ }
+ } else {
+ i63 = i67;
+ }
+ if ((i66 & 2 | 0) != 0 & (i64 | 0) == 35615) {
+ HEAP32[i10 >> 2] = _crc32(0, 0, 0) | 0;
+ HEAP8[i25] = 31;
+ HEAP8[i39] = -117;
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i25, 2) | 0;
+ HEAP32[i4 >> 2] = 1;
+ i63 = 0;
+ i64 = 0;
+ i66 = i26;
+ break L19;
+ }
+ HEAP32[i11 >> 2] = 0;
+ i67 = HEAP32[i38 >> 2] | 0;
+ if ((i67 | 0) != 0) {
+ HEAP32[i67 + 48 >> 2] = -1;
+ i66 = HEAP32[i12 >> 2] | 0;
+ }
+ if ((i66 & 1 | 0) != 0 ? ((((i64 << 8 & 65280) + (i64 >>> 8) | 0) >>> 0) % 31 | 0 | 0) == 0 : 0) {
+ if ((i64 & 15 | 0) != 8) {
+ HEAP32[i35 >> 2] = 11448;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break L19;
+ }
+ i66 = i64 >>> 4;
+ i63 = i63 + -4 | 0;
+ i68 = (i66 & 15) + 8 | 0;
+ i67 = HEAP32[i40 >> 2] | 0;
+ if ((i67 | 0) != 0) {
+ if (i68 >>> 0 > i67 >>> 0) {
+ HEAP32[i35 >> 2] = 11480;
+ HEAP32[i4 >> 2] = 29;
+ i64 = i66;
+ i66 = i26;
+ break L19;
+ }
+ } else {
+ HEAP32[i40 >> 2] = i68;
+ }
+ HEAP32[i41 >> 2] = 1 << i68;
+ i63 = _adler32(0, 0, 0) | 0;
+ HEAP32[i10 >> 2] = i63;
+ HEAP32[i9 >> 2] = i63;
+ HEAP32[i4 >> 2] = i64 >>> 12 & 2 ^ 11;
+ i63 = 0;
+ i64 = 0;
+ i66 = i26;
+ break L19;
+ }
+ HEAP32[i35 >> 2] = 11424;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break;
+ }
+ case 26:
+ {
+ if ((HEAP32[i12 >> 2] | 0) != 0) {
+ if (i67 >>> 0 < 32) {
+ i63 = i67;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 32) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ } else {
+ i63 = i67;
+ }
+ i66 = i59 - i26 | 0;
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + i66;
+ HEAP32[i14 >> 2] = (HEAP32[i14 >> 2] | 0) + i66;
+ if ((i59 | 0) != (i26 | 0)) {
+ i59 = HEAP32[i10 >> 2] | 0;
+ i67 = i19 + (0 - i66) | 0;
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ i59 = _adler32(i59, i67, i66) | 0;
+ } else {
+ i59 = _crc32(i59, i67, i66) | 0;
+ }
+ HEAP32[i10 >> 2] = i59;
+ HEAP32[i9 >> 2] = i59;
+ }
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ i59 = _llvm_bswap_i32(i64 | 0) | 0;
+ } else {
+ i59 = i64;
+ }
+ if ((i59 | 0) == (HEAP32[i10 >> 2] | 0)) {
+ i63 = 0;
+ i64 = 0;
+ i59 = i26;
+ } else {
+ HEAP32[i35 >> 2] = 11904;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ i59 = i26;
+ break L19;
+ }
+ } else {
+ i63 = i67;
+ }
+ HEAP32[i4 >> 2] = 27;
+ i60 = 277;
+ break;
+ }
+ case 27:
+ {
+ i63 = i67;
+ i60 = 277;
+ break;
+ }
+ case 28:
+ {
+ i63 = i67;
+ i61 = 1;
+ i60 = 285;
+ break L17;
+ }
+ case 29:
+ {
+ i63 = i67;
+ i61 = -3;
+ break L17;
+ }
+ case 25:
+ {
+ if ((i26 | 0) == 0) {
+ i63 = i67;
+ i26 = 0;
+ i60 = 285;
+ break L17;
+ }
+ HEAP8[i19] = HEAP32[i42 >> 2];
+ HEAP32[i4 >> 2] = 20;
+ i63 = i67;
+ i66 = i26 + -1 | 0;
+ i19 = i19 + 1 | 0;
+ break;
+ }
+ case 17:
+ {
+ i66 = HEAP32[i36 >> 2] | 0;
+ if (i66 >>> 0 < (HEAP32[i34 >> 2] | 0) >>> 0) {
+ i63 = i67;
+ i60 = 154;
+ } else {
+ i60 = 158;
+ }
+ break;
+ }
+ case 13:
+ {
+ i63 = i67 & 7;
+ i64 = i64 >>> i63;
+ i63 = i67 - i63 | 0;
+ if (i63 >>> 0 < 32) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 32) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ }
+ i66 = i64 & 65535;
+ if ((i66 | 0) == (i64 >>> 16 ^ 65535 | 0)) {
+ HEAP32[i42 >> 2] = i66;
+ HEAP32[i4 >> 2] = 14;
+ if (i43) {
+ i63 = 0;
+ i64 = 0;
+ i60 = 285;
+ break L17;
+ } else {
+ i63 = 0;
+ i64 = 0;
+ i60 = 143;
+ break L19;
+ }
+ } else {
+ HEAP32[i35 >> 2] = 11584;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break L19;
+ }
+ }
+ case 7:
+ {
+ i63 = i67;
+ i60 = 96;
+ break;
+ }
+ case 14:
+ {
+ i63 = i67;
+ i60 = 143;
+ break;
+ }
+ case 15:
+ {
+ i63 = i67;
+ i60 = 144;
+ break;
+ }
+ case 9:
+ {
+ if (i67 >>> 0 < 32) {
+ i63 = i67;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 32) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ }
+ i63 = _llvm_bswap_i32(i64 | 0) | 0;
+ HEAP32[i10 >> 2] = i63;
+ HEAP32[i9 >> 2] = i63;
+ HEAP32[i4 >> 2] = 10;
+ i63 = 0;
+ i64 = 0;
+ i60 = 121;
+ break;
+ }
+ case 30:
+ {
+ i60 = 299;
+ break L17;
+ }
+ case 6:
+ {
+ i63 = i67;
+ i60 = 83;
+ break;
+ }
+ case 3:
+ {
+ if (i67 >>> 0 < 16) {
+ i63 = i67;
+ i66 = i62;
+ i60 = 55;
+ } else {
+ i60 = 57;
+ }
+ break;
+ }
+ default:
+ {
+ i2 = -2;
+ i60 = 300;
+ break L17;
+ }
+ }
+ } while (0);
+ if ((i60 | 0) == 47) {
+ while (1) {
+ i60 = 0;
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i60 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 32) {
+ i62 = i60;
+ i60 = 47;
+ } else {
+ i62 = i60;
+ i60 = 49;
+ break;
+ }
+ }
+ } else if ((i60 | 0) == 121) {
+ if ((HEAP32[i46 >> 2] | 0) == 0) {
+ i60 = 122;
+ break;
+ }
+ i60 = _adler32(0, 0, 0) | 0;
+ HEAP32[i10 >> 2] = i60;
+ HEAP32[i9 >> 2] = i60;
+ HEAP32[i4 >> 2] = 11;
+ i60 = 124;
+ } else if ((i60 | 0) == 143) {
+ HEAP32[i4 >> 2] = 15;
+ i60 = 144;
+ } else if ((i60 | 0) == 154) {
+ while (1) {
+ i60 = 0;
+ if (i63 >>> 0 < 3) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i67 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 3) {
+ i62 = i67;
+ } else {
+ i62 = i67;
+ break;
+ }
+ }
+ }
+ HEAP32[i36 >> 2] = i66 + 1;
+ HEAP16[i4 + (HEAPU16[11384 + (i66 << 1) >> 1] << 1) + 112 >> 1] = i64 & 7;
+ i64 = i64 >>> 3;
+ i63 = i63 + -3 | 0;
+ i66 = HEAP32[i36 >> 2] | 0;
+ if (i66 >>> 0 < (HEAP32[i34 >> 2] | 0) >>> 0) {
+ i60 = 154;
+ } else {
+ i67 = i63;
+ i60 = 158;
+ break;
+ }
+ }
+ } else if ((i60 | 0) == 277) {
+ i60 = 0;
+ if ((HEAP32[i12 >> 2] | 0) == 0) {
+ i60 = 284;
+ break;
+ }
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ i60 = 284;
+ break;
+ }
+ if (i63 >>> 0 < 32) {
+ i66 = i62;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i62 = i66;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i62 = i66 + 1 | 0;
+ i64 = (HEAPU8[i66] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 32) {
+ i66 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i64 | 0) == (HEAP32[i14 >> 2] | 0)) {
+ i63 = 0;
+ i64 = 0;
+ i60 = 284;
+ break;
+ }
+ HEAP32[i35 >> 2] = 11928;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ }
+ do {
+ if ((i60 | 0) == 49) {
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 4 >> 2] = i64;
+ }
+ if ((HEAP32[i11 >> 2] & 512 | 0) != 0) {
+ HEAP8[i25] = i64;
+ HEAP8[i39] = i64 >>> 8;
+ HEAP8[i44] = i64 >>> 16;
+ HEAP8[i45] = i64 >>> 24;
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i25, 4) | 0;
+ }
+ HEAP32[i4 >> 2] = 3;
+ i63 = 0;
+ i64 = 0;
+ i66 = i62;
+ i60 = 55;
+ } else if ((i60 | 0) == 124) {
+ if (i47) {
+ i60 = 285;
+ break L17;
+ } else {
+ i60 = 125;
+ }
+ } else if ((i60 | 0) == 144) {
+ i60 = 0;
+ i66 = HEAP32[i42 >> 2] | 0;
+ if ((i66 | 0) == 0) {
+ HEAP32[i4 >> 2] = 11;
+ i66 = i26;
+ break;
+ }
+ i66 = i66 >>> 0 > i65 >>> 0 ? i65 : i66;
+ i67 = i66 >>> 0 > i26 >>> 0 ? i26 : i66;
+ if ((i67 | 0) == 0) {
+ i60 = 285;
+ break L17;
+ }
+ _memcpy(i19 | 0, i62 | 0, i67 | 0) | 0;
+ HEAP32[i42 >> 2] = (HEAP32[i42 >> 2] | 0) - i67;
+ i65 = i65 - i67 | 0;
+ i66 = i26 - i67 | 0;
+ i62 = i62 + i67 | 0;
+ i19 = i19 + i67 | 0;
+ } else if ((i60 | 0) == 158) {
+ i60 = 0;
+ if (i66 >>> 0 < 19) {
+ while (1) {
+ i61 = i66 + 1 | 0;
+ HEAP16[i4 + (HEAPU16[11384 + (i66 << 1) >> 1] << 1) + 112 >> 1] = 0;
+ if ((i61 | 0) == 19) {
+ break;
+ } else {
+ i66 = i61;
+ }
+ }
+ HEAP32[i36 >> 2] = 19;
+ }
+ HEAP32[i53 >> 2] = i52;
+ HEAP32[i48 >> 2] = i52;
+ HEAP32[i49 >> 2] = 7;
+ i61 = _inflate_table(0, i27, 19, i53, i49, i55) | 0;
+ if ((i61 | 0) == 0) {
+ HEAP32[i36 >> 2] = 0;
+ HEAP32[i4 >> 2] = 18;
+ i63 = 0;
+ i69 = i65;
+ i61 = 0;
+ i60 = 164;
+ break;
+ } else {
+ HEAP32[i35 >> 2] = 11656;
+ HEAP32[i4 >> 2] = 29;
+ i63 = i67;
+ i66 = i26;
+ break;
+ }
+ }
+ } while (0);
+ L163 : do {
+ if ((i60 | 0) == 55) {
+ while (1) {
+ i60 = 0;
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i62 = i66;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i62 = i66 + 1 | 0;
+ i64 = (HEAPU8[i66] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 16) {
+ i66 = i62;
+ i60 = 55;
+ } else {
+ i60 = 57;
+ break;
+ }
+ }
+ } else if ((i60 | 0) == 125) {
+ i60 = 0;
+ if ((HEAP32[i7 >> 2] | 0) != 0) {
+ i66 = i63 & 7;
+ HEAP32[i4 >> 2] = 26;
+ i63 = i63 - i66 | 0;
+ i64 = i64 >>> i66;
+ i66 = i26;
+ break;
+ }
+ if (i63 >>> 0 < 3) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i66 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 3) {
+ i62 = i66;
+ } else {
+ i62 = i66;
+ break;
+ }
+ }
+ }
+ HEAP32[i7 >> 2] = i64 & 1;
+ i66 = i64 >>> 1 & 3;
+ if ((i66 | 0) == 0) {
+ HEAP32[i4 >> 2] = 13;
+ } else if ((i66 | 0) == 1) {
+ HEAP32[i48 >> 2] = 11952;
+ HEAP32[i49 >> 2] = 9;
+ HEAP32[i50 >> 2] = 14e3;
+ HEAP32[i51 >> 2] = 5;
+ HEAP32[i4 >> 2] = 19;
+ if (i43) {
+ i60 = 133;
+ break L17;
+ }
+ } else if ((i66 | 0) == 2) {
+ HEAP32[i4 >> 2] = 16;
+ } else if ((i66 | 0) == 3) {
+ HEAP32[i35 >> 2] = 11560;
+ HEAP32[i4 >> 2] = 29;
+ }
+ i63 = i63 + -3 | 0;
+ i64 = i64 >>> 3;
+ i66 = i26;
+ } else if ((i60 | 0) == 164) {
+ i60 = 0;
+ i65 = HEAP32[i32 >> 2] | 0;
+ i66 = HEAP32[i33 >> 2] | 0;
+ do {
+ if (i63 >>> 0 < (i66 + i65 | 0) >>> 0) {
+ i71 = i67;
+ L181 : while (1) {
+ i70 = (1 << HEAP32[i49 >> 2]) + -1 | 0;
+ i72 = i70 & i64;
+ i68 = HEAP32[i48 >> 2] | 0;
+ i67 = HEAPU8[i68 + (i72 << 2) + 1 | 0] | 0;
+ if (i67 >>> 0 > i71 >>> 0) {
+ i67 = i71;
+ while (1) {
+ if ((i69 | 0) == 0) {
+ i63 = i67;
+ i65 = 0;
+ break L17;
+ }
+ i69 = i69 + -1 | 0;
+ i71 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i67) + i64 | 0;
+ i62 = i67 + 8 | 0;
+ i72 = i70 & i64;
+ i67 = HEAPU8[i68 + (i72 << 2) + 1 | 0] | 0;
+ if (i67 >>> 0 > i62 >>> 0) {
+ i67 = i62;
+ i62 = i71;
+ } else {
+ i70 = i62;
+ i62 = i71;
+ break;
+ }
+ }
+ } else {
+ i70 = i71;
+ }
+ i68 = HEAP16[i68 + (i72 << 2) + 2 >> 1] | 0;
+ L188 : do {
+ if ((i68 & 65535) < 16) {
+ if (i70 >>> 0 < i67 >>> 0) {
+ while (1) {
+ if ((i69 | 0) == 0) {
+ i63 = i70;
+ i65 = 0;
+ break L17;
+ }
+ i69 = i69 + -1 | 0;
+ i65 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i70) + i64 | 0;
+ i70 = i70 + 8 | 0;
+ if (i70 >>> 0 < i67 >>> 0) {
+ i62 = i65;
+ } else {
+ i62 = i65;
+ break;
+ }
+ }
+ }
+ HEAP32[i36 >> 2] = i63 + 1;
+ HEAP16[i4 + (i63 << 1) + 112 >> 1] = i68;
+ i71 = i70 - i67 | 0;
+ i64 = i64 >>> i67;
+ } else {
+ if (i68 << 16 >> 16 == 16) {
+ i68 = i67 + 2 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ while (1) {
+ if ((i69 | 0) == 0) {
+ i63 = i70;
+ i65 = 0;
+ i62 = i71;
+ break L17;
+ }
+ i69 = i69 + -1 | 0;
+ i62 = i71 + 1 | 0;
+ i64 = (HEAPU8[i71] << i70) + i64 | 0;
+ i70 = i70 + 8 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ i64 = i64 >>> i67;
+ i67 = i70 - i67 | 0;
+ if ((i63 | 0) == 0) {
+ i60 = 181;
+ break L181;
+ }
+ i67 = i67 + -2 | 0;
+ i68 = (i64 & 3) + 3 | 0;
+ i64 = i64 >>> 2;
+ i70 = HEAP16[i4 + (i63 + -1 << 1) + 112 >> 1] | 0;
+ } else if (i68 << 16 >> 16 == 17) {
+ i68 = i67 + 3 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ while (1) {
+ if ((i69 | 0) == 0) {
+ i63 = i70;
+ i65 = 0;
+ i62 = i71;
+ break L17;
+ }
+ i69 = i69 + -1 | 0;
+ i62 = i71 + 1 | 0;
+ i64 = (HEAPU8[i71] << i70) + i64 | 0;
+ i70 = i70 + 8 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ i64 = i64 >>> i67;
+ i67 = -3 - i67 + i70 | 0;
+ i68 = (i64 & 7) + 3 | 0;
+ i64 = i64 >>> 3;
+ i70 = 0;
+ } else {
+ i68 = i67 + 7 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ while (1) {
+ if ((i69 | 0) == 0) {
+ i63 = i70;
+ i65 = 0;
+ i62 = i71;
+ break L17;
+ }
+ i69 = i69 + -1 | 0;
+ i62 = i71 + 1 | 0;
+ i64 = (HEAPU8[i71] << i70) + i64 | 0;
+ i70 = i70 + 8 | 0;
+ if (i70 >>> 0 < i68 >>> 0) {
+ i71 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ i64 = i64 >>> i67;
+ i67 = -7 - i67 + i70 | 0;
+ i68 = (i64 & 127) + 11 | 0;
+ i64 = i64 >>> 7;
+ i70 = 0;
+ }
+ if ((i63 + i68 | 0) >>> 0 > (i66 + i65 | 0) >>> 0) {
+ i60 = 190;
+ break L181;
+ }
+ while (1) {
+ i68 = i68 + -1 | 0;
+ HEAP32[i36 >> 2] = i63 + 1;
+ HEAP16[i4 + (i63 << 1) + 112 >> 1] = i70;
+ if ((i68 | 0) == 0) {
+ i71 = i67;
+ break L188;
+ }
+ i63 = HEAP32[i36 >> 2] | 0;
+ }
+ }
+ } while (0);
+ i63 = HEAP32[i36 >> 2] | 0;
+ i65 = HEAP32[i32 >> 2] | 0;
+ i66 = HEAP32[i33 >> 2] | 0;
+ if (!(i63 >>> 0 < (i66 + i65 | 0) >>> 0)) {
+ i60 = 193;
+ break;
+ }
+ }
+ if ((i60 | 0) == 181) {
+ i60 = 0;
+ HEAP32[i35 >> 2] = 11688;
+ HEAP32[i4 >> 2] = 29;
+ i63 = i67;
+ i65 = i69;
+ i66 = i26;
+ break L163;
+ } else if ((i60 | 0) == 190) {
+ i60 = 0;
+ HEAP32[i35 >> 2] = 11688;
+ HEAP32[i4 >> 2] = 29;
+ i63 = i67;
+ i65 = i69;
+ i66 = i26;
+ break L163;
+ } else if ((i60 | 0) == 193) {
+ i60 = 0;
+ if ((HEAP32[i4 >> 2] | 0) == 29) {
+ i63 = i71;
+ i65 = i69;
+ i66 = i26;
+ break L163;
+ } else {
+ i63 = i71;
+ break;
+ }
+ }
+ } else {
+ i63 = i67;
+ }
+ } while (0);
+ if ((HEAP16[i56 >> 1] | 0) == 0) {
+ HEAP32[i35 >> 2] = 11720;
+ HEAP32[i4 >> 2] = 29;
+ i65 = i69;
+ i66 = i26;
+ break;
+ }
+ HEAP32[i53 >> 2] = i52;
+ HEAP32[i48 >> 2] = i52;
+ HEAP32[i49 >> 2] = 9;
+ i61 = _inflate_table(1, i27, i65, i53, i49, i55) | 0;
+ if ((i61 | 0) != 0) {
+ HEAP32[i35 >> 2] = 11760;
+ HEAP32[i4 >> 2] = 29;
+ i65 = i69;
+ i66 = i26;
+ break;
+ }
+ HEAP32[i50 >> 2] = HEAP32[i53 >> 2];
+ HEAP32[i51 >> 2] = 6;
+ i61 = _inflate_table(2, i4 + (HEAP32[i32 >> 2] << 1) + 112 | 0, HEAP32[i33 >> 2] | 0, i53, i51, i55) | 0;
+ if ((i61 | 0) == 0) {
+ HEAP32[i4 >> 2] = 19;
+ if (i43) {
+ i65 = i69;
+ i61 = 0;
+ i60 = 285;
+ break L17;
+ } else {
+ i65 = i69;
+ i61 = 0;
+ i60 = 201;
+ break;
+ }
+ } else {
+ HEAP32[i35 >> 2] = 11792;
+ HEAP32[i4 >> 2] = 29;
+ i65 = i69;
+ i66 = i26;
+ break;
+ }
+ }
+ } while (0);
+ if ((i60 | 0) == 57) {
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 8 >> 2] = i64 & 255;
+ HEAP32[i60 + 12 >> 2] = i64 >>> 8;
+ }
+ if ((HEAP32[i11 >> 2] & 512 | 0) != 0) {
+ HEAP8[i25] = i64;
+ HEAP8[i39] = i64 >>> 8;
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i25, 2) | 0;
+ }
+ HEAP32[i4 >> 2] = 4;
+ i63 = 0;
+ i64 = 0;
+ i60 = 62;
+ } else if ((i60 | 0) == 201) {
+ HEAP32[i4 >> 2] = 20;
+ i60 = 202;
+ }
+ do {
+ if ((i60 | 0) == 62) {
+ i60 = 0;
+ i66 = HEAP32[i11 >> 2] | 0;
+ if ((i66 & 1024 | 0) == 0) {
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 16 >> 2] = 0;
+ }
+ } else {
+ if (i63 >>> 0 < 16) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i67 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 16) {
+ i62 = i67;
+ } else {
+ i62 = i67;
+ break;
+ }
+ }
+ }
+ HEAP32[i42 >> 2] = i64;
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 20 >> 2] = i64;
+ i66 = HEAP32[i11 >> 2] | 0;
+ }
+ if ((i66 & 512 | 0) == 0) {
+ i63 = 0;
+ i64 = 0;
+ } else {
+ HEAP8[i25] = i64;
+ HEAP8[i39] = i64 >>> 8;
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i25, 2) | 0;
+ i63 = 0;
+ i64 = 0;
+ }
+ }
+ HEAP32[i4 >> 2] = 5;
+ i60 = 73;
+ } else if ((i60 | 0) == 202) {
+ i60 = 0;
+ if (i65 >>> 0 > 5 & i26 >>> 0 > 257) {
+ HEAP32[i8 >> 2] = i19;
+ HEAP32[i15 >> 2] = i26;
+ HEAP32[i2 >> 2] = i62;
+ HEAP32[i16 >> 2] = i65;
+ HEAP32[i17 >> 2] = i64;
+ HEAP32[i6 >> 2] = i63;
+ _inflate_fast(i2, i59);
+ i19 = HEAP32[i8 >> 2] | 0;
+ i66 = HEAP32[i15 >> 2] | 0;
+ i62 = HEAP32[i2 >> 2] | 0;
+ i65 = HEAP32[i16 >> 2] | 0;
+ i64 = HEAP32[i17 >> 2] | 0;
+ i63 = HEAP32[i6 >> 2] | 0;
+ if ((HEAP32[i4 >> 2] | 0) != 11) {
+ break;
+ }
+ HEAP32[i57 >> 2] = -1;
+ break;
+ }
+ HEAP32[i57 >> 2] = 0;
+ i69 = (1 << HEAP32[i49 >> 2]) + -1 | 0;
+ i71 = i69 & i64;
+ i66 = HEAP32[i48 >> 2] | 0;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ i67 = i68 & 255;
+ if (i67 >>> 0 > i63 >>> 0) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i70 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ i71 = i69 & i64;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ i67 = i68 & 255;
+ if (i67 >>> 0 > i63 >>> 0) {
+ i62 = i70;
+ } else {
+ i62 = i70;
+ break;
+ }
+ }
+ }
+ i69 = HEAP8[i66 + (i71 << 2) | 0] | 0;
+ i70 = HEAP16[i66 + (i71 << 2) + 2 >> 1] | 0;
+ i71 = i69 & 255;
+ if (!(i69 << 24 >> 24 == 0)) {
+ if ((i71 & 240 | 0) == 0) {
+ i69 = i70 & 65535;
+ i70 = (1 << i67 + i71) + -1 | 0;
+ i71 = ((i64 & i70) >>> i67) + i69 | 0;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ if (((i68 & 255) + i67 | 0) >>> 0 > i63 >>> 0) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i71 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ i62 = ((i64 & i70) >>> i67) + i69 | 0;
+ i68 = HEAP8[i66 + (i62 << 2) + 1 | 0] | 0;
+ if (((i68 & 255) + i67 | 0) >>> 0 > i63 >>> 0) {
+ i62 = i71;
+ } else {
+ i69 = i62;
+ i62 = i71;
+ break;
+ }
+ }
+ } else {
+ i69 = i71;
+ }
+ i70 = HEAP16[i66 + (i69 << 2) + 2 >> 1] | 0;
+ i69 = HEAP8[i66 + (i69 << 2) | 0] | 0;
+ HEAP32[i57 >> 2] = i67;
+ i66 = i67;
+ i63 = i63 - i67 | 0;
+ i64 = i64 >>> i67;
+ } else {
+ i66 = 0;
+ }
+ } else {
+ i66 = 0;
+ i69 = 0;
+ }
+ i72 = i68 & 255;
+ i64 = i64 >>> i72;
+ i63 = i63 - i72 | 0;
+ HEAP32[i57 >> 2] = i66 + i72;
+ HEAP32[i42 >> 2] = i70 & 65535;
+ i66 = i69 & 255;
+ if (i69 << 24 >> 24 == 0) {
+ HEAP32[i4 >> 2] = 25;
+ i66 = i26;
+ break;
+ }
+ if ((i66 & 32 | 0) != 0) {
+ HEAP32[i57 >> 2] = -1;
+ HEAP32[i4 >> 2] = 11;
+ i66 = i26;
+ break;
+ }
+ if ((i66 & 64 | 0) == 0) {
+ i66 = i66 & 15;
+ HEAP32[i37 >> 2] = i66;
+ HEAP32[i4 >> 2] = 21;
+ i60 = 221;
+ break;
+ } else {
+ HEAP32[i35 >> 2] = 11816;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break;
+ }
+ }
+ } while (0);
+ if ((i60 | 0) == 73) {
+ i68 = HEAP32[i11 >> 2] | 0;
+ if ((i68 & 1024 | 0) != 0) {
+ i67 = HEAP32[i42 >> 2] | 0;
+ i60 = i67 >>> 0 > i65 >>> 0 ? i65 : i67;
+ if ((i60 | 0) != 0) {
+ i66 = HEAP32[i38 >> 2] | 0;
+ if ((i66 | 0) != 0 ? (i20 = HEAP32[i66 + 16 >> 2] | 0, (i20 | 0) != 0) : 0) {
+ i67 = (HEAP32[i66 + 20 >> 2] | 0) - i67 | 0;
+ i66 = HEAP32[i66 + 24 >> 2] | 0;
+ _memcpy(i20 + i67 | 0, i62 | 0, ((i67 + i60 | 0) >>> 0 > i66 >>> 0 ? i66 - i67 | 0 : i60) | 0) | 0;
+ i68 = HEAP32[i11 >> 2] | 0;
+ }
+ if ((i68 & 512 | 0) != 0) {
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i62, i60) | 0;
+ }
+ i67 = (HEAP32[i42 >> 2] | 0) - i60 | 0;
+ HEAP32[i42 >> 2] = i67;
+ i65 = i65 - i60 | 0;
+ i62 = i62 + i60 | 0;
+ }
+ if ((i67 | 0) != 0) {
+ i60 = 285;
+ break;
+ }
+ }
+ HEAP32[i42 >> 2] = 0;
+ HEAP32[i4 >> 2] = 6;
+ i60 = 83;
+ } else if ((i60 | 0) == 221) {
+ i60 = 0;
+ if ((i66 | 0) == 0) {
+ i60 = HEAP32[i42 >> 2] | 0;
+ } else {
+ if (i63 >>> 0 < i66 >>> 0) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i67 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < i66 >>> 0) {
+ i62 = i67;
+ } else {
+ i62 = i67;
+ break;
+ }
+ }
+ }
+ i60 = (HEAP32[i42 >> 2] | 0) + ((1 << i66) + -1 & i64) | 0;
+ HEAP32[i42 >> 2] = i60;
+ HEAP32[i57 >> 2] = (HEAP32[i57 >> 2] | 0) + i66;
+ i63 = i63 - i66 | 0;
+ i64 = i64 >>> i66;
+ }
+ HEAP32[i58 >> 2] = i60;
+ HEAP32[i4 >> 2] = 22;
+ i60 = 228;
+ }
+ do {
+ if ((i60 | 0) == 83) {
+ if ((HEAP32[i11 >> 2] & 2048 | 0) == 0) {
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 28 >> 2] = 0;
+ }
+ } else {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i60 = 285;
+ break L17;
+ } else {
+ i66 = 0;
+ }
+ while (1) {
+ i60 = i66 + 1 | 0;
+ i67 = HEAP8[i62 + i66 | 0] | 0;
+ i66 = HEAP32[i38 >> 2] | 0;
+ if (((i66 | 0) != 0 ? (i23 = HEAP32[i66 + 28 >> 2] | 0, (i23 | 0) != 0) : 0) ? (i21 = HEAP32[i42 >> 2] | 0, i21 >>> 0 < (HEAP32[i66 + 32 >> 2] | 0) >>> 0) : 0) {
+ HEAP32[i42 >> 2] = i21 + 1;
+ HEAP8[i23 + i21 | 0] = i67;
+ }
+ i66 = i67 << 24 >> 24 != 0;
+ if (i66 & i60 >>> 0 < i65 >>> 0) {
+ i66 = i60;
+ } else {
+ break;
+ }
+ }
+ if ((HEAP32[i11 >> 2] & 512 | 0) != 0) {
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i62, i60) | 0;
+ }
+ i65 = i65 - i60 | 0;
+ i62 = i62 + i60 | 0;
+ if (i66) {
+ i60 = 285;
+ break L17;
+ }
+ }
+ HEAP32[i42 >> 2] = 0;
+ HEAP32[i4 >> 2] = 7;
+ i60 = 96;
+ } else if ((i60 | 0) == 228) {
+ i60 = 0;
+ i69 = (1 << HEAP32[i51 >> 2]) + -1 | 0;
+ i71 = i69 & i64;
+ i66 = HEAP32[i50 >> 2] | 0;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ i67 = i68 & 255;
+ if (i67 >>> 0 > i63 >>> 0) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i70 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ i71 = i69 & i64;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ i67 = i68 & 255;
+ if (i67 >>> 0 > i63 >>> 0) {
+ i62 = i70;
+ } else {
+ i62 = i70;
+ break;
+ }
+ }
+ }
+ i69 = HEAP8[i66 + (i71 << 2) | 0] | 0;
+ i70 = HEAP16[i66 + (i71 << 2) + 2 >> 1] | 0;
+ i71 = i69 & 255;
+ if ((i71 & 240 | 0) == 0) {
+ i69 = i70 & 65535;
+ i70 = (1 << i67 + i71) + -1 | 0;
+ i71 = ((i64 & i70) >>> i67) + i69 | 0;
+ i68 = HEAP8[i66 + (i71 << 2) + 1 | 0] | 0;
+ if (((i68 & 255) + i67 | 0) >>> 0 > i63 >>> 0) {
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i71 = i62 + 1 | 0;
+ i64 = (HEAPU8[i62] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ i62 = ((i64 & i70) >>> i67) + i69 | 0;
+ i68 = HEAP8[i66 + (i62 << 2) + 1 | 0] | 0;
+ if (((i68 & 255) + i67 | 0) >>> 0 > i63 >>> 0) {
+ i62 = i71;
+ } else {
+ i69 = i62;
+ i62 = i71;
+ break;
+ }
+ }
+ } else {
+ i69 = i71;
+ }
+ i70 = HEAP16[i66 + (i69 << 2) + 2 >> 1] | 0;
+ i69 = HEAP8[i66 + (i69 << 2) | 0] | 0;
+ i66 = (HEAP32[i57 >> 2] | 0) + i67 | 0;
+ HEAP32[i57 >> 2] = i66;
+ i63 = i63 - i67 | 0;
+ i64 = i64 >>> i67;
+ } else {
+ i66 = HEAP32[i57 >> 2] | 0;
+ }
+ i72 = i68 & 255;
+ i64 = i64 >>> i72;
+ i63 = i63 - i72 | 0;
+ HEAP32[i57 >> 2] = i66 + i72;
+ i66 = i69 & 255;
+ if ((i66 & 64 | 0) == 0) {
+ HEAP32[i54 >> 2] = i70 & 65535;
+ i66 = i66 & 15;
+ HEAP32[i37 >> 2] = i66;
+ HEAP32[i4 >> 2] = 23;
+ i60 = 240;
+ break;
+ } else {
+ HEAP32[i35 >> 2] = 11848;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break;
+ }
+ }
+ } while (0);
+ if ((i60 | 0) == 96) {
+ if ((HEAP32[i11 >> 2] & 4096 | 0) == 0) {
+ i60 = HEAP32[i38 >> 2] | 0;
+ if ((i60 | 0) != 0) {
+ HEAP32[i60 + 36 >> 2] = 0;
+ }
+ } else {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i60 = 285;
+ break;
+ } else {
+ i66 = 0;
+ }
+ while (1) {
+ i60 = i66 + 1 | 0;
+ i66 = HEAP8[i62 + i66 | 0] | 0;
+ i67 = HEAP32[i38 >> 2] | 0;
+ if (((i67 | 0) != 0 ? (i24 = HEAP32[i67 + 36 >> 2] | 0, (i24 | 0) != 0) : 0) ? (i22 = HEAP32[i42 >> 2] | 0, i22 >>> 0 < (HEAP32[i67 + 40 >> 2] | 0) >>> 0) : 0) {
+ HEAP32[i42 >> 2] = i22 + 1;
+ HEAP8[i24 + i22 | 0] = i66;
+ }
+ i66 = i66 << 24 >> 24 != 0;
+ if (i66 & i60 >>> 0 < i65 >>> 0) {
+ i66 = i60;
+ } else {
+ break;
+ }
+ }
+ if ((HEAP32[i11 >> 2] & 512 | 0) != 0) {
+ HEAP32[i10 >> 2] = _crc32(HEAP32[i10 >> 2] | 0, i62, i60) | 0;
+ }
+ i65 = i65 - i60 | 0;
+ i62 = i62 + i60 | 0;
+ if (i66) {
+ i60 = 285;
+ break;
+ }
+ }
+ HEAP32[i4 >> 2] = 8;
+ i60 = 109;
+ } else if ((i60 | 0) == 240) {
+ i60 = 0;
+ if ((i66 | 0) != 0) {
+ if (i63 >>> 0 < i66 >>> 0) {
+ i67 = i62;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i62 = i67;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i62 = i67 + 1 | 0;
+ i64 = (HEAPU8[i67] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < i66 >>> 0) {
+ i67 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ HEAP32[i54 >> 2] = (HEAP32[i54 >> 2] | 0) + ((1 << i66) + -1 & i64);
+ HEAP32[i57 >> 2] = (HEAP32[i57 >> 2] | 0) + i66;
+ i63 = i63 - i66 | 0;
+ i64 = i64 >>> i66;
+ }
+ HEAP32[i4 >> 2] = 24;
+ i60 = 246;
+ }
+ do {
+ if ((i60 | 0) == 109) {
+ i60 = 0;
+ i66 = HEAP32[i11 >> 2] | 0;
+ if ((i66 & 512 | 0) != 0) {
+ if (i63 >>> 0 < 16) {
+ i67 = i62;
+ while (1) {
+ if ((i65 | 0) == 0) {
+ i65 = 0;
+ i62 = i67;
+ break L17;
+ }
+ i65 = i65 + -1 | 0;
+ i62 = i67 + 1 | 0;
+ i64 = (HEAPU8[i67] << i63) + i64 | 0;
+ i63 = i63 + 8 | 0;
+ if (i63 >>> 0 < 16) {
+ i67 = i62;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i64 | 0) == (HEAP32[i10 >> 2] & 65535 | 0)) {
+ i63 = 0;
+ i64 = 0;
+ } else {
+ HEAP32[i35 >> 2] = 11536;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break;
+ }
+ }
+ i67 = HEAP32[i38 >> 2] | 0;
+ if ((i67 | 0) != 0) {
+ HEAP32[i67 + 44 >> 2] = i66 >>> 9 & 1;
+ HEAP32[i67 + 48 >> 2] = 1;
+ }
+ i66 = _crc32(0, 0, 0) | 0;
+ HEAP32[i10 >> 2] = i66;
+ HEAP32[i9 >> 2] = i66;
+ HEAP32[i4 >> 2] = 11;
+ i66 = i26;
+ } else if ((i60 | 0) == 246) {
+ i60 = 0;
+ if ((i26 | 0) == 0) {
+ i26 = 0;
+ i60 = 285;
+ break L17;
+ }
+ i67 = i59 - i26 | 0;
+ i66 = HEAP32[i54 >> 2] | 0;
+ if (i66 >>> 0 > i67 >>> 0) {
+ i67 = i66 - i67 | 0;
+ if (i67 >>> 0 > (HEAP32[i28 >> 2] | 0) >>> 0 ? (HEAP32[i29 >> 2] | 0) != 0 : 0) {
+ HEAP32[i35 >> 2] = 11872;
+ HEAP32[i4 >> 2] = 29;
+ i66 = i26;
+ break;
+ }
+ i68 = HEAP32[i30 >> 2] | 0;
+ if (i67 >>> 0 > i68 >>> 0) {
+ i68 = i67 - i68 | 0;
+ i66 = i68;
+ i68 = (HEAP32[i31 >> 2] | 0) + ((HEAP32[i18 >> 2] | 0) - i68) | 0;
+ } else {
+ i66 = i67;
+ i68 = (HEAP32[i31 >> 2] | 0) + (i68 - i67) | 0;
+ }
+ i69 = HEAP32[i42 >> 2] | 0;
+ i67 = i69;
+ i69 = i66 >>> 0 > i69 >>> 0 ? i69 : i66;
+ } else {
+ i69 = HEAP32[i42 >> 2] | 0;
+ i67 = i69;
+ i68 = i19 + (0 - i66) | 0;
+ }
+ i66 = i69 >>> 0 > i26 >>> 0 ? i26 : i69;
+ HEAP32[i42 >> 2] = i67 - i66;
+ i67 = ~i26;
+ i69 = ~i69;
+ i67 = i67 >>> 0 > i69 >>> 0 ? i67 : i69;
+ i69 = i66;
+ i70 = i19;
+ while (1) {
+ HEAP8[i70] = HEAP8[i68] | 0;
+ i69 = i69 + -1 | 0;
+ if ((i69 | 0) == 0) {
+ break;
+ } else {
+ i68 = i68 + 1 | 0;
+ i70 = i70 + 1 | 0;
+ }
+ }
+ i66 = i26 - i66 | 0;
+ i19 = i19 + ~i67 | 0;
+ if ((HEAP32[i42 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 20;
+ }
+ }
+ } while (0);
+ i68 = HEAP32[i4 >> 2] | 0;
+ i67 = i63;
+ i26 = i66;
+ }
+ if ((i60 | 0) == 122) {
+ HEAP32[i8 >> 2] = i19;
+ HEAP32[i15 >> 2] = i26;
+ HEAP32[i2 >> 2] = i62;
+ HEAP32[i16 >> 2] = i65;
+ HEAP32[i17 >> 2] = i64;
+ HEAP32[i6 >> 2] = i63;
+ i72 = 2;
+ STACKTOP = i1;
+ return i72 | 0;
+ } else if ((i60 | 0) == 133) {
+ i63 = i63 + -3 | 0;
+ i64 = i64 >>> 3;
+ } else if ((i60 | 0) == 284) {
+ HEAP32[i4 >> 2] = 28;
+ i61 = 1;
+ } else if ((i60 | 0) != 285) if ((i60 | 0) == 299) {
+ i72 = -4;
+ STACKTOP = i1;
+ return i72 | 0;
+ } else if ((i60 | 0) == 300) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ HEAP32[i8 >> 2] = i19;
+ HEAP32[i15 >> 2] = i26;
+ HEAP32[i2 >> 2] = i62;
+ HEAP32[i16 >> 2] = i65;
+ HEAP32[i17 >> 2] = i64;
+ HEAP32[i6 >> 2] = i63;
+ if ((HEAP32[i18 >> 2] | 0) == 0) {
+ if ((HEAP32[i4 >> 2] | 0) >>> 0 < 26 ? (i59 | 0) != (HEAP32[i15 >> 2] | 0) : 0) {
+ i60 = 289;
+ }
+ } else {
+ i60 = 289;
+ }
+ if ((i60 | 0) == 289 ? (_updatewindow(i2, i59) | 0) != 0 : 0) {
+ HEAP32[i4 >> 2] = 30;
+ i72 = -4;
+ STACKTOP = i1;
+ return i72 | 0;
+ }
+ i16 = HEAP32[i16 >> 2] | 0;
+ i72 = HEAP32[i15 >> 2] | 0;
+ i15 = i59 - i72 | 0;
+ i71 = i2 + 8 | 0;
+ HEAP32[i71 >> 2] = i5 - i16 + (HEAP32[i71 >> 2] | 0);
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + i15;
+ HEAP32[i14 >> 2] = (HEAP32[i14 >> 2] | 0) + i15;
+ i13 = (i59 | 0) == (i72 | 0);
+ if (!((HEAP32[i12 >> 2] | 0) == 0 | i13)) {
+ i12 = HEAP32[i10 >> 2] | 0;
+ i8 = (HEAP32[i8 >> 2] | 0) + (0 - i15) | 0;
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ i8 = _adler32(i12, i8, i15) | 0;
+ } else {
+ i8 = _crc32(i12, i8, i15) | 0;
+ }
+ HEAP32[i10 >> 2] = i8;
+ HEAP32[i9 >> 2] = i8;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i4 | 0) == 19) {
+ i8 = 256;
+ } else {
+ i8 = (i4 | 0) == 14 ? 256 : 0;
+ }
+ HEAP32[i2 + 44 >> 2] = ((HEAP32[i7 >> 2] | 0) != 0 ? 64 : 0) + (HEAP32[i6 >> 2] | 0) + ((i4 | 0) == 11 ? 128 : 0) + i8;
+ i72 = ((i5 | 0) == (i16 | 0) & i13 | (i3 | 0) == 4) & (i61 | 0) == 0 ? -5 : i61;
+ STACKTOP = i1;
+ return i72 | 0;
+}
+function _malloc(i12) {
+ i12 = i12 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0;
+ i1 = STACKTOP;
+ do {
+ if (i12 >>> 0 < 245) {
+ if (i12 >>> 0 < 11) {
+ i12 = 16;
+ } else {
+ i12 = i12 + 11 & -8;
+ }
+ i20 = i12 >>> 3;
+ i18 = HEAP32[3618] | 0;
+ i21 = i18 >>> i20;
+ if ((i21 & 3 | 0) != 0) {
+ i6 = (i21 & 1 ^ 1) + i20 | 0;
+ i5 = i6 << 1;
+ i3 = 14512 + (i5 << 2) | 0;
+ i5 = 14512 + (i5 + 2 << 2) | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ i2 = i7 + 8 | 0;
+ i4 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i3 | 0) != (i4 | 0)) {
+ if (i4 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i4 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i7 | 0)) {
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i5 >> 2] = i4;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[3618] = i18 & ~(1 << i6);
+ }
+ } while (0);
+ i32 = i6 << 3;
+ HEAP32[i7 + 4 >> 2] = i32 | 3;
+ i32 = i7 + (i32 | 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ if (i12 >>> 0 > (HEAP32[14480 >> 2] | 0) >>> 0) {
+ if ((i21 | 0) != 0) {
+ i7 = 2 << i20;
+ i7 = i21 << i20 & (i7 | 0 - i7);
+ i7 = (i7 & 0 - i7) + -1 | 0;
+ i2 = i7 >>> 12 & 16;
+ i7 = i7 >>> i2;
+ i6 = i7 >>> 5 & 8;
+ i7 = i7 >>> i6;
+ i5 = i7 >>> 2 & 4;
+ i7 = i7 >>> i5;
+ i4 = i7 >>> 1 & 2;
+ i7 = i7 >>> i4;
+ i3 = i7 >>> 1 & 1;
+ i3 = (i6 | i2 | i5 | i4 | i3) + (i7 >>> i3) | 0;
+ i7 = i3 << 1;
+ i4 = 14512 + (i7 << 2) | 0;
+ i7 = 14512 + (i7 + 2 << 2) | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i2 = i5 + 8 | 0;
+ i6 = HEAP32[i2 >> 2] | 0;
+ do {
+ if ((i4 | 0) != (i6 | 0)) {
+ if (i6 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i6 + 12 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i5 | 0)) {
+ HEAP32[i8 >> 2] = i4;
+ HEAP32[i7 >> 2] = i6;
+ break;
+ } else {
+ _abort();
+ }
+ } else {
+ HEAP32[3618] = i18 & ~(1 << i3);
+ }
+ } while (0);
+ i6 = i3 << 3;
+ i4 = i6 - i12 | 0;
+ HEAP32[i5 + 4 >> 2] = i12 | 3;
+ i3 = i5 + i12 | 0;
+ HEAP32[i5 + (i12 | 4) >> 2] = i4 | 1;
+ HEAP32[i5 + i6 >> 2] = i4;
+ i6 = HEAP32[14480 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[14492 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 14512 + (i9 << 2) | 0;
+ i7 = HEAP32[3618] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 14512 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i28 = i7;
+ i27 = i8;
+ }
+ } else {
+ HEAP32[3618] = i7 | i8;
+ i28 = 14512 + (i9 + 2 << 2) | 0;
+ i27 = i6;
+ }
+ HEAP32[i28 >> 2] = i5;
+ HEAP32[i27 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i27;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[14480 >> 2] = i4;
+ HEAP32[14492 >> 2] = i3;
+ i32 = i2;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[14476 >> 2] | 0;
+ if ((i18 | 0) != 0) {
+ i2 = (i18 & 0 - i18) + -1 | 0;
+ i31 = i2 >>> 12 & 16;
+ i2 = i2 >>> i31;
+ i30 = i2 >>> 5 & 8;
+ i2 = i2 >>> i30;
+ i32 = i2 >>> 2 & 4;
+ i2 = i2 >>> i32;
+ i6 = i2 >>> 1 & 2;
+ i2 = i2 >>> i6;
+ i3 = i2 >>> 1 & 1;
+ i3 = HEAP32[14776 + ((i30 | i31 | i32 | i6 | i3) + (i2 >>> i3) << 2) >> 2] | 0;
+ i2 = (HEAP32[i3 + 4 >> 2] & -8) - i12 | 0;
+ i6 = i3;
+ while (1) {
+ i5 = HEAP32[i6 + 16 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i5 = HEAP32[i6 + 20 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ i6 = (HEAP32[i5 + 4 >> 2] & -8) - i12 | 0;
+ i4 = i6 >>> 0 < i2 >>> 0;
+ i2 = i4 ? i6 : i2;
+ i6 = i5;
+ i3 = i4 ? i5 : i3;
+ }
+ i6 = HEAP32[14488 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i4 = i3 + i12 | 0;
+ if (!(i3 >>> 0 < i4 >>> 0)) {
+ _abort();
+ }
+ i5 = HEAP32[i3 + 24 >> 2] | 0;
+ i7 = HEAP32[i3 + 12 >> 2] | 0;
+ do {
+ if ((i7 | 0) == (i3 | 0)) {
+ i8 = i3 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i8 = i3 + 16 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) == 0) {
+ i26 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i10 = i7 + 20 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ i7 = i9;
+ i8 = i10;
+ continue;
+ }
+ i10 = i7 + 16 | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ } else {
+ i7 = i9;
+ i8 = i10;
+ }
+ }
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i8 >> 2] = 0;
+ i26 = i7;
+ break;
+ }
+ } else {
+ i8 = HEAP32[i3 + 8 >> 2] | 0;
+ if (i8 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ i6 = i8 + 12 | 0;
+ if ((HEAP32[i6 >> 2] | 0) != (i3 | 0)) {
+ _abort();
+ }
+ i9 = i7 + 8 | 0;
+ if ((HEAP32[i9 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i7;
+ HEAP32[i9 >> 2] = i8;
+ i26 = i7;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i5 | 0) != 0) {
+ i7 = HEAP32[i3 + 28 >> 2] | 0;
+ i6 = 14776 + (i7 << 2) | 0;
+ if ((i3 | 0) == (HEAP32[i6 >> 2] | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ if ((i26 | 0) == 0) {
+ HEAP32[14476 >> 2] = HEAP32[14476 >> 2] & ~(1 << i7);
+ break;
+ }
+ } else {
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i6 = i5 + 16 | 0;
+ if ((HEAP32[i6 >> 2] | 0) == (i3 | 0)) {
+ HEAP32[i6 >> 2] = i26;
+ } else {
+ HEAP32[i5 + 20 >> 2] = i26;
+ }
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ }
+ if (i26 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i26 + 24 >> 2] = i5;
+ i5 = HEAP32[i3 + 16 >> 2] | 0;
+ do {
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 16 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ } while (0);
+ i5 = HEAP32[i3 + 20 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i26 + 20 >> 2] = i5;
+ HEAP32[i5 + 24 >> 2] = i26;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i2 >>> 0 < 16) {
+ i32 = i2 + i12 | 0;
+ HEAP32[i3 + 4 >> 2] = i32 | 3;
+ i32 = i3 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ } else {
+ HEAP32[i3 + 4 >> 2] = i12 | 3;
+ HEAP32[i3 + (i12 | 4) >> 2] = i2 | 1;
+ HEAP32[i3 + (i2 + i12) >> 2] = i2;
+ i6 = HEAP32[14480 >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ i5 = HEAP32[14492 >> 2] | 0;
+ i8 = i6 >>> 3;
+ i9 = i8 << 1;
+ i6 = 14512 + (i9 << 2) | 0;
+ i7 = HEAP32[3618] | 0;
+ i8 = 1 << i8;
+ if ((i7 & i8 | 0) != 0) {
+ i7 = 14512 + (i9 + 2 << 2) | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if (i8 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i25 = i7;
+ i24 = i8;
+ }
+ } else {
+ HEAP32[3618] = i7 | i8;
+ i25 = 14512 + (i9 + 2 << 2) | 0;
+ i24 = i6;
+ }
+ HEAP32[i25 >> 2] = i5;
+ HEAP32[i24 + 12 >> 2] = i5;
+ HEAP32[i5 + 8 >> 2] = i24;
+ HEAP32[i5 + 12 >> 2] = i6;
+ }
+ HEAP32[14480 >> 2] = i2;
+ HEAP32[14492 >> 2] = i4;
+ }
+ i32 = i3 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ if (!(i12 >>> 0 > 4294967231)) {
+ i24 = i12 + 11 | 0;
+ i12 = i24 & -8;
+ i26 = HEAP32[14476 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i25 = 0 - i12 | 0;
+ i24 = i24 >>> 8;
+ if ((i24 | 0) != 0) {
+ if (i12 >>> 0 > 16777215) {
+ i27 = 31;
+ } else {
+ i31 = (i24 + 1048320 | 0) >>> 16 & 8;
+ i32 = i24 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i27 = (i32 + 245760 | 0) >>> 16 & 2;
+ i27 = 14 - (i30 | i31 | i27) + (i32 << i27 >>> 15) | 0;
+ i27 = i12 >>> (i27 + 7 | 0) & 1 | i27 << 1;
+ }
+ } else {
+ i27 = 0;
+ }
+ i30 = HEAP32[14776 + (i27 << 2) >> 2] | 0;
+ L126 : do {
+ if ((i30 | 0) == 0) {
+ i29 = 0;
+ i24 = 0;
+ } else {
+ if ((i27 | 0) == 31) {
+ i24 = 0;
+ } else {
+ i24 = 25 - (i27 >>> 1) | 0;
+ }
+ i29 = 0;
+ i28 = i12 << i24;
+ i24 = 0;
+ while (1) {
+ i32 = HEAP32[i30 + 4 >> 2] & -8;
+ i31 = i32 - i12 | 0;
+ if (i31 >>> 0 < i25 >>> 0) {
+ if ((i32 | 0) == (i12 | 0)) {
+ i25 = i31;
+ i29 = i30;
+ i24 = i30;
+ break L126;
+ } else {
+ i25 = i31;
+ i24 = i30;
+ }
+ }
+ i31 = HEAP32[i30 + 20 >> 2] | 0;
+ i30 = HEAP32[i30 + (i28 >>> 31 << 2) + 16 >> 2] | 0;
+ i29 = (i31 | 0) == 0 | (i31 | 0) == (i30 | 0) ? i29 : i31;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i28 = i28 << 1;
+ }
+ }
+ }
+ } while (0);
+ if ((i29 | 0) == 0 & (i24 | 0) == 0) {
+ i32 = 2 << i27;
+ i26 = i26 & (i32 | 0 - i32);
+ if ((i26 | 0) == 0) {
+ break;
+ }
+ i32 = (i26 & 0 - i26) + -1 | 0;
+ i28 = i32 >>> 12 & 16;
+ i32 = i32 >>> i28;
+ i27 = i32 >>> 5 & 8;
+ i32 = i32 >>> i27;
+ i30 = i32 >>> 2 & 4;
+ i32 = i32 >>> i30;
+ i31 = i32 >>> 1 & 2;
+ i32 = i32 >>> i31;
+ i29 = i32 >>> 1 & 1;
+ i29 = HEAP32[14776 + ((i27 | i28 | i30 | i31 | i29) + (i32 >>> i29) << 2) >> 2] | 0;
+ }
+ if ((i29 | 0) != 0) {
+ while (1) {
+ i27 = (HEAP32[i29 + 4 >> 2] & -8) - i12 | 0;
+ i26 = i27 >>> 0 < i25 >>> 0;
+ i25 = i26 ? i27 : i25;
+ i24 = i26 ? i29 : i24;
+ i26 = HEAP32[i29 + 16 >> 2] | 0;
+ if ((i26 | 0) != 0) {
+ i29 = i26;
+ continue;
+ }
+ i29 = HEAP32[i29 + 20 >> 2] | 0;
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ }
+ }
+ if ((i24 | 0) != 0 ? i25 >>> 0 < ((HEAP32[14480 >> 2] | 0) - i12 | 0) >>> 0 : 0) {
+ i4 = HEAP32[14488 >> 2] | 0;
+ if (i24 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i2 = i24 + i12 | 0;
+ if (!(i24 >>> 0 < i2 >>> 0)) {
+ _abort();
+ }
+ i3 = HEAP32[i24 + 24 >> 2] | 0;
+ i6 = HEAP32[i24 + 12 >> 2] | 0;
+ do {
+ if ((i6 | 0) == (i24 | 0)) {
+ i6 = i24 + 20 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i6 = i24 + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i22 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i8 = i5 + 20 | 0;
+ i7 = HEAP32[i8 >> 2] | 0;
+ if ((i7 | 0) != 0) {
+ i5 = i7;
+ i6 = i8;
+ continue;
+ }
+ i7 = i5 + 16 | 0;
+ i8 = HEAP32[i7 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i5 = i8;
+ i6 = i7;
+ }
+ }
+ if (i6 >>> 0 < i4 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = 0;
+ i22 = i5;
+ break;
+ }
+ } else {
+ i5 = HEAP32[i24 + 8 >> 2] | 0;
+ if (i5 >>> 0 < i4 >>> 0) {
+ _abort();
+ }
+ i7 = i5 + 12 | 0;
+ if ((HEAP32[i7 >> 2] | 0) != (i24 | 0)) {
+ _abort();
+ }
+ i4 = i6 + 8 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i7 >> 2] = i6;
+ HEAP32[i4 >> 2] = i5;
+ i22 = i6;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ do {
+ if ((i3 | 0) != 0) {
+ i4 = HEAP32[i24 + 28 >> 2] | 0;
+ i5 = 14776 + (i4 << 2) | 0;
+ if ((i24 | 0) == (HEAP32[i5 >> 2] | 0)) {
+ HEAP32[i5 >> 2] = i22;
+ if ((i22 | 0) == 0) {
+ HEAP32[14476 >> 2] = HEAP32[14476 >> 2] & ~(1 << i4);
+ break;
+ }
+ } else {
+ if (i3 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i4 = i3 + 16 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == (i24 | 0)) {
+ HEAP32[i4 >> 2] = i22;
+ } else {
+ HEAP32[i3 + 20 >> 2] = i22;
+ }
+ if ((i22 | 0) == 0) {
+ break;
+ }
+ }
+ if (i22 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i22 + 24 >> 2] = i3;
+ i3 = HEAP32[i24 + 16 >> 2] | 0;
+ do {
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 16 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ } while (0);
+ i3 = HEAP32[i24 + 20 >> 2] | 0;
+ if ((i3 | 0) != 0) {
+ if (i3 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i22 + 20 >> 2] = i3;
+ HEAP32[i3 + 24 >> 2] = i22;
+ break;
+ }
+ }
+ }
+ } while (0);
+ L204 : do {
+ if (!(i25 >>> 0 < 16)) {
+ HEAP32[i24 + 4 >> 2] = i12 | 3;
+ HEAP32[i24 + (i12 | 4) >> 2] = i25 | 1;
+ HEAP32[i24 + (i25 + i12) >> 2] = i25;
+ i4 = i25 >>> 3;
+ if (i25 >>> 0 < 256) {
+ i6 = i4 << 1;
+ i3 = 14512 + (i6 << 2) | 0;
+ i5 = HEAP32[3618] | 0;
+ i4 = 1 << i4;
+ if ((i5 & i4 | 0) != 0) {
+ i5 = 14512 + (i6 + 2 << 2) | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ if (i4 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i21 = i5;
+ i20 = i4;
+ }
+ } else {
+ HEAP32[3618] = i5 | i4;
+ i21 = 14512 + (i6 + 2 << 2) | 0;
+ i20 = i3;
+ }
+ HEAP32[i21 >> 2] = i2;
+ HEAP32[i20 + 12 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i20;
+ HEAP32[i24 + (i12 + 12) >> 2] = i3;
+ break;
+ }
+ i3 = i25 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i25 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i25 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i6 = 14776 + (i3 << 2) | 0;
+ HEAP32[i24 + (i12 + 28) >> 2] = i3;
+ HEAP32[i24 + (i12 + 20) >> 2] = 0;
+ HEAP32[i24 + (i12 + 16) >> 2] = 0;
+ i4 = HEAP32[14476 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[14476 >> 2] = i4 | i5;
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i6;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break;
+ }
+ i4 = HEAP32[i6 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L225 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i25 | 0)) {
+ i3 = i25 << i3;
+ while (1) {
+ i6 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i25 | 0)) {
+ i18 = i5;
+ break L225;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i24 + (i12 + 24) >> 2] = i4;
+ HEAP32[i24 + (i12 + 12) >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i2;
+ break L204;
+ }
+ } else {
+ i18 = i4;
+ }
+ } while (0);
+ i4 = i18 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[14488 >> 2] | 0;
+ if (i18 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i2;
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i24 + (i12 + 8) >> 2] = i3;
+ HEAP32[i24 + (i12 + 12) >> 2] = i18;
+ HEAP32[i24 + (i12 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = i25 + i12 | 0;
+ HEAP32[i24 + 4 >> 2] = i32 | 3;
+ i32 = i24 + (i32 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ } while (0);
+ i32 = i24 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ } else {
+ i12 = -1;
+ }
+ }
+ } while (0);
+ i18 = HEAP32[14480 >> 2] | 0;
+ if (!(i12 >>> 0 > i18 >>> 0)) {
+ i3 = i18 - i12 | 0;
+ i2 = HEAP32[14492 >> 2] | 0;
+ if (i3 >>> 0 > 15) {
+ HEAP32[14492 >> 2] = i2 + i12;
+ HEAP32[14480 >> 2] = i3;
+ HEAP32[i2 + (i12 + 4) >> 2] = i3 | 1;
+ HEAP32[i2 + i18 >> 2] = i3;
+ HEAP32[i2 + 4 >> 2] = i12 | 3;
+ } else {
+ HEAP32[14480 >> 2] = 0;
+ HEAP32[14492 >> 2] = 0;
+ HEAP32[i2 + 4 >> 2] = i18 | 3;
+ i32 = i2 + (i18 + 4) | 0;
+ HEAP32[i32 >> 2] = HEAP32[i32 >> 2] | 1;
+ }
+ i32 = i2 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i18 = HEAP32[14484 >> 2] | 0;
+ if (i12 >>> 0 < i18 >>> 0) {
+ i31 = i18 - i12 | 0;
+ HEAP32[14484 >> 2] = i31;
+ i32 = HEAP32[14496 >> 2] | 0;
+ HEAP32[14496 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ do {
+ if ((HEAP32[3736] | 0) == 0) {
+ i18 = _sysconf(30) | 0;
+ if ((i18 + -1 & i18 | 0) == 0) {
+ HEAP32[14952 >> 2] = i18;
+ HEAP32[14948 >> 2] = i18;
+ HEAP32[14956 >> 2] = -1;
+ HEAP32[14960 >> 2] = -1;
+ HEAP32[14964 >> 2] = 0;
+ HEAP32[14916 >> 2] = 0;
+ HEAP32[3736] = (_time(0) | 0) & -16 ^ 1431655768;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ i20 = i12 + 48 | 0;
+ i25 = HEAP32[14952 >> 2] | 0;
+ i21 = i12 + 47 | 0;
+ i22 = i25 + i21 | 0;
+ i25 = 0 - i25 | 0;
+ i18 = i22 & i25;
+ if (!(i18 >>> 0 > i12 >>> 0)) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i24 = HEAP32[14912 >> 2] | 0;
+ if ((i24 | 0) != 0 ? (i31 = HEAP32[14904 >> 2] | 0, i32 = i31 + i18 | 0, i32 >>> 0 <= i31 >>> 0 | i32 >>> 0 > i24 >>> 0) : 0) {
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ L269 : do {
+ if ((HEAP32[14916 >> 2] & 4 | 0) == 0) {
+ i26 = HEAP32[14496 >> 2] | 0;
+ L271 : do {
+ if ((i26 | 0) != 0) {
+ i24 = 14920 | 0;
+ while (1) {
+ i27 = HEAP32[i24 >> 2] | 0;
+ if (!(i27 >>> 0 > i26 >>> 0) ? (i23 = i24 + 4 | 0, (i27 + (HEAP32[i23 >> 2] | 0) | 0) >>> 0 > i26 >>> 0) : 0) {
+ break;
+ }
+ i24 = HEAP32[i24 + 8 >> 2] | 0;
+ if ((i24 | 0) == 0) {
+ i13 = 182;
+ break L271;
+ }
+ }
+ if ((i24 | 0) != 0) {
+ i25 = i22 - (HEAP32[14484 >> 2] | 0) & i25;
+ if (i25 >>> 0 < 2147483647) {
+ i13 = _sbrk(i25 | 0) | 0;
+ i26 = (i13 | 0) == ((HEAP32[i24 >> 2] | 0) + (HEAP32[i23 >> 2] | 0) | 0);
+ i22 = i13;
+ i24 = i25;
+ i23 = i26 ? i13 : -1;
+ i25 = i26 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i13 = 182;
+ }
+ } else {
+ i13 = 182;
+ }
+ } while (0);
+ do {
+ if ((i13 | 0) == 182) {
+ i23 = _sbrk(0) | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i24 = i23;
+ i22 = HEAP32[14948 >> 2] | 0;
+ i25 = i22 + -1 | 0;
+ if ((i25 & i24 | 0) == 0) {
+ i25 = i18;
+ } else {
+ i25 = i18 - i24 + (i25 + i24 & 0 - i22) | 0;
+ }
+ i24 = HEAP32[14904 >> 2] | 0;
+ i26 = i24 + i25 | 0;
+ if (i25 >>> 0 > i12 >>> 0 & i25 >>> 0 < 2147483647) {
+ i22 = HEAP32[14912 >> 2] | 0;
+ if ((i22 | 0) != 0 ? i26 >>> 0 <= i24 >>> 0 | i26 >>> 0 > i22 >>> 0 : 0) {
+ i25 = 0;
+ break;
+ }
+ i22 = _sbrk(i25 | 0) | 0;
+ i13 = (i22 | 0) == (i23 | 0);
+ i24 = i25;
+ i23 = i13 ? i23 : -1;
+ i25 = i13 ? i25 : 0;
+ i13 = 191;
+ } else {
+ i25 = 0;
+ }
+ } else {
+ i25 = 0;
+ }
+ }
+ } while (0);
+ L291 : do {
+ if ((i13 | 0) == 191) {
+ i13 = 0 - i24 | 0;
+ if ((i23 | 0) != (-1 | 0)) {
+ i17 = i23;
+ i14 = i25;
+ i13 = 202;
+ break L269;
+ }
+ do {
+ if ((i22 | 0) != (-1 | 0) & i24 >>> 0 < 2147483647 & i24 >>> 0 < i20 >>> 0 ? (i19 = HEAP32[14952 >> 2] | 0, i19 = i21 - i24 + i19 & 0 - i19, i19 >>> 0 < 2147483647) : 0) {
+ if ((_sbrk(i19 | 0) | 0) == (-1 | 0)) {
+ _sbrk(i13 | 0) | 0;
+ break L291;
+ } else {
+ i24 = i19 + i24 | 0;
+ break;
+ }
+ }
+ } while (0);
+ if ((i22 | 0) != (-1 | 0)) {
+ i17 = i22;
+ i14 = i24;
+ i13 = 202;
+ break L269;
+ }
+ }
+ } while (0);
+ HEAP32[14916 >> 2] = HEAP32[14916 >> 2] | 4;
+ i13 = 199;
+ } else {
+ i25 = 0;
+ i13 = 199;
+ }
+ } while (0);
+ if ((((i13 | 0) == 199 ? i18 >>> 0 < 2147483647 : 0) ? (i17 = _sbrk(i18 | 0) | 0, i16 = _sbrk(0) | 0, (i16 | 0) != (-1 | 0) & (i17 | 0) != (-1 | 0) & i17 >>> 0 < i16 >>> 0) : 0) ? (i15 = i16 - i17 | 0, i14 = i15 >>> 0 > (i12 + 40 | 0) >>> 0, i14) : 0) {
+ i14 = i14 ? i15 : i25;
+ i13 = 202;
+ }
+ if ((i13 | 0) == 202) {
+ i15 = (HEAP32[14904 >> 2] | 0) + i14 | 0;
+ HEAP32[14904 >> 2] = i15;
+ if (i15 >>> 0 > (HEAP32[14908 >> 2] | 0) >>> 0) {
+ HEAP32[14908 >> 2] = i15;
+ }
+ i15 = HEAP32[14496 >> 2] | 0;
+ L311 : do {
+ if ((i15 | 0) != 0) {
+ i21 = 14920 | 0;
+ while (1) {
+ i16 = HEAP32[i21 >> 2] | 0;
+ i19 = i21 + 4 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i17 | 0) == (i16 + i20 | 0)) {
+ i13 = 214;
+ break;
+ }
+ i18 = HEAP32[i21 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i21 = i18;
+ }
+ }
+ if (((i13 | 0) == 214 ? (HEAP32[i21 + 12 >> 2] & 8 | 0) == 0 : 0) ? i15 >>> 0 >= i16 >>> 0 & i15 >>> 0 < i17 >>> 0 : 0) {
+ HEAP32[i19 >> 2] = i20 + i14;
+ i2 = (HEAP32[14484 >> 2] | 0) + i14 | 0;
+ i3 = i15 + 8 | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i32 = i2 - i3 | 0;
+ HEAP32[14496 >> 2] = i15 + i3;
+ HEAP32[14484 >> 2] = i32;
+ HEAP32[i15 + (i3 + 4) >> 2] = i32 | 1;
+ HEAP32[i15 + (i2 + 4) >> 2] = 40;
+ HEAP32[14500 >> 2] = HEAP32[14960 >> 2];
+ break;
+ }
+ if (i17 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ HEAP32[14488 >> 2] = i17;
+ }
+ i19 = i17 + i14 | 0;
+ i16 = 14920 | 0;
+ while (1) {
+ if ((HEAP32[i16 >> 2] | 0) == (i19 | 0)) {
+ i13 = 224;
+ break;
+ }
+ i18 = HEAP32[i16 + 8 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ break;
+ } else {
+ i16 = i18;
+ }
+ }
+ if ((i13 | 0) == 224 ? (HEAP32[i16 + 12 >> 2] & 8 | 0) == 0 : 0) {
+ HEAP32[i16 >> 2] = i17;
+ i6 = i16 + 4 | 0;
+ HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i14;
+ i6 = i17 + 8 | 0;
+ if ((i6 & 7 | 0) == 0) {
+ i6 = 0;
+ } else {
+ i6 = 0 - i6 & 7;
+ }
+ i7 = i17 + (i14 + 8) | 0;
+ if ((i7 & 7 | 0) == 0) {
+ i13 = 0;
+ } else {
+ i13 = 0 - i7 & 7;
+ }
+ i15 = i17 + (i13 + i14) | 0;
+ i8 = i6 + i12 | 0;
+ i7 = i17 + i8 | 0;
+ i10 = i15 - (i17 + i6) - i12 | 0;
+ HEAP32[i17 + (i6 + 4) >> 2] = i12 | 3;
+ L348 : do {
+ if ((i15 | 0) != (HEAP32[14496 >> 2] | 0)) {
+ if ((i15 | 0) == (HEAP32[14492 >> 2] | 0)) {
+ i32 = (HEAP32[14480 >> 2] | 0) + i10 | 0;
+ HEAP32[14480 >> 2] = i32;
+ HEAP32[14492 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i32 + i8) >> 2] = i32;
+ break;
+ }
+ i12 = i14 + 4 | 0;
+ i18 = HEAP32[i17 + (i12 + i13) >> 2] | 0;
+ if ((i18 & 3 | 0) == 1) {
+ i11 = i18 & -8;
+ i16 = i18 >>> 3;
+ do {
+ if (!(i18 >>> 0 < 256)) {
+ i9 = HEAP32[i17 + ((i13 | 24) + i14) >> 2] | 0;
+ i19 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ do {
+ if ((i19 | 0) == (i15 | 0)) {
+ i19 = i13 | 16;
+ i18 = i17 + (i12 + i19) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i18 = i17 + (i19 + i14) | 0;
+ i16 = HEAP32[i18 >> 2] | 0;
+ if ((i16 | 0) == 0) {
+ i5 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i20 = i16 + 20 | 0;
+ i19 = HEAP32[i20 >> 2] | 0;
+ if ((i19 | 0) != 0) {
+ i16 = i19;
+ i18 = i20;
+ continue;
+ }
+ i19 = i16 + 16 | 0;
+ i20 = HEAP32[i19 >> 2] | 0;
+ if ((i20 | 0) == 0) {
+ break;
+ } else {
+ i16 = i20;
+ i18 = i19;
+ }
+ }
+ if (i18 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i18 >> 2] = 0;
+ i5 = i16;
+ break;
+ }
+ } else {
+ i18 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ if (i18 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i18 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ i20 = i19 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i19;
+ HEAP32[i20 >> 2] = i18;
+ i5 = i19;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i9 | 0) != 0) {
+ i16 = HEAP32[i17 + (i14 + 28 + i13) >> 2] | 0;
+ i18 = 14776 + (i16 << 2) | 0;
+ if ((i15 | 0) == (HEAP32[i18 >> 2] | 0)) {
+ HEAP32[i18 >> 2] = i5;
+ if ((i5 | 0) == 0) {
+ HEAP32[14476 >> 2] = HEAP32[14476 >> 2] & ~(1 << i16);
+ break;
+ }
+ } else {
+ if (i9 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i9 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ HEAP32[i16 >> 2] = i5;
+ } else {
+ HEAP32[i9 + 20 >> 2] = i5;
+ }
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i5 + 24 >> 2] = i9;
+ i15 = i13 | 16;
+ i9 = HEAP32[i17 + (i15 + i14) >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 16 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ } while (0);
+ i9 = HEAP32[i17 + (i12 + i15) >> 2] | 0;
+ if ((i9 | 0) != 0) {
+ if (i9 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 + 20 >> 2] = i9;
+ HEAP32[i9 + 24 >> 2] = i5;
+ break;
+ }
+ }
+ }
+ } else {
+ i5 = HEAP32[i17 + ((i13 | 8) + i14) >> 2] | 0;
+ i12 = HEAP32[i17 + (i14 + 12 + i13) >> 2] | 0;
+ i18 = 14512 + (i16 << 1 << 2) | 0;
+ if ((i5 | 0) != (i18 | 0)) {
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i5 + 12 >> 2] | 0) != (i15 | 0)) {
+ _abort();
+ }
+ }
+ if ((i12 | 0) == (i5 | 0)) {
+ HEAP32[3618] = HEAP32[3618] & ~(1 << i16);
+ break;
+ }
+ if ((i12 | 0) != (i18 | 0)) {
+ if (i12 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i12 + 8 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i15 | 0)) {
+ i9 = i16;
+ } else {
+ _abort();
+ }
+ } else {
+ i9 = i12 + 8 | 0;
+ }
+ HEAP32[i5 + 12 >> 2] = i12;
+ HEAP32[i9 >> 2] = i5;
+ }
+ } while (0);
+ i15 = i17 + ((i11 | i13) + i14) | 0;
+ i10 = i11 + i10 | 0;
+ }
+ i5 = i15 + 4 | 0;
+ HEAP32[i5 >> 2] = HEAP32[i5 >> 2] & -2;
+ HEAP32[i17 + (i8 + 4) >> 2] = i10 | 1;
+ HEAP32[i17 + (i10 + i8) >> 2] = i10;
+ i5 = i10 >>> 3;
+ if (i10 >>> 0 < 256) {
+ i10 = i5 << 1;
+ i2 = 14512 + (i10 << 2) | 0;
+ i9 = HEAP32[3618] | 0;
+ i5 = 1 << i5;
+ if ((i9 & i5 | 0) != 0) {
+ i9 = 14512 + (i10 + 2 << 2) | 0;
+ i5 = HEAP32[i9 >> 2] | 0;
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i3 = i9;
+ i4 = i5;
+ }
+ } else {
+ HEAP32[3618] = i9 | i5;
+ i3 = 14512 + (i10 + 2 << 2) | 0;
+ i4 = i2;
+ }
+ HEAP32[i3 >> 2] = i7;
+ HEAP32[i4 + 12 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ break;
+ }
+ i3 = i10 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i10 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i10 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i4 = 14776 + (i3 << 2) | 0;
+ HEAP32[i17 + (i8 + 28) >> 2] = i3;
+ HEAP32[i17 + (i8 + 20) >> 2] = 0;
+ HEAP32[i17 + (i8 + 16) >> 2] = 0;
+ i9 = HEAP32[14476 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i9 & i5 | 0) == 0) {
+ HEAP32[14476 >> 2] = i9 | i5;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break;
+ }
+ i4 = HEAP32[i4 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L444 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i10 | 0)) {
+ i3 = i10 << i3;
+ while (1) {
+ i5 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i9 = HEAP32[i5 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i9 + 4 >> 2] & -8 | 0) == (i10 | 0)) {
+ i2 = i9;
+ break L444;
+ } else {
+ i3 = i3 << 1;
+ i4 = i9;
+ }
+ }
+ if (i5 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i17 + (i8 + 24) >> 2] = i4;
+ HEAP32[i17 + (i8 + 12) >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i7;
+ break L348;
+ }
+ } else {
+ i2 = i4;
+ }
+ } while (0);
+ i4 = i2 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i5 = HEAP32[14488 >> 2] | 0;
+ if (i2 >>> 0 < i5 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i5 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i7;
+ HEAP32[i4 >> 2] = i7;
+ HEAP32[i17 + (i8 + 8) >> 2] = i3;
+ HEAP32[i17 + (i8 + 12) >> 2] = i2;
+ HEAP32[i17 + (i8 + 24) >> 2] = 0;
+ break;
+ }
+ } else {
+ i32 = (HEAP32[14484 >> 2] | 0) + i10 | 0;
+ HEAP32[14484 >> 2] = i32;
+ HEAP32[14496 >> 2] = i7;
+ HEAP32[i17 + (i8 + 4) >> 2] = i32 | 1;
+ }
+ } while (0);
+ i32 = i17 + (i6 | 8) | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ i3 = 14920 | 0;
+ while (1) {
+ i2 = HEAP32[i3 >> 2] | 0;
+ if (!(i2 >>> 0 > i15 >>> 0) ? (i11 = HEAP32[i3 + 4 >> 2] | 0, i10 = i2 + i11 | 0, i10 >>> 0 > i15 >>> 0) : 0) {
+ break;
+ }
+ i3 = HEAP32[i3 + 8 >> 2] | 0;
+ }
+ i3 = i2 + (i11 + -39) | 0;
+ if ((i3 & 7 | 0) == 0) {
+ i3 = 0;
+ } else {
+ i3 = 0 - i3 & 7;
+ }
+ i2 = i2 + (i11 + -47 + i3) | 0;
+ i2 = i2 >>> 0 < (i15 + 16 | 0) >>> 0 ? i15 : i2;
+ i3 = i2 + 8 | 0;
+ i4 = i17 + 8 | 0;
+ if ((i4 & 7 | 0) == 0) {
+ i4 = 0;
+ } else {
+ i4 = 0 - i4 & 7;
+ }
+ i32 = i14 + -40 - i4 | 0;
+ HEAP32[14496 >> 2] = i17 + i4;
+ HEAP32[14484 >> 2] = i32;
+ HEAP32[i17 + (i4 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[14500 >> 2] = HEAP32[14960 >> 2];
+ HEAP32[i2 + 4 >> 2] = 27;
+ HEAP32[i3 + 0 >> 2] = HEAP32[14920 >> 2];
+ HEAP32[i3 + 4 >> 2] = HEAP32[14924 >> 2];
+ HEAP32[i3 + 8 >> 2] = HEAP32[14928 >> 2];
+ HEAP32[i3 + 12 >> 2] = HEAP32[14932 >> 2];
+ HEAP32[14920 >> 2] = i17;
+ HEAP32[14924 >> 2] = i14;
+ HEAP32[14932 >> 2] = 0;
+ HEAP32[14928 >> 2] = i3;
+ i4 = i2 + 28 | 0;
+ HEAP32[i4 >> 2] = 7;
+ if ((i2 + 32 | 0) >>> 0 < i10 >>> 0) {
+ while (1) {
+ i3 = i4 + 4 | 0;
+ HEAP32[i3 >> 2] = 7;
+ if ((i4 + 8 | 0) >>> 0 < i10 >>> 0) {
+ i4 = i3;
+ } else {
+ break;
+ }
+ }
+ }
+ if ((i2 | 0) != (i15 | 0)) {
+ i2 = i2 - i15 | 0;
+ i3 = i15 + (i2 + 4) | 0;
+ HEAP32[i3 >> 2] = HEAP32[i3 >> 2] & -2;
+ HEAP32[i15 + 4 >> 2] = i2 | 1;
+ HEAP32[i15 + i2 >> 2] = i2;
+ i3 = i2 >>> 3;
+ if (i2 >>> 0 < 256) {
+ i4 = i3 << 1;
+ i2 = 14512 + (i4 << 2) | 0;
+ i5 = HEAP32[3618] | 0;
+ i3 = 1 << i3;
+ if ((i5 & i3 | 0) != 0) {
+ i4 = 14512 + (i4 + 2 << 2) | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ if (i3 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i7 = i4;
+ i8 = i3;
+ }
+ } else {
+ HEAP32[3618] = i5 | i3;
+ i7 = 14512 + (i4 + 2 << 2) | 0;
+ i8 = i2;
+ }
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i8 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i8;
+ HEAP32[i15 + 12 >> 2] = i2;
+ break;
+ }
+ i3 = i2 >>> 8;
+ if ((i3 | 0) != 0) {
+ if (i2 >>> 0 > 16777215) {
+ i3 = 31;
+ } else {
+ i31 = (i3 + 1048320 | 0) >>> 16 & 8;
+ i32 = i3 << i31;
+ i30 = (i32 + 520192 | 0) >>> 16 & 4;
+ i32 = i32 << i30;
+ i3 = (i32 + 245760 | 0) >>> 16 & 2;
+ i3 = 14 - (i30 | i31 | i3) + (i32 << i3 >>> 15) | 0;
+ i3 = i2 >>> (i3 + 7 | 0) & 1 | i3 << 1;
+ }
+ } else {
+ i3 = 0;
+ }
+ i7 = 14776 + (i3 << 2) | 0;
+ HEAP32[i15 + 28 >> 2] = i3;
+ HEAP32[i15 + 20 >> 2] = 0;
+ HEAP32[i15 + 16 >> 2] = 0;
+ i4 = HEAP32[14476 >> 2] | 0;
+ i5 = 1 << i3;
+ if ((i4 & i5 | 0) == 0) {
+ HEAP32[14476 >> 2] = i4 | i5;
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i7;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break;
+ }
+ i4 = HEAP32[i7 >> 2] | 0;
+ if ((i3 | 0) == 31) {
+ i3 = 0;
+ } else {
+ i3 = 25 - (i3 >>> 1) | 0;
+ }
+ L499 : do {
+ if ((HEAP32[i4 + 4 >> 2] & -8 | 0) != (i2 | 0)) {
+ i3 = i2 << i3;
+ while (1) {
+ i7 = i4 + (i3 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i2 | 0)) {
+ i6 = i5;
+ break L499;
+ } else {
+ i3 = i3 << 1;
+ i4 = i5;
+ }
+ }
+ if (i7 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i7 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i4;
+ HEAP32[i15 + 12 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i15;
+ break L311;
+ }
+ } else {
+ i6 = i4;
+ }
+ } while (0);
+ i4 = i6 + 8 | 0;
+ i3 = HEAP32[i4 >> 2] | 0;
+ i2 = HEAP32[14488 >> 2] | 0;
+ if (i6 >>> 0 < i2 >>> 0) {
+ _abort();
+ }
+ if (i3 >>> 0 < i2 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i3 + 12 >> 2] = i15;
+ HEAP32[i4 >> 2] = i15;
+ HEAP32[i15 + 8 >> 2] = i3;
+ HEAP32[i15 + 12 >> 2] = i6;
+ HEAP32[i15 + 24 >> 2] = 0;
+ break;
+ }
+ }
+ } else {
+ i32 = HEAP32[14488 >> 2] | 0;
+ if ((i32 | 0) == 0 | i17 >>> 0 < i32 >>> 0) {
+ HEAP32[14488 >> 2] = i17;
+ }
+ HEAP32[14920 >> 2] = i17;
+ HEAP32[14924 >> 2] = i14;
+ HEAP32[14932 >> 2] = 0;
+ HEAP32[14508 >> 2] = HEAP32[3736];
+ HEAP32[14504 >> 2] = -1;
+ i2 = 0;
+ do {
+ i32 = i2 << 1;
+ i31 = 14512 + (i32 << 2) | 0;
+ HEAP32[14512 + (i32 + 3 << 2) >> 2] = i31;
+ HEAP32[14512 + (i32 + 2 << 2) >> 2] = i31;
+ i2 = i2 + 1 | 0;
+ } while ((i2 | 0) != 32);
+ i2 = i17 + 8 | 0;
+ if ((i2 & 7 | 0) == 0) {
+ i2 = 0;
+ } else {
+ i2 = 0 - i2 & 7;
+ }
+ i32 = i14 + -40 - i2 | 0;
+ HEAP32[14496 >> 2] = i17 + i2;
+ HEAP32[14484 >> 2] = i32;
+ HEAP32[i17 + (i2 + 4) >> 2] = i32 | 1;
+ HEAP32[i17 + (i14 + -36) >> 2] = 40;
+ HEAP32[14500 >> 2] = HEAP32[14960 >> 2];
+ }
+ } while (0);
+ i2 = HEAP32[14484 >> 2] | 0;
+ if (i2 >>> 0 > i12 >>> 0) {
+ i31 = i2 - i12 | 0;
+ HEAP32[14484 >> 2] = i31;
+ i32 = HEAP32[14496 >> 2] | 0;
+ HEAP32[14496 >> 2] = i32 + i12;
+ HEAP32[i32 + (i12 + 4) >> 2] = i31 | 1;
+ HEAP32[i32 + 4 >> 2] = i12 | 3;
+ i32 = i32 + 8 | 0;
+ STACKTOP = i1;
+ return i32 | 0;
+ }
+ }
+ HEAP32[(___errno_location() | 0) >> 2] = 12;
+ i32 = 0;
+ STACKTOP = i1;
+ return i32 | 0;
+}
+function _deflate(i2, i10) {
+ i2 = i2 | 0;
+ i10 = i10 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0;
+ i1 = STACKTOP;
+ if ((i2 | 0) == 0) {
+ i37 = -2;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ i5 = i2 + 28 | 0;
+ i7 = HEAP32[i5 >> 2] | 0;
+ if ((i7 | 0) == 0 | i10 >>> 0 > 5) {
+ i37 = -2;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ i4 = i2 + 12 | 0;
+ do {
+ if ((HEAP32[i4 >> 2] | 0) != 0) {
+ if ((HEAP32[i2 >> 2] | 0) == 0 ? (HEAP32[i2 + 4 >> 2] | 0) != 0 : 0) {
+ break;
+ }
+ i11 = i7 + 4 | 0;
+ i29 = HEAP32[i11 >> 2] | 0;
+ i9 = (i10 | 0) == 4;
+ if ((i29 | 0) != 666 | i9) {
+ i3 = i2 + 16 | 0;
+ if ((HEAP32[i3 >> 2] | 0) == 0) {
+ HEAP32[i2 + 24 >> 2] = HEAP32[3180 >> 2];
+ i37 = -5;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ HEAP32[i7 >> 2] = i2;
+ i8 = i7 + 40 | 0;
+ i18 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i10;
+ do {
+ if ((i29 | 0) == 42) {
+ if ((HEAP32[i7 + 24 >> 2] | 0) != 2) {
+ i17 = (HEAP32[i7 + 48 >> 2] << 12) + -30720 | 0;
+ if ((HEAP32[i7 + 136 >> 2] | 0) <= 1 ? (i28 = HEAP32[i7 + 132 >> 2] | 0, (i28 | 0) >= 2) : 0) {
+ if ((i28 | 0) < 6) {
+ i28 = 64;
+ } else {
+ i28 = (i28 | 0) == 6 ? 128 : 192;
+ }
+ } else {
+ i28 = 0;
+ }
+ i28 = i28 | i17;
+ i17 = i7 + 108 | 0;
+ i37 = (HEAP32[i17 >> 2] | 0) == 0 ? i28 : i28 | 32;
+ HEAP32[i11 >> 2] = 113;
+ i29 = i7 + 20 | 0;
+ i30 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i30 + 1;
+ i28 = i7 + 8 | 0;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i30 | 0] = i37 >>> 8;
+ i30 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i30 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i30 | 0] = (i37 | ((i37 >>> 0) % 31 | 0)) ^ 31;
+ i30 = i2 + 48 | 0;
+ if ((HEAP32[i17 >> 2] | 0) != 0) {
+ i37 = HEAP32[i30 >> 2] | 0;
+ i36 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i36 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i36 | 0] = i37 >>> 24;
+ i36 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i36 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i36 | 0] = i37 >>> 16;
+ i36 = HEAP32[i30 >> 2] | 0;
+ i37 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i37 | 0] = i36 >>> 8;
+ i37 = HEAP32[i29 >> 2] | 0;
+ HEAP32[i29 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i37 | 0] = i36;
+ }
+ HEAP32[i30 >> 2] = _adler32(0, 0, 0) | 0;
+ i31 = HEAP32[i11 >> 2] | 0;
+ i17 = 32;
+ break;
+ }
+ i32 = i2 + 48 | 0;
+ HEAP32[i32 >> 2] = _crc32(0, 0, 0) | 0;
+ i30 = i7 + 20 | 0;
+ i28 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i28 + 1;
+ i29 = i7 + 8 | 0;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i28 | 0] = 31;
+ i28 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i28 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i28 | 0] = -117;
+ i28 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i28 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i28 | 0] = 8;
+ i28 = i7 + 28 | 0;
+ i33 = HEAP32[i28 >> 2] | 0;
+ if ((i33 | 0) == 0) {
+ i22 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i22 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i22 | 0] = 0;
+ i22 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i22 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i22 | 0] = 0;
+ i22 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i22 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i22 | 0] = 0;
+ i22 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i22 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i22 | 0] = 0;
+ i22 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i22 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i22 | 0] = 0;
+ i22 = HEAP32[i7 + 132 >> 2] | 0;
+ if ((i22 | 0) != 9) {
+ if ((HEAP32[i7 + 136 >> 2] | 0) > 1) {
+ i22 = 4;
+ } else {
+ i22 = (i22 | 0) < 2 ? 4 : 0;
+ }
+ } else {
+ i22 = 2;
+ }
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = i22;
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = 3;
+ HEAP32[i11 >> 2] = 113;
+ break;
+ }
+ i37 = (((HEAP32[i33 + 44 >> 2] | 0) != 0 ? 2 : 0) | (HEAP32[i33 >> 2] | 0) != 0 | ((HEAP32[i33 + 16 >> 2] | 0) == 0 ? 0 : 4) | ((HEAP32[i33 + 28 >> 2] | 0) == 0 ? 0 : 8) | ((HEAP32[i33 + 36 >> 2] | 0) == 0 ? 0 : 16)) & 255;
+ i17 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i17 | 0] = i37;
+ i17 = HEAP32[(HEAP32[i28 >> 2] | 0) + 4 >> 2] & 255;
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = i17;
+ i37 = (HEAP32[(HEAP32[i28 >> 2] | 0) + 4 >> 2] | 0) >>> 8 & 255;
+ i17 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i17 | 0] = i37;
+ i17 = (HEAP32[(HEAP32[i28 >> 2] | 0) + 4 >> 2] | 0) >>> 16 & 255;
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = i17;
+ i37 = (HEAP32[(HEAP32[i28 >> 2] | 0) + 4 >> 2] | 0) >>> 24 & 255;
+ i17 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i17 | 0] = i37;
+ i17 = HEAP32[i7 + 132 >> 2] | 0;
+ if ((i17 | 0) != 9) {
+ if ((HEAP32[i7 + 136 >> 2] | 0) > 1) {
+ i17 = 4;
+ } else {
+ i17 = (i17 | 0) < 2 ? 4 : 0;
+ }
+ } else {
+ i17 = 2;
+ }
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = i17;
+ i37 = HEAP32[(HEAP32[i28 >> 2] | 0) + 12 >> 2] & 255;
+ i17 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i17 | 0] = i37;
+ i17 = HEAP32[i28 >> 2] | 0;
+ if ((HEAP32[i17 + 16 >> 2] | 0) != 0) {
+ i17 = HEAP32[i17 + 20 >> 2] & 255;
+ i37 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i37 | 0] = i17;
+ i37 = (HEAP32[(HEAP32[i28 >> 2] | 0) + 20 >> 2] | 0) >>> 8 & 255;
+ i17 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i17 | 0] = i37;
+ i17 = HEAP32[i28 >> 2] | 0;
+ }
+ if ((HEAP32[i17 + 44 >> 2] | 0) != 0) {
+ HEAP32[i32 >> 2] = _crc32(HEAP32[i32 >> 2] | 0, HEAP32[i29 >> 2] | 0, HEAP32[i30 >> 2] | 0) | 0;
+ }
+ HEAP32[i7 + 32 >> 2] = 0;
+ HEAP32[i11 >> 2] = 69;
+ i17 = 34;
+ } else {
+ i31 = i29;
+ i17 = 32;
+ }
+ } while (0);
+ if ((i17 | 0) == 32) {
+ if ((i31 | 0) == 69) {
+ i28 = i7 + 28 | 0;
+ i17 = 34;
+ } else {
+ i17 = 55;
+ }
+ }
+ do {
+ if ((i17 | 0) == 34) {
+ i37 = HEAP32[i28 >> 2] | 0;
+ if ((HEAP32[i37 + 16 >> 2] | 0) == 0) {
+ HEAP32[i11 >> 2] = 73;
+ i17 = 57;
+ break;
+ }
+ i29 = i7 + 20 | 0;
+ i34 = HEAP32[i29 >> 2] | 0;
+ i17 = i7 + 32 | 0;
+ i36 = HEAP32[i17 >> 2] | 0;
+ L55 : do {
+ if (i36 >>> 0 < (HEAP32[i37 + 20 >> 2] & 65535) >>> 0) {
+ i30 = i7 + 12 | 0;
+ i32 = i2 + 48 | 0;
+ i31 = i7 + 8 | 0;
+ i33 = i2 + 20 | 0;
+ i35 = i34;
+ while (1) {
+ if ((i35 | 0) == (HEAP32[i30 >> 2] | 0)) {
+ if ((HEAP32[i37 + 44 >> 2] | 0) != 0 & i35 >>> 0 > i34 >>> 0) {
+ HEAP32[i32 >> 2] = _crc32(HEAP32[i32 >> 2] | 0, (HEAP32[i31 >> 2] | 0) + i34 | 0, i35 - i34 | 0) | 0;
+ }
+ i34 = HEAP32[i5 >> 2] | 0;
+ i35 = HEAP32[i34 + 20 >> 2] | 0;
+ i36 = HEAP32[i3 >> 2] | 0;
+ i35 = i35 >>> 0 > i36 >>> 0 ? i36 : i35;
+ if ((i35 | 0) != 0 ? (_memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i34 + 16 >> 2] | 0, i35 | 0) | 0, HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i35, i27 = (HEAP32[i5 >> 2] | 0) + 16 | 0, HEAP32[i27 >> 2] = (HEAP32[i27 >> 2] | 0) + i35, HEAP32[i33 >> 2] = (HEAP32[i33 >> 2] | 0) + i35, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i35, i27 = HEAP32[i5 >> 2] | 0, i36 = i27 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i35, (i37 | 0) == (i35 | 0)) : 0) {
+ HEAP32[i27 + 16 >> 2] = HEAP32[i27 + 8 >> 2];
+ }
+ i34 = HEAP32[i29 >> 2] | 0;
+ if ((i34 | 0) == (HEAP32[i30 >> 2] | 0)) {
+ break;
+ }
+ i37 = HEAP32[i28 >> 2] | 0;
+ i36 = HEAP32[i17 >> 2] | 0;
+ i35 = i34;
+ }
+ i36 = HEAP8[(HEAP32[i37 + 16 >> 2] | 0) + i36 | 0] | 0;
+ HEAP32[i29 >> 2] = i35 + 1;
+ HEAP8[(HEAP32[i31 >> 2] | 0) + i35 | 0] = i36;
+ i36 = (HEAP32[i17 >> 2] | 0) + 1 | 0;
+ HEAP32[i17 >> 2] = i36;
+ i37 = HEAP32[i28 >> 2] | 0;
+ if (!(i36 >>> 0 < (HEAP32[i37 + 20 >> 2] & 65535) >>> 0)) {
+ break L55;
+ }
+ i35 = HEAP32[i29 >> 2] | 0;
+ }
+ i37 = HEAP32[i28 >> 2] | 0;
+ }
+ } while (0);
+ if ((HEAP32[i37 + 44 >> 2] | 0) != 0 ? (i26 = HEAP32[i29 >> 2] | 0, i26 >>> 0 > i34 >>> 0) : 0) {
+ i37 = i2 + 48 | 0;
+ HEAP32[i37 >> 2] = _crc32(HEAP32[i37 >> 2] | 0, (HEAP32[i7 + 8 >> 2] | 0) + i34 | 0, i26 - i34 | 0) | 0;
+ i37 = HEAP32[i28 >> 2] | 0;
+ }
+ if ((HEAP32[i17 >> 2] | 0) == (HEAP32[i37 + 20 >> 2] | 0)) {
+ HEAP32[i17 >> 2] = 0;
+ HEAP32[i11 >> 2] = 73;
+ i17 = 57;
+ break;
+ } else {
+ i31 = HEAP32[i11 >> 2] | 0;
+ i17 = 55;
+ break;
+ }
+ }
+ } while (0);
+ if ((i17 | 0) == 55) {
+ if ((i31 | 0) == 73) {
+ i37 = HEAP32[i7 + 28 >> 2] | 0;
+ i17 = 57;
+ } else {
+ i17 = 76;
+ }
+ }
+ do {
+ if ((i17 | 0) == 57) {
+ i26 = i7 + 28 | 0;
+ if ((HEAP32[i37 + 28 >> 2] | 0) == 0) {
+ HEAP32[i11 >> 2] = 91;
+ i17 = 78;
+ break;
+ }
+ i27 = i7 + 20 | 0;
+ i35 = HEAP32[i27 >> 2] | 0;
+ i32 = i7 + 12 | 0;
+ i29 = i2 + 48 | 0;
+ i28 = i7 + 8 | 0;
+ i31 = i2 + 20 | 0;
+ i30 = i7 + 32 | 0;
+ i33 = i35;
+ while (1) {
+ if ((i33 | 0) == (HEAP32[i32 >> 2] | 0)) {
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 44 >> 2] | 0) != 0 & i33 >>> 0 > i35 >>> 0) {
+ HEAP32[i29 >> 2] = _crc32(HEAP32[i29 >> 2] | 0, (HEAP32[i28 >> 2] | 0) + i35 | 0, i33 - i35 | 0) | 0;
+ }
+ i33 = HEAP32[i5 >> 2] | 0;
+ i34 = HEAP32[i33 + 20 >> 2] | 0;
+ i35 = HEAP32[i3 >> 2] | 0;
+ i34 = i34 >>> 0 > i35 >>> 0 ? i35 : i34;
+ if ((i34 | 0) != 0 ? (_memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i33 + 16 >> 2] | 0, i34 | 0) | 0, HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i34, i25 = (HEAP32[i5 >> 2] | 0) + 16 | 0, HEAP32[i25 >> 2] = (HEAP32[i25 >> 2] | 0) + i34, HEAP32[i31 >> 2] = (HEAP32[i31 >> 2] | 0) + i34, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i34, i25 = HEAP32[i5 >> 2] | 0, i36 = i25 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i34, (i37 | 0) == (i34 | 0)) : 0) {
+ HEAP32[i25 + 16 >> 2] = HEAP32[i25 + 8 >> 2];
+ }
+ i35 = HEAP32[i27 >> 2] | 0;
+ if ((i35 | 0) == (HEAP32[i32 >> 2] | 0)) {
+ i25 = 1;
+ break;
+ } else {
+ i33 = i35;
+ }
+ }
+ i34 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i34 + 1;
+ i34 = HEAP8[(HEAP32[(HEAP32[i26 >> 2] | 0) + 28 >> 2] | 0) + i34 | 0] | 0;
+ HEAP32[i27 >> 2] = i33 + 1;
+ HEAP8[(HEAP32[i28 >> 2] | 0) + i33 | 0] = i34;
+ if (i34 << 24 >> 24 == 0) {
+ i17 = 68;
+ break;
+ }
+ i33 = HEAP32[i27 >> 2] | 0;
+ }
+ if ((i17 | 0) == 68) {
+ i25 = i34 & 255;
+ }
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 44 >> 2] | 0) != 0 ? (i24 = HEAP32[i27 >> 2] | 0, i24 >>> 0 > i35 >>> 0) : 0) {
+ HEAP32[i29 >> 2] = _crc32(HEAP32[i29 >> 2] | 0, (HEAP32[i28 >> 2] | 0) + i35 | 0, i24 - i35 | 0) | 0;
+ }
+ if ((i25 | 0) == 0) {
+ HEAP32[i30 >> 2] = 0;
+ HEAP32[i11 >> 2] = 91;
+ i17 = 78;
+ break;
+ } else {
+ i31 = HEAP32[i11 >> 2] | 0;
+ i17 = 76;
+ break;
+ }
+ }
+ } while (0);
+ if ((i17 | 0) == 76) {
+ if ((i31 | 0) == 91) {
+ i26 = i7 + 28 | 0;
+ i17 = 78;
+ } else {
+ i17 = 97;
+ }
+ }
+ do {
+ if ((i17 | 0) == 78) {
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 36 >> 2] | 0) == 0) {
+ HEAP32[i11 >> 2] = 103;
+ i17 = 99;
+ break;
+ }
+ i24 = i7 + 20 | 0;
+ i32 = HEAP32[i24 >> 2] | 0;
+ i29 = i7 + 12 | 0;
+ i27 = i2 + 48 | 0;
+ i25 = i7 + 8 | 0;
+ i28 = i2 + 20 | 0;
+ i30 = i7 + 32 | 0;
+ i31 = i32;
+ while (1) {
+ if ((i31 | 0) == (HEAP32[i29 >> 2] | 0)) {
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 44 >> 2] | 0) != 0 & i31 >>> 0 > i32 >>> 0) {
+ HEAP32[i27 >> 2] = _crc32(HEAP32[i27 >> 2] | 0, (HEAP32[i25 >> 2] | 0) + i32 | 0, i31 - i32 | 0) | 0;
+ }
+ i31 = HEAP32[i5 >> 2] | 0;
+ i33 = HEAP32[i31 + 20 >> 2] | 0;
+ i32 = HEAP32[i3 >> 2] | 0;
+ i32 = i33 >>> 0 > i32 >>> 0 ? i32 : i33;
+ if ((i32 | 0) != 0 ? (_memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i31 + 16 >> 2] | 0, i32 | 0) | 0, HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i32, i23 = (HEAP32[i5 >> 2] | 0) + 16 | 0, HEAP32[i23 >> 2] = (HEAP32[i23 >> 2] | 0) + i32, HEAP32[i28 >> 2] = (HEAP32[i28 >> 2] | 0) + i32, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i32, i23 = HEAP32[i5 >> 2] | 0, i36 = i23 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i32, (i37 | 0) == (i32 | 0)) : 0) {
+ HEAP32[i23 + 16 >> 2] = HEAP32[i23 + 8 >> 2];
+ }
+ i32 = HEAP32[i24 >> 2] | 0;
+ if ((i32 | 0) == (HEAP32[i29 >> 2] | 0)) {
+ i23 = 1;
+ break;
+ } else {
+ i31 = i32;
+ }
+ }
+ i33 = HEAP32[i30 >> 2] | 0;
+ HEAP32[i30 >> 2] = i33 + 1;
+ i33 = HEAP8[(HEAP32[(HEAP32[i26 >> 2] | 0) + 36 >> 2] | 0) + i33 | 0] | 0;
+ HEAP32[i24 >> 2] = i31 + 1;
+ HEAP8[(HEAP32[i25 >> 2] | 0) + i31 | 0] = i33;
+ if (i33 << 24 >> 24 == 0) {
+ i17 = 89;
+ break;
+ }
+ i31 = HEAP32[i24 >> 2] | 0;
+ }
+ if ((i17 | 0) == 89) {
+ i23 = i33 & 255;
+ }
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 44 >> 2] | 0) != 0 ? (i22 = HEAP32[i24 >> 2] | 0, i22 >>> 0 > i32 >>> 0) : 0) {
+ HEAP32[i27 >> 2] = _crc32(HEAP32[i27 >> 2] | 0, (HEAP32[i25 >> 2] | 0) + i32 | 0, i22 - i32 | 0) | 0;
+ }
+ if ((i23 | 0) == 0) {
+ HEAP32[i11 >> 2] = 103;
+ i17 = 99;
+ break;
+ } else {
+ i31 = HEAP32[i11 >> 2] | 0;
+ i17 = 97;
+ break;
+ }
+ }
+ } while (0);
+ if ((i17 | 0) == 97 ? (i31 | 0) == 103 : 0) {
+ i26 = i7 + 28 | 0;
+ i17 = 99;
+ }
+ do {
+ if ((i17 | 0) == 99) {
+ if ((HEAP32[(HEAP32[i26 >> 2] | 0) + 44 >> 2] | 0) == 0) {
+ HEAP32[i11 >> 2] = 113;
+ break;
+ }
+ i17 = i7 + 20 | 0;
+ i22 = i7 + 12 | 0;
+ if ((((HEAP32[i17 >> 2] | 0) + 2 | 0) >>> 0 > (HEAP32[i22 >> 2] | 0) >>> 0 ? (i20 = HEAP32[i5 >> 2] | 0, i21 = HEAP32[i20 + 20 >> 2] | 0, i23 = HEAP32[i3 >> 2] | 0, i21 = i21 >>> 0 > i23 >>> 0 ? i23 : i21, (i21 | 0) != 0) : 0) ? (_memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i20 + 16 >> 2] | 0, i21 | 0) | 0, HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i21, i19 = (HEAP32[i5 >> 2] | 0) + 16 | 0, HEAP32[i19 >> 2] = (HEAP32[i19 >> 2] | 0) + i21, i19 = i2 + 20 | 0, HEAP32[i19 >> 2] = (HEAP32[i19 >> 2] | 0) + i21, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i21, i19 = HEAP32[i5 >> 2] | 0, i36 = i19 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i21, (i37 | 0) == (i21 | 0)) : 0) {
+ HEAP32[i19 + 16 >> 2] = HEAP32[i19 + 8 >> 2];
+ }
+ i19 = HEAP32[i17 >> 2] | 0;
+ if (!((i19 + 2 | 0) >>> 0 > (HEAP32[i22 >> 2] | 0) >>> 0)) {
+ i37 = i2 + 48 | 0;
+ i34 = HEAP32[i37 >> 2] & 255;
+ HEAP32[i17 >> 2] = i19 + 1;
+ i35 = i7 + 8 | 0;
+ HEAP8[(HEAP32[i35 >> 2] | 0) + i19 | 0] = i34;
+ i34 = (HEAP32[i37 >> 2] | 0) >>> 8 & 255;
+ i36 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i17 >> 2] = i36 + 1;
+ HEAP8[(HEAP32[i35 >> 2] | 0) + i36 | 0] = i34;
+ HEAP32[i37 >> 2] = _crc32(0, 0, 0) | 0;
+ HEAP32[i11 >> 2] = 113;
+ }
+ }
+ } while (0);
+ i19 = i7 + 20 | 0;
+ if ((HEAP32[i19 >> 2] | 0) == 0) {
+ if ((HEAP32[i2 + 4 >> 2] | 0) == 0 ? (i18 | 0) >= (i10 | 0) & (i10 | 0) != 4 : 0) {
+ HEAP32[i2 + 24 >> 2] = HEAP32[3180 >> 2];
+ i37 = -5;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ } else {
+ i17 = HEAP32[i5 >> 2] | 0;
+ i20 = HEAP32[i17 + 20 >> 2] | 0;
+ i18 = HEAP32[i3 >> 2] | 0;
+ i20 = i20 >>> 0 > i18 >>> 0 ? i18 : i20;
+ if ((i20 | 0) != 0) {
+ _memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i17 + 16 >> 2] | 0, i20 | 0) | 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i20;
+ i17 = (HEAP32[i5 >> 2] | 0) + 16 | 0;
+ HEAP32[i17 >> 2] = (HEAP32[i17 >> 2] | 0) + i20;
+ i17 = i2 + 20 | 0;
+ HEAP32[i17 >> 2] = (HEAP32[i17 >> 2] | 0) + i20;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i20;
+ i17 = HEAP32[i5 >> 2] | 0;
+ i36 = i17 + 20 | 0;
+ i37 = HEAP32[i36 >> 2] | 0;
+ HEAP32[i36 >> 2] = i37 - i20;
+ if ((i37 | 0) == (i20 | 0)) {
+ HEAP32[i17 + 16 >> 2] = HEAP32[i17 + 8 >> 2];
+ }
+ i18 = HEAP32[i3 >> 2] | 0;
+ }
+ if ((i18 | 0) == 0) {
+ HEAP32[i8 >> 2] = -1;
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ }
+ i18 = (HEAP32[i11 >> 2] | 0) == 666;
+ i17 = (HEAP32[i2 + 4 >> 2] | 0) == 0;
+ if (i18) {
+ if (i17) {
+ i17 = 121;
+ } else {
+ HEAP32[i2 + 24 >> 2] = HEAP32[3180 >> 2];
+ i37 = -5;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ } else {
+ if (i17) {
+ i17 = 121;
+ } else {
+ i17 = 124;
+ }
+ }
+ do {
+ if ((i17 | 0) == 121) {
+ if ((HEAP32[i7 + 116 >> 2] | 0) == 0) {
+ if ((i10 | 0) != 0) {
+ if (i18) {
+ break;
+ } else {
+ i17 = 124;
+ break;
+ }
+ } else {
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ } else {
+ i17 = 124;
+ }
+ }
+ } while (0);
+ do {
+ if ((i17 | 0) == 124) {
+ i18 = HEAP32[i7 + 136 >> 2] | 0;
+ L185 : do {
+ if ((i18 | 0) == 2) {
+ i22 = i7 + 116 | 0;
+ i18 = i7 + 96 | 0;
+ i13 = i7 + 108 | 0;
+ i14 = i7 + 56 | 0;
+ i21 = i7 + 5792 | 0;
+ i20 = i7 + 5796 | 0;
+ i24 = i7 + 5784 | 0;
+ i23 = i7 + 5788 | 0;
+ i12 = i7 + 92 | 0;
+ while (1) {
+ if ((HEAP32[i22 >> 2] | 0) == 0 ? (_fill_window(i7), (HEAP32[i22 >> 2] | 0) == 0) : 0) {
+ break;
+ }
+ HEAP32[i18 >> 2] = 0;
+ i37 = HEAP8[(HEAP32[i14 >> 2] | 0) + (HEAP32[i13 >> 2] | 0) | 0] | 0;
+ i26 = HEAP32[i21 >> 2] | 0;
+ HEAP16[(HEAP32[i20 >> 2] | 0) + (i26 << 1) >> 1] = 0;
+ HEAP32[i21 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i24 >> 2] | 0) + i26 | 0] = i37;
+ i37 = i7 + ((i37 & 255) << 2) + 148 | 0;
+ HEAP16[i37 >> 1] = (HEAP16[i37 >> 1] | 0) + 1 << 16 >> 16;
+ i37 = (HEAP32[i21 >> 2] | 0) == ((HEAP32[i23 >> 2] | 0) + -1 | 0);
+ HEAP32[i22 >> 2] = (HEAP32[i22 >> 2] | 0) + -1;
+ i26 = (HEAP32[i13 >> 2] | 0) + 1 | 0;
+ HEAP32[i13 >> 2] = i26;
+ if (!i37) {
+ continue;
+ }
+ i25 = HEAP32[i12 >> 2] | 0;
+ if ((i25 | 0) > -1) {
+ i27 = (HEAP32[i14 >> 2] | 0) + i25 | 0;
+ } else {
+ i27 = 0;
+ }
+ __tr_flush_block(i7, i27, i26 - i25 | 0, 0);
+ HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
+ i26 = HEAP32[i7 >> 2] | 0;
+ i25 = i26 + 28 | 0;
+ i27 = HEAP32[i25 >> 2] | 0;
+ i30 = HEAP32[i27 + 20 >> 2] | 0;
+ i28 = i26 + 16 | 0;
+ i29 = HEAP32[i28 >> 2] | 0;
+ i29 = i30 >>> 0 > i29 >>> 0 ? i29 : i30;
+ if ((i29 | 0) != 0 ? (i16 = i26 + 12 | 0, _memcpy(HEAP32[i16 >> 2] | 0, HEAP32[i27 + 16 >> 2] | 0, i29 | 0) | 0, HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) + i29, i16 = (HEAP32[i25 >> 2] | 0) + 16 | 0, HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) + i29, i16 = i26 + 20 | 0, HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) + i29, HEAP32[i28 >> 2] = (HEAP32[i28 >> 2] | 0) - i29, i16 = HEAP32[i25 >> 2] | 0, i36 = i16 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i29, (i37 | 0) == (i29 | 0)) : 0) {
+ HEAP32[i16 + 16 >> 2] = HEAP32[i16 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i7 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ break L185;
+ }
+ }
+ if ((i10 | 0) != 0) {
+ i16 = HEAP32[i12 >> 2] | 0;
+ if ((i16 | 0) > -1) {
+ i14 = (HEAP32[i14 >> 2] | 0) + i16 | 0;
+ } else {
+ i14 = 0;
+ }
+ __tr_flush_block(i7, i14, (HEAP32[i13 >> 2] | 0) - i16 | 0, i9 & 1);
+ HEAP32[i12 >> 2] = HEAP32[i13 >> 2];
+ i14 = HEAP32[i7 >> 2] | 0;
+ i13 = i14 + 28 | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ i17 = HEAP32[i12 + 20 >> 2] | 0;
+ i16 = i14 + 16 | 0;
+ i18 = HEAP32[i16 >> 2] | 0;
+ i17 = i17 >>> 0 > i18 >>> 0 ? i18 : i17;
+ if ((i17 | 0) != 0 ? (i15 = i14 + 12 | 0, _memcpy(HEAP32[i15 >> 2] | 0, HEAP32[i12 + 16 >> 2] | 0, i17 | 0) | 0, HEAP32[i15 >> 2] = (HEAP32[i15 >> 2] | 0) + i17, i15 = (HEAP32[i13 >> 2] | 0) + 16 | 0, HEAP32[i15 >> 2] = (HEAP32[i15 >> 2] | 0) + i17, i15 = i14 + 20 | 0, HEAP32[i15 >> 2] = (HEAP32[i15 >> 2] | 0) + i17, HEAP32[i16 >> 2] = (HEAP32[i16 >> 2] | 0) - i17, i15 = HEAP32[i13 >> 2] | 0, i36 = i15 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i17, (i37 | 0) == (i17 | 0)) : 0) {
+ HEAP32[i15 + 16 >> 2] = HEAP32[i15 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i7 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i12 = i9 ? 2 : 0;
+ i17 = 183;
+ break;
+ } else {
+ i12 = i9 ? 3 : 1;
+ i17 = 183;
+ break;
+ }
+ }
+ } else if ((i18 | 0) == 3) {
+ i27 = i7 + 116 | 0;
+ i26 = (i10 | 0) == 0;
+ i22 = i7 + 96 | 0;
+ i15 = i7 + 108 | 0;
+ i20 = i7 + 5792 | 0;
+ i24 = i7 + 5796 | 0;
+ i23 = i7 + 5784 | 0;
+ i21 = i7 + (HEAPU8[296] << 2) + 2440 | 0;
+ i25 = i7 + 5788 | 0;
+ i18 = i7 + 56 | 0;
+ i16 = i7 + 92 | 0;
+ while (1) {
+ i29 = HEAP32[i27 >> 2] | 0;
+ if (i29 >>> 0 < 258) {
+ _fill_window(i7);
+ i29 = HEAP32[i27 >> 2] | 0;
+ if (i29 >>> 0 < 258 & i26) {
+ break L185;
+ }
+ if ((i29 | 0) == 0) {
+ break;
+ }
+ HEAP32[i22 >> 2] = 0;
+ if (i29 >>> 0 > 2) {
+ i17 = 151;
+ } else {
+ i28 = HEAP32[i15 >> 2] | 0;
+ i17 = 166;
+ }
+ } else {
+ HEAP32[i22 >> 2] = 0;
+ i17 = 151;
+ }
+ if ((i17 | 0) == 151) {
+ i17 = 0;
+ i28 = HEAP32[i15 >> 2] | 0;
+ if ((i28 | 0) != 0) {
+ i31 = HEAP32[i18 >> 2] | 0;
+ i30 = HEAP8[i31 + (i28 + -1) | 0] | 0;
+ if ((i30 << 24 >> 24 == (HEAP8[i31 + i28 | 0] | 0) ? i30 << 24 >> 24 == (HEAP8[i31 + (i28 + 1) | 0] | 0) : 0) ? (i14 = i31 + (i28 + 2) | 0, i30 << 24 >> 24 == (HEAP8[i14] | 0)) : 0) {
+ i31 = i31 + (i28 + 258) | 0;
+ i32 = i14;
+ do {
+ i33 = i32 + 1 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 2 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 3 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 4 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 5 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 6 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i33 = i32 + 7 | 0;
+ if (!(i30 << 24 >> 24 == (HEAP8[i33] | 0))) {
+ i32 = i33;
+ break;
+ }
+ i32 = i32 + 8 | 0;
+ } while (i30 << 24 >> 24 == (HEAP8[i32] | 0) & i32 >>> 0 < i31 >>> 0);
+ i30 = i32 - i31 + 258 | 0;
+ i29 = i30 >>> 0 > i29 >>> 0 ? i29 : i30;
+ HEAP32[i22 >> 2] = i29;
+ if (i29 >>> 0 > 2) {
+ i29 = i29 + 253 | 0;
+ i28 = HEAP32[i20 >> 2] | 0;
+ HEAP16[(HEAP32[i24 >> 2] | 0) + (i28 << 1) >> 1] = 1;
+ HEAP32[i20 >> 2] = i28 + 1;
+ HEAP8[(HEAP32[i23 >> 2] | 0) + i28 | 0] = i29;
+ i29 = i7 + ((HEAPU8[808 + (i29 & 255) | 0] | 256) + 1 << 2) + 148 | 0;
+ HEAP16[i29 >> 1] = (HEAP16[i29 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP16[i21 >> 1] = (HEAP16[i21 >> 1] | 0) + 1 << 16 >> 16;
+ i29 = (HEAP32[i20 >> 2] | 0) == ((HEAP32[i25 >> 2] | 0) + -1 | 0) | 0;
+ i28 = HEAP32[i22 >> 2] | 0;
+ HEAP32[i27 >> 2] = (HEAP32[i27 >> 2] | 0) - i28;
+ i28 = (HEAP32[i15 >> 2] | 0) + i28 | 0;
+ HEAP32[i15 >> 2] = i28;
+ HEAP32[i22 >> 2] = 0;
+ } else {
+ i17 = 166;
+ }
+ } else {
+ i17 = 166;
+ }
+ } else {
+ i28 = 0;
+ i17 = 166;
+ }
+ }
+ if ((i17 | 0) == 166) {
+ i17 = 0;
+ i29 = HEAP8[(HEAP32[i18 >> 2] | 0) + i28 | 0] | 0;
+ i28 = HEAP32[i20 >> 2] | 0;
+ HEAP16[(HEAP32[i24 >> 2] | 0) + (i28 << 1) >> 1] = 0;
+ HEAP32[i20 >> 2] = i28 + 1;
+ HEAP8[(HEAP32[i23 >> 2] | 0) + i28 | 0] = i29;
+ i29 = i7 + ((i29 & 255) << 2) + 148 | 0;
+ HEAP16[i29 >> 1] = (HEAP16[i29 >> 1] | 0) + 1 << 16 >> 16;
+ i29 = (HEAP32[i20 >> 2] | 0) == ((HEAP32[i25 >> 2] | 0) + -1 | 0) | 0;
+ HEAP32[i27 >> 2] = (HEAP32[i27 >> 2] | 0) + -1;
+ i28 = (HEAP32[i15 >> 2] | 0) + 1 | 0;
+ HEAP32[i15 >> 2] = i28;
+ }
+ if ((i29 | 0) == 0) {
+ continue;
+ }
+ i29 = HEAP32[i16 >> 2] | 0;
+ if ((i29 | 0) > -1) {
+ i30 = (HEAP32[i18 >> 2] | 0) + i29 | 0;
+ } else {
+ i30 = 0;
+ }
+ __tr_flush_block(i7, i30, i28 - i29 | 0, 0);
+ HEAP32[i16 >> 2] = HEAP32[i15 >> 2];
+ i30 = HEAP32[i7 >> 2] | 0;
+ i28 = i30 + 28 | 0;
+ i29 = HEAP32[i28 >> 2] | 0;
+ i33 = HEAP32[i29 + 20 >> 2] | 0;
+ i31 = i30 + 16 | 0;
+ i32 = HEAP32[i31 >> 2] | 0;
+ i32 = i33 >>> 0 > i32 >>> 0 ? i32 : i33;
+ if ((i32 | 0) != 0 ? (i13 = i30 + 12 | 0, _memcpy(HEAP32[i13 >> 2] | 0, HEAP32[i29 + 16 >> 2] | 0, i32 | 0) | 0, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + i32, i13 = (HEAP32[i28 >> 2] | 0) + 16 | 0, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + i32, i13 = i30 + 20 | 0, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) + i32, HEAP32[i31 >> 2] = (HEAP32[i31 >> 2] | 0) - i32, i13 = HEAP32[i28 >> 2] | 0, i36 = i13 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i32, (i37 | 0) == (i32 | 0)) : 0) {
+ HEAP32[i13 + 16 >> 2] = HEAP32[i13 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i7 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ break L185;
+ }
+ }
+ i13 = HEAP32[i16 >> 2] | 0;
+ if ((i13 | 0) > -1) {
+ i14 = (HEAP32[i18 >> 2] | 0) + i13 | 0;
+ } else {
+ i14 = 0;
+ }
+ __tr_flush_block(i7, i14, (HEAP32[i15 >> 2] | 0) - i13 | 0, i9 & 1);
+ HEAP32[i16 >> 2] = HEAP32[i15 >> 2];
+ i14 = HEAP32[i7 >> 2] | 0;
+ i16 = i14 + 28 | 0;
+ i15 = HEAP32[i16 >> 2] | 0;
+ i18 = HEAP32[i15 + 20 >> 2] | 0;
+ i13 = i14 + 16 | 0;
+ i17 = HEAP32[i13 >> 2] | 0;
+ i17 = i18 >>> 0 > i17 >>> 0 ? i17 : i18;
+ if ((i17 | 0) != 0 ? (i12 = i14 + 12 | 0, _memcpy(HEAP32[i12 >> 2] | 0, HEAP32[i15 + 16 >> 2] | 0, i17 | 0) | 0, HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + i17, i12 = (HEAP32[i16 >> 2] | 0) + 16 | 0, HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + i17, i12 = i14 + 20 | 0, HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) + i17, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) - i17, i12 = HEAP32[i16 >> 2] | 0, i36 = i12 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i17, (i37 | 0) == (i17 | 0)) : 0) {
+ HEAP32[i12 + 16 >> 2] = HEAP32[i12 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i7 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i12 = i9 ? 2 : 0;
+ i17 = 183;
+ break;
+ } else {
+ i12 = i9 ? 3 : 1;
+ i17 = 183;
+ break;
+ }
+ } else {
+ i12 = FUNCTION_TABLE_iii[HEAP32[184 + ((HEAP32[i7 + 132 >> 2] | 0) * 12 | 0) >> 2] & 3](i7, i10) | 0;
+ i17 = 183;
+ }
+ } while (0);
+ if ((i17 | 0) == 183) {
+ if ((i12 & -2 | 0) == 2) {
+ HEAP32[i11 >> 2] = 666;
+ }
+ if ((i12 & -3 | 0) != 0) {
+ if ((i12 | 0) != 1) {
+ break;
+ }
+ if ((i10 | 0) == 1) {
+ __tr_align(i7);
+ } else if (((i10 | 0) != 5 ? (__tr_stored_block(i7, 0, 0, 0), (i10 | 0) == 3) : 0) ? (i37 = HEAP32[i7 + 76 >> 2] | 0, i36 = HEAP32[i7 + 68 >> 2] | 0, HEAP16[i36 + (i37 + -1 << 1) >> 1] = 0, _memset(i36 | 0, 0, (i37 << 1) + -2 | 0) | 0, (HEAP32[i7 + 116 >> 2] | 0) == 0) : 0) {
+ HEAP32[i7 + 108 >> 2] = 0;
+ HEAP32[i7 + 92 >> 2] = 0;
+ }
+ i11 = HEAP32[i5 >> 2] | 0;
+ i12 = HEAP32[i11 + 20 >> 2] | 0;
+ i10 = HEAP32[i3 >> 2] | 0;
+ i12 = i12 >>> 0 > i10 >>> 0 ? i10 : i12;
+ if ((i12 | 0) != 0) {
+ _memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i11 + 16 >> 2] | 0, i12 | 0) | 0;
+ HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i12;
+ i10 = (HEAP32[i5 >> 2] | 0) + 16 | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + i12;
+ i10 = i2 + 20 | 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + i12;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i12;
+ i10 = HEAP32[i5 >> 2] | 0;
+ i36 = i10 + 20 | 0;
+ i37 = HEAP32[i36 >> 2] | 0;
+ HEAP32[i36 >> 2] = i37 - i12;
+ if ((i37 | 0) == (i12 | 0)) {
+ HEAP32[i10 + 16 >> 2] = HEAP32[i10 + 8 >> 2];
+ }
+ i10 = HEAP32[i3 >> 2] | 0;
+ }
+ if ((i10 | 0) != 0) {
+ break;
+ }
+ HEAP32[i8 >> 2] = -1;
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ }
+ if ((HEAP32[i3 >> 2] | 0) != 0) {
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ HEAP32[i8 >> 2] = -1;
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ } while (0);
+ if (!i9) {
+ i37 = 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ i8 = i7 + 24 | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ if ((i10 | 0) < 1) {
+ i37 = 1;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ i11 = i2 + 48 | 0;
+ i9 = HEAP32[i11 >> 2] | 0;
+ if ((i10 | 0) == 2) {
+ i34 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i34 + 1;
+ i36 = i7 + 8 | 0;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i34 | 0] = i9;
+ i34 = (HEAP32[i11 >> 2] | 0) >>> 8 & 255;
+ i35 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i35 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i35 | 0] = i34;
+ i35 = (HEAP32[i11 >> 2] | 0) >>> 16 & 255;
+ i34 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i34 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i34 | 0] = i35;
+ i34 = (HEAP32[i11 >> 2] | 0) >>> 24 & 255;
+ i35 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i35 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i35 | 0] = i34;
+ i35 = i2 + 8 | 0;
+ i34 = HEAP32[i35 >> 2] & 255;
+ i37 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i37 | 0] = i34;
+ i37 = (HEAP32[i35 >> 2] | 0) >>> 8 & 255;
+ i34 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i34 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i34 | 0] = i37;
+ i34 = (HEAP32[i35 >> 2] | 0) >>> 16 & 255;
+ i37 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i37 | 0] = i34;
+ i35 = (HEAP32[i35 >> 2] | 0) >>> 24 & 255;
+ i37 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i37 | 0] = i35;
+ } else {
+ i35 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i35 + 1;
+ i36 = i7 + 8 | 0;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i35 | 0] = i9 >>> 24;
+ i35 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i35 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i35 | 0] = i9 >>> 16;
+ i35 = HEAP32[i11 >> 2] | 0;
+ i37 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i37 | 0] = i35 >>> 8;
+ i37 = HEAP32[i19 >> 2] | 0;
+ HEAP32[i19 >> 2] = i37 + 1;
+ HEAP8[(HEAP32[i36 >> 2] | 0) + i37 | 0] = i35;
+ }
+ i7 = HEAP32[i5 >> 2] | 0;
+ i10 = HEAP32[i7 + 20 >> 2] | 0;
+ i9 = HEAP32[i3 >> 2] | 0;
+ i9 = i10 >>> 0 > i9 >>> 0 ? i9 : i10;
+ if ((i9 | 0) != 0 ? (_memcpy(HEAP32[i4 >> 2] | 0, HEAP32[i7 + 16 >> 2] | 0, i9 | 0) | 0, HEAP32[i4 >> 2] = (HEAP32[i4 >> 2] | 0) + i9, i6 = (HEAP32[i5 >> 2] | 0) + 16 | 0, HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i9, i6 = i2 + 20 | 0, HEAP32[i6 >> 2] = (HEAP32[i6 >> 2] | 0) + i9, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) - i9, i6 = HEAP32[i5 >> 2] | 0, i36 = i6 + 20 | 0, i37 = HEAP32[i36 >> 2] | 0, HEAP32[i36 >> 2] = i37 - i9, (i37 | 0) == (i9 | 0)) : 0) {
+ HEAP32[i6 + 16 >> 2] = HEAP32[i6 + 8 >> 2];
+ }
+ i2 = HEAP32[i8 >> 2] | 0;
+ if ((i2 | 0) > 0) {
+ HEAP32[i8 >> 2] = 0 - i2;
+ }
+ i37 = (HEAP32[i19 >> 2] | 0) == 0 | 0;
+ STACKTOP = i1;
+ return i37 | 0;
+ }
+ }
+ } while (0);
+ HEAP32[i2 + 24 >> 2] = HEAP32[3168 >> 2];
+ i37 = -2;
+ STACKTOP = i1;
+ return i37 | 0;
+}
+function _free(i7) {
+ i7 = i7 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0;
+ i1 = STACKTOP;
+ if ((i7 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = i7 + -8 | 0;
+ i16 = HEAP32[14488 >> 2] | 0;
+ if (i15 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i13 = HEAP32[i7 + -4 >> 2] | 0;
+ i12 = i13 & 3;
+ if ((i12 | 0) == 1) {
+ _abort();
+ }
+ i8 = i13 & -8;
+ i6 = i7 + (i8 + -8) | 0;
+ do {
+ if ((i13 & 1 | 0) == 0) {
+ i19 = HEAP32[i15 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i15 = -8 - i19 | 0;
+ i13 = i7 + i15 | 0;
+ i12 = i19 + i8 | 0;
+ if (i13 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((i13 | 0) == (HEAP32[14492 >> 2] | 0)) {
+ i2 = i7 + (i8 + -4) | 0;
+ if ((HEAP32[i2 >> 2] & 3 | 0) != 3) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ HEAP32[14480 >> 2] = i12;
+ HEAP32[i2 >> 2] = HEAP32[i2 >> 2] & -2;
+ HEAP32[i7 + (i15 + 4) >> 2] = i12 | 1;
+ HEAP32[i6 >> 2] = i12;
+ STACKTOP = i1;
+ return;
+ }
+ i18 = i19 >>> 3;
+ if (i19 >>> 0 < 256) {
+ i2 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ i11 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ i14 = 14512 + (i18 << 1 << 2) | 0;
+ if ((i2 | 0) != (i14 | 0)) {
+ if (i2 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i2 + 12 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ }
+ if ((i11 | 0) == (i2 | 0)) {
+ HEAP32[3618] = HEAP32[3618] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ if ((i11 | 0) != (i14 | 0)) {
+ if (i11 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i14 = i11 + 8 | 0;
+ if ((HEAP32[i14 >> 2] | 0) == (i13 | 0)) {
+ i17 = i14;
+ } else {
+ _abort();
+ }
+ } else {
+ i17 = i11 + 8 | 0;
+ }
+ HEAP32[i2 + 12 >> 2] = i11;
+ HEAP32[i17 >> 2] = i2;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ i17 = HEAP32[i7 + (i15 + 24) >> 2] | 0;
+ i18 = HEAP32[i7 + (i15 + 12) >> 2] | 0;
+ do {
+ if ((i18 | 0) == (i13 | 0)) {
+ i19 = i7 + (i15 + 20) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i19 = i7 + (i15 + 16) | 0;
+ i18 = HEAP32[i19 >> 2] | 0;
+ if ((i18 | 0) == 0) {
+ i14 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i21 = i18 + 20 | 0;
+ i20 = HEAP32[i21 >> 2] | 0;
+ if ((i20 | 0) != 0) {
+ i18 = i20;
+ i19 = i21;
+ continue;
+ }
+ i20 = i18 + 16 | 0;
+ i21 = HEAP32[i20 >> 2] | 0;
+ if ((i21 | 0) == 0) {
+ break;
+ } else {
+ i18 = i21;
+ i19 = i20;
+ }
+ }
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i19 >> 2] = 0;
+ i14 = i18;
+ break;
+ }
+ } else {
+ i19 = HEAP32[i7 + (i15 + 8) >> 2] | 0;
+ if (i19 >>> 0 < i16 >>> 0) {
+ _abort();
+ }
+ i16 = i19 + 12 | 0;
+ if ((HEAP32[i16 >> 2] | 0) != (i13 | 0)) {
+ _abort();
+ }
+ i20 = i18 + 8 | 0;
+ if ((HEAP32[i20 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i18;
+ HEAP32[i20 >> 2] = i19;
+ i14 = i18;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i17 | 0) != 0) {
+ i18 = HEAP32[i7 + (i15 + 28) >> 2] | 0;
+ i16 = 14776 + (i18 << 2) | 0;
+ if ((i13 | 0) == (HEAP32[i16 >> 2] | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ if ((i14 | 0) == 0) {
+ HEAP32[14476 >> 2] = HEAP32[14476 >> 2] & ~(1 << i18);
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ if (i17 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i16 = i17 + 16 | 0;
+ if ((HEAP32[i16 >> 2] | 0) == (i13 | 0)) {
+ HEAP32[i16 >> 2] = i14;
+ } else {
+ HEAP32[i17 + 20 >> 2] = i14;
+ }
+ if ((i14 | 0) == 0) {
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ }
+ if (i14 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i14 + 24 >> 2] = i17;
+ i16 = HEAP32[i7 + (i15 + 16) >> 2] | 0;
+ do {
+ if ((i16 | 0) != 0) {
+ if (i16 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 16 >> 2] = i16;
+ HEAP32[i16 + 24 >> 2] = i14;
+ break;
+ }
+ }
+ } while (0);
+ i15 = HEAP32[i7 + (i15 + 20) >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ if (i15 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i14 + 20 >> 2] = i15;
+ HEAP32[i15 + 24 >> 2] = i14;
+ i2 = i13;
+ i11 = i12;
+ break;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i13;
+ i11 = i12;
+ }
+ } else {
+ i2 = i15;
+ i11 = i8;
+ }
+ } while (0);
+ if (!(i2 >>> 0 < i6 >>> 0)) {
+ _abort();
+ }
+ i12 = i7 + (i8 + -4) | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 & 1 | 0) == 0) {
+ _abort();
+ }
+ if ((i13 & 2 | 0) == 0) {
+ if ((i6 | 0) == (HEAP32[14496 >> 2] | 0)) {
+ i21 = (HEAP32[14484 >> 2] | 0) + i11 | 0;
+ HEAP32[14484 >> 2] = i21;
+ HEAP32[14496 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ if ((i2 | 0) != (HEAP32[14492 >> 2] | 0)) {
+ STACKTOP = i1;
+ return;
+ }
+ HEAP32[14492 >> 2] = 0;
+ HEAP32[14480 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+ }
+ if ((i6 | 0) == (HEAP32[14492 >> 2] | 0)) {
+ i21 = (HEAP32[14480 >> 2] | 0) + i11 | 0;
+ HEAP32[14480 >> 2] = i21;
+ HEAP32[14492 >> 2] = i2;
+ HEAP32[i2 + 4 >> 2] = i21 | 1;
+ HEAP32[i2 + i21 >> 2] = i21;
+ STACKTOP = i1;
+ return;
+ }
+ i11 = (i13 & -8) + i11 | 0;
+ i12 = i13 >>> 3;
+ do {
+ if (!(i13 >>> 0 < 256)) {
+ i10 = HEAP32[i7 + (i8 + 16) >> 2] | 0;
+ i15 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ do {
+ if ((i15 | 0) == (i6 | 0)) {
+ i13 = i7 + (i8 + 12) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i13 = i7 + (i8 + 8) | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ if ((i12 | 0) == 0) {
+ i9 = 0;
+ break;
+ }
+ }
+ while (1) {
+ i14 = i12 + 20 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) != 0) {
+ i12 = i15;
+ i13 = i14;
+ continue;
+ }
+ i14 = i12 + 16 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ if ((i15 | 0) == 0) {
+ break;
+ } else {
+ i12 = i15;
+ i13 = i14;
+ }
+ }
+ if (i13 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i13 >> 2] = 0;
+ i9 = i12;
+ break;
+ }
+ } else {
+ i13 = HEAP32[i7 + i8 >> 2] | 0;
+ if (i13 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i14 = i13 + 12 | 0;
+ if ((HEAP32[i14 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ i12 = i15 + 8 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i14 >> 2] = i15;
+ HEAP32[i12 >> 2] = i13;
+ i9 = i15;
+ break;
+ } else {
+ _abort();
+ }
+ }
+ } while (0);
+ if ((i10 | 0) != 0) {
+ i12 = HEAP32[i7 + (i8 + 20) >> 2] | 0;
+ i13 = 14776 + (i12 << 2) | 0;
+ if ((i6 | 0) == (HEAP32[i13 >> 2] | 0)) {
+ HEAP32[i13 >> 2] = i9;
+ if ((i9 | 0) == 0) {
+ HEAP32[14476 >> 2] = HEAP32[14476 >> 2] & ~(1 << i12);
+ break;
+ }
+ } else {
+ if (i10 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i12 = i10 + 16 | 0;
+ if ((HEAP32[i12 >> 2] | 0) == (i6 | 0)) {
+ HEAP32[i12 >> 2] = i9;
+ } else {
+ HEAP32[i10 + 20 >> 2] = i9;
+ }
+ if ((i9 | 0) == 0) {
+ break;
+ }
+ }
+ if (i9 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ HEAP32[i9 + 24 >> 2] = i10;
+ i6 = HEAP32[i7 + (i8 + 8) >> 2] | 0;
+ do {
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 16 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ } while (0);
+ i6 = HEAP32[i7 + (i8 + 12) >> 2] | 0;
+ if ((i6 | 0) != 0) {
+ if (i6 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i9 + 20 >> 2] = i6;
+ HEAP32[i6 + 24 >> 2] = i9;
+ break;
+ }
+ }
+ }
+ } else {
+ i9 = HEAP32[i7 + i8 >> 2] | 0;
+ i7 = HEAP32[i7 + (i8 | 4) >> 2] | 0;
+ i8 = 14512 + (i12 << 1 << 2) | 0;
+ if ((i9 | 0) != (i8 | 0)) {
+ if (i9 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ if ((HEAP32[i9 + 12 >> 2] | 0) != (i6 | 0)) {
+ _abort();
+ }
+ }
+ if ((i7 | 0) == (i9 | 0)) {
+ HEAP32[3618] = HEAP32[3618] & ~(1 << i12);
+ break;
+ }
+ if ((i7 | 0) != (i8 | 0)) {
+ if (i7 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ }
+ i8 = i7 + 8 | 0;
+ if ((HEAP32[i8 >> 2] | 0) == (i6 | 0)) {
+ i10 = i8;
+ } else {
+ _abort();
+ }
+ } else {
+ i10 = i7 + 8 | 0;
+ }
+ HEAP32[i9 + 12 >> 2] = i7;
+ HEAP32[i10 >> 2] = i9;
+ }
+ } while (0);
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ if ((i2 | 0) == (HEAP32[14492 >> 2] | 0)) {
+ HEAP32[14480 >> 2] = i11;
+ STACKTOP = i1;
+ return;
+ }
+ } else {
+ HEAP32[i12 >> 2] = i13 & -2;
+ HEAP32[i2 + 4 >> 2] = i11 | 1;
+ HEAP32[i2 + i11 >> 2] = i11;
+ }
+ i6 = i11 >>> 3;
+ if (i11 >>> 0 < 256) {
+ i7 = i6 << 1;
+ i3 = 14512 + (i7 << 2) | 0;
+ i8 = HEAP32[3618] | 0;
+ i6 = 1 << i6;
+ if ((i8 & i6 | 0) != 0) {
+ i6 = 14512 + (i7 + 2 << 2) | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ if (i7 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ i4 = i6;
+ i5 = i7;
+ }
+ } else {
+ HEAP32[3618] = i8 | i6;
+ i4 = 14512 + (i7 + 2 << 2) | 0;
+ i5 = i3;
+ }
+ HEAP32[i4 >> 2] = i2;
+ HEAP32[i5 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i3;
+ STACKTOP = i1;
+ return;
+ }
+ i4 = i11 >>> 8;
+ if ((i4 | 0) != 0) {
+ if (i11 >>> 0 > 16777215) {
+ i4 = 31;
+ } else {
+ i20 = (i4 + 1048320 | 0) >>> 16 & 8;
+ i21 = i4 << i20;
+ i19 = (i21 + 520192 | 0) >>> 16 & 4;
+ i21 = i21 << i19;
+ i4 = (i21 + 245760 | 0) >>> 16 & 2;
+ i4 = 14 - (i19 | i20 | i4) + (i21 << i4 >>> 15) | 0;
+ i4 = i11 >>> (i4 + 7 | 0) & 1 | i4 << 1;
+ }
+ } else {
+ i4 = 0;
+ }
+ i5 = 14776 + (i4 << 2) | 0;
+ HEAP32[i2 + 28 >> 2] = i4;
+ HEAP32[i2 + 20 >> 2] = 0;
+ HEAP32[i2 + 16 >> 2] = 0;
+ i7 = HEAP32[14476 >> 2] | 0;
+ i6 = 1 << i4;
+ L199 : do {
+ if ((i7 & i6 | 0) != 0) {
+ i5 = HEAP32[i5 >> 2] | 0;
+ if ((i4 | 0) == 31) {
+ i4 = 0;
+ } else {
+ i4 = 25 - (i4 >>> 1) | 0;
+ }
+ L204 : do {
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) != (i11 | 0)) {
+ i4 = i11 << i4;
+ i7 = i5;
+ while (1) {
+ i6 = i7 + (i4 >>> 31 << 2) + 16 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ }
+ if ((HEAP32[i5 + 4 >> 2] & -8 | 0) == (i11 | 0)) {
+ i3 = i5;
+ break L204;
+ } else {
+ i4 = i4 << 1;
+ i7 = i5;
+ }
+ }
+ if (i6 >>> 0 < (HEAP32[14488 >> 2] | 0) >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i6 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i7;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ break L199;
+ }
+ } else {
+ i3 = i5;
+ }
+ } while (0);
+ i5 = i3 + 8 | 0;
+ i4 = HEAP32[i5 >> 2] | 0;
+ i6 = HEAP32[14488 >> 2] | 0;
+ if (i3 >>> 0 < i6 >>> 0) {
+ _abort();
+ }
+ if (i4 >>> 0 < i6 >>> 0) {
+ _abort();
+ } else {
+ HEAP32[i4 + 12 >> 2] = i2;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i4;
+ HEAP32[i2 + 12 >> 2] = i3;
+ HEAP32[i2 + 24 >> 2] = 0;
+ break;
+ }
+ } else {
+ HEAP32[14476 >> 2] = i7 | i6;
+ HEAP32[i5 >> 2] = i2;
+ HEAP32[i2 + 24 >> 2] = i5;
+ HEAP32[i2 + 12 >> 2] = i2;
+ HEAP32[i2 + 8 >> 2] = i2;
+ }
+ } while (0);
+ i21 = (HEAP32[14504 >> 2] | 0) + -1 | 0;
+ HEAP32[14504 >> 2] = i21;
+ if ((i21 | 0) == 0) {
+ i2 = 14928 | 0;
+ } else {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i2 = HEAP32[i2 >> 2] | 0;
+ if ((i2 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 8 | 0;
+ }
+ }
+ HEAP32[14504 >> 2] = -1;
+ STACKTOP = i1;
+ return;
+}
+function _build_tree(i4, i9) {
+ i4 = i4 | 0;
+ i9 = i9 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 32 | 0;
+ i1 = i2;
+ i3 = HEAP32[i9 >> 2] | 0;
+ i7 = i9 + 8 | 0;
+ i11 = HEAP32[i7 >> 2] | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ i11 = HEAP32[i11 + 12 >> 2] | 0;
+ i8 = i4 + 5200 | 0;
+ HEAP32[i8 >> 2] = 0;
+ i6 = i4 + 5204 | 0;
+ HEAP32[i6 >> 2] = 573;
+ if ((i11 | 0) > 0) {
+ i5 = -1;
+ i13 = 0;
+ do {
+ if ((HEAP16[i3 + (i13 << 2) >> 1] | 0) == 0) {
+ HEAP16[i3 + (i13 << 2) + 2 >> 1] = 0;
+ } else {
+ i5 = (HEAP32[i8 >> 2] | 0) + 1 | 0;
+ HEAP32[i8 >> 2] = i5;
+ HEAP32[i4 + (i5 << 2) + 2908 >> 2] = i13;
+ HEAP8[i4 + i13 + 5208 | 0] = 0;
+ i5 = i13;
+ }
+ i13 = i13 + 1 | 0;
+ } while ((i13 | 0) != (i11 | 0));
+ i14 = HEAP32[i8 >> 2] | 0;
+ if ((i14 | 0) < 2) {
+ i10 = 3;
+ }
+ } else {
+ i14 = 0;
+ i5 = -1;
+ i10 = 3;
+ }
+ if ((i10 | 0) == 3) {
+ i10 = i4 + 5800 | 0;
+ i13 = i4 + 5804 | 0;
+ if ((i12 | 0) == 0) {
+ do {
+ i12 = (i5 | 0) < 2;
+ i13 = i5 + 1 | 0;
+ i5 = i12 ? i13 : i5;
+ i23 = i12 ? i13 : 0;
+ i14 = i14 + 1 | 0;
+ HEAP32[i8 >> 2] = i14;
+ HEAP32[i4 + (i14 << 2) + 2908 >> 2] = i23;
+ HEAP16[i3 + (i23 << 2) >> 1] = 1;
+ HEAP8[i4 + i23 + 5208 | 0] = 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
+ i14 = HEAP32[i8 >> 2] | 0;
+ } while ((i14 | 0) < 2);
+ } else {
+ do {
+ i15 = (i5 | 0) < 2;
+ i16 = i5 + 1 | 0;
+ i5 = i15 ? i16 : i5;
+ i23 = i15 ? i16 : 0;
+ i14 = i14 + 1 | 0;
+ HEAP32[i8 >> 2] = i14;
+ HEAP32[i4 + (i14 << 2) + 2908 >> 2] = i23;
+ HEAP16[i3 + (i23 << 2) >> 1] = 1;
+ HEAP8[i4 + i23 + 5208 | 0] = 0;
+ HEAP32[i10 >> 2] = (HEAP32[i10 >> 2] | 0) + -1;
+ HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) - (HEAPU16[i12 + (i23 << 2) + 2 >> 1] | 0);
+ i14 = HEAP32[i8 >> 2] | 0;
+ } while ((i14 | 0) < 2);
+ }
+ }
+ i10 = i9 + 4 | 0;
+ HEAP32[i10 >> 2] = i5;
+ i12 = HEAP32[i8 >> 2] | 0;
+ if ((i12 | 0) > 1) {
+ i18 = i12;
+ i13 = (i12 | 0) / 2 | 0;
+ do {
+ i12 = HEAP32[i4 + (i13 << 2) + 2908 >> 2] | 0;
+ i14 = i4 + i12 + 5208 | 0;
+ i17 = i13 << 1;
+ L21 : do {
+ if ((i17 | 0) > (i18 | 0)) {
+ i15 = i13;
+ } else {
+ i16 = i3 + (i12 << 2) | 0;
+ i15 = i13;
+ while (1) {
+ do {
+ if ((i17 | 0) < (i18 | 0)) {
+ i18 = i17 | 1;
+ i19 = HEAP32[i4 + (i18 << 2) + 2908 >> 2] | 0;
+ i22 = HEAP16[i3 + (i19 << 2) >> 1] | 0;
+ i20 = HEAP32[i4 + (i17 << 2) + 2908 >> 2] | 0;
+ i21 = HEAP16[i3 + (i20 << 2) >> 1] | 0;
+ if (!((i22 & 65535) < (i21 & 65535))) {
+ if (!(i22 << 16 >> 16 == i21 << 16 >> 16)) {
+ break;
+ }
+ if ((HEAPU8[i4 + i19 + 5208 | 0] | 0) > (HEAPU8[i4 + i20 + 5208 | 0] | 0)) {
+ break;
+ }
+ }
+ i17 = i18;
+ }
+ } while (0);
+ i19 = HEAP16[i16 >> 1] | 0;
+ i18 = HEAP32[i4 + (i17 << 2) + 2908 >> 2] | 0;
+ i20 = HEAP16[i3 + (i18 << 2) >> 1] | 0;
+ if ((i19 & 65535) < (i20 & 65535)) {
+ break L21;
+ }
+ if (i19 << 16 >> 16 == i20 << 16 >> 16 ? (HEAPU8[i14] | 0) <= (HEAPU8[i4 + i18 + 5208 | 0] | 0) : 0) {
+ break L21;
+ }
+ HEAP32[i4 + (i15 << 2) + 2908 >> 2] = i18;
+ i19 = i17 << 1;
+ i18 = HEAP32[i8 >> 2] | 0;
+ if ((i19 | 0) > (i18 | 0)) {
+ i15 = i17;
+ break;
+ } else {
+ i15 = i17;
+ i17 = i19;
+ }
+ }
+ }
+ } while (0);
+ HEAP32[i4 + (i15 << 2) + 2908 >> 2] = i12;
+ i13 = i13 + -1 | 0;
+ i18 = HEAP32[i8 >> 2] | 0;
+ } while ((i13 | 0) > 0);
+ } else {
+ i18 = i12;
+ }
+ i12 = i4 + 2912 | 0;
+ while (1) {
+ i13 = HEAP32[i12 >> 2] | 0;
+ i20 = i18 + -1 | 0;
+ HEAP32[i8 >> 2] = i20;
+ i14 = HEAP32[i4 + (i18 << 2) + 2908 >> 2] | 0;
+ HEAP32[i12 >> 2] = i14;
+ i15 = i4 + i14 + 5208 | 0;
+ L40 : do {
+ if ((i18 | 0) < 3) {
+ i17 = 1;
+ } else {
+ i16 = i3 + (i14 << 2) | 0;
+ i17 = 1;
+ i18 = 2;
+ while (1) {
+ do {
+ if ((i18 | 0) < (i20 | 0)) {
+ i22 = i18 | 1;
+ i21 = HEAP32[i4 + (i22 << 2) + 2908 >> 2] | 0;
+ i23 = HEAP16[i3 + (i21 << 2) >> 1] | 0;
+ i20 = HEAP32[i4 + (i18 << 2) + 2908 >> 2] | 0;
+ i19 = HEAP16[i3 + (i20 << 2) >> 1] | 0;
+ if (!((i23 & 65535) < (i19 & 65535))) {
+ if (!(i23 << 16 >> 16 == i19 << 16 >> 16)) {
+ break;
+ }
+ if ((HEAPU8[i4 + i21 + 5208 | 0] | 0) > (HEAPU8[i4 + i20 + 5208 | 0] | 0)) {
+ break;
+ }
+ }
+ i18 = i22;
+ }
+ } while (0);
+ i21 = HEAP16[i16 >> 1] | 0;
+ i20 = HEAP32[i4 + (i18 << 2) + 2908 >> 2] | 0;
+ i19 = HEAP16[i3 + (i20 << 2) >> 1] | 0;
+ if ((i21 & 65535) < (i19 & 65535)) {
+ break L40;
+ }
+ if (i21 << 16 >> 16 == i19 << 16 >> 16 ? (HEAPU8[i15] | 0) <= (HEAPU8[i4 + i20 + 5208 | 0] | 0) : 0) {
+ break L40;
+ }
+ HEAP32[i4 + (i17 << 2) + 2908 >> 2] = i20;
+ i19 = i18 << 1;
+ i20 = HEAP32[i8 >> 2] | 0;
+ if ((i19 | 0) > (i20 | 0)) {
+ i17 = i18;
+ break;
+ } else {
+ i17 = i18;
+ i18 = i19;
+ }
+ }
+ }
+ } while (0);
+ HEAP32[i4 + (i17 << 2) + 2908 >> 2] = i14;
+ i17 = HEAP32[i12 >> 2] | 0;
+ i14 = (HEAP32[i6 >> 2] | 0) + -1 | 0;
+ HEAP32[i6 >> 2] = i14;
+ HEAP32[i4 + (i14 << 2) + 2908 >> 2] = i13;
+ i14 = (HEAP32[i6 >> 2] | 0) + -1 | 0;
+ HEAP32[i6 >> 2] = i14;
+ HEAP32[i4 + (i14 << 2) + 2908 >> 2] = i17;
+ i14 = i3 + (i11 << 2) | 0;
+ HEAP16[i14 >> 1] = (HEAPU16[i3 + (i17 << 2) >> 1] | 0) + (HEAPU16[i3 + (i13 << 2) >> 1] | 0);
+ i18 = HEAP8[i4 + i13 + 5208 | 0] | 0;
+ i16 = HEAP8[i4 + i17 + 5208 | 0] | 0;
+ i15 = i4 + i11 + 5208 | 0;
+ HEAP8[i15] = (((i18 & 255) < (i16 & 255) ? i16 : i18) & 255) + 1;
+ i19 = i11 & 65535;
+ HEAP16[i3 + (i17 << 2) + 2 >> 1] = i19;
+ HEAP16[i3 + (i13 << 2) + 2 >> 1] = i19;
+ i13 = i11 + 1 | 0;
+ HEAP32[i12 >> 2] = i11;
+ i19 = HEAP32[i8 >> 2] | 0;
+ L56 : do {
+ if ((i19 | 0) < 2) {
+ i16 = 1;
+ } else {
+ i16 = 1;
+ i17 = 2;
+ while (1) {
+ do {
+ if ((i17 | 0) < (i19 | 0)) {
+ i21 = i17 | 1;
+ i22 = HEAP32[i4 + (i21 << 2) + 2908 >> 2] | 0;
+ i19 = HEAP16[i3 + (i22 << 2) >> 1] | 0;
+ i18 = HEAP32[i4 + (i17 << 2) + 2908 >> 2] | 0;
+ i20 = HEAP16[i3 + (i18 << 2) >> 1] | 0;
+ if (!((i19 & 65535) < (i20 & 65535))) {
+ if (!(i19 << 16 >> 16 == i20 << 16 >> 16)) {
+ break;
+ }
+ if ((HEAPU8[i4 + i22 + 5208 | 0] | 0) > (HEAPU8[i4 + i18 + 5208 | 0] | 0)) {
+ break;
+ }
+ }
+ i17 = i21;
+ }
+ } while (0);
+ i19 = HEAP16[i14 >> 1] | 0;
+ i20 = HEAP32[i4 + (i17 << 2) + 2908 >> 2] | 0;
+ i18 = HEAP16[i3 + (i20 << 2) >> 1] | 0;
+ if ((i19 & 65535) < (i18 & 65535)) {
+ break L56;
+ }
+ if (i19 << 16 >> 16 == i18 << 16 >> 16 ? (HEAPU8[i15] | 0) <= (HEAPU8[i4 + i20 + 5208 | 0] | 0) : 0) {
+ break L56;
+ }
+ HEAP32[i4 + (i16 << 2) + 2908 >> 2] = i20;
+ i18 = i17 << 1;
+ i19 = HEAP32[i8 >> 2] | 0;
+ if ((i18 | 0) > (i19 | 0)) {
+ i16 = i17;
+ break;
+ } else {
+ i16 = i17;
+ i17 = i18;
+ }
+ }
+ }
+ } while (0);
+ HEAP32[i4 + (i16 << 2) + 2908 >> 2] = i11;
+ i18 = HEAP32[i8 >> 2] | 0;
+ if ((i18 | 0) > 1) {
+ i11 = i13;
+ } else {
+ break;
+ }
+ }
+ i12 = HEAP32[i12 >> 2] | 0;
+ i8 = (HEAP32[i6 >> 2] | 0) + -1 | 0;
+ HEAP32[i6 >> 2] = i8;
+ HEAP32[i4 + (i8 << 2) + 2908 >> 2] = i12;
+ i8 = HEAP32[i9 >> 2] | 0;
+ i9 = HEAP32[i10 >> 2] | 0;
+ i7 = HEAP32[i7 >> 2] | 0;
+ i12 = HEAP32[i7 >> 2] | 0;
+ i11 = HEAP32[i7 + 4 >> 2] | 0;
+ i10 = HEAP32[i7 + 8 >> 2] | 0;
+ i7 = HEAP32[i7 + 16 >> 2] | 0;
+ i13 = i4 + 2876 | 0;
+ i14 = i13 + 32 | 0;
+ do {
+ HEAP16[i13 >> 1] = 0;
+ i13 = i13 + 2 | 0;
+ } while ((i13 | 0) < (i14 | 0));
+ i14 = HEAP32[i6 >> 2] | 0;
+ HEAP16[i8 + (HEAP32[i4 + (i14 << 2) + 2908 >> 2] << 2) + 2 >> 1] = 0;
+ i14 = i14 + 1 | 0;
+ L72 : do {
+ if ((i14 | 0) < 573) {
+ i6 = i4 + 5800 | 0;
+ i13 = i4 + 5804 | 0;
+ if ((i12 | 0) == 0) {
+ i18 = 0;
+ do {
+ i12 = HEAP32[i4 + (i14 << 2) + 2908 >> 2] | 0;
+ i13 = i8 + (i12 << 2) + 2 | 0;
+ i15 = HEAPU16[i8 + (HEAPU16[i13 >> 1] << 2) + 2 >> 1] | 0;
+ i16 = (i15 | 0) < (i7 | 0);
+ i15 = i16 ? i15 + 1 | 0 : i7;
+ i18 = (i16 & 1 ^ 1) + i18 | 0;
+ HEAP16[i13 >> 1] = i15;
+ if ((i12 | 0) <= (i9 | 0)) {
+ i23 = i4 + (i15 << 1) + 2876 | 0;
+ HEAP16[i23 >> 1] = (HEAP16[i23 >> 1] | 0) + 1 << 16 >> 16;
+ if ((i12 | 0) < (i10 | 0)) {
+ i13 = 0;
+ } else {
+ i13 = HEAP32[i11 + (i12 - i10 << 2) >> 2] | 0;
+ }
+ i23 = Math_imul(HEAPU16[i8 + (i12 << 2) >> 1] | 0, i13 + i15 | 0) | 0;
+ HEAP32[i6 >> 2] = i23 + (HEAP32[i6 >> 2] | 0);
+ }
+ i14 = i14 + 1 | 0;
+ } while ((i14 | 0) != 573);
+ } else {
+ i18 = 0;
+ do {
+ i15 = HEAP32[i4 + (i14 << 2) + 2908 >> 2] | 0;
+ i16 = i8 + (i15 << 2) + 2 | 0;
+ i17 = HEAPU16[i8 + (HEAPU16[i16 >> 1] << 2) + 2 >> 1] | 0;
+ i19 = (i17 | 0) < (i7 | 0);
+ i17 = i19 ? i17 + 1 | 0 : i7;
+ i18 = (i19 & 1 ^ 1) + i18 | 0;
+ HEAP16[i16 >> 1] = i17;
+ if ((i15 | 0) <= (i9 | 0)) {
+ i23 = i4 + (i17 << 1) + 2876 | 0;
+ HEAP16[i23 >> 1] = (HEAP16[i23 >> 1] | 0) + 1 << 16 >> 16;
+ if ((i15 | 0) < (i10 | 0)) {
+ i16 = 0;
+ } else {
+ i16 = HEAP32[i11 + (i15 - i10 << 2) >> 2] | 0;
+ }
+ i23 = HEAPU16[i8 + (i15 << 2) >> 1] | 0;
+ i22 = Math_imul(i23, i16 + i17 | 0) | 0;
+ HEAP32[i6 >> 2] = i22 + (HEAP32[i6 >> 2] | 0);
+ i23 = Math_imul((HEAPU16[i12 + (i15 << 2) + 2 >> 1] | 0) + i16 | 0, i23) | 0;
+ HEAP32[i13 >> 2] = i23 + (HEAP32[i13 >> 2] | 0);
+ }
+ i14 = i14 + 1 | 0;
+ } while ((i14 | 0) != 573);
+ }
+ if ((i18 | 0) != 0) {
+ i10 = i4 + (i7 << 1) + 2876 | 0;
+ do {
+ i12 = i7;
+ while (1) {
+ i11 = i12 + -1 | 0;
+ i13 = i4 + (i11 << 1) + 2876 | 0;
+ i14 = HEAP16[i13 >> 1] | 0;
+ if (i14 << 16 >> 16 == 0) {
+ i12 = i11;
+ } else {
+ break;
+ }
+ }
+ HEAP16[i13 >> 1] = i14 + -1 << 16 >> 16;
+ i11 = i4 + (i12 << 1) + 2876 | 0;
+ HEAP16[i11 >> 1] = (HEAPU16[i11 >> 1] | 0) + 2;
+ i11 = (HEAP16[i10 >> 1] | 0) + -1 << 16 >> 16;
+ HEAP16[i10 >> 1] = i11;
+ i18 = i18 + -2 | 0;
+ } while ((i18 | 0) > 0);
+ if ((i7 | 0) != 0) {
+ i12 = 573;
+ while (1) {
+ i10 = i7 & 65535;
+ if (!(i11 << 16 >> 16 == 0)) {
+ i11 = i11 & 65535;
+ do {
+ do {
+ i12 = i12 + -1 | 0;
+ i15 = HEAP32[i4 + (i12 << 2) + 2908 >> 2] | 0;
+ } while ((i15 | 0) > (i9 | 0));
+ i13 = i8 + (i15 << 2) + 2 | 0;
+ i14 = HEAPU16[i13 >> 1] | 0;
+ if ((i14 | 0) != (i7 | 0)) {
+ i23 = Math_imul(HEAPU16[i8 + (i15 << 2) >> 1] | 0, i7 - i14 | 0) | 0;
+ HEAP32[i6 >> 2] = i23 + (HEAP32[i6 >> 2] | 0);
+ HEAP16[i13 >> 1] = i10;
+ }
+ i11 = i11 + -1 | 0;
+ } while ((i11 | 0) != 0);
+ }
+ i7 = i7 + -1 | 0;
+ if ((i7 | 0) == 0) {
+ break L72;
+ }
+ i11 = HEAP16[i4 + (i7 << 1) + 2876 >> 1] | 0;
+ }
+ }
+ }
+ }
+ } while (0);
+ i7 = 1;
+ i6 = 0;
+ do {
+ i6 = (HEAPU16[i4 + (i7 + -1 << 1) + 2876 >> 1] | 0) + (i6 & 65534) << 1;
+ HEAP16[i1 + (i7 << 1) >> 1] = i6;
+ i7 = i7 + 1 | 0;
+ } while ((i7 | 0) != 16);
+ if ((i5 | 0) < 0) {
+ STACKTOP = i2;
+ return;
+ } else {
+ i4 = 0;
+ }
+ while (1) {
+ i23 = HEAP16[i3 + (i4 << 2) + 2 >> 1] | 0;
+ i7 = i23 & 65535;
+ if (!(i23 << 16 >> 16 == 0)) {
+ i8 = i1 + (i7 << 1) | 0;
+ i6 = HEAP16[i8 >> 1] | 0;
+ HEAP16[i8 >> 1] = i6 + 1 << 16 >> 16;
+ i6 = i6 & 65535;
+ i8 = 0;
+ while (1) {
+ i8 = i8 | i6 & 1;
+ i7 = i7 + -1 | 0;
+ if ((i7 | 0) <= 0) {
+ break;
+ } else {
+ i6 = i6 >>> 1;
+ i8 = i8 << 1;
+ }
+ }
+ HEAP16[i3 + (i4 << 2) >> 1] = i8;
+ }
+ if ((i4 | 0) == (i5 | 0)) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ STACKTOP = i2;
+ return;
+}
+function _deflate_slow(i2, i6) {
+ i2 = i2 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0;
+ i1 = STACKTOP;
+ i15 = i2 + 116 | 0;
+ i16 = (i6 | 0) == 0;
+ i17 = i2 + 72 | 0;
+ i18 = i2 + 88 | 0;
+ i5 = i2 + 108 | 0;
+ i7 = i2 + 56 | 0;
+ i19 = i2 + 84 | 0;
+ i20 = i2 + 68 | 0;
+ i22 = i2 + 52 | 0;
+ i21 = i2 + 64 | 0;
+ i9 = i2 + 96 | 0;
+ i10 = i2 + 120 | 0;
+ i11 = i2 + 112 | 0;
+ i12 = i2 + 100 | 0;
+ i26 = i2 + 5792 | 0;
+ i27 = i2 + 5796 | 0;
+ i29 = i2 + 5784 | 0;
+ i23 = i2 + 5788 | 0;
+ i8 = i2 + 104 | 0;
+ i4 = i2 + 92 | 0;
+ i24 = i2 + 128 | 0;
+ i14 = i2 + 44 | 0;
+ i13 = i2 + 136 | 0;
+ L1 : while (1) {
+ i30 = HEAP32[i15 >> 2] | 0;
+ while (1) {
+ if (i30 >>> 0 < 262) {
+ _fill_window(i2);
+ i30 = HEAP32[i15 >> 2] | 0;
+ if (i30 >>> 0 < 262 & i16) {
+ i2 = 0;
+ i30 = 50;
+ break L1;
+ }
+ if ((i30 | 0) == 0) {
+ i30 = 40;
+ break L1;
+ }
+ if (!(i30 >>> 0 > 2)) {
+ HEAP32[i10 >> 2] = HEAP32[i9 >> 2];
+ HEAP32[i12 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i9 >> 2] = 2;
+ i32 = 2;
+ i30 = 16;
+ } else {
+ i30 = 8;
+ }
+ } else {
+ i30 = 8;
+ }
+ do {
+ if ((i30 | 0) == 8) {
+ i30 = 0;
+ i34 = HEAP32[i5 >> 2] | 0;
+ i31 = ((HEAPU8[(HEAP32[i7 >> 2] | 0) + (i34 + 2) | 0] | 0) ^ HEAP32[i17 >> 2] << HEAP32[i18 >> 2]) & HEAP32[i19 >> 2];
+ HEAP32[i17 >> 2] = i31;
+ i31 = (HEAP32[i20 >> 2] | 0) + (i31 << 1) | 0;
+ i35 = HEAP16[i31 >> 1] | 0;
+ HEAP16[(HEAP32[i21 >> 2] | 0) + ((HEAP32[i22 >> 2] & i34) << 1) >> 1] = i35;
+ i32 = i35 & 65535;
+ HEAP16[i31 >> 1] = i34;
+ i31 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i10 >> 2] = i31;
+ HEAP32[i12 >> 2] = HEAP32[i11 >> 2];
+ HEAP32[i9 >> 2] = 2;
+ if (!(i35 << 16 >> 16 == 0)) {
+ if (i31 >>> 0 < (HEAP32[i24 >> 2] | 0) >>> 0) {
+ if (!(((HEAP32[i5 >> 2] | 0) - i32 | 0) >>> 0 > ((HEAP32[i14 >> 2] | 0) + -262 | 0) >>> 0)) {
+ i32 = _longest_match(i2, i32) | 0;
+ HEAP32[i9 >> 2] = i32;
+ if (i32 >>> 0 < 6) {
+ if ((HEAP32[i13 >> 2] | 0) != 1) {
+ if ((i32 | 0) != 3) {
+ i30 = 16;
+ break;
+ }
+ if (!(((HEAP32[i5 >> 2] | 0) - (HEAP32[i11 >> 2] | 0) | 0) >>> 0 > 4096)) {
+ i32 = 3;
+ i30 = 16;
+ break;
+ }
+ }
+ HEAP32[i9 >> 2] = 2;
+ i32 = 2;
+ i30 = 16;
+ } else {
+ i30 = 16;
+ }
+ } else {
+ i32 = 2;
+ i30 = 16;
+ }
+ } else {
+ i32 = 2;
+ }
+ } else {
+ i32 = 2;
+ i30 = 16;
+ }
+ }
+ } while (0);
+ if ((i30 | 0) == 16) {
+ i31 = HEAP32[i10 >> 2] | 0;
+ }
+ if (!(i31 >>> 0 < 3 | i32 >>> 0 > i31 >>> 0)) {
+ break;
+ }
+ if ((HEAP32[i8 >> 2] | 0) == 0) {
+ HEAP32[i8 >> 2] = 1;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ i30 = (HEAP32[i15 >> 2] | 0) + -1 | 0;
+ HEAP32[i15 >> 2] = i30;
+ continue;
+ }
+ i35 = HEAP8[(HEAP32[i7 >> 2] | 0) + ((HEAP32[i5 >> 2] | 0) + -1) | 0] | 0;
+ i34 = HEAP32[i26 >> 2] | 0;
+ HEAP16[(HEAP32[i27 >> 2] | 0) + (i34 << 1) >> 1] = 0;
+ HEAP32[i26 >> 2] = i34 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i34 | 0] = i35;
+ i35 = i2 + ((i35 & 255) << 2) + 148 | 0;
+ HEAP16[i35 >> 1] = (HEAP16[i35 >> 1] | 0) + 1 << 16 >> 16;
+ if ((HEAP32[i26 >> 2] | 0) == ((HEAP32[i23 >> 2] | 0) + -1 | 0)) {
+ i30 = HEAP32[i4 >> 2] | 0;
+ if ((i30 | 0) > -1) {
+ i31 = (HEAP32[i7 >> 2] | 0) + i30 | 0;
+ } else {
+ i31 = 0;
+ }
+ __tr_flush_block(i2, i31, (HEAP32[i5 >> 2] | 0) - i30 | 0, 0);
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i33 = HEAP32[i2 >> 2] | 0;
+ i32 = i33 + 28 | 0;
+ i30 = HEAP32[i32 >> 2] | 0;
+ i35 = HEAP32[i30 + 20 >> 2] | 0;
+ i31 = i33 + 16 | 0;
+ i34 = HEAP32[i31 >> 2] | 0;
+ i34 = i35 >>> 0 > i34 >>> 0 ? i34 : i35;
+ if ((i34 | 0) != 0 ? (i28 = i33 + 12 | 0, _memcpy(HEAP32[i28 >> 2] | 0, HEAP32[i30 + 16 >> 2] | 0, i34 | 0) | 0, HEAP32[i28 >> 2] = (HEAP32[i28 >> 2] | 0) + i34, i28 = (HEAP32[i32 >> 2] | 0) + 16 | 0, HEAP32[i28 >> 2] = (HEAP32[i28 >> 2] | 0) + i34, i28 = i33 + 20 | 0, HEAP32[i28 >> 2] = (HEAP32[i28 >> 2] | 0) + i34, HEAP32[i31 >> 2] = (HEAP32[i31 >> 2] | 0) - i34, i28 = HEAP32[i32 >> 2] | 0, i33 = i28 + 20 | 0, i35 = HEAP32[i33 >> 2] | 0, HEAP32[i33 >> 2] = i35 - i34, (i35 | 0) == (i34 | 0)) : 0) {
+ HEAP32[i28 + 16 >> 2] = HEAP32[i28 + 8 >> 2];
+ }
+ }
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + 1;
+ i30 = (HEAP32[i15 >> 2] | 0) + -1 | 0;
+ HEAP32[i15 >> 2] = i30;
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i2 = 0;
+ i30 = 50;
+ break L1;
+ }
+ }
+ i34 = HEAP32[i5 >> 2] | 0;
+ i30 = i34 + -3 + (HEAP32[i15 >> 2] | 0) | 0;
+ i35 = i31 + 253 | 0;
+ i31 = i34 + 65535 - (HEAP32[i12 >> 2] | 0) | 0;
+ i34 = HEAP32[i26 >> 2] | 0;
+ HEAP16[(HEAP32[i27 >> 2] | 0) + (i34 << 1) >> 1] = i31;
+ HEAP32[i26 >> 2] = i34 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i34 | 0] = i35;
+ i35 = i2 + ((HEAPU8[808 + (i35 & 255) | 0] | 0 | 256) + 1 << 2) + 148 | 0;
+ HEAP16[i35 >> 1] = (HEAP16[i35 >> 1] | 0) + 1 << 16 >> 16;
+ i31 = i31 + 65535 & 65535;
+ if (!(i31 >>> 0 < 256)) {
+ i31 = (i31 >>> 7) + 256 | 0;
+ }
+ i32 = i2 + ((HEAPU8[296 + i31 | 0] | 0) << 2) + 2440 | 0;
+ HEAP16[i32 >> 1] = (HEAP16[i32 >> 1] | 0) + 1 << 16 >> 16;
+ i32 = HEAP32[i26 >> 2] | 0;
+ i31 = (HEAP32[i23 >> 2] | 0) + -1 | 0;
+ i34 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i15 >> 2] = 1 - i34 + (HEAP32[i15 >> 2] | 0);
+ i34 = i34 + -2 | 0;
+ HEAP32[i10 >> 2] = i34;
+ i33 = HEAP32[i5 >> 2] | 0;
+ while (1) {
+ i35 = i33 + 1 | 0;
+ HEAP32[i5 >> 2] = i35;
+ if (!(i35 >>> 0 > i30 >>> 0)) {
+ i36 = ((HEAPU8[(HEAP32[i7 >> 2] | 0) + (i33 + 3) | 0] | 0) ^ HEAP32[i17 >> 2] << HEAP32[i18 >> 2]) & HEAP32[i19 >> 2];
+ HEAP32[i17 >> 2] = i36;
+ i36 = (HEAP32[i20 >> 2] | 0) + (i36 << 1) | 0;
+ HEAP16[(HEAP32[i21 >> 2] | 0) + ((HEAP32[i22 >> 2] & i35) << 1) >> 1] = HEAP16[i36 >> 1] | 0;
+ HEAP16[i36 >> 1] = i35;
+ }
+ i34 = i34 + -1 | 0;
+ HEAP32[i10 >> 2] = i34;
+ if ((i34 | 0) == 0) {
+ break;
+ } else {
+ i33 = i35;
+ }
+ }
+ HEAP32[i8 >> 2] = 0;
+ HEAP32[i9 >> 2] = 2;
+ i30 = i33 + 2 | 0;
+ HEAP32[i5 >> 2] = i30;
+ if ((i32 | 0) != (i31 | 0)) {
+ continue;
+ }
+ i32 = HEAP32[i4 >> 2] | 0;
+ if ((i32 | 0) > -1) {
+ i31 = (HEAP32[i7 >> 2] | 0) + i32 | 0;
+ } else {
+ i31 = 0;
+ }
+ __tr_flush_block(i2, i31, i30 - i32 | 0, 0);
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i33 = HEAP32[i2 >> 2] | 0;
+ i31 = i33 + 28 | 0;
+ i32 = HEAP32[i31 >> 2] | 0;
+ i35 = HEAP32[i32 + 20 >> 2] | 0;
+ i30 = i33 + 16 | 0;
+ i34 = HEAP32[i30 >> 2] | 0;
+ i34 = i35 >>> 0 > i34 >>> 0 ? i34 : i35;
+ if ((i34 | 0) != 0 ? (i25 = i33 + 12 | 0, _memcpy(HEAP32[i25 >> 2] | 0, HEAP32[i32 + 16 >> 2] | 0, i34 | 0) | 0, HEAP32[i25 >> 2] = (HEAP32[i25 >> 2] | 0) + i34, i25 = (HEAP32[i31 >> 2] | 0) + 16 | 0, HEAP32[i25 >> 2] = (HEAP32[i25 >> 2] | 0) + i34, i25 = i33 + 20 | 0, HEAP32[i25 >> 2] = (HEAP32[i25 >> 2] | 0) + i34, HEAP32[i30 >> 2] = (HEAP32[i30 >> 2] | 0) - i34, i25 = HEAP32[i31 >> 2] | 0, i35 = i25 + 20 | 0, i36 = HEAP32[i35 >> 2] | 0, HEAP32[i35 >> 2] = i36 - i34, (i36 | 0) == (i34 | 0)) : 0) {
+ HEAP32[i25 + 16 >> 2] = HEAP32[i25 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i2 = 0;
+ i30 = 50;
+ break;
+ }
+ }
+ if ((i30 | 0) == 40) {
+ if ((HEAP32[i8 >> 2] | 0) != 0) {
+ i36 = HEAP8[(HEAP32[i7 >> 2] | 0) + ((HEAP32[i5 >> 2] | 0) + -1) | 0] | 0;
+ i35 = HEAP32[i26 >> 2] | 0;
+ HEAP16[(HEAP32[i27 >> 2] | 0) + (i35 << 1) >> 1] = 0;
+ HEAP32[i26 >> 2] = i35 + 1;
+ HEAP8[(HEAP32[i29 >> 2] | 0) + i35 | 0] = i36;
+ i36 = i2 + ((i36 & 255) << 2) + 148 | 0;
+ HEAP16[i36 >> 1] = (HEAP16[i36 >> 1] | 0) + 1 << 16 >> 16;
+ HEAP32[i8 >> 2] = 0;
+ }
+ i8 = HEAP32[i4 >> 2] | 0;
+ if ((i8 | 0) > -1) {
+ i7 = (HEAP32[i7 >> 2] | 0) + i8 | 0;
+ } else {
+ i7 = 0;
+ }
+ i6 = (i6 | 0) == 4;
+ __tr_flush_block(i2, i7, (HEAP32[i5 >> 2] | 0) - i8 | 0, i6 & 1);
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i4 = HEAP32[i2 >> 2] | 0;
+ i7 = i4 + 28 | 0;
+ i5 = HEAP32[i7 >> 2] | 0;
+ i10 = HEAP32[i5 + 20 >> 2] | 0;
+ i8 = i4 + 16 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ i9 = i10 >>> 0 > i9 >>> 0 ? i9 : i10;
+ if ((i9 | 0) != 0 ? (i3 = i4 + 12 | 0, _memcpy(HEAP32[i3 >> 2] | 0, HEAP32[i5 + 16 >> 2] | 0, i9 | 0) | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, i3 = (HEAP32[i7 >> 2] | 0) + 16 | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, i3 = i4 + 20 | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) - i9, i3 = HEAP32[i7 >> 2] | 0, i35 = i3 + 20 | 0, i36 = HEAP32[i35 >> 2] | 0, HEAP32[i35 >> 2] = i36 - i9, (i36 | 0) == (i9 | 0)) : 0) {
+ HEAP32[i3 + 16 >> 2] = HEAP32[i3 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i36 = i6 ? 2 : 0;
+ STACKTOP = i1;
+ return i36 | 0;
+ } else {
+ i36 = i6 ? 3 : 1;
+ STACKTOP = i1;
+ return i36 | 0;
+ }
+ } else if ((i30 | 0) == 50) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ return 0;
+}
+function _inflate_fast(i7, i19) {
+ i7 = i7 | 0;
+ i19 = i19 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0, i37 = 0;
+ i1 = STACKTOP;
+ i11 = HEAP32[i7 + 28 >> 2] | 0;
+ i29 = HEAP32[i7 >> 2] | 0;
+ i5 = i7 + 4 | 0;
+ i8 = i29 + ((HEAP32[i5 >> 2] | 0) + -6) | 0;
+ i9 = i7 + 12 | 0;
+ i28 = HEAP32[i9 >> 2] | 0;
+ i4 = i7 + 16 | 0;
+ i25 = HEAP32[i4 >> 2] | 0;
+ i6 = i28 + (i25 + -258) | 0;
+ i17 = HEAP32[i11 + 44 >> 2] | 0;
+ i12 = HEAP32[i11 + 48 >> 2] | 0;
+ i18 = HEAP32[i11 + 52 >> 2] | 0;
+ i3 = i11 + 56 | 0;
+ i2 = i11 + 60 | 0;
+ i16 = HEAP32[i11 + 76 >> 2] | 0;
+ i13 = HEAP32[i11 + 80 >> 2] | 0;
+ i14 = (1 << HEAP32[i11 + 84 >> 2]) + -1 | 0;
+ i15 = (1 << HEAP32[i11 + 88 >> 2]) + -1 | 0;
+ i19 = i28 + (i25 + ~i19) | 0;
+ i25 = i11 + 7104 | 0;
+ i20 = i18 + -1 | 0;
+ i27 = (i12 | 0) == 0;
+ i24 = (HEAP32[i11 + 40 >> 2] | 0) + -1 | 0;
+ i21 = i24 + i12 | 0;
+ i22 = i12 + -1 | 0;
+ i23 = i19 + -1 | 0;
+ i26 = i19 - i12 | 0;
+ i31 = HEAP32[i2 >> 2] | 0;
+ i30 = HEAP32[i3 >> 2] | 0;
+ i29 = i29 + -1 | 0;
+ i28 = i28 + -1 | 0;
+ L1 : do {
+ if (i31 >>> 0 < 15) {
+ i37 = i29 + 2 | 0;
+ i33 = i31 + 16 | 0;
+ i30 = ((HEAPU8[i29 + 1 | 0] | 0) << i31) + i30 + ((HEAPU8[i37] | 0) << i31 + 8) | 0;
+ i29 = i37;
+ } else {
+ i33 = i31;
+ }
+ i31 = i30 & i14;
+ i34 = HEAP8[i16 + (i31 << 2) | 0] | 0;
+ i32 = HEAP16[i16 + (i31 << 2) + 2 >> 1] | 0;
+ i31 = HEAPU8[i16 + (i31 << 2) + 1 | 0] | 0;
+ i30 = i30 >>> i31;
+ i31 = i33 - i31 | 0;
+ do {
+ if (!(i34 << 24 >> 24 == 0)) {
+ i33 = i34 & 255;
+ while (1) {
+ if ((i33 & 16 | 0) != 0) {
+ break;
+ }
+ if ((i33 & 64 | 0) != 0) {
+ i10 = 55;
+ break L1;
+ }
+ i37 = (i30 & (1 << i33) + -1) + (i32 & 65535) | 0;
+ i33 = HEAP8[i16 + (i37 << 2) | 0] | 0;
+ i32 = HEAP16[i16 + (i37 << 2) + 2 >> 1] | 0;
+ i37 = HEAPU8[i16 + (i37 << 2) + 1 | 0] | 0;
+ i30 = i30 >>> i37;
+ i31 = i31 - i37 | 0;
+ if (i33 << 24 >> 24 == 0) {
+ i10 = 6;
+ break;
+ } else {
+ i33 = i33 & 255;
+ }
+ }
+ if ((i10 | 0) == 6) {
+ i32 = i32 & 255;
+ i10 = 7;
+ break;
+ }
+ i32 = i32 & 65535;
+ i33 = i33 & 15;
+ if ((i33 | 0) != 0) {
+ if (i31 >>> 0 < i33 >>> 0) {
+ i29 = i29 + 1 | 0;
+ i35 = i31 + 8 | 0;
+ i34 = ((HEAPU8[i29] | 0) << i31) + i30 | 0;
+ } else {
+ i35 = i31;
+ i34 = i30;
+ }
+ i31 = i35 - i33 | 0;
+ i30 = i34 >>> i33;
+ i32 = (i34 & (1 << i33) + -1) + i32 | 0;
+ }
+ if (i31 >>> 0 < 15) {
+ i37 = i29 + 2 | 0;
+ i34 = i31 + 16 | 0;
+ i30 = ((HEAPU8[i29 + 1 | 0] | 0) << i31) + i30 + ((HEAPU8[i37] | 0) << i31 + 8) | 0;
+ i29 = i37;
+ } else {
+ i34 = i31;
+ }
+ i37 = i30 & i15;
+ i33 = HEAP16[i13 + (i37 << 2) + 2 >> 1] | 0;
+ i31 = HEAPU8[i13 + (i37 << 2) + 1 | 0] | 0;
+ i30 = i30 >>> i31;
+ i31 = i34 - i31 | 0;
+ i34 = HEAPU8[i13 + (i37 << 2) | 0] | 0;
+ if ((i34 & 16 | 0) == 0) {
+ do {
+ if ((i34 & 64 | 0) != 0) {
+ i10 = 52;
+ break L1;
+ }
+ i34 = (i30 & (1 << i34) + -1) + (i33 & 65535) | 0;
+ i33 = HEAP16[i13 + (i34 << 2) + 2 >> 1] | 0;
+ i37 = HEAPU8[i13 + (i34 << 2) + 1 | 0] | 0;
+ i30 = i30 >>> i37;
+ i31 = i31 - i37 | 0;
+ i34 = HEAPU8[i13 + (i34 << 2) | 0] | 0;
+ } while ((i34 & 16 | 0) == 0);
+ }
+ i33 = i33 & 65535;
+ i34 = i34 & 15;
+ if (i31 >>> 0 < i34 >>> 0) {
+ i35 = i29 + 1 | 0;
+ i30 = ((HEAPU8[i35] | 0) << i31) + i30 | 0;
+ i36 = i31 + 8 | 0;
+ if (i36 >>> 0 < i34 >>> 0) {
+ i29 = i29 + 2 | 0;
+ i31 = i31 + 16 | 0;
+ i30 = ((HEAPU8[i29] | 0) << i36) + i30 | 0;
+ } else {
+ i31 = i36;
+ i29 = i35;
+ }
+ }
+ i33 = (i30 & (1 << i34) + -1) + i33 | 0;
+ i30 = i30 >>> i34;
+ i31 = i31 - i34 | 0;
+ i35 = i28;
+ i34 = i35 - i19 | 0;
+ if (!(i33 >>> 0 > i34 >>> 0)) {
+ i34 = i28 + (0 - i33) | 0;
+ while (1) {
+ HEAP8[i28 + 1 | 0] = HEAP8[i34 + 1 | 0] | 0;
+ HEAP8[i28 + 2 | 0] = HEAP8[i34 + 2 | 0] | 0;
+ i35 = i34 + 3 | 0;
+ i33 = i28 + 3 | 0;
+ HEAP8[i33] = HEAP8[i35] | 0;
+ i32 = i32 + -3 | 0;
+ if (!(i32 >>> 0 > 2)) {
+ break;
+ } else {
+ i34 = i35;
+ i28 = i33;
+ }
+ }
+ if ((i32 | 0) == 0) {
+ i28 = i33;
+ break;
+ }
+ i33 = i28 + 4 | 0;
+ HEAP8[i33] = HEAP8[i34 + 4 | 0] | 0;
+ if (!(i32 >>> 0 > 1)) {
+ i28 = i33;
+ break;
+ }
+ i28 = i28 + 5 | 0;
+ HEAP8[i28] = HEAP8[i34 + 5 | 0] | 0;
+ break;
+ }
+ i34 = i33 - i34 | 0;
+ if (i34 >>> 0 > i17 >>> 0 ? (HEAP32[i25 >> 2] | 0) != 0 : 0) {
+ i10 = 22;
+ break L1;
+ }
+ do {
+ if (i27) {
+ i36 = i18 + (i24 - i34) | 0;
+ if (i34 >>> 0 < i32 >>> 0) {
+ i32 = i32 - i34 | 0;
+ i35 = i33 - i35 | 0;
+ i37 = i28;
+ do {
+ i36 = i36 + 1 | 0;
+ i37 = i37 + 1 | 0;
+ HEAP8[i37] = HEAP8[i36] | 0;
+ i34 = i34 + -1 | 0;
+ } while ((i34 | 0) != 0);
+ i33 = i28 + (i23 + i35 + (1 - i33)) | 0;
+ i28 = i28 + (i19 + i35) | 0;
+ } else {
+ i33 = i36;
+ }
+ } else {
+ if (!(i12 >>> 0 < i34 >>> 0)) {
+ i36 = i18 + (i22 - i34) | 0;
+ if (!(i34 >>> 0 < i32 >>> 0)) {
+ i33 = i36;
+ break;
+ }
+ i32 = i32 - i34 | 0;
+ i35 = i33 - i35 | 0;
+ i37 = i28;
+ do {
+ i36 = i36 + 1 | 0;
+ i37 = i37 + 1 | 0;
+ HEAP8[i37] = HEAP8[i36] | 0;
+ i34 = i34 + -1 | 0;
+ } while ((i34 | 0) != 0);
+ i33 = i28 + (i23 + i35 + (1 - i33)) | 0;
+ i28 = i28 + (i19 + i35) | 0;
+ break;
+ }
+ i37 = i18 + (i21 - i34) | 0;
+ i36 = i34 - i12 | 0;
+ if (i36 >>> 0 < i32 >>> 0) {
+ i32 = i32 - i36 | 0;
+ i34 = i33 - i35 | 0;
+ i35 = i28;
+ do {
+ i37 = i37 + 1 | 0;
+ i35 = i35 + 1 | 0;
+ HEAP8[i35] = HEAP8[i37] | 0;
+ i36 = i36 + -1 | 0;
+ } while ((i36 | 0) != 0);
+ i35 = i28 + (i26 + i34) | 0;
+ if (i12 >>> 0 < i32 >>> 0) {
+ i32 = i32 - i12 | 0;
+ i37 = i20;
+ i36 = i12;
+ do {
+ i37 = i37 + 1 | 0;
+ i35 = i35 + 1 | 0;
+ HEAP8[i35] = HEAP8[i37] | 0;
+ i36 = i36 + -1 | 0;
+ } while ((i36 | 0) != 0);
+ i33 = i28 + (i23 + i34 + (1 - i33)) | 0;
+ i28 = i28 + (i19 + i34) | 0;
+ } else {
+ i33 = i20;
+ i28 = i35;
+ }
+ } else {
+ i33 = i37;
+ }
+ }
+ } while (0);
+ if (i32 >>> 0 > 2) {
+ do {
+ HEAP8[i28 + 1 | 0] = HEAP8[i33 + 1 | 0] | 0;
+ HEAP8[i28 + 2 | 0] = HEAP8[i33 + 2 | 0] | 0;
+ i33 = i33 + 3 | 0;
+ i28 = i28 + 3 | 0;
+ HEAP8[i28] = HEAP8[i33] | 0;
+ i32 = i32 + -3 | 0;
+ } while (i32 >>> 0 > 2);
+ }
+ if ((i32 | 0) != 0) {
+ i34 = i28 + 1 | 0;
+ HEAP8[i34] = HEAP8[i33 + 1 | 0] | 0;
+ if (i32 >>> 0 > 1) {
+ i28 = i28 + 2 | 0;
+ HEAP8[i28] = HEAP8[i33 + 2 | 0] | 0;
+ } else {
+ i28 = i34;
+ }
+ }
+ } else {
+ i32 = i32 & 255;
+ i10 = 7;
+ }
+ } while (0);
+ if ((i10 | 0) == 7) {
+ i10 = 0;
+ i28 = i28 + 1 | 0;
+ HEAP8[i28] = i32;
+ }
+ } while (i29 >>> 0 < i8 >>> 0 & i28 >>> 0 < i6 >>> 0);
+ do {
+ if ((i10 | 0) == 22) {
+ HEAP32[i7 + 24 >> 2] = 14384;
+ HEAP32[i11 >> 2] = 29;
+ } else if ((i10 | 0) == 52) {
+ HEAP32[i7 + 24 >> 2] = 14416;
+ HEAP32[i11 >> 2] = 29;
+ } else if ((i10 | 0) == 55) {
+ if ((i33 & 32 | 0) == 0) {
+ HEAP32[i7 + 24 >> 2] = 14440;
+ HEAP32[i11 >> 2] = 29;
+ break;
+ } else {
+ HEAP32[i11 >> 2] = 11;
+ break;
+ }
+ }
+ } while (0);
+ i37 = i31 >>> 3;
+ i11 = i29 + (0 - i37) | 0;
+ i10 = i31 - (i37 << 3) | 0;
+ i12 = (1 << i10) + -1 & i30;
+ HEAP32[i7 >> 2] = i29 + (1 - i37);
+ HEAP32[i9 >> 2] = i28 + 1;
+ if (i11 >>> 0 < i8 >>> 0) {
+ i7 = i8 - i11 | 0;
+ } else {
+ i7 = i8 - i11 | 0;
+ }
+ HEAP32[i5 >> 2] = i7 + 5;
+ if (i28 >>> 0 < i6 >>> 0) {
+ i37 = i6 - i28 | 0;
+ i37 = i37 + 257 | 0;
+ HEAP32[i4 >> 2] = i37;
+ HEAP32[i3 >> 2] = i12;
+ HEAP32[i2 >> 2] = i10;
+ STACKTOP = i1;
+ return;
+ } else {
+ i37 = i6 - i28 | 0;
+ i37 = i37 + 257 | 0;
+ HEAP32[i4 >> 2] = i37;
+ HEAP32[i3 >> 2] = i12;
+ HEAP32[i2 >> 2] = i10;
+ STACKTOP = i1;
+ return;
+ }
+}
+function _send_tree(i2, i13, i12) {
+ i2 = i2 | 0;
+ i13 = i13 | 0;
+ i12 = i12 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0;
+ i11 = STACKTOP;
+ i15 = HEAP16[i13 + 2 >> 1] | 0;
+ i16 = i15 << 16 >> 16 == 0;
+ i7 = i2 + 2754 | 0;
+ i4 = i2 + 5820 | 0;
+ i8 = i2 + 2752 | 0;
+ i3 = i2 + 5816 | 0;
+ i14 = i2 + 20 | 0;
+ i10 = i2 + 8 | 0;
+ i9 = i2 + 2758 | 0;
+ i1 = i2 + 2756 | 0;
+ i5 = i2 + 2750 | 0;
+ i6 = i2 + 2748 | 0;
+ i21 = i16 ? 138 : 7;
+ i23 = i16 ? 3 : 4;
+ i18 = 0;
+ i15 = i15 & 65535;
+ i24 = -1;
+ L1 : while (1) {
+ i20 = 0;
+ while (1) {
+ if ((i18 | 0) > (i12 | 0)) {
+ break L1;
+ }
+ i18 = i18 + 1 | 0;
+ i19 = HEAP16[i13 + (i18 << 2) + 2 >> 1] | 0;
+ i16 = i19 & 65535;
+ i22 = i20 + 1 | 0;
+ i17 = (i15 | 0) == (i16 | 0);
+ if (!((i22 | 0) < (i21 | 0) & i17)) {
+ break;
+ } else {
+ i20 = i22;
+ }
+ }
+ do {
+ if ((i22 | 0) >= (i23 | 0)) {
+ if ((i15 | 0) != 0) {
+ if ((i15 | 0) == (i24 | 0)) {
+ i23 = HEAP16[i3 >> 1] | 0;
+ i21 = HEAP32[i4 >> 2] | 0;
+ i20 = i22;
+ } else {
+ i22 = HEAPU16[i2 + (i15 << 2) + 2686 >> 1] | 0;
+ i21 = HEAP32[i4 >> 2] | 0;
+ i24 = HEAPU16[i2 + (i15 << 2) + 2684 >> 1] | 0;
+ i25 = HEAPU16[i3 >> 1] | 0 | i24 << i21;
+ i23 = i25 & 65535;
+ HEAP16[i3 >> 1] = i23;
+ if ((i21 | 0) > (16 - i22 | 0)) {
+ i23 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i23 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i23 | 0] = i25;
+ i23 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i21 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i21 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i21 | 0] = i23;
+ i21 = HEAP32[i4 >> 2] | 0;
+ i23 = i24 >>> (16 - i21 | 0) & 65535;
+ HEAP16[i3 >> 1] = i23;
+ i21 = i22 + -16 + i21 | 0;
+ } else {
+ i21 = i21 + i22 | 0;
+ }
+ HEAP32[i4 >> 2] = i21;
+ }
+ i22 = HEAPU16[i5 >> 1] | 0;
+ i24 = HEAPU16[i6 >> 1] | 0;
+ i23 = i23 & 65535 | i24 << i21;
+ HEAP16[i3 >> 1] = i23;
+ if ((i21 | 0) > (16 - i22 | 0)) {
+ i21 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i21 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i21 | 0] = i23;
+ i23 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i21 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i21 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i21 | 0] = i23;
+ i21 = HEAP32[i4 >> 2] | 0;
+ i23 = i24 >>> (16 - i21 | 0);
+ HEAP16[i3 >> 1] = i23;
+ i21 = i22 + -16 + i21 | 0;
+ } else {
+ i21 = i21 + i22 | 0;
+ }
+ HEAP32[i4 >> 2] = i21;
+ i20 = i20 + 65533 & 65535;
+ i22 = i23 & 65535 | i20 << i21;
+ HEAP16[i3 >> 1] = i22;
+ if ((i21 | 0) > 14) {
+ i26 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i26 | 0] = i22;
+ i26 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i26;
+ i27 = HEAP32[i4 >> 2] | 0;
+ HEAP16[i3 >> 1] = i20 >>> (16 - i27 | 0);
+ HEAP32[i4 >> 2] = i27 + -14;
+ break;
+ } else {
+ HEAP32[i4 >> 2] = i21 + 2;
+ break;
+ }
+ }
+ if ((i22 | 0) < 11) {
+ i24 = HEAPU16[i7 >> 1] | 0;
+ i23 = HEAP32[i4 >> 2] | 0;
+ i21 = HEAPU16[i8 >> 1] | 0;
+ i22 = HEAPU16[i3 >> 1] | 0 | i21 << i23;
+ HEAP16[i3 >> 1] = i22;
+ if ((i23 | 0) > (16 - i24 | 0)) {
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i22;
+ i22 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i22;
+ i27 = HEAP32[i4 >> 2] | 0;
+ i22 = i21 >>> (16 - i27 | 0);
+ HEAP16[i3 >> 1] = i22;
+ i21 = i24 + -16 + i27 | 0;
+ } else {
+ i21 = i23 + i24 | 0;
+ }
+ HEAP32[i4 >> 2] = i21;
+ i20 = i20 + 65534 & 65535;
+ i22 = i22 & 65535 | i20 << i21;
+ HEAP16[i3 >> 1] = i22;
+ if ((i21 | 0) > 13) {
+ i26 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i26 | 0] = i22;
+ i26 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i26;
+ i27 = HEAP32[i4 >> 2] | 0;
+ HEAP16[i3 >> 1] = i20 >>> (16 - i27 | 0);
+ HEAP32[i4 >> 2] = i27 + -13;
+ break;
+ } else {
+ HEAP32[i4 >> 2] = i21 + 3;
+ break;
+ }
+ } else {
+ i21 = HEAPU16[i9 >> 1] | 0;
+ i24 = HEAP32[i4 >> 2] | 0;
+ i23 = HEAPU16[i1 >> 1] | 0;
+ i22 = HEAPU16[i3 >> 1] | 0 | i23 << i24;
+ HEAP16[i3 >> 1] = i22;
+ if ((i24 | 0) > (16 - i21 | 0)) {
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i22;
+ i22 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i22;
+ i27 = HEAP32[i4 >> 2] | 0;
+ i22 = i23 >>> (16 - i27 | 0);
+ HEAP16[i3 >> 1] = i22;
+ i21 = i21 + -16 + i27 | 0;
+ } else {
+ i21 = i24 + i21 | 0;
+ }
+ HEAP32[i4 >> 2] = i21;
+ i20 = i20 + 65526 & 65535;
+ i22 = i22 & 65535 | i20 << i21;
+ HEAP16[i3 >> 1] = i22;
+ if ((i21 | 0) > 9) {
+ i26 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i26 | 0] = i22;
+ i26 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i27 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i27 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i27 | 0] = i26;
+ i27 = HEAP32[i4 >> 2] | 0;
+ HEAP16[i3 >> 1] = i20 >>> (16 - i27 | 0);
+ HEAP32[i4 >> 2] = i27 + -9;
+ break;
+ } else {
+ HEAP32[i4 >> 2] = i21 + 7;
+ break;
+ }
+ }
+ } else {
+ i20 = i2 + (i15 << 2) + 2686 | 0;
+ i21 = i2 + (i15 << 2) + 2684 | 0;
+ i23 = HEAP32[i4 >> 2] | 0;
+ i26 = HEAP16[i3 >> 1] | 0;
+ do {
+ i24 = HEAPU16[i20 >> 1] | 0;
+ i25 = HEAPU16[i21 >> 1] | 0;
+ i27 = i26 & 65535 | i25 << i23;
+ i26 = i27 & 65535;
+ HEAP16[i3 >> 1] = i26;
+ if ((i23 | 0) > (16 - i24 | 0)) {
+ i26 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i26 | 0] = i27;
+ i26 = (HEAPU16[i3 >> 1] | 0) >>> 8 & 255;
+ i23 = HEAP32[i14 >> 2] | 0;
+ HEAP32[i14 >> 2] = i23 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i23 | 0] = i26;
+ i23 = HEAP32[i4 >> 2] | 0;
+ i26 = i25 >>> (16 - i23 | 0) & 65535;
+ HEAP16[i3 >> 1] = i26;
+ i23 = i24 + -16 + i23 | 0;
+ } else {
+ i23 = i23 + i24 | 0;
+ }
+ HEAP32[i4 >> 2] = i23;
+ i22 = i22 + -1 | 0;
+ } while ((i22 | 0) != 0);
+ }
+ } while (0);
+ if (i19 << 16 >> 16 == 0) {
+ i24 = i15;
+ i21 = 138;
+ i23 = 3;
+ i15 = i16;
+ continue;
+ }
+ i24 = i15;
+ i21 = i17 ? 6 : 7;
+ i23 = i17 ? 3 : 4;
+ i15 = i16;
+ }
+ STACKTOP = i11;
+ return;
+}
+function __tr_flush_block(i2, i4, i6, i3) {
+ i2 = i2 | 0;
+ i4 = i4 | 0;
+ i6 = i6 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i1 = STACKTOP;
+ if ((HEAP32[i2 + 132 >> 2] | 0) > 0) {
+ i5 = (HEAP32[i2 >> 2] | 0) + 44 | 0;
+ if ((HEAP32[i5 >> 2] | 0) == 2) {
+ i8 = -201342849;
+ i9 = 0;
+ while (1) {
+ if ((i8 & 1 | 0) != 0 ? (HEAP16[i2 + (i9 << 2) + 148 >> 1] | 0) != 0 : 0) {
+ i8 = 0;
+ break;
+ }
+ i9 = i9 + 1 | 0;
+ if ((i9 | 0) < 32) {
+ i8 = i8 >>> 1;
+ } else {
+ i7 = 6;
+ break;
+ }
+ }
+ L9 : do {
+ if ((i7 | 0) == 6) {
+ if (((HEAP16[i2 + 184 >> 1] | 0) == 0 ? (HEAP16[i2 + 188 >> 1] | 0) == 0 : 0) ? (HEAP16[i2 + 200 >> 1] | 0) == 0 : 0) {
+ i8 = 32;
+ while (1) {
+ i7 = i8 + 1 | 0;
+ if ((HEAP16[i2 + (i8 << 2) + 148 >> 1] | 0) != 0) {
+ i8 = 1;
+ break L9;
+ }
+ if ((i7 | 0) < 256) {
+ i8 = i7;
+ } else {
+ i8 = 0;
+ break;
+ }
+ }
+ } else {
+ i8 = 1;
+ }
+ }
+ } while (0);
+ HEAP32[i5 >> 2] = i8;
+ }
+ _build_tree(i2, i2 + 2840 | 0);
+ _build_tree(i2, i2 + 2852 | 0);
+ _scan_tree(i2, i2 + 148 | 0, HEAP32[i2 + 2844 >> 2] | 0);
+ _scan_tree(i2, i2 + 2440 | 0, HEAP32[i2 + 2856 >> 2] | 0);
+ _build_tree(i2, i2 + 2864 | 0);
+ i5 = 18;
+ while (1) {
+ i7 = i5 + -1 | 0;
+ if ((HEAP16[i2 + (HEAPU8[2888 + i5 | 0] << 2) + 2686 >> 1] | 0) != 0) {
+ break;
+ }
+ if ((i7 | 0) > 2) {
+ i5 = i7;
+ } else {
+ i5 = i7;
+ break;
+ }
+ }
+ i10 = i2 + 5800 | 0;
+ i7 = (i5 * 3 | 0) + 17 + (HEAP32[i10 >> 2] | 0) | 0;
+ HEAP32[i10 >> 2] = i7;
+ i7 = (i7 + 10 | 0) >>> 3;
+ i10 = ((HEAP32[i2 + 5804 >> 2] | 0) + 10 | 0) >>> 3;
+ i9 = i10 >>> 0 > i7 >>> 0 ? i7 : i10;
+ } else {
+ i10 = i6 + 5 | 0;
+ i5 = 0;
+ i9 = i10;
+ }
+ do {
+ if ((i6 + 4 | 0) >>> 0 > i9 >>> 0 | (i4 | 0) == 0) {
+ i4 = i2 + 5820 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ i8 = (i7 | 0) > 13;
+ if ((HEAP32[i2 + 136 >> 2] | 0) == 4 | (i10 | 0) == (i9 | 0)) {
+ i9 = i3 + 2 & 65535;
+ i6 = i2 + 5816 | 0;
+ i5 = HEAPU16[i6 >> 1] | i9 << i7;
+ HEAP16[i6 >> 1] = i5;
+ if (i8) {
+ i12 = i2 + 20 | 0;
+ i13 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i13 + 1;
+ i14 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i13 | 0] = i5;
+ i13 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i5 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i5 + 1;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i5 | 0] = i13;
+ i5 = HEAP32[i4 >> 2] | 0;
+ HEAP16[i6 >> 1] = i9 >>> (16 - i5 | 0);
+ i5 = i5 + -13 | 0;
+ } else {
+ i5 = i7 + 3 | 0;
+ }
+ HEAP32[i4 >> 2] = i5;
+ _compress_block(i2, 1136, 2288);
+ break;
+ }
+ i10 = i3 + 4 & 65535;
+ i6 = i2 + 5816 | 0;
+ i9 = HEAPU16[i6 >> 1] | i10 << i7;
+ HEAP16[i6 >> 1] = i9;
+ if (i8) {
+ i13 = i2 + 20 | 0;
+ i12 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i12 + 1;
+ i14 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i12 | 0] = i9;
+ i9 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i12 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i12 + 1;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i12 | 0] = i9;
+ i12 = HEAP32[i4 >> 2] | 0;
+ i9 = i10 >>> (16 - i12 | 0);
+ HEAP16[i6 >> 1] = i9;
+ i12 = i12 + -13 | 0;
+ } else {
+ i12 = i7 + 3 | 0;
+ }
+ HEAP32[i4 >> 2] = i12;
+ i7 = HEAP32[i2 + 2844 >> 2] | 0;
+ i8 = HEAP32[i2 + 2856 >> 2] | 0;
+ i10 = i7 + 65280 & 65535;
+ i11 = i9 & 65535 | i10 << i12;
+ HEAP16[i6 >> 1] = i11;
+ if ((i12 | 0) > 11) {
+ i13 = i2 + 20 | 0;
+ i9 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i9 + 1;
+ i14 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i9 | 0] = i11;
+ i11 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i9 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i9 + 1;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i9 | 0] = i11;
+ i9 = HEAP32[i4 >> 2] | 0;
+ i11 = i10 >>> (16 - i9 | 0);
+ HEAP16[i6 >> 1] = i11;
+ i9 = i9 + -11 | 0;
+ } else {
+ i9 = i12 + 5 | 0;
+ }
+ HEAP32[i4 >> 2] = i9;
+ i10 = i8 & 65535;
+ i11 = i10 << i9 | i11 & 65535;
+ HEAP16[i6 >> 1] = i11;
+ if ((i9 | 0) > 11) {
+ i13 = i2 + 20 | 0;
+ i9 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i9 + 1;
+ i14 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i9 | 0] = i11;
+ i11 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i9 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i13 >> 2] = i9 + 1;
+ HEAP8[(HEAP32[i14 >> 2] | 0) + i9 | 0] = i11;
+ i9 = HEAP32[i4 >> 2] | 0;
+ i11 = i10 >>> (16 - i9 | 0);
+ HEAP16[i6 >> 1] = i11;
+ i9 = i9 + -11 | 0;
+ } else {
+ i9 = i9 + 5 | 0;
+ }
+ HEAP32[i4 >> 2] = i9;
+ i10 = i5 + 65533 & 65535;
+ i14 = i10 << i9 | i11 & 65535;
+ HEAP16[i6 >> 1] = i14;
+ if ((i9 | 0) > 12) {
+ i12 = i2 + 20 | 0;
+ i11 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i11 + 1;
+ i13 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i13 >> 2] | 0) + i11 | 0] = i14;
+ i14 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i11 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i13 >> 2] | 0) + i11 | 0] = i14;
+ i11 = HEAP32[i4 >> 2] | 0;
+ i14 = i10 >>> (16 - i11 | 0);
+ HEAP16[i6 >> 1] = i14;
+ i11 = i11 + -12 | 0;
+ } else {
+ i11 = i9 + 4 | 0;
+ }
+ HEAP32[i4 >> 2] = i11;
+ if ((i5 | 0) > -1) {
+ i10 = i2 + 20 | 0;
+ i9 = i2 + 8 | 0;
+ i12 = 0;
+ while (1) {
+ i13 = HEAPU16[i2 + (HEAPU8[2888 + i12 | 0] << 2) + 2686 >> 1] | 0;
+ i14 = i13 << i11 | i14 & 65535;
+ HEAP16[i6 >> 1] = i14;
+ if ((i11 | 0) > 13) {
+ i11 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i10 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i9 >> 2] | 0) + i11 | 0] = i14;
+ i14 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i11 = HEAP32[i10 >> 2] | 0;
+ HEAP32[i10 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i9 >> 2] | 0) + i11 | 0] = i14;
+ i11 = HEAP32[i4 >> 2] | 0;
+ i14 = i13 >>> (16 - i11 | 0);
+ HEAP16[i6 >> 1] = i14;
+ i11 = i11 + -13 | 0;
+ } else {
+ i11 = i11 + 3 | 0;
+ }
+ HEAP32[i4 >> 2] = i11;
+ if ((i12 | 0) == (i5 | 0)) {
+ break;
+ } else {
+ i12 = i12 + 1 | 0;
+ }
+ }
+ }
+ i13 = i2 + 148 | 0;
+ _send_tree(i2, i13, i7);
+ i14 = i2 + 2440 | 0;
+ _send_tree(i2, i14, i8);
+ _compress_block(i2, i13, i14);
+ } else {
+ __tr_stored_block(i2, i4, i6, i3);
+ }
+ } while (0);
+ _init_block(i2);
+ if ((i3 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ i3 = i2 + 5820 | 0;
+ i4 = HEAP32[i3 >> 2] | 0;
+ if ((i4 | 0) <= 8) {
+ i5 = i2 + 5816 | 0;
+ if ((i4 | 0) > 0) {
+ i13 = HEAP16[i5 >> 1] & 255;
+ i12 = i2 + 20 | 0;
+ i14 = HEAP32[i12 >> 2] | 0;
+ HEAP32[i12 >> 2] = i14 + 1;
+ HEAP8[(HEAP32[i2 + 8 >> 2] | 0) + i14 | 0] = i13;
+ }
+ } else {
+ i5 = i2 + 5816 | 0;
+ i14 = HEAP16[i5 >> 1] & 255;
+ i11 = i2 + 20 | 0;
+ i12 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i12 + 1;
+ i13 = i2 + 8 | 0;
+ HEAP8[(HEAP32[i13 >> 2] | 0) + i12 | 0] = i14;
+ i12 = (HEAPU16[i5 >> 1] | 0) >>> 8 & 255;
+ i14 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i14 + 1;
+ HEAP8[(HEAP32[i13 >> 2] | 0) + i14 | 0] = i12;
+ }
+ HEAP16[i5 >> 1] = 0;
+ HEAP32[i3 >> 2] = 0;
+ STACKTOP = i1;
+ return;
+}
+function _deflate_fast(i3, i6) {
+ i3 = i3 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i2 = 0, i4 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0, i34 = 0, i35 = 0, i36 = 0;
+ i1 = STACKTOP;
+ i20 = i3 + 116 | 0;
+ i22 = (i6 | 0) == 0;
+ i23 = i3 + 72 | 0;
+ i24 = i3 + 88 | 0;
+ i5 = i3 + 108 | 0;
+ i7 = i3 + 56 | 0;
+ i9 = i3 + 84 | 0;
+ i10 = i3 + 68 | 0;
+ i11 = i3 + 52 | 0;
+ i12 = i3 + 64 | 0;
+ i19 = i3 + 44 | 0;
+ i21 = i3 + 96 | 0;
+ i16 = i3 + 112 | 0;
+ i13 = i3 + 5792 | 0;
+ i17 = i3 + 5796 | 0;
+ i18 = i3 + 5784 | 0;
+ i14 = i3 + 5788 | 0;
+ i15 = i3 + 128 | 0;
+ i4 = i3 + 92 | 0;
+ while (1) {
+ if ((HEAP32[i20 >> 2] | 0) >>> 0 < 262) {
+ _fill_window(i3);
+ i25 = HEAP32[i20 >> 2] | 0;
+ if (i25 >>> 0 < 262 & i22) {
+ i2 = 0;
+ i25 = 34;
+ break;
+ }
+ if ((i25 | 0) == 0) {
+ i25 = 26;
+ break;
+ }
+ if (!(i25 >>> 0 > 2)) {
+ i25 = 9;
+ } else {
+ i25 = 6;
+ }
+ } else {
+ i25 = 6;
+ }
+ if ((i25 | 0) == 6) {
+ i25 = 0;
+ i26 = HEAP32[i5 >> 2] | 0;
+ i34 = ((HEAPU8[(HEAP32[i7 >> 2] | 0) + (i26 + 2) | 0] | 0) ^ HEAP32[i23 >> 2] << HEAP32[i24 >> 2]) & HEAP32[i9 >> 2];
+ HEAP32[i23 >> 2] = i34;
+ i34 = (HEAP32[i10 >> 2] | 0) + (i34 << 1) | 0;
+ i35 = HEAP16[i34 >> 1] | 0;
+ HEAP16[(HEAP32[i12 >> 2] | 0) + ((HEAP32[i11 >> 2] & i26) << 1) >> 1] = i35;
+ i27 = i35 & 65535;
+ HEAP16[i34 >> 1] = i26;
+ if (!(i35 << 16 >> 16 == 0) ? !((i26 - i27 | 0) >>> 0 > ((HEAP32[i19 >> 2] | 0) + -262 | 0) >>> 0) : 0) {
+ i26 = _longest_match(i3, i27) | 0;
+ HEAP32[i21 >> 2] = i26;
+ } else {
+ i25 = 9;
+ }
+ }
+ if ((i25 | 0) == 9) {
+ i26 = HEAP32[i21 >> 2] | 0;
+ }
+ do {
+ if (i26 >>> 0 > 2) {
+ i35 = i26 + 253 | 0;
+ i25 = (HEAP32[i5 >> 2] | 0) - (HEAP32[i16 >> 2] | 0) | 0;
+ i34 = HEAP32[i13 >> 2] | 0;
+ HEAP16[(HEAP32[i17 >> 2] | 0) + (i34 << 1) >> 1] = i25;
+ HEAP32[i13 >> 2] = i34 + 1;
+ HEAP8[(HEAP32[i18 >> 2] | 0) + i34 | 0] = i35;
+ i35 = i3 + ((HEAPU8[808 + (i35 & 255) | 0] | 0 | 256) + 1 << 2) + 148 | 0;
+ HEAP16[i35 >> 1] = (HEAP16[i35 >> 1] | 0) + 1 << 16 >> 16;
+ i25 = i25 + 65535 & 65535;
+ if (!(i25 >>> 0 < 256)) {
+ i25 = (i25 >>> 7) + 256 | 0;
+ }
+ i25 = i3 + ((HEAPU8[296 + i25 | 0] | 0) << 2) + 2440 | 0;
+ HEAP16[i25 >> 1] = (HEAP16[i25 >> 1] | 0) + 1 << 16 >> 16;
+ i25 = (HEAP32[i13 >> 2] | 0) == ((HEAP32[i14 >> 2] | 0) + -1 | 0) | 0;
+ i26 = HEAP32[i21 >> 2] | 0;
+ i35 = (HEAP32[i20 >> 2] | 0) - i26 | 0;
+ HEAP32[i20 >> 2] = i35;
+ if (!(i26 >>> 0 <= (HEAP32[i15 >> 2] | 0) >>> 0 & i35 >>> 0 > 2)) {
+ i26 = (HEAP32[i5 >> 2] | 0) + i26 | 0;
+ HEAP32[i5 >> 2] = i26;
+ HEAP32[i21 >> 2] = 0;
+ i34 = HEAP32[i7 >> 2] | 0;
+ i35 = HEAPU8[i34 + i26 | 0] | 0;
+ HEAP32[i23 >> 2] = i35;
+ HEAP32[i23 >> 2] = ((HEAPU8[i34 + (i26 + 1) | 0] | 0) ^ i35 << HEAP32[i24 >> 2]) & HEAP32[i9 >> 2];
+ break;
+ }
+ i30 = i26 + -1 | 0;
+ HEAP32[i21 >> 2] = i30;
+ i34 = HEAP32[i24 >> 2] | 0;
+ i33 = HEAP32[i7 >> 2] | 0;
+ i35 = HEAP32[i9 >> 2] | 0;
+ i32 = HEAP32[i10 >> 2] | 0;
+ i27 = HEAP32[i11 >> 2] | 0;
+ i29 = HEAP32[i12 >> 2] | 0;
+ i26 = HEAP32[i5 >> 2] | 0;
+ i31 = HEAP32[i23 >> 2] | 0;
+ while (1) {
+ i28 = i26 + 1 | 0;
+ HEAP32[i5 >> 2] = i28;
+ i31 = ((HEAPU8[i33 + (i26 + 3) | 0] | 0) ^ i31 << i34) & i35;
+ HEAP32[i23 >> 2] = i31;
+ i36 = i32 + (i31 << 1) | 0;
+ HEAP16[i29 + ((i27 & i28) << 1) >> 1] = HEAP16[i36 >> 1] | 0;
+ HEAP16[i36 >> 1] = i28;
+ i30 = i30 + -1 | 0;
+ HEAP32[i21 >> 2] = i30;
+ if ((i30 | 0) == 0) {
+ break;
+ } else {
+ i26 = i28;
+ }
+ }
+ i26 = i26 + 2 | 0;
+ HEAP32[i5 >> 2] = i26;
+ } else {
+ i25 = HEAP8[(HEAP32[i7 >> 2] | 0) + (HEAP32[i5 >> 2] | 0) | 0] | 0;
+ i26 = HEAP32[i13 >> 2] | 0;
+ HEAP16[(HEAP32[i17 >> 2] | 0) + (i26 << 1) >> 1] = 0;
+ HEAP32[i13 >> 2] = i26 + 1;
+ HEAP8[(HEAP32[i18 >> 2] | 0) + i26 | 0] = i25;
+ i25 = i3 + ((i25 & 255) << 2) + 148 | 0;
+ HEAP16[i25 >> 1] = (HEAP16[i25 >> 1] | 0) + 1 << 16 >> 16;
+ i25 = (HEAP32[i13 >> 2] | 0) == ((HEAP32[i14 >> 2] | 0) + -1 | 0) | 0;
+ HEAP32[i20 >> 2] = (HEAP32[i20 >> 2] | 0) + -1;
+ i26 = (HEAP32[i5 >> 2] | 0) + 1 | 0;
+ HEAP32[i5 >> 2] = i26;
+ }
+ } while (0);
+ if ((i25 | 0) == 0) {
+ continue;
+ }
+ i25 = HEAP32[i4 >> 2] | 0;
+ if ((i25 | 0) > -1) {
+ i27 = (HEAP32[i7 >> 2] | 0) + i25 | 0;
+ } else {
+ i27 = 0;
+ }
+ __tr_flush_block(i3, i27, i26 - i25 | 0, 0);
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i27 = HEAP32[i3 >> 2] | 0;
+ i28 = i27 + 28 | 0;
+ i25 = HEAP32[i28 >> 2] | 0;
+ i30 = HEAP32[i25 + 20 >> 2] | 0;
+ i26 = i27 + 16 | 0;
+ i29 = HEAP32[i26 >> 2] | 0;
+ i29 = i30 >>> 0 > i29 >>> 0 ? i29 : i30;
+ if ((i29 | 0) != 0 ? (i8 = i27 + 12 | 0, _memcpy(HEAP32[i8 >> 2] | 0, HEAP32[i25 + 16 >> 2] | 0, i29 | 0) | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i29, i8 = (HEAP32[i28 >> 2] | 0) + 16 | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i29, i8 = i27 + 20 | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i29, HEAP32[i26 >> 2] = (HEAP32[i26 >> 2] | 0) - i29, i8 = HEAP32[i28 >> 2] | 0, i35 = i8 + 20 | 0, i36 = HEAP32[i35 >> 2] | 0, HEAP32[i35 >> 2] = i36 - i29, (i36 | 0) == (i29 | 0)) : 0) {
+ HEAP32[i8 + 16 >> 2] = HEAP32[i8 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i2 = 0;
+ i25 = 34;
+ break;
+ }
+ }
+ if ((i25 | 0) == 26) {
+ i8 = HEAP32[i4 >> 2] | 0;
+ if ((i8 | 0) > -1) {
+ i7 = (HEAP32[i7 >> 2] | 0) + i8 | 0;
+ } else {
+ i7 = 0;
+ }
+ i6 = (i6 | 0) == 4;
+ __tr_flush_block(i3, i7, (HEAP32[i5 >> 2] | 0) - i8 | 0, i6 & 1);
+ HEAP32[i4 >> 2] = HEAP32[i5 >> 2];
+ i5 = HEAP32[i3 >> 2] | 0;
+ i7 = i5 + 28 | 0;
+ i4 = HEAP32[i7 >> 2] | 0;
+ i10 = HEAP32[i4 + 20 >> 2] | 0;
+ i8 = i5 + 16 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ i9 = i10 >>> 0 > i9 >>> 0 ? i9 : i10;
+ if ((i9 | 0) != 0 ? (i2 = i5 + 12 | 0, _memcpy(HEAP32[i2 >> 2] | 0, HEAP32[i4 + 16 >> 2] | 0, i9 | 0) | 0, HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + i9, i2 = (HEAP32[i7 >> 2] | 0) + 16 | 0, HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + i9, i2 = i5 + 20 | 0, HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + i9, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) - i9, i2 = HEAP32[i7 >> 2] | 0, i35 = i2 + 20 | 0, i36 = HEAP32[i35 >> 2] | 0, HEAP32[i35 >> 2] = i36 - i9, (i36 | 0) == (i9 | 0)) : 0) {
+ HEAP32[i2 + 16 >> 2] = HEAP32[i2 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i3 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i36 = i6 ? 2 : 0;
+ STACKTOP = i1;
+ return i36 | 0;
+ } else {
+ i36 = i6 ? 3 : 1;
+ STACKTOP = i1;
+ return i36 | 0;
+ }
+ } else if ((i25 | 0) == 34) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ return 0;
+}
+function _inflate_table(i11, i5, i13, i2, i1, i10) {
+ i11 = i11 | 0;
+ i5 = i5 | 0;
+ i13 = i13 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i10 = i10 | 0;
+ var i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i12 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0, i25 = 0, i26 = 0, i27 = 0, i28 = 0, i29 = 0, i30 = 0, i31 = 0, i32 = 0, i33 = 0;
+ i3 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i7 = i3 + 32 | 0;
+ i12 = i3;
+ i4 = i7 + 0 | 0;
+ i9 = i4 + 32 | 0;
+ do {
+ HEAP16[i4 >> 1] = 0;
+ i4 = i4 + 2 | 0;
+ } while ((i4 | 0) < (i9 | 0));
+ i14 = (i13 | 0) == 0;
+ if (!i14) {
+ i4 = 0;
+ do {
+ i32 = i7 + (HEAPU16[i5 + (i4 << 1) >> 1] << 1) | 0;
+ HEAP16[i32 >> 1] = (HEAP16[i32 >> 1] | 0) + 1 << 16 >> 16;
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) != (i13 | 0));
+ }
+ i4 = HEAP32[i1 >> 2] | 0;
+ i9 = 15;
+ while (1) {
+ i15 = i9 + -1 | 0;
+ if ((HEAP16[i7 + (i9 << 1) >> 1] | 0) != 0) {
+ break;
+ }
+ if ((i15 | 0) == 0) {
+ i6 = 7;
+ break;
+ } else {
+ i9 = i15;
+ }
+ }
+ if ((i6 | 0) == 7) {
+ i32 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i2 >> 2] = i32 + 4;
+ HEAP8[i32] = 64;
+ HEAP8[i32 + 1 | 0] = 1;
+ HEAP16[i32 + 2 >> 1] = 0;
+ i32 = HEAP32[i2 >> 2] | 0;
+ HEAP32[i2 >> 2] = i32 + 4;
+ HEAP8[i32] = 64;
+ HEAP8[i32 + 1 | 0] = 1;
+ HEAP16[i32 + 2 >> 1] = 0;
+ HEAP32[i1 >> 2] = 1;
+ i32 = 0;
+ STACKTOP = i3;
+ return i32 | 0;
+ }
+ i4 = i4 >>> 0 > i9 >>> 0 ? i9 : i4;
+ L12 : do {
+ if (i9 >>> 0 > 1) {
+ i27 = 1;
+ while (1) {
+ i15 = i27 + 1 | 0;
+ if ((HEAP16[i7 + (i27 << 1) >> 1] | 0) != 0) {
+ break L12;
+ }
+ if (i15 >>> 0 < i9 >>> 0) {
+ i27 = i15;
+ } else {
+ i27 = i15;
+ break;
+ }
+ }
+ } else {
+ i27 = 1;
+ }
+ } while (0);
+ i4 = i4 >>> 0 < i27 >>> 0 ? i27 : i4;
+ i16 = 1;
+ i15 = 1;
+ do {
+ i16 = (i16 << 1) - (HEAPU16[i7 + (i15 << 1) >> 1] | 0) | 0;
+ i15 = i15 + 1 | 0;
+ if ((i16 | 0) < 0) {
+ i8 = -1;
+ i6 = 56;
+ break;
+ }
+ } while (i15 >>> 0 < 16);
+ if ((i6 | 0) == 56) {
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ if ((i16 | 0) > 0 ? !((i11 | 0) != 0 & (i9 | 0) == 1) : 0) {
+ i32 = -1;
+ STACKTOP = i3;
+ return i32 | 0;
+ }
+ HEAP16[i12 + 2 >> 1] = 0;
+ i16 = 0;
+ i15 = 1;
+ do {
+ i16 = (HEAPU16[i7 + (i15 << 1) >> 1] | 0) + (i16 & 65535) | 0;
+ i15 = i15 + 1 | 0;
+ HEAP16[i12 + (i15 << 1) >> 1] = i16;
+ } while ((i15 | 0) != 15);
+ if (!i14) {
+ i15 = 0;
+ do {
+ i14 = HEAP16[i5 + (i15 << 1) >> 1] | 0;
+ if (!(i14 << 16 >> 16 == 0)) {
+ i31 = i12 + ((i14 & 65535) << 1) | 0;
+ i32 = HEAP16[i31 >> 1] | 0;
+ HEAP16[i31 >> 1] = i32 + 1 << 16 >> 16;
+ HEAP16[i10 + ((i32 & 65535) << 1) >> 1] = i15;
+ }
+ i15 = i15 + 1 | 0;
+ } while ((i15 | 0) != (i13 | 0));
+ }
+ if ((i11 | 0) == 1) {
+ i14 = 1 << i4;
+ if (i14 >>> 0 > 851) {
+ i32 = 1;
+ STACKTOP = i3;
+ return i32 | 0;
+ } else {
+ i16 = 0;
+ i20 = 1;
+ i17 = 14128 + -514 | 0;
+ i19 = 256;
+ i18 = 14192 + -514 | 0;
+ }
+ } else if ((i11 | 0) != 0) {
+ i14 = 1 << i4;
+ i16 = (i11 | 0) == 2;
+ if (i16 & i14 >>> 0 > 591) {
+ i32 = 1;
+ STACKTOP = i3;
+ return i32 | 0;
+ } else {
+ i20 = 0;
+ i17 = 14256;
+ i19 = -1;
+ i18 = 14320;
+ }
+ } else {
+ i16 = 0;
+ i14 = 1 << i4;
+ i20 = 0;
+ i17 = i10;
+ i19 = 19;
+ i18 = i10;
+ }
+ i11 = i14 + -1 | 0;
+ i12 = i4 & 255;
+ i22 = i4;
+ i21 = 0;
+ i25 = 0;
+ i13 = -1;
+ i15 = HEAP32[i2 >> 2] | 0;
+ i24 = 0;
+ L44 : while (1) {
+ i23 = 1 << i22;
+ while (1) {
+ i29 = i27 - i21 | 0;
+ i22 = i29 & 255;
+ i28 = HEAP16[i10 + (i24 << 1) >> 1] | 0;
+ i30 = i28 & 65535;
+ if ((i30 | 0) >= (i19 | 0)) {
+ if ((i30 | 0) > (i19 | 0)) {
+ i26 = HEAP16[i18 + (i30 << 1) >> 1] & 255;
+ i28 = HEAP16[i17 + (i30 << 1) >> 1] | 0;
+ } else {
+ i26 = 96;
+ i28 = 0;
+ }
+ } else {
+ i26 = 0;
+ }
+ i31 = 1 << i29;
+ i30 = i25 >>> i21;
+ i32 = i23;
+ while (1) {
+ i29 = i32 - i31 | 0;
+ i33 = i29 + i30 | 0;
+ HEAP8[i15 + (i33 << 2) | 0] = i26;
+ HEAP8[i15 + (i33 << 2) + 1 | 0] = i22;
+ HEAP16[i15 + (i33 << 2) + 2 >> 1] = i28;
+ if ((i32 | 0) == (i31 | 0)) {
+ break;
+ } else {
+ i32 = i29;
+ }
+ }
+ i26 = 1 << i27 + -1;
+ while (1) {
+ if ((i26 & i25 | 0) == 0) {
+ break;
+ } else {
+ i26 = i26 >>> 1;
+ }
+ }
+ if ((i26 | 0) == 0) {
+ i25 = 0;
+ } else {
+ i25 = (i26 + -1 & i25) + i26 | 0;
+ }
+ i24 = i24 + 1 | 0;
+ i32 = i7 + (i27 << 1) | 0;
+ i33 = (HEAP16[i32 >> 1] | 0) + -1 << 16 >> 16;
+ HEAP16[i32 >> 1] = i33;
+ if (i33 << 16 >> 16 == 0) {
+ if ((i27 | 0) == (i9 | 0)) {
+ break L44;
+ }
+ i27 = HEAPU16[i5 + (HEAPU16[i10 + (i24 << 1) >> 1] << 1) >> 1] | 0;
+ }
+ if (!(i27 >>> 0 > i4 >>> 0)) {
+ continue;
+ }
+ i26 = i25 & i11;
+ if ((i26 | 0) != (i13 | 0)) {
+ break;
+ }
+ }
+ i28 = (i21 | 0) == 0 ? i4 : i21;
+ i23 = i15 + (i23 << 2) | 0;
+ i31 = i27 - i28 | 0;
+ L67 : do {
+ if (i27 >>> 0 < i9 >>> 0) {
+ i29 = i27;
+ i30 = i31;
+ i31 = 1 << i31;
+ while (1) {
+ i31 = i31 - (HEAPU16[i7 + (i29 << 1) >> 1] | 0) | 0;
+ if ((i31 | 0) < 1) {
+ break L67;
+ }
+ i30 = i30 + 1 | 0;
+ i29 = i30 + i28 | 0;
+ if (i29 >>> 0 < i9 >>> 0) {
+ i31 = i31 << 1;
+ } else {
+ break;
+ }
+ }
+ } else {
+ i30 = i31;
+ }
+ } while (0);
+ i29 = (1 << i30) + i14 | 0;
+ if (i20 & i29 >>> 0 > 851 | i16 & i29 >>> 0 > 591) {
+ i8 = 1;
+ i6 = 56;
+ break;
+ }
+ HEAP8[(HEAP32[i2 >> 2] | 0) + (i26 << 2) | 0] = i30;
+ HEAP8[(HEAP32[i2 >> 2] | 0) + (i26 << 2) + 1 | 0] = i12;
+ i22 = HEAP32[i2 >> 2] | 0;
+ HEAP16[i22 + (i26 << 2) + 2 >> 1] = (i23 - i22 | 0) >>> 2;
+ i22 = i30;
+ i21 = i28;
+ i13 = i26;
+ i15 = i23;
+ i14 = i29;
+ }
+ if ((i6 | 0) == 56) {
+ STACKTOP = i3;
+ return i8 | 0;
+ }
+ L77 : do {
+ if ((i25 | 0) != 0) {
+ do {
+ if ((i21 | 0) != 0) {
+ if ((i25 & i11 | 0) != (i13 | 0)) {
+ i21 = 0;
+ i22 = i12;
+ i9 = i4;
+ i15 = HEAP32[i2 >> 2] | 0;
+ }
+ } else {
+ i21 = 0;
+ }
+ i5 = i25 >>> i21;
+ HEAP8[i15 + (i5 << 2) | 0] = 64;
+ HEAP8[i15 + (i5 << 2) + 1 | 0] = i22;
+ HEAP16[i15 + (i5 << 2) + 2 >> 1] = 0;
+ i5 = 1 << i9 + -1;
+ while (1) {
+ if ((i5 & i25 | 0) == 0) {
+ break;
+ } else {
+ i5 = i5 >>> 1;
+ }
+ }
+ if ((i5 | 0) == 0) {
+ break L77;
+ }
+ i25 = (i5 + -1 & i25) + i5 | 0;
+ } while ((i25 | 0) != 0);
+ }
+ } while (0);
+ HEAP32[i2 >> 2] = (HEAP32[i2 >> 2] | 0) + (i14 << 2);
+ HEAP32[i1 >> 2] = i4;
+ i33 = 0;
+ STACKTOP = i3;
+ return i33 | 0;
+}
+function _compress_block(i1, i3, i7) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i4 = 0, i5 = 0, i6 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0;
+ i2 = STACKTOP;
+ i11 = i1 + 5792 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ i14 = HEAP32[i1 + 5820 >> 2] | 0;
+ i17 = HEAP16[i1 + 5816 >> 1] | 0;
+ } else {
+ i9 = i1 + 5796 | 0;
+ i10 = i1 + 5784 | 0;
+ i8 = i1 + 5820 | 0;
+ i12 = i1 + 5816 | 0;
+ i5 = i1 + 20 | 0;
+ i6 = i1 + 8 | 0;
+ i14 = 0;
+ while (1) {
+ i20 = HEAP16[(HEAP32[i9 >> 2] | 0) + (i14 << 1) >> 1] | 0;
+ i13 = i20 & 65535;
+ i4 = i14 + 1 | 0;
+ i14 = HEAPU8[(HEAP32[i10 >> 2] | 0) + i14 | 0] | 0;
+ do {
+ if (i20 << 16 >> 16 == 0) {
+ i15 = HEAPU16[i3 + (i14 << 2) + 2 >> 1] | 0;
+ i13 = HEAP32[i8 >> 2] | 0;
+ i14 = HEAPU16[i3 + (i14 << 2) >> 1] | 0;
+ i16 = HEAPU16[i12 >> 1] | 0 | i14 << i13;
+ i17 = i16 & 65535;
+ HEAP16[i12 >> 1] = i17;
+ if ((i13 | 0) > (16 - i15 | 0)) {
+ i17 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i17 | 0] = i16;
+ i17 = (HEAPU16[i12 >> 1] | 0) >>> 8 & 255;
+ i20 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i20 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i20 | 0] = i17;
+ i20 = HEAP32[i8 >> 2] | 0;
+ i17 = i14 >>> (16 - i20 | 0) & 65535;
+ HEAP16[i12 >> 1] = i17;
+ i14 = i15 + -16 + i20 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ } else {
+ i14 = i13 + i15 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ }
+ } else {
+ i15 = HEAPU8[808 + i14 | 0] | 0;
+ i19 = (i15 | 256) + 1 | 0;
+ i18 = HEAPU16[i3 + (i19 << 2) + 2 >> 1] | 0;
+ i17 = HEAP32[i8 >> 2] | 0;
+ i19 = HEAPU16[i3 + (i19 << 2) >> 1] | 0;
+ i20 = HEAPU16[i12 >> 1] | 0 | i19 << i17;
+ i16 = i20 & 65535;
+ HEAP16[i12 >> 1] = i16;
+ if ((i17 | 0) > (16 - i18 | 0)) {
+ i16 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i16 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i16 | 0] = i20;
+ i16 = (HEAPU16[i12 >> 1] | 0) >>> 8 & 255;
+ i20 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i20 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i20 | 0] = i16;
+ i20 = HEAP32[i8 >> 2] | 0;
+ i16 = i19 >>> (16 - i20 | 0) & 65535;
+ HEAP16[i12 >> 1] = i16;
+ i18 = i18 + -16 + i20 | 0;
+ } else {
+ i18 = i17 + i18 | 0;
+ }
+ HEAP32[i8 >> 2] = i18;
+ i17 = HEAP32[2408 + (i15 << 2) >> 2] | 0;
+ do {
+ if ((i15 + -8 | 0) >>> 0 < 20) {
+ i14 = i14 - (HEAP32[2528 + (i15 << 2) >> 2] | 0) & 65535;
+ i15 = i14 << i18 | i16 & 65535;
+ i16 = i15 & 65535;
+ HEAP16[i12 >> 1] = i16;
+ if ((i18 | 0) > (16 - i17 | 0)) {
+ i16 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i16 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i16 | 0] = i15;
+ i16 = (HEAPU16[i12 >> 1] | 0) >>> 8 & 255;
+ i20 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i20 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i20 | 0] = i16;
+ i20 = HEAP32[i8 >> 2] | 0;
+ i16 = i14 >>> (16 - i20 | 0) & 65535;
+ HEAP16[i12 >> 1] = i16;
+ i14 = i17 + -16 + i20 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ } else {
+ i14 = i18 + i17 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ }
+ } else {
+ i14 = i18;
+ }
+ } while (0);
+ i13 = i13 + -1 | 0;
+ if (i13 >>> 0 < 256) {
+ i15 = i13;
+ } else {
+ i15 = (i13 >>> 7) + 256 | 0;
+ }
+ i15 = HEAPU8[296 + i15 | 0] | 0;
+ i17 = HEAPU16[i7 + (i15 << 2) + 2 >> 1] | 0;
+ i18 = HEAPU16[i7 + (i15 << 2) >> 1] | 0;
+ i19 = i16 & 65535 | i18 << i14;
+ i16 = i19 & 65535;
+ HEAP16[i12 >> 1] = i16;
+ if ((i14 | 0) > (16 - i17 | 0)) {
+ i20 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i20 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i20 | 0] = i19;
+ i20 = (HEAPU16[i12 >> 1] | 0) >>> 8 & 255;
+ i14 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i14 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i14 | 0] = i20;
+ i14 = HEAP32[i8 >> 2] | 0;
+ i20 = i18 >>> (16 - i14 | 0) & 65535;
+ HEAP16[i12 >> 1] = i20;
+ i14 = i17 + -16 + i14 | 0;
+ i17 = i20;
+ } else {
+ i14 = i14 + i17 | 0;
+ i17 = i16;
+ }
+ HEAP32[i8 >> 2] = i14;
+ i16 = HEAP32[2648 + (i15 << 2) >> 2] | 0;
+ if ((i15 + -4 | 0) >>> 0 < 26) {
+ i13 = i13 - (HEAP32[2768 + (i15 << 2) >> 2] | 0) & 65535;
+ i15 = i13 << i14 | i17 & 65535;
+ i17 = i15 & 65535;
+ HEAP16[i12 >> 1] = i17;
+ if ((i14 | 0) > (16 - i16 | 0)) {
+ i17 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i17 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i17 | 0] = i15;
+ i17 = (HEAPU16[i12 >> 1] | 0) >>> 8 & 255;
+ i14 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i5 >> 2] = i14 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i14 | 0] = i17;
+ i14 = HEAP32[i8 >> 2] | 0;
+ i17 = i13 >>> (16 - i14 | 0) & 65535;
+ HEAP16[i12 >> 1] = i17;
+ i14 = i16 + -16 + i14 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ } else {
+ i14 = i14 + i16 | 0;
+ HEAP32[i8 >> 2] = i14;
+ break;
+ }
+ }
+ }
+ } while (0);
+ if (i4 >>> 0 < (HEAP32[i11 >> 2] | 0) >>> 0) {
+ i14 = i4;
+ } else {
+ break;
+ }
+ }
+ }
+ i5 = i3 + 1026 | 0;
+ i6 = HEAPU16[i5 >> 1] | 0;
+ i4 = i1 + 5820 | 0;
+ i3 = HEAPU16[i3 + 1024 >> 1] | 0;
+ i7 = i1 + 5816 | 0;
+ i8 = i17 & 65535 | i3 << i14;
+ HEAP16[i7 >> 1] = i8;
+ if ((i14 | 0) > (16 - i6 | 0)) {
+ i17 = i1 + 20 | 0;
+ i18 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i17 >> 2] = i18 + 1;
+ i20 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i20 >> 2] | 0) + i18 | 0] = i8;
+ i18 = (HEAPU16[i7 >> 1] | 0) >>> 8 & 255;
+ i19 = HEAP32[i17 >> 2] | 0;
+ HEAP32[i17 >> 2] = i19 + 1;
+ HEAP8[(HEAP32[i20 >> 2] | 0) + i19 | 0] = i18;
+ i19 = HEAP32[i4 >> 2] | 0;
+ HEAP16[i7 >> 1] = i3 >>> (16 - i19 | 0);
+ i19 = i6 + -16 + i19 | 0;
+ HEAP32[i4 >> 2] = i19;
+ i19 = HEAP16[i5 >> 1] | 0;
+ i19 = i19 & 65535;
+ i20 = i1 + 5812 | 0;
+ HEAP32[i20 >> 2] = i19;
+ STACKTOP = i2;
+ return;
+ } else {
+ i19 = i14 + i6 | 0;
+ HEAP32[i4 >> 2] = i19;
+ i19 = HEAP16[i5 >> 1] | 0;
+ i19 = i19 & 65535;
+ i20 = i1 + 5812 | 0;
+ HEAP32[i20 >> 2] = i19;
+ STACKTOP = i2;
+ return;
+ }
+}
+function _deflate_stored(i2, i5) {
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i3 = 0, i4 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0;
+ i1 = STACKTOP;
+ i4 = (HEAP32[i2 + 12 >> 2] | 0) + -5 | 0;
+ i11 = i4 >>> 0 < 65535 ? i4 : 65535;
+ i12 = i2 + 116 | 0;
+ i4 = i2 + 108 | 0;
+ i6 = i2 + 92 | 0;
+ i10 = i2 + 44 | 0;
+ i7 = i2 + 56 | 0;
+ while (1) {
+ i13 = HEAP32[i12 >> 2] | 0;
+ if (i13 >>> 0 < 2) {
+ _fill_window(i2);
+ i13 = HEAP32[i12 >> 2] | 0;
+ if ((i13 | i5 | 0) == 0) {
+ i2 = 0;
+ i8 = 28;
+ break;
+ }
+ if ((i13 | 0) == 0) {
+ i8 = 20;
+ break;
+ }
+ }
+ i13 = (HEAP32[i4 >> 2] | 0) + i13 | 0;
+ HEAP32[i4 >> 2] = i13;
+ HEAP32[i12 >> 2] = 0;
+ i14 = HEAP32[i6 >> 2] | 0;
+ i15 = i14 + i11 | 0;
+ if (!((i13 | 0) != 0 & i13 >>> 0 < i15 >>> 0)) {
+ HEAP32[i12 >> 2] = i13 - i15;
+ HEAP32[i4 >> 2] = i15;
+ if ((i14 | 0) > -1) {
+ i13 = (HEAP32[i7 >> 2] | 0) + i14 | 0;
+ } else {
+ i13 = 0;
+ }
+ __tr_flush_block(i2, i13, i11, 0);
+ HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
+ i16 = HEAP32[i2 >> 2] | 0;
+ i14 = i16 + 28 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ i17 = HEAP32[i15 + 20 >> 2] | 0;
+ i13 = i16 + 16 | 0;
+ i18 = HEAP32[i13 >> 2] | 0;
+ i17 = i17 >>> 0 > i18 >>> 0 ? i18 : i17;
+ if ((i17 | 0) != 0 ? (i8 = i16 + 12 | 0, _memcpy(HEAP32[i8 >> 2] | 0, HEAP32[i15 + 16 >> 2] | 0, i17 | 0) | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i17, i8 = (HEAP32[i14 >> 2] | 0) + 16 | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i17, i8 = i16 + 20 | 0, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) + i17, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) - i17, i8 = HEAP32[i14 >> 2] | 0, i16 = i8 + 20 | 0, i18 = HEAP32[i16 >> 2] | 0, HEAP32[i16 >> 2] = i18 - i17, (i18 | 0) == (i17 | 0)) : 0) {
+ HEAP32[i8 + 16 >> 2] = HEAP32[i8 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i2 = 0;
+ i8 = 28;
+ break;
+ }
+ i14 = HEAP32[i6 >> 2] | 0;
+ i13 = HEAP32[i4 >> 2] | 0;
+ }
+ i13 = i13 - i14 | 0;
+ if (i13 >>> 0 < ((HEAP32[i10 >> 2] | 0) + -262 | 0) >>> 0) {
+ continue;
+ }
+ if ((i14 | 0) > -1) {
+ i14 = (HEAP32[i7 >> 2] | 0) + i14 | 0;
+ } else {
+ i14 = 0;
+ }
+ __tr_flush_block(i2, i14, i13, 0);
+ HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
+ i16 = HEAP32[i2 >> 2] | 0;
+ i14 = i16 + 28 | 0;
+ i15 = HEAP32[i14 >> 2] | 0;
+ i17 = HEAP32[i15 + 20 >> 2] | 0;
+ i13 = i16 + 16 | 0;
+ i18 = HEAP32[i13 >> 2] | 0;
+ i17 = i17 >>> 0 > i18 >>> 0 ? i18 : i17;
+ if ((i17 | 0) != 0 ? (i9 = i16 + 12 | 0, _memcpy(HEAP32[i9 >> 2] | 0, HEAP32[i15 + 16 >> 2] | 0, i17 | 0) | 0, HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + i17, i9 = (HEAP32[i14 >> 2] | 0) + 16 | 0, HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + i17, i9 = i16 + 20 | 0, HEAP32[i9 >> 2] = (HEAP32[i9 >> 2] | 0) + i17, HEAP32[i13 >> 2] = (HEAP32[i13 >> 2] | 0) - i17, i9 = HEAP32[i14 >> 2] | 0, i16 = i9 + 20 | 0, i18 = HEAP32[i16 >> 2] | 0, HEAP32[i16 >> 2] = i18 - i17, (i18 | 0) == (i17 | 0)) : 0) {
+ HEAP32[i9 + 16 >> 2] = HEAP32[i9 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i2 = 0;
+ i8 = 28;
+ break;
+ }
+ }
+ if ((i8 | 0) == 20) {
+ i8 = HEAP32[i6 >> 2] | 0;
+ if ((i8 | 0) > -1) {
+ i7 = (HEAP32[i7 >> 2] | 0) + i8 | 0;
+ } else {
+ i7 = 0;
+ }
+ i5 = (i5 | 0) == 4;
+ __tr_flush_block(i2, i7, (HEAP32[i4 >> 2] | 0) - i8 | 0, i5 & 1);
+ HEAP32[i6 >> 2] = HEAP32[i4 >> 2];
+ i4 = HEAP32[i2 >> 2] | 0;
+ i7 = i4 + 28 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ i9 = HEAP32[i6 + 20 >> 2] | 0;
+ i8 = i4 + 16 | 0;
+ i10 = HEAP32[i8 >> 2] | 0;
+ i9 = i9 >>> 0 > i10 >>> 0 ? i10 : i9;
+ if ((i9 | 0) != 0 ? (i3 = i4 + 12 | 0, _memcpy(HEAP32[i3 >> 2] | 0, HEAP32[i6 + 16 >> 2] | 0, i9 | 0) | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, i3 = (HEAP32[i7 >> 2] | 0) + 16 | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, i3 = i4 + 20 | 0, HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + i9, HEAP32[i8 >> 2] = (HEAP32[i8 >> 2] | 0) - i9, i3 = HEAP32[i7 >> 2] | 0, i17 = i3 + 20 | 0, i18 = HEAP32[i17 >> 2] | 0, HEAP32[i17 >> 2] = i18 - i9, (i18 | 0) == (i9 | 0)) : 0) {
+ HEAP32[i3 + 16 >> 2] = HEAP32[i3 + 8 >> 2];
+ }
+ if ((HEAP32[(HEAP32[i2 >> 2] | 0) + 16 >> 2] | 0) == 0) {
+ i18 = i5 ? 2 : 0;
+ STACKTOP = i1;
+ return i18 | 0;
+ } else {
+ i18 = i5 ? 3 : 1;
+ STACKTOP = i1;
+ return i18 | 0;
+ }
+ } else if ((i8 | 0) == 28) {
+ STACKTOP = i1;
+ return i2 | 0;
+ }
+ return 0;
+}
+function _fill_window(i15) {
+ i15 = i15 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0, i24 = 0;
+ i2 = STACKTOP;
+ i16 = i15 + 44 | 0;
+ i9 = HEAP32[i16 >> 2] | 0;
+ i4 = i15 + 60 | 0;
+ i8 = i15 + 116 | 0;
+ i3 = i15 + 108 | 0;
+ i5 = i9 + -262 | 0;
+ i1 = i15 + 56 | 0;
+ i17 = i15 + 72 | 0;
+ i6 = i15 + 88 | 0;
+ i7 = i15 + 84 | 0;
+ i11 = i15 + 112 | 0;
+ i12 = i15 + 92 | 0;
+ i13 = i15 + 76 | 0;
+ i14 = i15 + 68 | 0;
+ i10 = i15 + 64 | 0;
+ i19 = HEAP32[i8 >> 2] | 0;
+ i21 = i9;
+ while (1) {
+ i20 = HEAP32[i3 >> 2] | 0;
+ i19 = (HEAP32[i4 >> 2] | 0) - i19 - i20 | 0;
+ if (!(i20 >>> 0 < (i5 + i21 | 0) >>> 0)) {
+ i20 = HEAP32[i1 >> 2] | 0;
+ _memcpy(i20 | 0, i20 + i9 | 0, i9 | 0) | 0;
+ HEAP32[i11 >> 2] = (HEAP32[i11 >> 2] | 0) - i9;
+ i20 = (HEAP32[i3 >> 2] | 0) - i9 | 0;
+ HEAP32[i3 >> 2] = i20;
+ HEAP32[i12 >> 2] = (HEAP32[i12 >> 2] | 0) - i9;
+ i22 = HEAP32[i13 >> 2] | 0;
+ i21 = i22;
+ i22 = (HEAP32[i14 >> 2] | 0) + (i22 << 1) | 0;
+ do {
+ i22 = i22 + -2 | 0;
+ i23 = HEAPU16[i22 >> 1] | 0;
+ if (i23 >>> 0 < i9 >>> 0) {
+ i23 = 0;
+ } else {
+ i23 = i23 - i9 & 65535;
+ }
+ HEAP16[i22 >> 1] = i23;
+ i21 = i21 + -1 | 0;
+ } while ((i21 | 0) != 0);
+ i22 = i9;
+ i21 = (HEAP32[i10 >> 2] | 0) + (i9 << 1) | 0;
+ do {
+ i21 = i21 + -2 | 0;
+ i23 = HEAPU16[i21 >> 1] | 0;
+ if (i23 >>> 0 < i9 >>> 0) {
+ i23 = 0;
+ } else {
+ i23 = i23 - i9 & 65535;
+ }
+ HEAP16[i21 >> 1] = i23;
+ i22 = i22 + -1 | 0;
+ } while ((i22 | 0) != 0);
+ i19 = i19 + i9 | 0;
+ }
+ i21 = HEAP32[i15 >> 2] | 0;
+ i24 = i21 + 4 | 0;
+ i23 = HEAP32[i24 >> 2] | 0;
+ if ((i23 | 0) == 0) {
+ i18 = 28;
+ break;
+ }
+ i22 = HEAP32[i8 >> 2] | 0;
+ i20 = (HEAP32[i1 >> 2] | 0) + (i22 + i20) | 0;
+ i19 = i23 >>> 0 > i19 >>> 0 ? i19 : i23;
+ if ((i19 | 0) == 0) {
+ i19 = 0;
+ } else {
+ HEAP32[i24 >> 2] = i23 - i19;
+ i22 = HEAP32[(HEAP32[i21 + 28 >> 2] | 0) + 24 >> 2] | 0;
+ if ((i22 | 0) == 1) {
+ i22 = i21 + 48 | 0;
+ HEAP32[i22 >> 2] = _adler32(HEAP32[i22 >> 2] | 0, HEAP32[i21 >> 2] | 0, i19) | 0;
+ i22 = i21;
+ } else if ((i22 | 0) == 2) {
+ i22 = i21 + 48 | 0;
+ HEAP32[i22 >> 2] = _crc32(HEAP32[i22 >> 2] | 0, HEAP32[i21 >> 2] | 0, i19) | 0;
+ i22 = i21;
+ } else {
+ i22 = i21;
+ }
+ _memcpy(i20 | 0, HEAP32[i22 >> 2] | 0, i19 | 0) | 0;
+ HEAP32[i22 >> 2] = (HEAP32[i22 >> 2] | 0) + i19;
+ i22 = i21 + 8 | 0;
+ HEAP32[i22 >> 2] = (HEAP32[i22 >> 2] | 0) + i19;
+ i22 = HEAP32[i8 >> 2] | 0;
+ }
+ i19 = i22 + i19 | 0;
+ HEAP32[i8 >> 2] = i19;
+ if (i19 >>> 0 > 2 ? (i23 = HEAP32[i3 >> 2] | 0, i22 = HEAP32[i1 >> 2] | 0, i24 = HEAPU8[i22 + i23 | 0] | 0, HEAP32[i17 >> 2] = i24, HEAP32[i17 >> 2] = ((HEAPU8[i22 + (i23 + 1) | 0] | 0) ^ i24 << HEAP32[i6 >> 2]) & HEAP32[i7 >> 2], !(i19 >>> 0 < 262)) : 0) {
+ break;
+ }
+ if ((HEAP32[(HEAP32[i15 >> 2] | 0) + 4 >> 2] | 0) == 0) {
+ break;
+ }
+ i21 = HEAP32[i16 >> 2] | 0;
+ }
+ if ((i18 | 0) == 28) {
+ STACKTOP = i2;
+ return;
+ }
+ i5 = i15 + 5824 | 0;
+ i6 = HEAP32[i5 >> 2] | 0;
+ i4 = HEAP32[i4 >> 2] | 0;
+ if (!(i6 >>> 0 < i4 >>> 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i19 + (HEAP32[i3 >> 2] | 0) | 0;
+ if (i6 >>> 0 < i3 >>> 0) {
+ i4 = i4 - i3 | 0;
+ i24 = i4 >>> 0 > 258 ? 258 : i4;
+ _memset((HEAP32[i1 >> 2] | 0) + i3 | 0, 0, i24 | 0) | 0;
+ HEAP32[i5 >> 2] = i24 + i3;
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i3 + 258 | 0;
+ if (!(i6 >>> 0 < i3 >>> 0)) {
+ STACKTOP = i2;
+ return;
+ }
+ i3 = i3 - i6 | 0;
+ i4 = i4 - i6 | 0;
+ i24 = i3 >>> 0 > i4 >>> 0 ? i4 : i3;
+ _memset((HEAP32[i1 >> 2] | 0) + i6 | 0, 0, i24 | 0) | 0;
+ HEAP32[i5 >> 2] = (HEAP32[i5 >> 2] | 0) + i24;
+ STACKTOP = i2;
+ return;
+}
+function __tr_align(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
+ i2 = STACKTOP;
+ i3 = i1 + 5820 | 0;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i4 = i1 + 5816 | 0;
+ i7 = HEAPU16[i4 >> 1] | 0 | 2 << i6;
+ i5 = i7 & 65535;
+ HEAP16[i4 >> 1] = i5;
+ if ((i6 | 0) > 13) {
+ i8 = i1 + 20 | 0;
+ i6 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 + 1;
+ i5 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i5 >> 2] | 0) + i6 | 0] = i7;
+ i7 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i6 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 + 1;
+ HEAP8[(HEAP32[i5 >> 2] | 0) + i6 | 0] = i7;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i5 = 2 >>> (16 - i6 | 0) & 65535;
+ HEAP16[i4 >> 1] = i5;
+ i6 = i6 + -13 | 0;
+ } else {
+ i6 = i6 + 3 | 0;
+ }
+ HEAP32[i3 >> 2] = i6;
+ if ((i6 | 0) > 9) {
+ i7 = i1 + 20 | 0;
+ i6 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i6 + 1;
+ i8 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i6 | 0] = i5;
+ i5 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i6 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i6 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i6 | 0] = i5;
+ HEAP16[i4 >> 1] = 0;
+ i6 = (HEAP32[i3 >> 2] | 0) + -9 | 0;
+ i5 = 0;
+ } else {
+ i6 = i6 + 7 | 0;
+ }
+ HEAP32[i3 >> 2] = i6;
+ if ((i6 | 0) != 16) {
+ if ((i6 | 0) > 7) {
+ i6 = i1 + 20 | 0;
+ i7 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i7 + 1;
+ HEAP8[(HEAP32[i1 + 8 >> 2] | 0) + i7 | 0] = i5;
+ i7 = (HEAPU16[i4 >> 1] | 0) >>> 8;
+ HEAP16[i4 >> 1] = i7;
+ i6 = (HEAP32[i3 >> 2] | 0) + -8 | 0;
+ HEAP32[i3 >> 2] = i6;
+ } else {
+ i7 = i5;
+ }
+ } else {
+ i9 = i1 + 20 | 0;
+ i8 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i8 + 1;
+ i7 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i7 >> 2] | 0) + i8 | 0] = i5;
+ i8 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i6 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i6 + 1;
+ HEAP8[(HEAP32[i7 >> 2] | 0) + i6 | 0] = i8;
+ HEAP16[i4 >> 1] = 0;
+ HEAP32[i3 >> 2] = 0;
+ i6 = 0;
+ i7 = 0;
+ }
+ i5 = i1 + 5812 | 0;
+ if ((11 - i6 + (HEAP32[i5 >> 2] | 0) | 0) >= 9) {
+ HEAP32[i5 >> 2] = 7;
+ STACKTOP = i2;
+ return;
+ }
+ i7 = i7 & 65535 | 2 << i6;
+ HEAP16[i4 >> 1] = i7;
+ if ((i6 | 0) > 13) {
+ i8 = i1 + 20 | 0;
+ i6 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 + 1;
+ i9 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i9 >> 2] | 0) + i6 | 0] = i7;
+ i7 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i6 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i6 + 1;
+ HEAP8[(HEAP32[i9 >> 2] | 0) + i6 | 0] = i7;
+ i6 = HEAP32[i3 >> 2] | 0;
+ i7 = 2 >>> (16 - i6 | 0);
+ HEAP16[i4 >> 1] = i7;
+ i6 = i6 + -13 | 0;
+ } else {
+ i6 = i6 + 3 | 0;
+ }
+ i7 = i7 & 255;
+ HEAP32[i3 >> 2] = i6;
+ if ((i6 | 0) > 9) {
+ i8 = i1 + 20 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i9 + 1;
+ i6 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i9 | 0] = i7;
+ i9 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i7 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i7 + 1;
+ HEAP8[(HEAP32[i6 >> 2] | 0) + i7 | 0] = i9;
+ HEAP16[i4 >> 1] = 0;
+ i7 = 0;
+ i6 = (HEAP32[i3 >> 2] | 0) + -9 | 0;
+ } else {
+ i6 = i6 + 7 | 0;
+ }
+ HEAP32[i3 >> 2] = i6;
+ if ((i6 | 0) == 16) {
+ i6 = i1 + 20 | 0;
+ i9 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i9 + 1;
+ i8 = i1 + 8 | 0;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i9 | 0] = i7;
+ i7 = (HEAPU16[i4 >> 1] | 0) >>> 8 & 255;
+ i9 = HEAP32[i6 >> 2] | 0;
+ HEAP32[i6 >> 2] = i9 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i9 | 0] = i7;
+ HEAP16[i4 >> 1] = 0;
+ HEAP32[i3 >> 2] = 0;
+ HEAP32[i5 >> 2] = 7;
+ STACKTOP = i2;
+ return;
+ }
+ if ((i6 | 0) <= 7) {
+ HEAP32[i5 >> 2] = 7;
+ STACKTOP = i2;
+ return;
+ }
+ i8 = i1 + 20 | 0;
+ i9 = HEAP32[i8 >> 2] | 0;
+ HEAP32[i8 >> 2] = i9 + 1;
+ HEAP8[(HEAP32[i1 + 8 >> 2] | 0) + i9 | 0] = i7;
+ HEAP16[i4 >> 1] = (HEAPU16[i4 >> 1] | 0) >>> 8;
+ HEAP32[i3 >> 2] = (HEAP32[i3 >> 2] | 0) + -8;
+ HEAP32[i5 >> 2] = 7;
+ STACKTOP = i2;
+ return;
+}
+function _adler32(i6, i4, i5) {
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0, i17 = 0, i18 = 0, i19 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0;
+ i1 = STACKTOP;
+ i3 = i6 >>> 16;
+ i6 = i6 & 65535;
+ if ((i5 | 0) == 1) {
+ i2 = (HEAPU8[i4] | 0) + i6 | 0;
+ i2 = i2 >>> 0 > 65520 ? i2 + -65521 | 0 : i2;
+ i3 = i2 + i3 | 0;
+ i8 = (i3 >>> 0 > 65520 ? i3 + 15 | 0 : i3) << 16 | i2;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ if ((i4 | 0) == 0) {
+ i8 = 1;
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ if (i5 >>> 0 < 16) {
+ if ((i5 | 0) != 0) {
+ while (1) {
+ i5 = i5 + -1 | 0;
+ i6 = (HEAPU8[i4] | 0) + i6 | 0;
+ i3 = i6 + i3 | 0;
+ if ((i5 | 0) == 0) {
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ }
+ }
+ }
+ i8 = ((i3 >>> 0) % 65521 | 0) << 16 | (i6 >>> 0 > 65520 ? i6 + -65521 | 0 : i6);
+ STACKTOP = i1;
+ return i8 | 0;
+ }
+ if (i5 >>> 0 > 5551) {
+ do {
+ i5 = i5 + -5552 | 0;
+ i7 = i4;
+ i8 = 347;
+ while (1) {
+ i23 = (HEAPU8[i7] | 0) + i6 | 0;
+ i22 = i23 + (HEAPU8[i7 + 1 | 0] | 0) | 0;
+ i21 = i22 + (HEAPU8[i7 + 2 | 0] | 0) | 0;
+ i20 = i21 + (HEAPU8[i7 + 3 | 0] | 0) | 0;
+ i19 = i20 + (HEAPU8[i7 + 4 | 0] | 0) | 0;
+ i18 = i19 + (HEAPU8[i7 + 5 | 0] | 0) | 0;
+ i17 = i18 + (HEAPU8[i7 + 6 | 0] | 0) | 0;
+ i16 = i17 + (HEAPU8[i7 + 7 | 0] | 0) | 0;
+ i15 = i16 + (HEAPU8[i7 + 8 | 0] | 0) | 0;
+ i14 = i15 + (HEAPU8[i7 + 9 | 0] | 0) | 0;
+ i13 = i14 + (HEAPU8[i7 + 10 | 0] | 0) | 0;
+ i12 = i13 + (HEAPU8[i7 + 11 | 0] | 0) | 0;
+ i11 = i12 + (HEAPU8[i7 + 12 | 0] | 0) | 0;
+ i10 = i11 + (HEAPU8[i7 + 13 | 0] | 0) | 0;
+ i9 = i10 + (HEAPU8[i7 + 14 | 0] | 0) | 0;
+ i6 = i9 + (HEAPU8[i7 + 15 | 0] | 0) | 0;
+ i3 = i23 + i3 + i22 + i21 + i20 + i19 + i18 + i17 + i16 + i15 + i14 + i13 + i12 + i11 + i10 + i9 + i6 | 0;
+ i8 = i8 + -1 | 0;
+ if ((i8 | 0) == 0) {
+ break;
+ } else {
+ i7 = i7 + 16 | 0;
+ }
+ }
+ i4 = i4 + 5552 | 0;
+ i6 = (i6 >>> 0) % 65521 | 0;
+ i3 = (i3 >>> 0) % 65521 | 0;
+ } while (i5 >>> 0 > 5551);
+ if ((i5 | 0) != 0) {
+ if (i5 >>> 0 > 15) {
+ i2 = 15;
+ } else {
+ i2 = 16;
+ }
+ }
+ } else {
+ i2 = 15;
+ }
+ if ((i2 | 0) == 15) {
+ while (1) {
+ i5 = i5 + -16 | 0;
+ i9 = (HEAPU8[i4] | 0) + i6 | 0;
+ i10 = i9 + (HEAPU8[i4 + 1 | 0] | 0) | 0;
+ i11 = i10 + (HEAPU8[i4 + 2 | 0] | 0) | 0;
+ i12 = i11 + (HEAPU8[i4 + 3 | 0] | 0) | 0;
+ i13 = i12 + (HEAPU8[i4 + 4 | 0] | 0) | 0;
+ i14 = i13 + (HEAPU8[i4 + 5 | 0] | 0) | 0;
+ i15 = i14 + (HEAPU8[i4 + 6 | 0] | 0) | 0;
+ i16 = i15 + (HEAPU8[i4 + 7 | 0] | 0) | 0;
+ i17 = i16 + (HEAPU8[i4 + 8 | 0] | 0) | 0;
+ i18 = i17 + (HEAPU8[i4 + 9 | 0] | 0) | 0;
+ i19 = i18 + (HEAPU8[i4 + 10 | 0] | 0) | 0;
+ i20 = i19 + (HEAPU8[i4 + 11 | 0] | 0) | 0;
+ i21 = i20 + (HEAPU8[i4 + 12 | 0] | 0) | 0;
+ i22 = i21 + (HEAPU8[i4 + 13 | 0] | 0) | 0;
+ i23 = i22 + (HEAPU8[i4 + 14 | 0] | 0) | 0;
+ i6 = i23 + (HEAPU8[i4 + 15 | 0] | 0) | 0;
+ i3 = i9 + i3 + i10 + i11 + i12 + i13 + i14 + i15 + i16 + i17 + i18 + i19 + i20 + i21 + i22 + i23 + i6 | 0;
+ i4 = i4 + 16 | 0;
+ if (!(i5 >>> 0 > 15)) {
+ break;
+ } else {
+ i2 = 15;
+ }
+ }
+ if ((i5 | 0) == 0) {
+ i2 = 17;
+ } else {
+ i2 = 16;
+ }
+ }
+ if ((i2 | 0) == 16) {
+ while (1) {
+ i5 = i5 + -1 | 0;
+ i6 = (HEAPU8[i4] | 0) + i6 | 0;
+ i3 = i6 + i3 | 0;
+ if ((i5 | 0) == 0) {
+ i2 = 17;
+ break;
+ } else {
+ i4 = i4 + 1 | 0;
+ i2 = 16;
+ }
+ }
+ }
+ if ((i2 | 0) == 17) {
+ i6 = (i6 >>> 0) % 65521 | 0;
+ i3 = (i3 >>> 0) % 65521 | 0;
+ }
+ i23 = i3 << 16 | i6;
+ STACKTOP = i1;
+ return i23 | 0;
+}
+function _crc32(i4, i2, i3) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ var i1 = 0, i5 = 0;
+ i1 = STACKTOP;
+ if ((i2 | 0) == 0) {
+ i5 = 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ i4 = ~i4;
+ L4 : do {
+ if ((i3 | 0) != 0) {
+ while (1) {
+ if ((i2 & 3 | 0) == 0) {
+ break;
+ }
+ i4 = HEAP32[3192 + (((HEAPU8[i2] | 0) ^ i4 & 255) << 2) >> 2] ^ i4 >>> 8;
+ i3 = i3 + -1 | 0;
+ if ((i3 | 0) == 0) {
+ break L4;
+ } else {
+ i2 = i2 + 1 | 0;
+ }
+ }
+ if (i3 >>> 0 > 31) {
+ while (1) {
+ i4 = HEAP32[i2 >> 2] ^ i4;
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 4 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 8 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 12 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 16 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 20 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 24 >> 2];
+ i5 = i2 + 32 | 0;
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2] ^ HEAP32[i2 + 28 >> 2];
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2];
+ i3 = i3 + -32 | 0;
+ if (i3 >>> 0 > 31) {
+ i2 = i5;
+ } else {
+ i2 = i5;
+ break;
+ }
+ }
+ }
+ if (i3 >>> 0 > 3) {
+ while (1) {
+ i5 = i2 + 4 | 0;
+ i4 = HEAP32[i2 >> 2] ^ i4;
+ i4 = HEAP32[5240 + ((i4 >>> 8 & 255) << 2) >> 2] ^ HEAP32[6264 + ((i4 & 255) << 2) >> 2] ^ HEAP32[4216 + ((i4 >>> 16 & 255) << 2) >> 2] ^ HEAP32[3192 + (i4 >>> 24 << 2) >> 2];
+ i3 = i3 + -4 | 0;
+ if (i3 >>> 0 > 3) {
+ i2 = i5;
+ } else {
+ i2 = i5;
+ break;
+ }
+ }
+ }
+ if ((i3 | 0) != 0) {
+ while (1) {
+ i4 = HEAP32[3192 + (((HEAPU8[i2] | 0) ^ i4 & 255) << 2) >> 2] ^ i4 >>> 8;
+ i3 = i3 + -1 | 0;
+ if ((i3 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 1 | 0;
+ }
+ }
+ }
+ }
+ } while (0);
+ i5 = ~i4;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _deflateInit2_(i3, i7, i8, i10, i4, i1, i5, i6) {
+ i3 = i3 | 0;
+ i7 = i7 | 0;
+ i8 = i8 | 0;
+ i10 = i10 | 0;
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i9 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0;
+ i2 = STACKTOP;
+ if ((i5 | 0) == 0) {
+ i12 = -6;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ if (!((HEAP8[i5] | 0) == 49 & (i6 | 0) == 56)) {
+ i12 = -6;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ if ((i3 | 0) == 0) {
+ i12 = -2;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ i5 = i3 + 24 | 0;
+ HEAP32[i5 >> 2] = 0;
+ i6 = i3 + 32 | 0;
+ i9 = HEAP32[i6 >> 2] | 0;
+ if ((i9 | 0) == 0) {
+ HEAP32[i6 >> 2] = 1;
+ HEAP32[i3 + 40 >> 2] = 0;
+ i9 = 1;
+ }
+ i11 = i3 + 36 | 0;
+ if ((HEAP32[i11 >> 2] | 0) == 0) {
+ HEAP32[i11 >> 2] = 1;
+ }
+ i7 = (i7 | 0) == -1 ? 6 : i7;
+ if ((i10 | 0) < 0) {
+ i10 = 0 - i10 | 0;
+ i11 = 0;
+ } else {
+ i11 = (i10 | 0) > 15;
+ i10 = i11 ? i10 + -16 | 0 : i10;
+ i11 = i11 ? 2 : 1;
+ }
+ if (!((i4 + -1 | 0) >>> 0 < 9 & (i8 | 0) == 8)) {
+ i12 = -2;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ if ((i10 + -8 | 0) >>> 0 > 7 | i7 >>> 0 > 9 | i1 >>> 0 > 4) {
+ i12 = -2;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ i12 = (i10 | 0) == 8 ? 9 : i10;
+ i10 = i3 + 40 | 0;
+ i8 = FUNCTION_TABLE_iiii[i9 & 1](HEAP32[i10 >> 2] | 0, 1, 5828) | 0;
+ if ((i8 | 0) == 0) {
+ i12 = -4;
+ STACKTOP = i2;
+ return i12 | 0;
+ }
+ HEAP32[i3 + 28 >> 2] = i8;
+ HEAP32[i8 >> 2] = i3;
+ HEAP32[i8 + 24 >> 2] = i11;
+ HEAP32[i8 + 28 >> 2] = 0;
+ HEAP32[i8 + 48 >> 2] = i12;
+ i14 = 1 << i12;
+ i11 = i8 + 44 | 0;
+ HEAP32[i11 >> 2] = i14;
+ HEAP32[i8 + 52 >> 2] = i14 + -1;
+ i12 = i4 + 7 | 0;
+ HEAP32[i8 + 80 >> 2] = i12;
+ i12 = 1 << i12;
+ i13 = i8 + 76 | 0;
+ HEAP32[i13 >> 2] = i12;
+ HEAP32[i8 + 84 >> 2] = i12 + -1;
+ HEAP32[i8 + 88 >> 2] = ((i4 + 9 | 0) >>> 0) / 3 | 0;
+ i12 = i8 + 56 | 0;
+ HEAP32[i12 >> 2] = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 1](HEAP32[i10 >> 2] | 0, i14, 2) | 0;
+ i14 = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 1](HEAP32[i10 >> 2] | 0, HEAP32[i11 >> 2] | 0, 2) | 0;
+ i9 = i8 + 64 | 0;
+ HEAP32[i9 >> 2] = i14;
+ _memset(i14 | 0, 0, HEAP32[i11 >> 2] << 1 | 0) | 0;
+ i11 = i8 + 68 | 0;
+ HEAP32[i11 >> 2] = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 1](HEAP32[i10 >> 2] | 0, HEAP32[i13 >> 2] | 0, 2) | 0;
+ HEAP32[i8 + 5824 >> 2] = 0;
+ i4 = 1 << i4 + 6;
+ i13 = i8 + 5788 | 0;
+ HEAP32[i13 >> 2] = i4;
+ i4 = FUNCTION_TABLE_iiii[HEAP32[i6 >> 2] & 1](HEAP32[i10 >> 2] | 0, i4, 4) | 0;
+ HEAP32[i8 + 8 >> 2] = i4;
+ i6 = HEAP32[i13 >> 2] | 0;
+ HEAP32[i8 + 12 >> 2] = i6 << 2;
+ if (((HEAP32[i12 >> 2] | 0) != 0 ? (HEAP32[i9 >> 2] | 0) != 0 : 0) ? !((HEAP32[i11 >> 2] | 0) == 0 | (i4 | 0) == 0) : 0) {
+ HEAP32[i8 + 5796 >> 2] = i4 + (i6 >>> 1 << 1);
+ HEAP32[i8 + 5784 >> 2] = i4 + (i6 * 3 | 0);
+ HEAP32[i8 + 132 >> 2] = i7;
+ HEAP32[i8 + 136 >> 2] = i1;
+ HEAP8[i8 + 36 | 0] = 8;
+ i14 = _deflateReset(i3) | 0;
+ STACKTOP = i2;
+ return i14 | 0;
+ }
+ HEAP32[i8 + 4 >> 2] = 666;
+ HEAP32[i5 >> 2] = HEAP32[3176 >> 2];
+ _deflateEnd(i3) | 0;
+ i14 = -4;
+ STACKTOP = i2;
+ return i14 | 0;
+}
+function _longest_match(i19, i16) {
+ i19 = i19 | 0;
+ i16 = i16 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i17 = 0, i18 = 0, i20 = 0, i21 = 0, i22 = 0, i23 = 0;
+ i1 = STACKTOP;
+ i18 = HEAP32[i19 + 124 >> 2] | 0;
+ i3 = HEAP32[i19 + 56 >> 2] | 0;
+ i5 = HEAP32[i19 + 108 >> 2] | 0;
+ i4 = i3 + i5 | 0;
+ i20 = HEAP32[i19 + 120 >> 2] | 0;
+ i10 = HEAP32[i19 + 144 >> 2] | 0;
+ i2 = (HEAP32[i19 + 44 >> 2] | 0) + -262 | 0;
+ i8 = i5 >>> 0 > i2 >>> 0 ? i5 - i2 | 0 : 0;
+ i6 = HEAP32[i19 + 64 >> 2] | 0;
+ i7 = HEAP32[i19 + 52 >> 2] | 0;
+ i9 = i3 + (i5 + 258) | 0;
+ i2 = HEAP32[i19 + 116 >> 2] | 0;
+ i12 = i10 >>> 0 > i2 >>> 0 ? i2 : i10;
+ i11 = i19 + 112 | 0;
+ i15 = i3 + (i5 + 1) | 0;
+ i14 = i3 + (i5 + 2) | 0;
+ i13 = i9;
+ i10 = i5 + 257 | 0;
+ i17 = i20;
+ i18 = i20 >>> 0 < (HEAP32[i19 + 140 >> 2] | 0) >>> 0 ? i18 : i18 >>> 2;
+ i19 = HEAP8[i3 + (i20 + i5) | 0] | 0;
+ i20 = HEAP8[i3 + (i5 + -1 + i20) | 0] | 0;
+ while (1) {
+ i21 = i3 + i16 | 0;
+ if ((((HEAP8[i3 + (i16 + i17) | 0] | 0) == i19 << 24 >> 24 ? (HEAP8[i3 + (i17 + -1 + i16) | 0] | 0) == i20 << 24 >> 24 : 0) ? (HEAP8[i21] | 0) == (HEAP8[i4] | 0) : 0) ? (HEAP8[i3 + (i16 + 1) | 0] | 0) == (HEAP8[i15] | 0) : 0) {
+ i21 = i3 + (i16 + 2) | 0;
+ i22 = i14;
+ do {
+ i23 = i22 + 1 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 1 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 2 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 2 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 3 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 3 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 4 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 4 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 5 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 5 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 6 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 6 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i23 = i22 + 7 | 0;
+ if ((HEAP8[i23] | 0) != (HEAP8[i21 + 7 | 0] | 0)) {
+ i22 = i23;
+ break;
+ }
+ i22 = i22 + 8 | 0;
+ i21 = i21 + 8 | 0;
+ } while ((HEAP8[i22] | 0) == (HEAP8[i21] | 0) & i22 >>> 0 < i9 >>> 0);
+ i21 = i22 - i13 | 0;
+ i22 = i21 + 258 | 0;
+ if ((i22 | 0) > (i17 | 0)) {
+ HEAP32[i11 >> 2] = i16;
+ if ((i22 | 0) >= (i12 | 0)) {
+ i17 = i22;
+ i3 = 20;
+ break;
+ }
+ i17 = i22;
+ i19 = HEAP8[i3 + (i22 + i5) | 0] | 0;
+ i20 = HEAP8[i3 + (i10 + i21) | 0] | 0;
+ }
+ }
+ i16 = HEAPU16[i6 + ((i16 & i7) << 1) >> 1] | 0;
+ if (!(i16 >>> 0 > i8 >>> 0)) {
+ i3 = 20;
+ break;
+ }
+ i18 = i18 + -1 | 0;
+ if ((i18 | 0) == 0) {
+ i3 = 20;
+ break;
+ }
+ }
+ if ((i3 | 0) == 20) {
+ STACKTOP = i1;
+ return (i17 >>> 0 > i2 >>> 0 ? i2 : i17) | 0;
+ }
+ return 0;
+}
+function __tr_stored_block(i3, i2, i5, i6) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i1 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i1 = STACKTOP;
+ i4 = i3 + 5820 | 0;
+ i7 = HEAP32[i4 >> 2] | 0;
+ i9 = i6 & 65535;
+ i6 = i3 + 5816 | 0;
+ i8 = HEAPU16[i6 >> 1] | 0 | i9 << i7;
+ HEAP16[i6 >> 1] = i8;
+ if ((i7 | 0) > 13) {
+ i11 = i3 + 20 | 0;
+ i7 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i7 + 1;
+ i10 = i3 + 8 | 0;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i7 | 0] = i8;
+ i8 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i7 = HEAP32[i11 >> 2] | 0;
+ HEAP32[i11 >> 2] = i7 + 1;
+ HEAP8[(HEAP32[i10 >> 2] | 0) + i7 | 0] = i8;
+ i7 = HEAP32[i4 >> 2] | 0;
+ i8 = i9 >>> (16 - i7 | 0);
+ HEAP16[i6 >> 1] = i8;
+ i7 = i7 + -13 | 0;
+ } else {
+ i7 = i7 + 3 | 0;
+ }
+ i8 = i8 & 255;
+ HEAP32[i4 >> 2] = i7;
+ do {
+ if ((i7 | 0) <= 8) {
+ i9 = i3 + 20 | 0;
+ if ((i7 | 0) > 0) {
+ i7 = HEAP32[i9 >> 2] | 0;
+ HEAP32[i9 >> 2] = i7 + 1;
+ i11 = i3 + 8 | 0;
+ HEAP8[(HEAP32[i11 >> 2] | 0) + i7 | 0] = i8;
+ i7 = i9;
+ i8 = i11;
+ break;
+ } else {
+ i7 = i9;
+ i8 = i3 + 8 | 0;
+ break;
+ }
+ } else {
+ i7 = i3 + 20 | 0;
+ i10 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i10 + 1;
+ i11 = i3 + 8 | 0;
+ HEAP8[(HEAP32[i11 >> 2] | 0) + i10 | 0] = i8;
+ i10 = (HEAPU16[i6 >> 1] | 0) >>> 8 & 255;
+ i8 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i8 + 1;
+ HEAP8[(HEAP32[i11 >> 2] | 0) + i8 | 0] = i10;
+ i8 = i11;
+ }
+ } while (0);
+ HEAP16[i6 >> 1] = 0;
+ HEAP32[i4 >> 2] = 0;
+ HEAP32[i3 + 5812 >> 2] = 8;
+ i10 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i10 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i10 | 0] = i5;
+ i10 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i10 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i10 | 0] = i5 >>> 8;
+ i10 = i5 & 65535 ^ 65535;
+ i11 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i11 | 0] = i10;
+ i11 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i11 | 0] = i10 >>> 8;
+ if ((i5 | 0) == 0) {
+ STACKTOP = i1;
+ return;
+ }
+ while (1) {
+ i5 = i5 + -1 | 0;
+ i10 = HEAP8[i2] | 0;
+ i11 = HEAP32[i7 >> 2] | 0;
+ HEAP32[i7 >> 2] = i11 + 1;
+ HEAP8[(HEAP32[i8 >> 2] | 0) + i11 | 0] = i10;
+ if ((i5 | 0) == 0) {
+ break;
+ } else {
+ i2 = i2 + 1 | 0;
+ }
+ }
+ STACKTOP = i1;
+ return;
+}
+function _inflateInit_(i1, i3, i4) {
+ i1 = i1 | 0;
+ i3 = i3 | 0;
+ i4 = i4 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0;
+ i2 = STACKTOP;
+ if ((i3 | 0) == 0) {
+ i11 = -6;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ if (!((HEAP8[i3] | 0) == 49 & (i4 | 0) == 56)) {
+ i11 = -6;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ if ((i1 | 0) == 0) {
+ i11 = -2;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ i3 = i1 + 24 | 0;
+ HEAP32[i3 >> 2] = 0;
+ i4 = i1 + 32 | 0;
+ i6 = HEAP32[i4 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ HEAP32[i4 >> 2] = 1;
+ HEAP32[i1 + 40 >> 2] = 0;
+ i6 = 1;
+ }
+ i4 = i1 + 36 | 0;
+ if ((HEAP32[i4 >> 2] | 0) == 0) {
+ HEAP32[i4 >> 2] = 1;
+ }
+ i5 = i1 + 40 | 0;
+ i8 = FUNCTION_TABLE_iiii[i6 & 1](HEAP32[i5 >> 2] | 0, 1, 7116) | 0;
+ if ((i8 | 0) == 0) {
+ i11 = -4;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ i6 = i1 + 28 | 0;
+ HEAP32[i6 >> 2] = i8;
+ HEAP32[i8 + 52 >> 2] = 0;
+ i9 = HEAP32[i6 >> 2] | 0;
+ do {
+ if ((i9 | 0) != 0) {
+ i10 = i9 + 52 | 0;
+ i11 = HEAP32[i10 >> 2] | 0;
+ i7 = i9 + 36 | 0;
+ if ((i11 | 0) != 0) {
+ if ((HEAP32[i7 >> 2] | 0) == 15) {
+ i10 = i9;
+ } else {
+ FUNCTION_TABLE_vii[HEAP32[i4 >> 2] & 1](HEAP32[i5 >> 2] | 0, i11);
+ HEAP32[i10 >> 2] = 0;
+ i10 = HEAP32[i6 >> 2] | 0;
+ }
+ HEAP32[i9 + 8 >> 2] = 1;
+ HEAP32[i7 >> 2] = 15;
+ if ((i10 | 0) == 0) {
+ break;
+ } else {
+ i9 = i10;
+ }
+ } else {
+ HEAP32[i9 + 8 >> 2] = 1;
+ HEAP32[i7 >> 2] = 15;
+ }
+ HEAP32[i9 + 28 >> 2] = 0;
+ HEAP32[i1 + 20 >> 2] = 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i3 >> 2] = 0;
+ HEAP32[i1 + 48 >> 2] = 1;
+ HEAP32[i9 >> 2] = 0;
+ HEAP32[i9 + 4 >> 2] = 0;
+ HEAP32[i9 + 12 >> 2] = 0;
+ HEAP32[i9 + 20 >> 2] = 32768;
+ HEAP32[i9 + 32 >> 2] = 0;
+ HEAP32[i9 + 40 >> 2] = 0;
+ HEAP32[i9 + 44 >> 2] = 0;
+ HEAP32[i9 + 48 >> 2] = 0;
+ HEAP32[i9 + 56 >> 2] = 0;
+ HEAP32[i9 + 60 >> 2] = 0;
+ i11 = i9 + 1328 | 0;
+ HEAP32[i9 + 108 >> 2] = i11;
+ HEAP32[i9 + 80 >> 2] = i11;
+ HEAP32[i9 + 76 >> 2] = i11;
+ HEAP32[i9 + 7104 >> 2] = 1;
+ HEAP32[i9 + 7108 >> 2] = -1;
+ i11 = 0;
+ STACKTOP = i2;
+ return i11 | 0;
+ }
+ } while (0);
+ FUNCTION_TABLE_vii[HEAP32[i4 >> 2] & 1](HEAP32[i5 >> 2] | 0, i8);
+ HEAP32[i6 >> 2] = 0;
+ i11 = -2;
+ STACKTOP = i2;
+ return i11 | 0;
+}
+function _init_block(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ i3 = 0;
+ do {
+ HEAP16[i1 + (i3 << 2) + 148 >> 1] = 0;
+ i3 = i3 + 1 | 0;
+ } while ((i3 | 0) != 286);
+ HEAP16[i1 + 2440 >> 1] = 0;
+ HEAP16[i1 + 2444 >> 1] = 0;
+ HEAP16[i1 + 2448 >> 1] = 0;
+ HEAP16[i1 + 2452 >> 1] = 0;
+ HEAP16[i1 + 2456 >> 1] = 0;
+ HEAP16[i1 + 2460 >> 1] = 0;
+ HEAP16[i1 + 2464 >> 1] = 0;
+ HEAP16[i1 + 2468 >> 1] = 0;
+ HEAP16[i1 + 2472 >> 1] = 0;
+ HEAP16[i1 + 2476 >> 1] = 0;
+ HEAP16[i1 + 2480 >> 1] = 0;
+ HEAP16[i1 + 2484 >> 1] = 0;
+ HEAP16[i1 + 2488 >> 1] = 0;
+ HEAP16[i1 + 2492 >> 1] = 0;
+ HEAP16[i1 + 2496 >> 1] = 0;
+ HEAP16[i1 + 2500 >> 1] = 0;
+ HEAP16[i1 + 2504 >> 1] = 0;
+ HEAP16[i1 + 2508 >> 1] = 0;
+ HEAP16[i1 + 2512 >> 1] = 0;
+ HEAP16[i1 + 2516 >> 1] = 0;
+ HEAP16[i1 + 2520 >> 1] = 0;
+ HEAP16[i1 + 2524 >> 1] = 0;
+ HEAP16[i1 + 2528 >> 1] = 0;
+ HEAP16[i1 + 2532 >> 1] = 0;
+ HEAP16[i1 + 2536 >> 1] = 0;
+ HEAP16[i1 + 2540 >> 1] = 0;
+ HEAP16[i1 + 2544 >> 1] = 0;
+ HEAP16[i1 + 2548 >> 1] = 0;
+ HEAP16[i1 + 2552 >> 1] = 0;
+ HEAP16[i1 + 2556 >> 1] = 0;
+ HEAP16[i1 + 2684 >> 1] = 0;
+ HEAP16[i1 + 2688 >> 1] = 0;
+ HEAP16[i1 + 2692 >> 1] = 0;
+ HEAP16[i1 + 2696 >> 1] = 0;
+ HEAP16[i1 + 2700 >> 1] = 0;
+ HEAP16[i1 + 2704 >> 1] = 0;
+ HEAP16[i1 + 2708 >> 1] = 0;
+ HEAP16[i1 + 2712 >> 1] = 0;
+ HEAP16[i1 + 2716 >> 1] = 0;
+ HEAP16[i1 + 2720 >> 1] = 0;
+ HEAP16[i1 + 2724 >> 1] = 0;
+ HEAP16[i1 + 2728 >> 1] = 0;
+ HEAP16[i1 + 2732 >> 1] = 0;
+ HEAP16[i1 + 2736 >> 1] = 0;
+ HEAP16[i1 + 2740 >> 1] = 0;
+ HEAP16[i1 + 2744 >> 1] = 0;
+ HEAP16[i1 + 2748 >> 1] = 0;
+ HEAP16[i1 + 2752 >> 1] = 0;
+ HEAP16[i1 + 2756 >> 1] = 0;
+ HEAP16[i1 + 1172 >> 1] = 1;
+ HEAP32[i1 + 5804 >> 2] = 0;
+ HEAP32[i1 + 5800 >> 2] = 0;
+ HEAP32[i1 + 5808 >> 2] = 0;
+ HEAP32[i1 + 5792 >> 2] = 0;
+ STACKTOP = i2;
+ return;
+}
+function _deflateReset(i1) {
+ i1 = i1 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0;
+ i2 = STACKTOP;
+ if ((i1 | 0) == 0) {
+ i5 = -2;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ i3 = HEAP32[i1 + 28 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ i5 = -2;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ if ((HEAP32[i1 + 32 >> 2] | 0) == 0) {
+ i5 = -2;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ if ((HEAP32[i1 + 36 >> 2] | 0) == 0) {
+ i5 = -2;
+ STACKTOP = i2;
+ return i5 | 0;
+ }
+ HEAP32[i1 + 20 >> 2] = 0;
+ HEAP32[i1 + 8 >> 2] = 0;
+ HEAP32[i1 + 24 >> 2] = 0;
+ HEAP32[i1 + 44 >> 2] = 2;
+ HEAP32[i3 + 20 >> 2] = 0;
+ HEAP32[i3 + 16 >> 2] = HEAP32[i3 + 8 >> 2];
+ i4 = i3 + 24 | 0;
+ i5 = HEAP32[i4 >> 2] | 0;
+ if ((i5 | 0) < 0) {
+ i5 = 0 - i5 | 0;
+ HEAP32[i4 >> 2] = i5;
+ }
+ HEAP32[i3 + 4 >> 2] = (i5 | 0) != 0 ? 42 : 113;
+ if ((i5 | 0) == 2) {
+ i4 = _crc32(0, 0, 0) | 0;
+ } else {
+ i4 = _adler32(0, 0, 0) | 0;
+ }
+ HEAP32[i1 + 48 >> 2] = i4;
+ HEAP32[i3 + 40 >> 2] = 0;
+ __tr_init(i3);
+ HEAP32[i3 + 60 >> 2] = HEAP32[i3 + 44 >> 2] << 1;
+ i5 = HEAP32[i3 + 76 >> 2] | 0;
+ i4 = HEAP32[i3 + 68 >> 2] | 0;
+ HEAP16[i4 + (i5 + -1 << 1) >> 1] = 0;
+ _memset(i4 | 0, 0, (i5 << 1) + -2 | 0) | 0;
+ i5 = HEAP32[i3 + 132 >> 2] | 0;
+ HEAP32[i3 + 128 >> 2] = HEAPU16[178 + (i5 * 12 | 0) >> 1] | 0;
+ HEAP32[i3 + 140 >> 2] = HEAPU16[176 + (i5 * 12 | 0) >> 1] | 0;
+ HEAP32[i3 + 144 >> 2] = HEAPU16[180 + (i5 * 12 | 0) >> 1] | 0;
+ HEAP32[i3 + 124 >> 2] = HEAPU16[182 + (i5 * 12 | 0) >> 1] | 0;
+ HEAP32[i3 + 108 >> 2] = 0;
+ HEAP32[i3 + 92 >> 2] = 0;
+ HEAP32[i3 + 116 >> 2] = 0;
+ HEAP32[i3 + 120 >> 2] = 2;
+ HEAP32[i3 + 96 >> 2] = 2;
+ HEAP32[i3 + 112 >> 2] = 0;
+ HEAP32[i3 + 104 >> 2] = 0;
+ HEAP32[i3 + 72 >> 2] = 0;
+ i5 = 0;
+ STACKTOP = i2;
+ return i5 | 0;
+}
+function _updatewindow(i6, i4) {
+ i6 = i6 | 0;
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0;
+ i1 = STACKTOP;
+ i2 = HEAP32[i6 + 28 >> 2] | 0;
+ i3 = i2 + 52 | 0;
+ i8 = HEAP32[i3 >> 2] | 0;
+ if ((i8 | 0) == 0) {
+ i8 = FUNCTION_TABLE_iiii[HEAP32[i6 + 32 >> 2] & 1](HEAP32[i6 + 40 >> 2] | 0, 1 << HEAP32[i2 + 36 >> 2], 1) | 0;
+ HEAP32[i3 >> 2] = i8;
+ if ((i8 | 0) == 0) {
+ i10 = 1;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ }
+ i5 = i2 + 40 | 0;
+ i10 = HEAP32[i5 >> 2] | 0;
+ if ((i10 | 0) == 0) {
+ i10 = 1 << HEAP32[i2 + 36 >> 2];
+ HEAP32[i5 >> 2] = i10;
+ HEAP32[i2 + 48 >> 2] = 0;
+ HEAP32[i2 + 44 >> 2] = 0;
+ }
+ i4 = i4 - (HEAP32[i6 + 16 >> 2] | 0) | 0;
+ if (!(i4 >>> 0 < i10 >>> 0)) {
+ _memcpy(i8 | 0, (HEAP32[i6 + 12 >> 2] | 0) + (0 - i10) | 0, i10 | 0) | 0;
+ HEAP32[i2 + 48 >> 2] = 0;
+ HEAP32[i2 + 44 >> 2] = HEAP32[i5 >> 2];
+ i10 = 0;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i7 = i2 + 48 | 0;
+ i9 = HEAP32[i7 >> 2] | 0;
+ i10 = i10 - i9 | 0;
+ i10 = i10 >>> 0 > i4 >>> 0 ? i4 : i10;
+ i6 = i6 + 12 | 0;
+ _memcpy(i8 + i9 | 0, (HEAP32[i6 >> 2] | 0) + (0 - i4) | 0, i10 | 0) | 0;
+ i8 = i4 - i10 | 0;
+ if ((i4 | 0) != (i10 | 0)) {
+ _memcpy(HEAP32[i3 >> 2] | 0, (HEAP32[i6 >> 2] | 0) + (0 - i8) | 0, i8 | 0) | 0;
+ HEAP32[i7 >> 2] = i8;
+ HEAP32[i2 + 44 >> 2] = HEAP32[i5 >> 2];
+ i10 = 0;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ i6 = (HEAP32[i7 >> 2] | 0) + i4 | 0;
+ i3 = HEAP32[i5 >> 2] | 0;
+ HEAP32[i7 >> 2] = (i6 | 0) == (i3 | 0) ? 0 : i6;
+ i5 = i2 + 44 | 0;
+ i2 = HEAP32[i5 >> 2] | 0;
+ if (!(i2 >>> 0 < i3 >>> 0)) {
+ i10 = 0;
+ STACKTOP = i1;
+ return i10 | 0;
+ }
+ HEAP32[i5 >> 2] = i2 + i4;
+ i10 = 0;
+ STACKTOP = i1;
+ return i10 | 0;
+}
+function _scan_tree(i1, i5, i6) {
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i6 = i6 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i7 = 0, i8 = 0, i9 = 0, i10 = 0, i11 = 0, i12 = 0, i13 = 0, i14 = 0, i15 = 0, i16 = 0;
+ i8 = STACKTOP;
+ i10 = HEAP16[i5 + 2 >> 1] | 0;
+ i9 = i10 << 16 >> 16 == 0;
+ HEAP16[i5 + (i6 + 1 << 2) + 2 >> 1] = -1;
+ i2 = i1 + 2752 | 0;
+ i3 = i1 + 2756 | 0;
+ i4 = i1 + 2748 | 0;
+ i7 = i9 ? 138 : 7;
+ i9 = i9 ? 3 : 4;
+ i13 = 0;
+ i11 = i10 & 65535;
+ i12 = -1;
+ L1 : while (1) {
+ i14 = 0;
+ do {
+ if ((i13 | 0) > (i6 | 0)) {
+ break L1;
+ }
+ i13 = i13 + 1 | 0;
+ i16 = HEAP16[i5 + (i13 << 2) + 2 >> 1] | 0;
+ i10 = i16 & 65535;
+ i14 = i14 + 1 | 0;
+ i15 = (i11 | 0) == (i10 | 0);
+ } while ((i14 | 0) < (i7 | 0) & i15);
+ do {
+ if ((i14 | 0) >= (i9 | 0)) {
+ if ((i11 | 0) == 0) {
+ if ((i14 | 0) < 11) {
+ HEAP16[i2 >> 1] = (HEAP16[i2 >> 1] | 0) + 1 << 16 >> 16;
+ break;
+ } else {
+ HEAP16[i3 >> 1] = (HEAP16[i3 >> 1] | 0) + 1 << 16 >> 16;
+ break;
+ }
+ } else {
+ if ((i11 | 0) != (i12 | 0)) {
+ i14 = i1 + (i11 << 2) + 2684 | 0;
+ HEAP16[i14 >> 1] = (HEAP16[i14 >> 1] | 0) + 1 << 16 >> 16;
+ }
+ HEAP16[i4 >> 1] = (HEAP16[i4 >> 1] | 0) + 1 << 16 >> 16;
+ break;
+ }
+ } else {
+ i12 = i1 + (i11 << 2) + 2684 | 0;
+ HEAP16[i12 >> 1] = (HEAPU16[i12 >> 1] | 0) + i14;
+ }
+ } while (0);
+ if (i16 << 16 >> 16 == 0) {
+ i12 = i11;
+ i7 = 138;
+ i9 = 3;
+ i11 = i10;
+ continue;
+ }
+ i12 = i11;
+ i7 = i15 ? 6 : 7;
+ i9 = i15 ? 3 : 4;
+ i11 = i10;
+ }
+ STACKTOP = i8;
+ return;
+}
+function _deflateEnd(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i3 = STACKTOP;
+ if ((i4 | 0) == 0) {
+ i7 = -2;
+ STACKTOP = i3;
+ return i7 | 0;
+ }
+ i1 = i4 + 28 | 0;
+ i6 = HEAP32[i1 >> 2] | 0;
+ if ((i6 | 0) == 0) {
+ i7 = -2;
+ STACKTOP = i3;
+ return i7 | 0;
+ }
+ i2 = HEAP32[i6 + 4 >> 2] | 0;
+ switch (i2 | 0) {
+ case 42:
+ case 69:
+ case 73:
+ case 91:
+ case 103:
+ case 113:
+ case 666:
+ {
+ break;
+ }
+ default:
+ {
+ i7 = -2;
+ STACKTOP = i3;
+ return i7 | 0;
+ }
+ }
+ i5 = HEAP32[i6 + 8 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ FUNCTION_TABLE_vii[HEAP32[i4 + 36 >> 2] & 1](HEAP32[i4 + 40 >> 2] | 0, i5);
+ i6 = HEAP32[i1 >> 2] | 0;
+ }
+ i5 = HEAP32[i6 + 68 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ FUNCTION_TABLE_vii[HEAP32[i4 + 36 >> 2] & 1](HEAP32[i4 + 40 >> 2] | 0, i5);
+ i6 = HEAP32[i1 >> 2] | 0;
+ }
+ i5 = HEAP32[i6 + 64 >> 2] | 0;
+ if ((i5 | 0) != 0) {
+ FUNCTION_TABLE_vii[HEAP32[i4 + 36 >> 2] & 1](HEAP32[i4 + 40 >> 2] | 0, i5);
+ i6 = HEAP32[i1 >> 2] | 0;
+ }
+ i7 = HEAP32[i6 + 56 >> 2] | 0;
+ i5 = i4 + 36 | 0;
+ if ((i7 | 0) == 0) {
+ i4 = i4 + 40 | 0;
+ } else {
+ i4 = i4 + 40 | 0;
+ FUNCTION_TABLE_vii[HEAP32[i5 >> 2] & 1](HEAP32[i4 >> 2] | 0, i7);
+ i6 = HEAP32[i1 >> 2] | 0;
+ }
+ FUNCTION_TABLE_vii[HEAP32[i5 >> 2] & 1](HEAP32[i4 >> 2] | 0, i6);
+ HEAP32[i1 >> 2] = 0;
+ i7 = (i2 | 0) == 113 ? -3 : 0;
+ STACKTOP = i3;
+ return i7 | 0;
+}
+function _main(i4, i5) {
+ i4 = i4 | 0;
+ i5 = i5 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i6 = 0;
+ i1 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i2 = i1;
+ L1 : do {
+ if ((i4 | 0) > 1) {
+ i4 = HEAP8[HEAP32[i5 + 4 >> 2] | 0] | 0;
+ switch (i4 | 0) {
+ case 50:
+ {
+ i2 = 250;
+ break L1;
+ }
+ case 51:
+ {
+ i3 = 4;
+ break L1;
+ }
+ case 52:
+ {
+ i2 = 2500;
+ break L1;
+ }
+ case 53:
+ {
+ i2 = 5e3;
+ break L1;
+ }
+ case 48:
+ {
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ case 49:
+ {
+ i2 = 60;
+ break L1;
+ }
+ default:
+ {
+ HEAP32[i2 >> 2] = i4 + -48;
+ _printf(144, i2 | 0) | 0;
+ i6 = -1;
+ STACKTOP = i1;
+ return i6 | 0;
+ }
+ }
+ } else {
+ i3 = 4;
+ }
+ } while (0);
+ if ((i3 | 0) == 4) {
+ i2 = 500;
+ }
+ i3 = _malloc(1e5) | 0;
+ i4 = 0;
+ i6 = 0;
+ i5 = 17;
+ while (1) {
+ do {
+ if ((i6 | 0) <= 0) {
+ if ((i4 & 7 | 0) == 0) {
+ i6 = i4 & 31;
+ i5 = 0;
+ break;
+ } else {
+ i5 = (((Math_imul(i4, i4) | 0) >>> 0) % 6714 | 0) & 255;
+ break;
+ }
+ } else {
+ i6 = i6 + -1 | 0;
+ }
+ } while (0);
+ HEAP8[i3 + i4 | 0] = i5;
+ i4 = i4 + 1 | 0;
+ if ((i4 | 0) == 1e5) {
+ i4 = 0;
+ break;
+ }
+ }
+ do {
+ _doit(i3, 1e5, i4);
+ i4 = i4 + 1 | 0;
+ } while ((i4 | 0) < (i2 | 0));
+ _puts(160) | 0;
+ i6 = 0;
+ STACKTOP = i1;
+ return i6 | 0;
+}
+function _doit(i6, i1, i7) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0, i5 = 0, i8 = 0, i9 = 0;
+ i5 = STACKTOP;
+ STACKTOP = STACKTOP + 16 | 0;
+ i4 = i5;
+ i3 = i5 + 12 | 0;
+ i2 = i5 + 8 | 0;
+ i8 = _compressBound(i1) | 0;
+ i9 = HEAP32[2] | 0;
+ if ((i9 | 0) == 0) {
+ i9 = _malloc(i8) | 0;
+ HEAP32[2] = i9;
+ }
+ if ((HEAP32[4] | 0) == 0) {
+ HEAP32[4] = _malloc(i1) | 0;
+ }
+ HEAP32[i3 >> 2] = i8;
+ _compress(i9, i3, i6, i1) | 0;
+ i7 = (i7 | 0) == 0;
+ if (i7) {
+ i9 = HEAP32[i3 >> 2] | 0;
+ HEAP32[i4 >> 2] = i1;
+ HEAP32[i4 + 4 >> 2] = i9;
+ _printf(24, i4 | 0) | 0;
+ }
+ HEAP32[i2 >> 2] = i1;
+ _uncompress(HEAP32[4] | 0, i2, HEAP32[2] | 0, HEAP32[i3 >> 2] | 0) | 0;
+ if ((HEAP32[i2 >> 2] | 0) != (i1 | 0)) {
+ ___assert_fail(40, 72, 24, 104);
+ }
+ if (!i7) {
+ STACKTOP = i5;
+ return;
+ }
+ if ((_strcmp(i6, HEAP32[4] | 0) | 0) == 0) {
+ STACKTOP = i5;
+ return;
+ } else {
+ ___assert_fail(112, 72, 25, 104);
+ }
+}
+function _uncompress(i6, i1, i5, i7) {
+ i6 = i6 | 0;
+ i1 = i1 | 0;
+ i5 = i5 | 0;
+ i7 = i7 | 0;
+ var i2 = 0, i3 = 0, i4 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i3 = i2;
+ HEAP32[i3 >> 2] = i5;
+ i5 = i3 + 4 | 0;
+ HEAP32[i5 >> 2] = i7;
+ HEAP32[i3 + 12 >> 2] = i6;
+ HEAP32[i3 + 16 >> 2] = HEAP32[i1 >> 2];
+ HEAP32[i3 + 32 >> 2] = 0;
+ HEAP32[i3 + 36 >> 2] = 0;
+ i6 = _inflateInit_(i3, 2992, 56) | 0;
+ if ((i6 | 0) != 0) {
+ i7 = i6;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ i6 = _inflate(i3, 4) | 0;
+ if ((i6 | 0) == 1) {
+ HEAP32[i1 >> 2] = HEAP32[i3 + 20 >> 2];
+ i7 = _inflateEnd(i3) | 0;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ _inflateEnd(i3) | 0;
+ if ((i6 | 0) == 2) {
+ i7 = -3;
+ STACKTOP = i2;
+ return i7 | 0;
+ } else if ((i6 | 0) == -5) {
+ i4 = 4;
+ }
+ if ((i4 | 0) == 4 ? (HEAP32[i5 >> 2] | 0) == 0 : 0) {
+ i7 = -3;
+ STACKTOP = i2;
+ return i7 | 0;
+ }
+ i7 = i6;
+ STACKTOP = i2;
+ return i7 | 0;
+}
+function _compress(i4, i1, i6, i5) {
+ i4 = i4 | 0;
+ i1 = i1 | 0;
+ i6 = i6 | 0;
+ i5 = i5 | 0;
+ var i2 = 0, i3 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + 64 | 0;
+ i3 = i2;
+ HEAP32[i3 >> 2] = i6;
+ HEAP32[i3 + 4 >> 2] = i5;
+ HEAP32[i3 + 12 >> 2] = i4;
+ HEAP32[i3 + 16 >> 2] = HEAP32[i1 >> 2];
+ HEAP32[i3 + 32 >> 2] = 0;
+ HEAP32[i3 + 36 >> 2] = 0;
+ HEAP32[i3 + 40 >> 2] = 0;
+ i4 = _deflateInit_(i3, -1, 168, 56) | 0;
+ if ((i4 | 0) != 0) {
+ i6 = i4;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ i4 = _deflate(i3, 4) | 0;
+ if ((i4 | 0) == 1) {
+ HEAP32[i1 >> 2] = HEAP32[i3 + 20 >> 2];
+ i6 = _deflateEnd(i3) | 0;
+ STACKTOP = i2;
+ return i6 | 0;
+ } else {
+ _deflateEnd(i3) | 0;
+ i6 = (i4 | 0) == 0 ? -5 : i4;
+ STACKTOP = i2;
+ return i6 | 0;
+ }
+ return 0;
+}
+function _inflateEnd(i4) {
+ i4 = i4 | 0;
+ var i1 = 0, i2 = 0, i3 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i1 = STACKTOP;
+ if ((i4 | 0) == 0) {
+ i7 = -2;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i2 = i4 + 28 | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ if ((i3 | 0) == 0) {
+ i7 = -2;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i6 = i4 + 36 | 0;
+ i5 = HEAP32[i6 >> 2] | 0;
+ if ((i5 | 0) == 0) {
+ i7 = -2;
+ STACKTOP = i1;
+ return i7 | 0;
+ }
+ i7 = HEAP32[i3 + 52 >> 2] | 0;
+ i4 = i4 + 40 | 0;
+ if ((i7 | 0) != 0) {
+ FUNCTION_TABLE_vii[i5 & 1](HEAP32[i4 >> 2] | 0, i7);
+ i5 = HEAP32[i6 >> 2] | 0;
+ i3 = HEAP32[i2 >> 2] | 0;
+ }
+ FUNCTION_TABLE_vii[i5 & 1](HEAP32[i4 >> 2] | 0, i3);
+ HEAP32[i2 >> 2] = 0;
+ i7 = 0;
+ STACKTOP = i1;
+ return i7 | 0;
+}
+function _memcpy(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i4 = 0;
+ if ((i1 | 0) >= 4096) return _emscripten_memcpy_big(i3 | 0, i2 | 0, i1 | 0) | 0;
+ i4 = i3 | 0;
+ if ((i3 & 3) == (i2 & 3)) {
+ while (i3 & 3) {
+ if ((i1 | 0) == 0) return i4 | 0;
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ while ((i1 | 0) >= 4) {
+ HEAP32[i3 >> 2] = HEAP32[i2 >> 2];
+ i3 = i3 + 4 | 0;
+ i2 = i2 + 4 | 0;
+ i1 = i1 - 4 | 0;
+ }
+ }
+ while ((i1 | 0) > 0) {
+ HEAP8[i3] = HEAP8[i2] | 0;
+ i3 = i3 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i1 = i1 - 1 | 0;
+ }
+ return i4 | 0;
+}
+function _strcmp(i4, i2) {
+ i4 = i4 | 0;
+ i2 = i2 | 0;
+ var i1 = 0, i3 = 0, i5 = 0;
+ i1 = STACKTOP;
+ i5 = HEAP8[i4] | 0;
+ i3 = HEAP8[i2] | 0;
+ if (i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0) {
+ i4 = i5;
+ i5 = i3;
+ i4 = i4 & 255;
+ i5 = i5 & 255;
+ i5 = i4 - i5 | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+ }
+ do {
+ i4 = i4 + 1 | 0;
+ i2 = i2 + 1 | 0;
+ i5 = HEAP8[i4] | 0;
+ i3 = HEAP8[i2] | 0;
+ } while (!(i5 << 24 >> 24 != i3 << 24 >> 24 | i5 << 24 >> 24 == 0 | i3 << 24 >> 24 == 0));
+ i4 = i5 & 255;
+ i5 = i3 & 255;
+ i5 = i4 - i5 | 0;
+ STACKTOP = i1;
+ return i5 | 0;
+}
+function _memset(i1, i4, i3) {
+ i1 = i1 | 0;
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ var i2 = 0, i5 = 0, i6 = 0, i7 = 0;
+ i2 = i1 + i3 | 0;
+ if ((i3 | 0) >= 20) {
+ i4 = i4 & 255;
+ i7 = i1 & 3;
+ i6 = i4 | i4 << 8 | i4 << 16 | i4 << 24;
+ i5 = i2 & ~3;
+ if (i7) {
+ i7 = i1 + 4 - i7 | 0;
+ while ((i1 | 0) < (i7 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ }
+ while ((i1 | 0) < (i5 | 0)) {
+ HEAP32[i1 >> 2] = i6;
+ i1 = i1 + 4 | 0;
+ }
+ }
+ while ((i1 | 0) < (i2 | 0)) {
+ HEAP8[i1] = i4;
+ i1 = i1 + 1 | 0;
+ }
+ return i1 - i3 | 0;
+}
+function copyTempDouble(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+ HEAP8[tempDoublePtr + 4 | 0] = HEAP8[i1 + 4 | 0];
+ HEAP8[tempDoublePtr + 5 | 0] = HEAP8[i1 + 5 | 0];
+ HEAP8[tempDoublePtr + 6 | 0] = HEAP8[i1 + 6 | 0];
+ HEAP8[tempDoublePtr + 7 | 0] = HEAP8[i1 + 7 | 0];
+}
+function __tr_init(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ HEAP32[i1 + 2840 >> 2] = i1 + 148;
+ HEAP32[i1 + 2848 >> 2] = 1064;
+ HEAP32[i1 + 2852 >> 2] = i1 + 2440;
+ HEAP32[i1 + 2860 >> 2] = 1088;
+ HEAP32[i1 + 2864 >> 2] = i1 + 2684;
+ HEAP32[i1 + 2872 >> 2] = 1112;
+ HEAP16[i1 + 5816 >> 1] = 0;
+ HEAP32[i1 + 5820 >> 2] = 0;
+ HEAP32[i1 + 5812 >> 2] = 8;
+ _init_block(i1);
+ STACKTOP = i2;
+ return;
+}
+function copyTempFloat(i1) {
+ i1 = i1 | 0;
+ HEAP8[tempDoublePtr] = HEAP8[i1];
+ HEAP8[tempDoublePtr + 1 | 0] = HEAP8[i1 + 1 | 0];
+ HEAP8[tempDoublePtr + 2 | 0] = HEAP8[i1 + 2 | 0];
+ HEAP8[tempDoublePtr + 3 | 0] = HEAP8[i1 + 3 | 0];
+}
+function _deflateInit_(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ var i5 = 0;
+ i5 = STACKTOP;
+ i4 = _deflateInit2_(i4, i3, 8, 15, 8, 0, i2, i1) | 0;
+ STACKTOP = i5;
+ return i4 | 0;
+}
+function _zcalloc(i3, i1, i2) {
+ i3 = i3 | 0;
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ var i4 = 0;
+ i4 = STACKTOP;
+ i3 = _malloc(Math_imul(i2, i1) | 0) | 0;
+ STACKTOP = i4;
+ return i3 | 0;
+}
+function dynCall_iiii(i4, i3, i2, i1) {
+ i4 = i4 | 0;
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iiii[i4 & 1](i3 | 0, i2 | 0, i1 | 0) | 0;
+}
+function runPostSets() {}
+function _strlen(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = i1;
+ while (HEAP8[i2] | 0) {
+ i2 = i2 + 1 | 0;
+ }
+ return i2 - i1 | 0;
+}
+function stackAlloc(i1) {
+ i1 = i1 | 0;
+ var i2 = 0;
+ i2 = STACKTOP;
+ STACKTOP = STACKTOP + i1 | 0;
+ STACKTOP = STACKTOP + 7 & -8;
+ return i2 | 0;
+}
+function dynCall_iii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ return FUNCTION_TABLE_iii[i3 & 3](i2 | 0, i1 | 0) | 0;
+}
+function setThrew(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ if ((__THREW__ | 0) == 0) {
+ __THREW__ = i1;
+ threwValue = i2;
+ }
+}
+function dynCall_vii(i3, i2, i1) {
+ i3 = i3 | 0;
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ FUNCTION_TABLE_vii[i3 & 1](i2 | 0, i1 | 0);
+}
+function _zcfree(i2, i1) {
+ i2 = i2 | 0;
+ i1 = i1 | 0;
+ i2 = STACKTOP;
+ _free(i1);
+ STACKTOP = i2;
+ return;
+}
+function _compressBound(i1) {
+ i1 = i1 | 0;
+ return i1 + 13 + (i1 >>> 12) + (i1 >>> 14) + (i1 >>> 25) | 0;
+}
+function b0(i1, i2, i3) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ i3 = i3 | 0;
+ abort(0);
+ return 0;
+}
+function b2(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(2);
+ return 0;
+}
+function b1(i1, i2) {
+ i1 = i1 | 0;
+ i2 = i2 | 0;
+ abort(1);
+}
+function stackRestore(i1) {
+ i1 = i1 | 0;
+ STACKTOP = i1;
+}
+function setTempRet9(i1) {
+ i1 = i1 | 0;
+ tempRet9 = i1;
+}
+function setTempRet8(i1) {
+ i1 = i1 | 0;
+ tempRet8 = i1;
+}
+function setTempRet7(i1) {
+ i1 = i1 | 0;
+ tempRet7 = i1;
+}
+function setTempRet6(i1) {
+ i1 = i1 | 0;
+ tempRet6 = i1;
+}
+function setTempRet5(i1) {
+ i1 = i1 | 0;
+ tempRet5 = i1;
+}
+function setTempRet4(i1) {
+ i1 = i1 | 0;
+ tempRet4 = i1;
+}
+function setTempRet3(i1) {
+ i1 = i1 | 0;
+ tempRet3 = i1;
+}
+function setTempRet2(i1) {
+ i1 = i1 | 0;
+ tempRet2 = i1;
+}
+function setTempRet1(i1) {
+ i1 = i1 | 0;
+ tempRet1 = i1;
+}
+function setTempRet0(i1) {
+ i1 = i1 | 0;
+ tempRet0 = i1;
+}
+function stackSave() {
+ return STACKTOP | 0;
+}
+
+// EMSCRIPTEN_END_FUNCS
+ var FUNCTION_TABLE_iiii = [b0,_zcalloc];
+ var FUNCTION_TABLE_vii = [b1,_zcfree];
+ var FUNCTION_TABLE_iii = [b2,_deflate_stored,_deflate_fast,_deflate_slow];
+
+ return { _strlen: _strlen, _free: _free, _main: _main, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, setTempRet1: setTempRet1, setTempRet2: setTempRet2, setTempRet3: setTempRet3, setTempRet4: setTempRet4, setTempRet5: setTempRet5, setTempRet6: setTempRet6, setTempRet7: setTempRet7, setTempRet8: setTempRet8, setTempRet9: setTempRet9, dynCall_iiii: dynCall_iiii, dynCall_vii: dynCall_vii, dynCall_iii: dynCall_iii };
+})
+// EMSCRIPTEN_END_ASM
+({ "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array }, { "abort": abort, "assert": assert, "asmPrintInt": asmPrintInt, "asmPrintFloat": asmPrintFloat, "min": Math_min, "invoke_iiii": invoke_iiii, "invoke_vii": invoke_vii, "invoke_iii": invoke_iii, "_send": _send, "___setErrNo": ___setErrNo, "___assert_fail": ___assert_fail, "_fflush": _fflush, "_pwrite": _pwrite, "__reallyNegative": __reallyNegative, "_sbrk": _sbrk, "___errno_location": ___errno_location, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_fileno": _fileno, "_sysconf": _sysconf, "_puts": _puts, "_mkport": _mkport, "_write": _write, "_llvm_bswap_i32": _llvm_bswap_i32, "_fputc": _fputc, "_abort": _abort, "_fwrite": _fwrite, "_time": _time, "_fprintf": _fprintf, "__formatString": __formatString, "_fputs": _fputs, "_printf": _printf, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "NaN": NaN, "Infinity": Infinity }, buffer);
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _free = Module["_free"] = asm["_free"];
+var _main = Module["_main"] = asm["_main"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
+var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
+var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
+
+Runtime.stackAlloc = function(size) { return asm['stackAlloc'](size) };
+Runtime.stackSave = function() { return asm['stackSave']() };
+Runtime.stackRestore = function(top) { asm['stackRestore'](top) };
+
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ var data = Module['readBinary'](memoryInitializer);
+ HEAPU8.set(data, STATIC_BASE);
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run([].concat(Module["arguments"]));
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ ensureInitRuntime();
+
+ var argc = args.length+1;
+ function pad() {
+ for (var i = 0; i < 4-1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL) ];
+ pad();
+ for (var i = 0; i < argc-1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ }
+ catch(e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+ throw 'abort() at ' + stackTrace() + extra;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+
+run([].concat(Module["arguments"]));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM32 = new stdlib.Float32Array(heap);
+ function load(i) {
+ i = i|0;
+ i = +MEM32[i >> 2];
+ return i;
+ }
+ function store(i, v) {
+ i = i|0;
+ v = +v;
+ MEM32[i >> 2] = v;
+ }
+ return { load: load, store: store };
+}
+
+var m = Module(this, {}, new ArrayBuffer(4));
+
+m.store(0, 42.0);
+for (var i = 1; i < 64; ++i) {
+ m.store(i * 4 * 32 * 1024, i);
+}
+assertEquals(42.0, m.load(0));
+for (var i = 1; i < 64; ++i) {
+ assertEquals(NaN, m.load(i * 4 * 32 * 1024));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM32 = new stdlib.Float32Array(heap);
+ function foo(i) {
+ MEM32[0] = (i >>> 0) / 2;
+ return MEM32[0];
+ }
+ return { foo: foo };
+}
+
+var foo = Module(this, {}, new ArrayBuffer(64 * 1024)).foo;
+assertEquals(0.5, foo(1));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM64 = new stdlib.Float64Array(heap);
+ function load(i) {
+ i = i|0;
+ i = +MEM64[i >> 3];
+ return i;
+ }
+ function store(i, v) {
+ i = i|0;
+ v = +v;
+ MEM64[i >> 3] = v;
+ }
+ return { load: load, store: store };
+}
+
+var m = Module(this, {}, new ArrayBuffer(8));
+
+m.store(0, 3.12);
+for (var i = 1; i < 64; ++i) {
+ m.store(i * 8 * 32 * 1024, i);
+}
+assertEquals(3.12, m.load(0));
+for (var i = 1; i < 64; ++i) {
+ assertEquals(NaN, m.load(i * 8 * 32 * 1024));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM64 = new stdlib.Float64Array(heap);
+ function foo(i) {
+ MEM64[0] = (i >>> 0) / 2;
+ return MEM64[0];
+ }
+ return { foo: foo };
+}
+
+var foo = Module(this, {}, new ArrayBuffer(64 * 1024)).foo;
+assertEquals(0.5, foo(1));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = +i;
+ return +(i * -1);
+ }
+ function f2(i) {
+ i = +i;
+ return +(-1 * i);
+ }
+ return { f1: f1, f2: f2 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(64 * 1024));
+
+assertEquals(NaN, m.f1(NaN));
+assertEquals(NaN, m.f2(NaN));
+assertEquals(Infinity, 1 / m.f1(-0));
+assertEquals(Infinity, 1 / m.f2(-0));
+assertEquals(Infinity, m.f1(-Infinity));
+assertEquals(Infinity, m.f2(-Infinity));
+assertEquals(-Infinity, 1 / m.f1(0));
+assertEquals(-Infinity, 1 / m.f2(0));
+assertEquals(-Infinity, m.f1(Infinity));
+assertEquals(-Infinity, m.f2(Infinity));
+for (var i = -2147483648; i < 2147483648; i += 3999777) {
+ assertEquals(-i, m.f1(i));
+ assertEquals(-i, m.f2(i));
+}
--- /dev/null
+// 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.
+
+function Module() {
+ "use asm";
+
+ function if0() {
+ if (0) return 11;
+ return 12;
+ }
+
+ function if1() {
+ if (1) return 13;
+ return 14;
+ }
+
+ function if2() {
+ if (0) return 15;
+ else return 16;
+ }
+
+ function if3() {
+ if (1) return 17;
+ else return 18;
+ }
+
+ function if4() {
+ return 1 ? 19 : 20;
+ }
+
+ function if5() {
+ return 0 ? 21 : 22;
+ }
+
+ function if6() {
+ var x = 0 ? 23 : 24;
+ return x;
+ }
+
+ function if7() {
+ if (0) { var x = 0 ? 25 : 26; }
+ else { var x = 0 ? 27 : 28; }
+ return x;
+ }
+
+ function if8() {
+ if (0) {
+ if (0) { var x = 0 ? 29 : 30; }
+ else { var x = 0 ? 31 : 32; }
+ } else {
+ if (0) { var x = 0 ? 33 : 34; }
+ else { var x = 0 ? 35 : 36; }
+ }
+ return x;
+ }
+
+ return {if0: if0, if1: if1, if2: if2, if3: if3, if4: if4, if5: if5, if6: if6, if7: if7, if8: if8 };
+}
+
+var m = Module();
+assertEquals(12, m.if0());
+assertEquals(13, m.if1());
+assertEquals(16, m.if2());
+assertEquals(17, m.if3());
+assertEquals(19, m.if4());
+assertEquals(22, m.if5());
+assertEquals(24, m.if6());
+assertEquals(28, m.if7());
+assertEquals(36, m.if8());
+
+
+function Spec(a,b,c) {
+ "use asm";
+
+ var xx = a | 0;
+ var yy = b | 0;
+ var zz = c | 0;
+
+ function f() {
+ if (xx) {
+ if (yy) { var x = zz ? 29 : 30; }
+ else { var x = zz ? 31 : 32; }
+ } else {
+ if (yy) { var x = zz ? 33 : 34; }
+ else { var x = zz ? 35 : 36; }
+ }
+ return x;
+ }
+ return {f: f};
+}
+
+assertEquals(36, Spec(0,0,0).f());
+assertEquals(35, Spec(0,0,1).f());
+assertEquals(34, Spec(0,1,0).f());
+assertEquals(33, Spec(0,1,1).f());
+assertEquals(32, Spec(1,0,0).f());
+assertEquals(31, Spec(1,0,1).f());
+assertEquals(30, Spec(1,1,0).f());
+assertEquals(29, Spec(1,1,1).f());
--- /dev/null
+// 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.
+
+function Module() {
+ "use asm";
+
+ function if0() {
+ var x = 0 ? 11 : 12;
+ return (x == 11) | 0;
+ }
+
+ function if1() {
+ var x = 1 ? 13 : 14;
+ return (x == 13) | 0;
+ }
+
+ function if2() {
+ var x = 0 ? 15 : 16;
+ return (x != 15) | 0;
+ }
+
+ function if3() {
+ var x = 1 ? 17 : 18;
+ return (x != 17) | 0;
+ }
+
+ function if4() {
+ var x = 0 ? 19 : 20;
+ var y = (x == 19) ? 21 : 22;
+ return y;
+ }
+
+ function if5() {
+ var x = 1 ? 23 : 24;
+ var y = (x == 23) ? 25 : 26;
+ return y;
+ }
+
+ function if6() {
+ var x = 0 ? 27 : 28;
+ var y = (x == 27) ? 29 : 30;
+ var z = (y == 29) ? 31 : 32;
+ return z;
+ }
+
+ function if7() {
+ var x = 1 ? 33 : 34;
+ var y = (x == 33) ? 35 : 36;
+ var z = (y == 35) ? 37 : 38;
+ var w = (z == 37) ? 39 : 40;
+ return w;
+ }
+
+ function if8() {
+ if (0) {
+ var x = 0 ? 43 : 44;
+ var y = (x == 43) ? 45 : 46;
+ var z = (y == 45) ? 47 : 48;
+ var w = (z == 47) ? 49 : 50;
+ } else {
+ var x = 1 ? 53 : 54;
+ var y = (x == 53) ? 55 : 56;
+ var z = (y == 55) ? 57 : 58;
+ var w = (z == 57) ? 59 : 60;
+ }
+ return w;
+ }
+
+ return {if0: if0, if1: if1, if2: if2, if3: if3, if4: if4, if5: if5, if6: if6, if7: if7, if8: if8 };
+}
+
+var m = Module();
+assertEquals(0, m.if0());
+assertEquals(1, m.if1());
+assertEquals(1, m.if2());
+assertEquals(0, m.if3());
+assertEquals(22, m.if4());
+assertEquals(25, m.if5());
+assertEquals(32, m.if6());
+assertEquals(39, m.if7());
+assertEquals(59, m.if8());
+
+
+function Spec(a,b) {
+ "use asm";
+
+ var xx = a | 0;
+ var yy = b | 0;
+
+ function f() {
+ if (xx) {
+ var x = yy ? 43 : 44;
+ var y = (x == 43) ? 45 : 46;
+ var z = (y == 45) ? 47 : 48;
+ var w = (z == 47) ? 49 : 50;
+ } else {
+ var x = yy ? 53 : 54;
+ var y = (x == 53) ? 55 : 56;
+ var z = (y == 55) ? 57 : 58;
+ var w = (z == 57) ? 59 : 60;
+ }
+ return w;
+ }
+ return {f: f};
+}
+
+assertEquals(60, Spec(0,0).f());
+assertEquals(59, Spec(0,1).f());
+assertEquals(50, Spec(1,0).f());
+assertEquals(49, Spec(1,1).f());
--- /dev/null
+// 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.
+
+var error = "error";
+function counter(x) {
+ return (function() { if (x-- == 0) throw error;});
+}
+
+function Module() {
+ "use asm";
+
+ function w0(f) {
+ while (1) f();
+ return 108;
+ }
+
+ function w1(f) {
+ if (1) while (1) f();
+ return 109;
+ }
+
+ function w2(f) {
+ if (1) while (1) f();
+ else while (1) f();
+ return 110;
+ }
+
+ function w3(f) {
+ if (0) while (1) f();
+ return 111;
+ }
+
+ return { w0: w0, w1: w1, w2: w2, w3: w3 };
+}
+
+var m = Module();
+assertThrows(function() { m.w0(counter(5)) }, error);
+assertThrows(function() { m.w1(counter(5)) }, error);
+assertThrows(function() { m.w2(counter(5)) }, error);
+assertEquals(111, m.w3(counter(5)));
--- /dev/null
+// 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.
+
+function Module() {
+ "use asm";
+
+ function w0(a) {
+ a = a | 0;
+ if (a) while (1);
+ return 42;
+ }
+
+ function w1(a) {
+ a = a | 0;
+ while (1) return 42;
+ return 106;
+ }
+
+ function d0(a) {
+ a = a | 0;
+ if (a) do ; while(1);
+ return 42;
+ }
+
+ function d1(a) {
+ a = a | 0;
+ do return 42; while(1);
+ return 107;
+ }
+
+ function f0(a) {
+ a = a | 0;
+ if (a) for (;;) ;
+ return 42;
+ }
+
+ function f1(a) {
+ a = a | 0;
+ for(;;) return 42;
+ return 108;
+ }
+
+ return { w0: w0, w1: w1, d0: d0, d1: d1, f0: f0, f1: f1 };
+}
+
+var m = Module();
+assertEquals(42, m.w0(0));
+assertEquals(42, m.w1(0));
+assertEquals(42, m.d0(0));
+assertEquals(42, m.d1(0));
+assertEquals(42, m.f0(0));
+assertEquals(42, m.f1(0));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM16 = new stdlib.Int16Array(heap);
+ function load(i) {
+ i = i|0;
+ i = MEM16[i >> 1] | 0;
+ return i;
+ }
+ function loadm1() {
+ return MEM16[-1] | 0;
+ }
+ function store(i, v) {
+ i = i|0;
+ v = v|0;
+ MEM16[i >> 1] = v;
+ }
+ function storem1(v) {
+ v = v|0;
+ MEM16[-1] = v;
+ }
+ return {load: load, loadm1: loadm1, store: store, storem1: storem1};
+}
+
+var m = Module(this, {}, new ArrayBuffer(2));
+
+m.store(-1000, 4);
+assertEquals(0, m.load(-1000));
+assertEquals(0, m.loadm1());
+m.storem1(1);
+assertEquals(0, m.loadm1());
+m.store(0, 32767);
+for (var i = 1; i < 64; ++i) {
+ m.store(i * 2 * 32 * 1024, i);
+}
+assertEquals(32767, m.load(0));
+for (var i = 1; i < 64; ++i) {
+ assertEquals(0, m.load(i * 2 * 32 * 1024));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = i|0;
+ return i / 3 | 0;
+ }
+ function f2(i) {
+ i = i|0;
+ return i / 13 | 0;
+ }
+ function f3(i) {
+ i = i|0;
+ return i / 1024 | 0;
+ }
+ function f4(i) {
+ i = i|0;
+ return i / 3733331 | 0;
+ }
+ return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = -2147483648; i < 2147483648; i += 3999777) {
+ assertEquals(i / 3 | 0, m.f1(i));
+ assertEquals(i / 13 | 0, m.f2(i));
+ assertEquals(i / 1024 | 0, m.f3(i));
+ assertEquals(i / 3733331 | 0, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = i|0;
+ return i % 3;
+ }
+ function f2(i) {
+ i = i|0;
+ return i % 9;
+ }
+ function f3(i) {
+ i = i|0;
+ return i % 1024;
+ }
+ function f4(i) {
+ i = i|0;
+ return i % 3133335;
+ }
+ return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = -2147483648; i < 2147483648; i += 3999773) {
+ assertEquals(i % 3, m.f1(i));
+ assertEquals(i % 9, m.f2(i));
+ assertEquals(i % 1024, m.f3(i));
+ assertEquals(i % 3133335, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = i|0;
+ return i * 3 | 0;
+ }
+ function f2(i) {
+ i = i|0;
+ return i * 7 | 0;
+ }
+ function f3(i) {
+ i = i|0;
+ return i * 1024 | 0;
+ }
+ function f4(i) {
+ i = i|0;
+ return i * 3333339 | 0;
+ }
+ return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = -2147483648; i < 2147483648; i += 3999771) {
+ assertEquals(i * 3 | 0, m.f1(i));
+ assertEquals(i * 7 | 0, m.f2(i));
+ assertEquals(i * 1024 | 0, m.f3(i));
+ assertEquals(i * 3333339 | 0, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f0(i) {
+ i = i|0;
+ return i % 2 | 0;
+ }
+ function f1(i) {
+ i = i|0;
+ return i % 3 | 0;
+ }
+ function f2(i) {
+ i = i|0;
+ return i % 9 | 0;
+ }
+ function f3(i) {
+ i = i|0;
+ return i % 1024 | 0;
+ }
+ function f4(i) {
+ i = i|0;
+ return i % 3333339 | 0;
+ }
+ return { f0: f0, f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = -2147483648; i < 2147483648; i += 3999773) {
+ assertEquals(i % 2 | 0, m.f0(i));
+ assertEquals(i % 3 | 0, m.f1(i));
+ assertEquals(i % 9 | 0, m.f2(i));
+ assertEquals(i % 1024 | 0, m.f3(i));
+ assertEquals(i % 3333339 | 0, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = i>>>0;
+ return i / 3 | 0;
+ }
+ function f2(i) {
+ i = i>>>0;
+ return i / 17 | 0;
+ }
+ function f3(i) {
+ i = i>>>0;
+ return i / 1024 | 0;
+ }
+ function f4(i) {
+ i = i>>>0;
+ return i / 3343330 | 0;
+ }
+ return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = 0; i < 4294967296; i += 3999777) {
+ assertEquals(i / 3 | 0, m.f1(i));
+ assertEquals(i / 17 | 0, m.f2(i));
+ assertEquals(i / 1024 | 0, m.f3(i));
+ assertEquals(i / 3343330 | 0, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ function f1(i) {
+ i = i>>>0;
+ return i % 3;
+ }
+ function f2(i) {
+ i = i>>>0;
+ return i % 11;
+ }
+ function f3(i) {
+ i = i>>>0;
+ return i % 1024;
+ }
+ function f4(i) {
+ i = i>>>0;
+ return i % 3333337;
+ }
+ return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = 0; i < 4294967296; i += 3999777) {
+ assertEquals(i % 3, m.f1(i));
+ assertEquals(i % 11, m.f2(i));
+ assertEquals(i % 1024, m.f3(i));
+ assertEquals(i % 3333337, m.f4(i));
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM32 = new stdlib.Int32Array(heap);
+ function loadm4194304() {
+ return MEM32[-4194304];
+ }
+ function loadm0() {
+ return MEM32[-0];
+ }
+ function load0() {
+ return MEM32[0];
+ }
+ function load4() {
+ return MEM32[4];
+ }
+ function storem4194304(v) {
+ MEM32[-4194304] = v;
+ }
+ function storem0(v) {
+ MEM32[-0] = v;
+ }
+ function store0(v) {
+ MEM32[0] = v;
+ }
+ function store4(v) {
+ MEM32[4] = v;
+ }
+ return { loadm4194304: loadm4194304, storem4194304: storem4194304,
+ loadm0: loadm0, storem0: storem0, load0: load0, store0: store0,
+ load4: load4, store4: store4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(4));
+
+assertEquals(undefined, m.loadm4194304());
+assertEquals(0, m.loadm0());
+assertEquals(0, m.load0());
+assertEquals(undefined, m.load4());
+m.storem4194304(123456789);
+assertEquals(undefined, m.loadm4194304());
+assertEquals(0, m.loadm0());
+assertEquals(0, m.load0());
+assertEquals(undefined, m.load4());
+m.storem0(987654321);
+assertEquals(undefined, m.loadm4194304());
+assertEquals(987654321, m.loadm0());
+assertEquals(987654321, m.load0());
+assertEquals(undefined, m.load4());
+m.store0(0x12345678);
+assertEquals(undefined, m.loadm4194304());
+assertEquals(0x12345678, m.loadm0());
+assertEquals(0x12345678, m.load0());
+assertEquals(undefined, m.load4());
+m.store4(43);
+assertEquals(undefined, m.loadm4194304());
+assertEquals(0x12345678, m.loadm0());
+assertEquals(0x12345678, m.load0());
+assertEquals(undefined, m.load4());
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM32 = new stdlib.Int32Array(heap);
+ function load(i) {
+ i = i|0;
+ i = MEM32[i >> 2] | 0;
+ return i;
+ }
+ function store(i, v) {
+ i = i|0;
+ v = v|0;
+ MEM32[i >> 2] = v;
+ }
+ return { load: load, store: store };
+}
+
+var m = Module(this, {}, new ArrayBuffer(4));
+
+m.store(0, 0x12345678);
+for (var i = 1; i < 64; ++i) {
+ m.store(i * 4 * 32 * 1024, i);
+}
+assertEquals(0x12345678, m.load(0));
+for (var i = 1; i < 64; ++i) {
+ assertEquals(0, m.load(i * 4 * 32 * 1024));
+}
--- /dev/null
+// 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.
+
+var stdlib = {};
+var foreign = {};
+var heap = new ArrayBuffer(64 * 1024);
+
+function Int32Div(divisor) {
+ var name = "div_";
+ if (divisor < 0) {
+ name += "minus_";
+ }
+ name += Math.abs(divisor);
+ var m = eval("function Module(stdlib, foreign, heap) {\n"
+ + " \"use asm\";\n"
+ + " function " + name + "(dividend) {\n"
+ + " return ((dividend | 0) / " + divisor + ") | 0;\n"
+ + " }\n"
+ + " return { f: " + name + "}\n"
+ + "}; Module");
+ return m(stdlib, foreign, heap).f;
+}
+
+var divisors = [-2147483648, -32 * 1024, -1000, -16, -7, -2, -1, 0,
+ 1, 3, 4, 10, 64, 100, 1024, 2147483647];
+for (var i in divisors) {
+ var divisor = divisors[i];
+ var div = Int32Div(divisor);
+ for (var dividend = -2147483648; dividend < 2147483648; dividend += 3999773) {
+ assertEquals((dividend / divisor) | 0, div(dividend));
+ }
+}
--- /dev/null
+// 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.
+
+var stdlib = {};
+var foreign = {};
+var heap = new ArrayBuffer(64 * 1024);
+
+function Int32Mod(divisor) {
+ var name = "mod_";
+ if (divisor < 0) {
+ name += "minus_";
+ }
+ name += Math.abs(divisor);
+ var m = eval("function Module(stdlib, foreign, heap) {\n"
+ + " \"use asm\";\n"
+ + " function " + name + "(dividend) {\n"
+ + " return ((dividend | 0) % " + divisor + ") | 0;\n"
+ + " }\n"
+ + " return { f: " + name + "}\n"
+ + "}; Module");
+ return m(stdlib, foreign, heap).f;
+}
+
+var divisors = [-2147483648, -32 * 1024, -1000, -16, -7, -2, -1,
+ 1, 3, 4, 10, 64, 100, 1024, 2147483647];
+for (var i in divisors) {
+ var divisor = divisors[i];
+ var mod = Int32Mod(divisor);
+ for (var dividend = -2147483648; dividend < 2147483648; dividend += 3999773) {
+ assertEquals((dividend % divisor) | 0, mod(dividend));
+ }
+}
--- /dev/null
+// 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.
+
+function Module(stdlib) {
+ "use asm";
+
+ var ceil = stdlib.Math.ceil;
+
+ // f: double -> float
+ function f(a) {
+ a = +a;
+ return ceil(a);
+ }
+
+ return { f: f };
+}
+
+var f = Module({ Math: Math }).f;
+
+assertTrue(isNaN(f(NaN)));
+assertTrue(isNaN(f(undefined)));
+assertTrue(isNaN(f(function() {})));
+
+assertEquals(0, f(0));
+assertEquals(+0, f(+0));
+assertEquals(-0, f(-0));
+assertEquals(1, f(0.49999));
+assertEquals(1, f(0.6));
+assertEquals(1, f(0.5));
+assertEquals(-0, f(-0.1));
+assertEquals(-0, f(-0.5));
+assertEquals(-0, f(-0.6));
+assertEquals(-1, f(-1.6));
+assertEquals(-0, f(-0.50001));
+
+assertEquals("Infinity", String(f(Infinity)));
+assertEquals("-Infinity", String(f(-Infinity)));
--- /dev/null
+// 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.
+
+function Module(stdlib) {
+ "use asm";
+
+ var floor = stdlib.Math.floor;
+
+ // f: double -> float
+ function f(a) {
+ a = +a;
+ return floor(a);
+ }
+
+ return { f: f };
+}
+
+var f = Module({ Math: Math }).f;
+
+assertTrue(isNaN(f(NaN)));
+assertTrue(isNaN(f(undefined)));
+assertTrue(isNaN(f(function() {})));
+
+assertEquals(0, f(0));
+assertEquals(+0, f(+0));
+assertEquals(-0, f(-0));
+assertEquals(0, f(0.49999));
+assertEquals(+0, f(0.6));
+assertEquals(+0, f(0.5));
+assertEquals(-1, f(-0.1));
+assertEquals(-1, f(-0.5));
+assertEquals(-1, f(-0.6));
+assertEquals(-2, f(-1.6));
+assertEquals(-1, f(-0.50001));
+
+assertEquals("Infinity", String(f(Infinity)));
+assertEquals("-Infinity", String(f(-Infinity)));
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ 'use asm';
+
+ function foo1(i1) {
+ i1 = i1 | 0;
+ var i10 = i1 >> 5;
+ if (i10 >>> 0 < 5) {
+ return 1;
+ } else {
+ return 0;
+ }
+ return 0;
+ }
+
+ function foo2(i1) {
+ i1 = i1 | 0;
+ var i10 = i1 / 32 | 0;
+ if (i10 >>> 0 < 5) {
+ return 1;
+ } else {
+ return 0;
+ }
+ return 0;
+ }
+
+ function foo3(i1) {
+ i1 = i1 | 0;
+ var i10 = (i1 + 32 | 0) / 32 | 0;
+ if (i10 >>> 0 < 5) {
+ return 1;
+ } else {
+ return 0;
+ }
+ return 0;
+ }
+ return {foo1: foo1, foo2: foo2, foo3: foo3};
+}
+
+var m = Module(this, {}, undefined);
+
+for (var i = 0; i < 4 * 32; i++) {
+ assertEquals(1, m.foo1(i));
+ assertEquals(1, m.foo2(i));
+ assertEquals(1, m.foo3(i));
+}
+
+for (var i = 4 * 32; i < 5 * 32; i++) {
+ assertEquals(1, m.foo1(i));
+ assertEquals(1, m.foo2(i));
+ assertEquals(0, m.foo3(i));
+}
+
+for (var i = 5 * 32; i < 10 * 32; i++) {
+ assertEquals(0, m.foo1(i));
+ assertEquals(0, m.foo2(i));
+ assertEquals(0, m.foo3(i));
+}
--- /dev/null
+// 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.
+
+var stdlib = {};
+var foreign = {};
+var heap = new ArrayBuffer(64 * 1024);
+
+function Uint32Div(divisor) {
+ var name = "div_";
+ name += divisor;
+ var m = eval("function Module(stdlib, foreign, heap) {\n"
+ + " \"use asm\";\n"
+ + " function " + name + "(dividend) {\n"
+ + " return ((dividend >>> 0) / " + divisor + ") >>> 0;\n"
+ + " }\n"
+ + " return { f: " + name + "}\n"
+ + "}; Module");
+ return m(stdlib, foreign, heap).f;
+}
+
+var divisors = [0, 1, 3, 4, 10, 42, 64, 100, 1024, 2147483647, 4294967295];
+for (var i in divisors) {
+ var divisor = divisors[i];
+ var div = Uint32Div(divisor);
+ for (var dividend = 0; dividend < 4294967296; dividend += 3999773) {
+ assertEquals((dividend / divisor) >>> 0, div(dividend));
+ }
+}
+
+var div = (function(stdlib, foreign, heap) {
+ "use asm";
+ function div(dividend, divisor) {
+ return (dividend >>> 0) / (divisor >>> 0) | 0;
+ }
+ return {div: div};
+})(stdlib, foreign, heap).div;
+
+for (var i in divisors) {
+ var divisor = divisors[i];
+ for (var dividend = 0; dividend < 4294967296; dividend += 3999773) {
+ assertEquals((dividend >>> 0) / (divisor >>> 0) | 0,
+ div(dividend, divisor));
+ }
+}
--- /dev/null
+// 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.
+
+var stdlib = {};
+var foreign = {};
+var heap = new ArrayBuffer(64 * 1024);
+
+function Uint32Mod(divisor) {
+ var name = "mod_";
+ name += divisor;
+ var m = eval("function Module(stdlib, foreign, heap) {\n"
+ + " \"use asm\";\n"
+ + " function " + name + "(dividend) {\n"
+ + " return ((dividend >>> 0) % " + divisor + ") >>> 0;\n"
+ + " }\n"
+ + " return { f: " + name + "}\n"
+ + "}; Module");
+ return m(stdlib, foreign, heap).f;
+}
+
+var divisors = [0, 1, 3, 4, 10, 42, 64, 100, 1024, 2147483647, 4294967295];
+for (var i in divisors) {
+ var divisor = divisors[i];
+ var mod = Uint32Mod(divisor);
+ for (var dividend = 0; dividend < 4294967296; dividend += 3999773) {
+ assertEquals((dividend % divisor) >>> 0, mod(dividend));
+ }
+}
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, heap) {
+ "use asm";
+ var MEM8 = new stdlib.Uint8Array(heap);
+ function load(i) {
+ i = i|0;
+ i = MEM8[i] | 0;
+ return i;
+ }
+ function store(i, v) {
+ i = i|0;
+ v = v|0;
+ MEM8[i] = v;
+ }
+ return { load: load, store: store };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1));
+
+m.store(0, 255);
+for (var i = 1; i < 64; ++i) {
+ m.store(i * 1 * 32 * 1024, i);
+}
+assertEquals(255, m.load(0));
+for (var i = 1; i < 64; ++i) {
+ assertEquals(0, m.load(i * 1 * 32 * 1024));
+}
--- /dev/null
+// 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.
+
+var stdlib = {};
+var foreign = {};
+var heap = new ArrayBuffer(64 * 1024);
+
+function Word32And(rhs) {
+ var name = "and_0x" + Number(rhs).toString(16);
+ var m = eval("function Module(stdlib, foreign, heap) {\n"
+ + " \"use asm\";\n"
+ + " function " + name + "(lhs) {\n"
+ + " return (lhs | 0) & 0x" + Number(rhs).toString(16) + ";\n"
+ + " }\n"
+ + " return { f: " + name + "}\n"
+ + "}; Module");
+ return m(stdlib, foreign, heap).f;
+}
+
+var masks = [0xffffffff, 0xf0f0f0f0, 0x80ffffff, 0x07f77f0f, 0xdeadbeef,
+ 0x0fffff00, 0x0ff0, 0xff, 0x00];
+for (var i in masks) {
+ var rhs = masks[i];
+ var and = Word32And(rhs);
+ for (var lhs = -2147483648; lhs < 2147483648; lhs += 3999773) {
+ assertEquals(lhs & rhs, and(lhs));
+ }
+}
// On MacOS X 10.7.5, this test needs a stack size of at least 788 kBytes.
// Flags: --stack-size=800
+// Flags: --turbo-deoptimization
// Test that we can make large object literals that work.
// Also test that we can attempt to make even larger object literals without
assertEquals('foo', o.p || (o.p == 0));
assertEquals('foo', o.p || (o.p == null));
assertEquals('foo', o.p || (o.p == o.p));
+
+// JSToBoolean(x:string)
+function f(x) { return !!("" + x); }
+assertEquals(false, f(""));
+assertEquals(true, f("narf"));
+assertEquals(true, f(12345678));
+assertEquals(true, f(undefined));
assertEquals([1,7,7,7,7,7,3], a.slice(0, 7));
assertEquals(0xffffffff, a.length);
assertEquals(10, a[0xfffffffe + 5 - 1]);
-
-a = [1];
-Object.defineProperty(a, "1", {writable:false, configurable:false, value: 100});
-assertThrows("a.unshift(4);", TypeError);
-assertEquals([1, 100, 100], a);
-var desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.writable);
-assertEquals(false, desc.configurable);
-
-a = [1];
-var g = function() { return 100; };
-Object.defineProperty(a, "1", {get:g});
-assertThrows("a.unshift(0);", TypeError);
-assertEquals([1, 100, 100], a);
-desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.configurable);
-assertEquals(g, desc.get);
-
-a = [1];
-var c = 0;
-var s = function(v) { c += 1; };
-Object.defineProperty(a, "1", {set:s});
-a.unshift(10);
-assertEquals([10, undefined, undefined], a);
-assertEquals(1, c);
-desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.configurable);
-assertEquals(s, desc.set);
-
-a = [1];
-Object.defineProperty(a, "1", {configurable:false, value:10});
-assertThrows("a.splice(1,1);", TypeError);
-assertEquals([1, 10], a);
-desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.configurable);
-
-a = [0,1,2,3,4,5,6];
-Object.defineProperty(a, "3", {configurable:false, writable:false, value:3});
-assertThrows("a.splice(1,4);", TypeError);
-assertEquals([0,5,6,3,,,,,], a);
-desc = Object.getOwnPropertyDescriptor(a, "3");
-assertEquals(false, desc.configurable);
-assertEquals(false, desc.writable);
-
-a = [0,1,2,3,4,5,6];
-Object.defineProperty(a, "5", {configurable:false, value:5});
-assertThrows("a.splice(1,4);", TypeError);
-assertEquals([0,5,6,3,4,5,,,], a);
-desc = Object.getOwnPropertyDescriptor(a, "5");
-assertEquals(false, desc.configurable);
-
-a = [1,2,3,,5];
-Object.defineProperty(a, "1", {configurable:false, writable:true, value:2});
-assertEquals(1, a.shift());
-assertEquals([2,3,,5], a);
-desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.configurable);
-assertEquals(true, desc.writable);
-assertThrows("a.shift();", TypeError);
-assertEquals([3,3,,5], a);
-desc = Object.getOwnPropertyDescriptor(a, "1");
-assertEquals(false, desc.configurable);
-assertEquals(true, desc.writable);
-
-a = [1,2,3];
-Object.defineProperty(a, "2", {configurable:false, value:3});
-assertThrows("a.pop();", TypeError);
-assertEquals([1,2,3], a);
-desc = Object.getOwnPropertyDescriptor(a, "2");
-assertEquals(false, desc.configurable);
-
-a = [1,2,,,5];
-Object.defineProperty(a, "4", {writable:true, configurable:false, value:5});
-assertThrows("a.sort();", TypeError);
-assertEquals([1,2,5,,5], a);
-desc = Object.getOwnPropertyDescriptor(a, "2");
-assertEquals(true, desc.configurable);
-desc = Object.getOwnPropertyDescriptor(a, "4");
-assertEquals(false, desc.configurable);
-
-a = [1,2,3,,5,6];
-Object.defineProperty(a, "4", {value:5, writable:false});
-assertThrows("a.sort();", TypeError);
-assertEquals([1,2,3,5,5,6], a);
-desc = Object.getOwnPropertyDescriptor(a, "4");
-assertEquals(false, desc.writable);
--- /dev/null
+// 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 --noalways-opt
+
+var global = this;
+
+Array.prototype.f = function() {
+ return 0;
+};
+
+(function() {
+ var called = 0;
+
+ function g(x, y, called) {
+ return called + 1;
+ }
+
+ function f(deopt, called) {
+ return g([].f.call({}), deopt + 1, called);
+ }
+
+ called = f(0, called);
+ called = f(0, called);
+ %OptimizeFunctionOnNextCall(f);
+ called = f(0, called);
+ assertOptimized(f);
+ called = f({}, called);
+ assertUnoptimized(f);
+ assertEquals(4, called);
+})();
+
+(function() {
+ // The array built-ins are only inlined if the receiver is a
+ // HConstant, this seems to require a *unique* global identifier
+ // each time.
+ global.a1 = [1,2,3,4];
+ var obj = {value: 3};
+
+ function f(b) {
+ return [].pop.call(a1) + b.value;
+ }
+
+ assertEquals(7, f(obj));
+ assertEquals(6, f(obj));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals(5, f(obj));
+ assertOptimized(f);
+ assertEquals(4, f({d: 0, value: 3}));
+ assertUnoptimized(f);
+ assertEquals(0, a1.length);
+})();
+
+
+(function() {
+ global.a2 = [1,2,3,4];
+ var obj = {value: 3};
+
+ function f(b) {
+ return [].shift.call(a2) + b.value;
+ }
+
+ assertEquals(4, f(obj));
+ assertEquals(5, f(obj));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals(6, f(obj));
+ assertOptimized(f);
+ assertEquals(7, f({d: 0, value: 3}));
+ assertUnoptimized(f);
+ assertEquals(0, a2.length);
+})();
+
+(function() {
+ global.a3 = [1,2,3,4];
+ var obj = {value: 3};
+
+ function f(b) {
+ return [].push.call(a3, b.value);
+ }
+
+ assertEquals(5, f(obj));
+ assertEquals(6, f(obj));
+ %OptimizeFunctionOnNextCall(f);
+ assertEquals(7, f(obj));
+ assertOptimized(f);
+ assertEquals(8, f({d: 0, value: 3}));
+ assertUnoptimized(f);
+ assertEquals(8, a3.length);
+ assertEquals(3, a3[7]);
+})();
+
+(function() {
+ global.a4 = [1,2,3,4];
+ var obj = {value: 3};
+
+ function f(b) {
+ return [].indexOf.call(a4, b.value);
+ }
+
+ f(obj);
+ f(obj);
+ %OptimizeFunctionOnNextCall(f);
+ var index1 = f(obj);
+ assertOptimized(f);
+ var index2 = f({d: 0, value: 3});
+ assertUnoptimized(f);
+
+ assertEquals(2, index1);
+ assertEquals(index1, index2);
+})();
+
+(function() {
+ global.a5 = [1,2,3,4];
+ var obj = {value: 3};
+
+ function f(b) {
+ return [].lastIndexOf.call(a5, b.value);
+ }
+
+ f(obj);
+ f(obj);
+ %OptimizeFunctionOnNextCall(f);
+ var index1 = f(obj);
+ assertOptimized(f);
+ var index2 = f({d: 0, value: 3});
+ assertUnoptimized(f);
+
+ assertEquals(2, index1);
+ assertEquals(index1, index2);
+})();
--- /dev/null
+// 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 --noalways-opt
+
+(function() {
+ function f(x) {
+ for (i = 0; i < 1; i++) {
+ x.call(this);
+ }
+ }
+
+ function g() {}
+
+ f(g);
+ f(g);
+ %OptimizeFunctionOnNextCall(f);
+ assertThrows(function() { f('whatever') }, TypeError);
+})();
--- /dev/null
+// 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 --noalways-opt
+
+var global = this;
+
+// For the HConstant
+Array.prototype.fun = function() {
+ funRecv = this;
+ called++;
+ assertEquals(0, arguments.length);
+};
+
+Array.prototype.funStrict = function() {
+ "use strict";
+ funStrictRecv = this;
+ called++;
+ assertEquals(0, arguments.length);
+};
+
+Array.prototype.manyArgs = function() {
+ "use strict";
+ assertEquals(5, arguments.length);
+ assertEquals(0, this);
+ assertEquals(5, arguments[4]);
+ called++;
+}
+
+Array.prototype.manyArgsSloppy = function() {
+ assertEquals(global, this);
+ assertEquals(5, arguments.length);
+ assertEquals(5, arguments[4]);
+ called++;
+}
+
+var array = [];
+for (var i = 0; i < 100; ++i) {
+ array[i] = i;
+}
+
+var copy = array.slice();
+
+function unshiftsArray(num) {
+ [].unshift.call(array, num);
+}
+
+unshiftsArray(50);
+unshiftsArray(60);
+%OptimizeFunctionOnNextCall(unshiftsArray);
+unshiftsArray(80);
+unshiftsArray(50);
+unshiftsArray(60);
+
+copy.unshift(50);
+copy.unshift(60);
+copy.unshift(80);
+copy.unshift(50);
+copy.unshift(60);
+
+assertOptimized(unshiftsArray);
+assertArrayEquals(array, copy);
+
+
+var called = 0;
+var funRecv;
+
+function callNoArgs() {
+ [].fun.call();
+}
+
+callNoArgs();
+callNoArgs();
+assertEquals(this, funRecv);
+%OptimizeFunctionOnNextCall(callNoArgs);
+callNoArgs();
+assertEquals(this, funRecv);
+assertEquals(3, called);
+assertOptimized(callNoArgs);
+
+var funStrictRecv;
+called = 0;
+
+function callStrictNoArgs() {
+ [].funStrict.call();
+}
+
+callStrictNoArgs();
+callStrictNoArgs();
+assertEquals(undefined, funStrictRecv);
+%OptimizeFunctionOnNextCall(callStrictNoArgs);
+callStrictNoArgs();
+assertEquals(undefined, funStrictRecv);
+assertEquals(3, called);
+assertOptimized(callStrictNoArgs);
+
+called = 0;
+
+
+function callManyArgs() {
+ [].manyArgs.call(0, 1, 2, 3, 4, 5);
+}
+
+callManyArgs();
+callManyArgs();
+%OptimizeFunctionOnNextCall(callManyArgs);
+callManyArgs();
+assertOptimized(callManyArgs);
+assertEquals(called, 3);
+
+called = 0;
+
+
+function callManyArgsSloppy() {
+ [].manyArgsSloppy.call(null, 1, 2, 3, 4, 5);
+}
+
+callManyArgsSloppy();
+callManyArgsSloppy();
+%OptimizeFunctionOnNextCall(callManyArgsSloppy);
+callManyArgsSloppy();
+assertOptimized(callManyArgsSloppy);
+assertEquals(called, 3);
+
+var str = "hello";
+var code = str.charCodeAt(3);
+called = 0;
+function callBuiltinIndirectly() {
+ called++;
+ return "".charCodeAt.call(str, 3);
+}
+
+callBuiltinIndirectly();
+callBuiltinIndirectly();
+%OptimizeFunctionOnNextCall(callBuiltinIndirectly);
+assertEquals(code, callBuiltinIndirectly());
+assertOptimized(callBuiltinIndirectly);
+assertEquals(3, called);
+
+this.array = [1,2,3,4,5,6,7,8,9];
+var copy = this.array.slice();
+called = 0;
+
+function callInlineableBuiltinIndirectlyWhileInlined() {
+ called++;
+ return [].push.apply(array, arguments);
+}
+
+function callInlined(num) {
+ return callInlineableBuiltinIndirectlyWhileInlined(num);
+}
+
+callInlineableBuiltinIndirectlyWhileInlined(1);
+callInlineableBuiltinIndirectlyWhileInlined(2);
+%OptimizeFunctionOnNextCall(callInlineableBuiltinIndirectlyWhileInlined);
+callInlineableBuiltinIndirectlyWhileInlined(3);
+assertOptimized(callInlineableBuiltinIndirectlyWhileInlined);
+
+callInlined(1);
+callInlined(2);
+%OptimizeFunctionOnNextCall(callInlined);
+callInlined(3);
+copy.push(1, 2, 3, 1, 2, 3);
+assertOptimized(callInlined);
+assertArrayEquals(copy, this.array);
+assertEquals(6, called);
--- /dev/null
+// 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.
+
+function Module(stdlib, foreign, buffer) {
+ "use asm";
+ var HEAP32 = new stdlib.Int32Array(buffer);
+ function g(a) {
+ HEAP32[a] = 9982 * 100;
+ return a;
+ }
+ function f(i1) {
+ i1 = i1 | 0;
+ var i2 = HEAP32[i1 >> 2] | 0;
+ g(i1);
+ L2909: {
+ L2: {
+ if (0) {
+ if (0) break L2;
+ g(i2);
+ break L2909;
+ }
+ }
+ var r = (HEAP32[1] | 0) / 100 | 0;
+ g(r);
+ return r;
+ }
+ }
+ return {f: f};
+}
+
+var f = Module(this, {}, new ArrayBuffer(64 * 1024)).f;
+assertEquals(9982, f(1));
--- /dev/null
+// 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.
+
+function f() {
+ var x = 0;
+ var y = 0;
+ x ^= undefined;
+ assertEquals(x /= 1);
+ assertEquals(NaN, y %= 1);
+ assertEquals(y = 1);
+ f();
+ y = -2;
+ assertEquals(x >>= 1);
+ assertEquals(0, ((y+(y+(y+((y^(x%5))+y)))+(y+y))>>y)+y);
+}
+try { f(); } catch (e) {}
--- /dev/null
+// 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.
+
+
+function Module() {
+ "use asm";
+ function f() {
+ var $0 = 0, $25 = 0, $i$014$i = 0, $sum$013$i = 0, $v_0$01$i = 0, $v_1$02$i = 0, $v_10$011$i = 0, $v_11$012$i = 0, $v_2$03$i = 0, $v_3$04$i = 0, $v_4$05$i = 0, $v_5$06$i = 0, $v_6$07$i = 0, $v_7$08$i = 0, $v_8$09$i = 0, $v_9$010$i = 0;
+ $i$014$i = 0;
+ $sum$013$i = 0;
+ $v_0$01$i = 8;
+ $v_1$02$i = 9;
+ $v_10$011$i = 18;
+ $v_11$012$i = 19;
+ $v_2$03$i = 10;
+ $v_3$04$i = 11;
+ $v_4$05$i = 12;
+ $v_5$06$i = 13;
+ $v_6$07$i = 14;
+ $v_7$08$i = 15;
+ $v_8$09$i = 16;
+ $v_9$010$i = 17;
+ do {
+ $v_0$01$i = $v_3$04$i + $v_9$010$i + $v_0$01$i | 0;
+ $v_1$02$i = $v_4$05$i + $v_10$011$i + $v_1$02$i | 0;
+ $v_2$03$i = $v_5$06$i + $v_11$012$i + $v_2$03$i | 0;
+ $v_3$04$i = $v_3$04$i + $v_6$07$i + $v_0$01$i | 0;
+ $v_4$05$i = $v_4$05$i + $v_7$08$i + $v_1$02$i | 0;
+ $v_5$06$i = $v_5$06$i + $v_8$09$i + $v_2$03$i | 0;
+ $v_6$07$i = $v_6$07$i + $v_9$010$i + $v_3$04$i | 0;
+ $v_7$08$i = $v_7$08$i + $v_10$011$i + $v_4$05$i | 0;
+ $v_8$09$i = $v_8$09$i + $v_11$012$i + $v_5$06$i | 0;
+ $v_9$010$i = $v_0$01$i + $v_9$010$i + $v_6$07$i | 0;
+ $v_10$011$i = $v_1$02$i + $v_10$011$i + $v_7$08$i | 0;
+ $v_11$012$i = $v_2$03$i + $v_11$012$i + $v_8$09$i | 0;
+ $25 = $v_0$01$i + $v_1$02$i | 0;
+ $sum$013$i = $v_2$03$i + $sum$013$i + $v_5$06$i + $v_4$05$i + $v_8$09$i + $v_3$04$i + $25 + $v_7$08$i + $v_11$012$i + $v_6$07$i + $v_10$011$i + $v_9$010$i | 0;
+ $i$014$i = $i$014$i + 1 | 0;
+ } while (($i$014$i | 0) <= 0);
+ return $sum$013$i - ($v_5$06$i + $v_2$03$i + $v_4$05$i + $v_8$09$i + $25 + $v_3$04$i + $v_7$08$i + $v_11$012$i + $v_6$07$i + $v_10$011$i + $v_9$010$i);
+ }
+ return { f: f };
+}
+
+Module().f();
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --allow-natives-syntax --noopt-safe-uint32-operations
+// Flags: --allow-natives-syntax
// Check the results of `left >>> right`. The result is always unsigned (and
// therefore positive).
// (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
+// Flags: --expose-debug-as debug --turbo-deoptimization
// Get the Debug object exposed from the debug context global object.
Debug = debug.Debug
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --expose-debug-as debug --expose-gc --send-idle-notification
+// Flags: --allow-natives-syntax
// Get the Debug object exposed from the debug context global object.
Debug = debug.Debug;
}
// This has to be updated if the number of native scripts change.
-assertTrue(named_native_count == 26 || named_native_count == 27);
+assertEquals(%NativeScriptsCount(), named_native_count);
// Only the 'gc' extension is loaded.
assertEquals(1, extension_count);
// This script and mjsunit.js has been loaded. If using d8, d8 loads
--- /dev/null
+// 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: --turbo-filter=g --allow-natives-syntax
+
+// Test that Debug::PrepareForBreakPoints can deal with turbofan code (g)
+// on the stack. Without deoptimization support, we will not be able to
+// replace optimized code for g by unoptimized code with debug break slots.
+// This would cause stepping to fail (V8 issue 3660).
+
+function f(x) {
+ g(x);
+ var a = 0; // Break 6
+ return a; // Break 7
+} // Break 8
+
+function g(x) {
+ if (x) h();
+ var a = 0; // Break 2
+ var b = 1; // Break 3
+ return a + b; // Break 4
+} // Break 5
+
+function h() {
+ debugger; // Break 0
+} // Break 1
+
+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 {
+ exec_state.prepareStep(Debug.StepAction.StepNext, 1);
+ print(exec_state.frame(0).sourceLineText());
+ var match = exec_state.frame(0).sourceLineText().match(/Break (\d)/);
+ assertNotNull(match);
+ assertEquals(break_count++, parseInt(match[1]));
+ } catch (e) {
+ print(e + e.stack);
+ exception = e;
+ }
+}
+
+f(0);
+f(0);
+%OptimizeFunctionOnNextCall(g);
+
+Debug.setListener(listener);
+
+f(1);
+
+Debug.setListener(null); // Break 9
+assertNull(exception);
+assertEquals(10, break_count);
--- /dev/null
+// 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
+
+function f0() {
+ var v00 = 0; // Break 1
+ var v01 = 1;
+ // Normal function call in a catch scope.
+ try {
+ throw 1;
+ } catch (e) {
+ try{
+ f1();
+ } catch (e) {
+ var v02 = 2; // Break 13
+ }
+ }
+ var v03 = 3;
+ var v04 = 4;
+}
+
+function f1() {
+ var v10 = 0; // Break 2
+ var v11 = 1;
+ // Getter call.
+ var v12 = o.get;
+ var v13 = 3 // Break 4
+ // Setter call.
+ o.set = 2;
+ var v14 = 4; // Break 6
+ // Function.prototype.call.
+ f2.call();
+ var v15 = 5; // Break 12
+ var v16 = 6;
+ // Exit function by throw.
+ throw 1;
+ var v17 = 7;
+}
+
+function get() {
+ var g0 = 0; // Break 3
+ var g1 = 1;
+ return 3;
+}
+
+function set() {
+ var s0 = 0; // Break 5
+ return 3;
+}
+
+function f2() {
+ var v20 = 0; // Break 7
+ // Construct call.
+ var v21 = new c0();
+ var v22 = 2; // Break 9
+ // Bound function.
+ b0();
+ return 2; // Break 11
+}
+
+function c0() {
+ this.v0 = 0; // Break 8
+ this.v1 = 1;
+}
+
+function f3() {
+ var v30 = 0; // Break 10
+ var v31 = 1;
+ return 3;
+}
+
+var b0 = f3.bind(o);
+
+var o = {};
+Object.defineProperty(o, "get", { get : get });
+Object.defineProperty(o, "set", { set : set });
+
+Debug = debug.Debug;
+var break_count = 0
+var exception = null;
+var step_size;
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ var line = exec_state.frame(0).sourceLineText();
+ print(line);
+ var match = line.match(/\/\/ Break (\d+)$/);
+ assertEquals(2, match.length);
+ assertEquals(break_count, parseInt(match[1]));
+ break_count += step_size;
+ exec_state.prepareStep(Debug.StepAction.StepFrame, step_size);
+ } catch (e) {
+ print(e + e.stack);
+ exception = e;
+ }
+}
+
+for (step_size = 1; step_size < 6; step_size++) {
+ print("step size = " + step_size);
+ break_count = 0;
+ Debug.setListener(listener);
+ debugger; // Break 0
+ f0();
+ Debug.setListener(null); // Break 14
+ assertTrue(break_count > 14);
+}
+
+assertNull(exception);
assertTrue(descriptor.writable);
assertFalse(descriptor.enumerable);
assertTrue(descriptor.configurable);
- assertEquals(descriptor.value, [].values);
- assertEquals(arguments[Symbol.iterator], [].values);
+ assertEquals(descriptor.value, [][Symbol.iterator]);
+ assertEquals(arguments[Symbol.iterator], [][Symbol.iterator]);
}
TestDirectArgumentsIteratorProperty();
var o = arguments;
assertTrue(o.hasOwnProperty(Symbol.iterator));
assertFalse(o.propertyIsEnumerable(Symbol.iterator));
- assertEquals(o[Symbol.iterator], [].values);
+ assertEquals(o[Symbol.iterator], [][Symbol.iterator]);
}
TestIndirectArgumentsIteratorProperty();
"use strict";
var o = {__proto__:arguments};
- assertSame([].values, o[Symbol.iterator]);
+ assertSame([][Symbol.iterator], o[Symbol.iterator]);
// Make o dict-mode.
%OptimizeObjectForAddingMultipleProperties(o, 0);
assertFalse(o.hasOwnProperty(Symbol.iterator));
- assertSame([].values, o[Symbol.iterator]);
+ assertSame([][Symbol.iterator], o[Symbol.iterator]);
o[Symbol.iterator] = 10;
assertTrue(o.hasOwnProperty(Symbol.iterator));
assertEquals(10, o[Symbol.iterator]);
- assertSame([].values, arguments[Symbol.iterator]);
+ assertSame([][Symbol.iterator], arguments[Symbol.iterator]);
// Frozen o.
o = Object.freeze({__proto__:arguments});
- assertSame([].values, o[Symbol.iterator]);
+ assertSame([][Symbol.iterator], o[Symbol.iterator]);
assertFalse(o.hasOwnProperty(Symbol.iterator));
- assertSame([].values, o[Symbol.iterator]);
+ assertSame([][Symbol.iterator], o[Symbol.iterator]);
// This should throw, but currently it doesn't, because
// ExecutableAccessorInfo callbacks don't see the current strict mode.
// See note in accessors.cc:SetPropertyOnInstanceIfInherited.
o[Symbol.iterator] = 10;
assertFalse(o.hasOwnProperty(Symbol.iterator));
- assertEquals([].values, o[Symbol.iterator]);
- assertSame([].values, arguments[Symbol.iterator]);
+ assertEquals([][Symbol.iterator], o[Symbol.iterator]);
+ assertSame([][Symbol.iterator], arguments[Symbol.iterator]);
}
TestArgumentsAsProto();
// (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 --harmony-tostring
var NONE = 0;
function TestArrayPrototype() {
assertHasOwnProperty(Array.prototype, 'entries', DONT_ENUM);
- assertHasOwnProperty(Array.prototype, 'values', DONT_ENUM);
assertHasOwnProperty(Array.prototype, 'keys', DONT_ENUM);
assertHasOwnProperty(Array.prototype, Symbol.iterator, DONT_ENUM);
-
- assertEquals(Array.prototype.values, Array.prototype[Symbol.iterator]);
}
TestArrayPrototype();
function TestValues() {
var array = ['a', 'b', 'c'];
- var iterator = array.values();
+ var iterator = array[Symbol.iterator]();
assertIteratorResult('a', false, iterator.next());
assertIteratorResult('b', false, iterator.next());
assertIteratorResult('c', false, iterator.next());
function TestValuesMutate() {
var array = ['a', 'b', 'c'];
- var iterator = array.values();
+ var iterator = array[Symbol.iterator]();
assertIteratorResult('a', false, iterator.next());
assertIteratorResult('b', false, iterator.next());
assertIteratorResult('c', false, iterator.next());
function TestArrayIteratorPrototype() {
var array = [];
- var iterator = array.values();
+ var iterator = array.keys();
var ArrayIteratorPrototype = iterator.__proto__;
- assertEquals(ArrayIteratorPrototype, array.values().__proto__);
+ assertEquals(ArrayIteratorPrototype, array[Symbol.iterator]().__proto__);
assertEquals(ArrayIteratorPrototype, array.keys().__proto__);
assertEquals(ArrayIteratorPrototype, array.entries().__proto__);
assertEquals(Object.prototype, ArrayIteratorPrototype.__proto__);
- assertEquals('Array Iterator', %_ClassOf(array.values()));
+ assertEquals('Array Iterator', %_ClassOf(array[Symbol.iterator]()));
assertEquals('Array Iterator', %_ClassOf(array.keys()));
assertEquals('Array Iterator', %_ClassOf(array.entries()));
Object.getOwnPropertyNames(ArrayIteratorPrototype));
assertHasOwnProperty(ArrayIteratorPrototype, 'next', DONT_ENUM);
assertHasOwnProperty(ArrayIteratorPrototype, Symbol.iterator, DONT_ENUM);
+
+ assertEquals("[object Array Iterator]",
+ Object.prototype.toString.call(iterator));
+ assertEquals("Array Iterator", ArrayIteratorPrototype[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(
+ ArrayIteratorPrototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("Array Iterator", desc.value);
}
TestArrayIteratorPrototype();
var buffer = [];
var array = [0, 'a', true, false, null, /* hole */, undefined, NaN];
var i = 0;
- for (var value of array.values()) {
+ for (var value of array[Symbol.iterator]()) {
buffer[i++] = value;
}
function TestNonOwnSlots() {
var array = [0];
- var iterator = array.values();
+ var iterator = array[Symbol.iterator]();
var object = {__proto__: iterator};
assertThrows(function() {
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --harmony-tostring
(function TestSetIterator() {
assertEquals(new Set().values().__proto__, SetIteratorPrototype);
assertEquals(new Set().entries().__proto__, SetIteratorPrototype);
+
+ assertEquals("[object Set Iterator]",
+ Object.prototype.toString.call(iter));
+ assertEquals("Set Iterator", SetIteratorPrototype[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(
+ SetIteratorPrototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("Set Iterator", desc.value);
})();
assertEquals(new Map().values().__proto__, MapIteratorPrototype);
assertEquals(new Map().keys().__proto__, MapIteratorPrototype);
assertEquals(new Map().entries().__proto__, MapIteratorPrototype);
+
+ assertEquals("[object Map Iterator]",
+ Object.prototype.toString.call(iter));
+ assertEquals("Map Iterator", MapIteratorPrototype[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(
+ MapIteratorPrototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("Map Iterator", desc.value);
})();
// (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
+// Flags: --expose-gc --allow-natives-syntax --harmony-tostring
function assertSize(expected, collection) {
function TestPrototype(C) {
assertTrue(C.prototype instanceof Object);
assertEquals({
- value: {},
+ value: C.prototype,
writable: false,
enumerable: false,
configurable: false
assertEquals(4950, accumulated);
})();
+
+(function TestSetForEachReceiverAsObject() {
+ var set = new Set(["1", "2"]);
+
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ var a = [];
+ set.forEach(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ set.forEach(function() { a.push(this); }, {});
+ assertEquals(a[0], a[1]);
+})();
+
+
+(function TestSetForEachReceiverAsObjectInStrictMode() {
+ var set = new Set(["1", "2"]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ var a = [];
+ set.forEach(function() { 'use strict'; a.push(this); }, "");
+ assertTrue(a[0] === "" && a[0] === a[1]);
+})();
+
+
(function TestMapForEachInvalidTypes() {
assertThrows(function() {
Map.prototype.map.forEach.call({});
})();
+(function TestMapForEachReceiverAsObject() {
+ var map = new Map();
+ map.set("key1", "value1");
+ map.set("key2", "value2");
+
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ var a = [];
+ map.forEach(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ map.forEach(function() { a.push(this); }, {});
+ assertEquals(a[0], a[1]);
+})();
+
+
+(function TestMapForEachReceiverAsObjectInStrictMode() {
+ var map = new Map();
+ map.set("key1", "value1");
+ map.set("key2", "value2");
+
+ // In strict mode primitive values should not be coerced to an object.
+ var a = [];
+ map.forEach(function() { 'use strict'; a.push(this); }, "");
+ assertTrue(a[0] === "" && a[0] === a[1]);
+})();
+
+
// Allows testing iterator-based constructors easily.
var oneAndTwo = new Map();
var k0 = {key: 0};
}
TestMapConstructorIterableValue(Map);
TestMapConstructorIterableValue(WeakMap);
+
+function TestCollectionToString(C) {
+ assertEquals("[object " + C.name + "]",
+ Object.prototype.toString.call(new C()));
+}
+TestCollectionToString(Map);
+TestCollectionToString(Set);
+TestCollectionToString(WeakMap);
+TestCollectionToString(WeakSet);
// (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-scoping --allow-natives-syntax
+// Flags: --harmony-scoping --allow-natives-syntax --harmony-tostring
// Test instantations of generators.
assertTrue(iter instanceof g);
assertEquals("Generator", %_ClassOf(iter));
assertEquals("[object Generator]", String(iter));
+ assertEquals("[object Generator]", Object.prototype.toString.call(iter));
assertEquals([], Object.getOwnPropertyNames(iter));
assertTrue(iter !== new g());
}
--- /dev/null
+// 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: --harmony-tostring
+
+function testJSONToString() {
+ assertEquals('[object JSON]', "" + JSON);
+ assertEquals("JSON", JSON[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(JSON, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("JSON", desc.value);
+}
+testJSONToString();
--- /dev/null
+// 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: --harmony-tostring
+
+function testMathToString() {
+ assertEquals('[object Math]', "" + Math);
+ assertEquals("Math", Math[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(Math, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("Math", desc.value);
+}
+testMathToString();
--- /dev/null
+// 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
+// Test the mirror object for collection iterators.
+
+function testIteratorMirror(iter, offset, expected) {
+ while (offset-- > 0) iter.next();
+
+ var mirror = debug.MakeMirror(iter);
+ assertTrue(mirror.isIterator());
+
+ var preview = mirror.preview();
+ assertArrayEquals(expected, preview);
+
+ // Check that iterator has not changed after taking preview.
+ var values = [];
+ for (var i of iter) values.push(i);
+ assertArrayEquals(expected, values);
+}
+
+var o1 = { foo: 1 };
+var o2 = { foo: 2 };
+
+var map = new Map();
+map.set(41, 42);
+map.set(o1, o2);
+
+testIteratorMirror(map.keys(), 0, [41, o1]);
+testIteratorMirror(map.values(), 0, [42, o2]);
+testIteratorMirror(map.entries(), 0, [[41, 42], [o1, o2]]);
+
+testIteratorMirror(map.keys(), 1, [o1]);
+testIteratorMirror(map.values(), 1, [o2]);
+testIteratorMirror(map.entries(), 1, [[o1, o2]]);
+
+testIteratorMirror(map.keys(), 2, []);
+testIteratorMirror(map.values(), 2, []);
+testIteratorMirror(map.entries(), 2, []);
+
+var set = new Set();
+set.add(41);
+set.add(42);
+set.add(o1);
+set.add(o2);
+
+testIteratorMirror(set.keys(), 0, [41, 42, o1, o2]);
+testIteratorMirror(set.values(), 0, [41, 42, o1, o2]);
+testIteratorMirror(set.entries(), 0, [[41, 41], [42, 42], [o1, o1], [o2, o2]]);
+
+testIteratorMirror(set.keys(), 1, [42, o1, o2]);
+testIteratorMirror(set.values(), 1, [42, o1, o2]);
+testIteratorMirror(set.entries(), 1, [[42, 42], [o1, o1], [o2, o2]]);
+
+testIteratorMirror(set.keys(), 3, [o2]);
+testIteratorMirror(set.values(), 3, [o2]);
+testIteratorMirror(set.entries(), 3, [[o2, o2]]);
+
+testIteratorMirror(set.keys(), 5, []);
+testIteratorMirror(set.values(), 5, []);
+testIteratorMirror(set.entries(), 5, []);
--- /dev/null
+// 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: --harmony-tostring
+
+var global = this;
+
+var funs = {
+ Object: [ Object ],
+ Function: [ Function ],
+ Array: [ Array ],
+ String: [ String ],
+ Boolean: [ Boolean ],
+ Number: [ Number ],
+ Date: [ Date ],
+ RegExp: [ RegExp ],
+ Error: [ Error, TypeError, RangeError, SyntaxError, ReferenceError,
+ EvalError, URIError ]
+}
+for (f in funs) {
+ for (i in funs[f]) {
+ assertEquals("[object " + f + "]",
+ Object.prototype.toString.call(new funs[f][i]),
+ funs[f][i]);
+ assertEquals("[object Function]",
+ Object.prototype.toString.call(funs[f][i]),
+ funs[f][i]);
+ }
+}
+
+function testToStringTag(className) {
+ // Using builtin toStringTags
+ var obj = {};
+ obj[Symbol.toStringTag] = className;
+ assertEquals("[object ~" + className + "]",
+ Object.prototype.toString.call(obj));
+
+ // Getter throws
+ obj = {};
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ get: function() { throw className; }
+ });
+ assertThrows(function() {
+ Object.prototype.toString.call(obj);
+ }, className);
+
+ // Getter does not throw
+ obj = {};
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ get: function() { return className; }
+ });
+ assertEquals("[object ~" + className + "]",
+ Object.prototype.toString.call(obj));
+
+ // Custom, non-builtin toStringTags
+ obj = {};
+ obj[Symbol.toStringTag] = "X" + className;
+ assertEquals("[object X" + className + "]",
+ Object.prototype.toString.call(obj));
+
+ // With getter
+ obj = {};
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ get: function() { return "X" + className; }
+ });
+ assertEquals("[object X" + className + "]",
+ Object.prototype.toString.call(obj));
+
+ // Undefined toStringTag should return [object className]
+ var obj = className === "Arguments" ?
+ (function() { return arguments; })() : new global[className];
+ obj[Symbol.toStringTag] = undefined;
+ assertEquals("[object " + className + "]",
+ Object.prototype.toString.call(obj));
+
+ // With getter
+ var obj = className === "Arguments" ?
+ (function() { return arguments; })() : new global[className];
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ get: function() { return undefined; }
+ });
+ assertEquals("[object " + className + "]",
+ Object.prototype.toString.call(obj));
+}
+
+[
+ "Arguments",
+ "Array",
+ "Boolean",
+ "Date",
+ "Error",
+ "Function",
+ "Number",
+ "RegExp",
+ "String"
+].forEach(testToStringTag);
+
+function testToStringTagNonString(value) {
+ var obj = {};
+ obj[Symbol.toStringTag] = value;
+ assertEquals("[object ???]", Object.prototype.toString.call(obj));
+
+ // With getter
+ obj = {};
+ Object.defineProperty(obj, Symbol.toStringTag, {
+ get: function() { return value; }
+ });
+ assertEquals("[object ???]", Object.prototype.toString.call(obj));
+}
+
+[
+ null,
+ function() {},
+ [],
+ {},
+ /regexp/,
+ 42,
+ Symbol("sym"),
+ new Date(),
+ (function() { return arguments; })(),
+ true,
+ new Error("oops"),
+ new String("str")
+].forEach(testToStringTagNonString);
+
+function testObjectToStringPropertyDesc() {
+ var desc = Object.getOwnPropertyDescriptor(Object.prototype, "toString");
+ assertTrue(desc.writable);
+ assertFalse(desc.enumerable);
+ assertTrue(desc.configurable);
+}
+testObjectToStringPropertyDesc();
// (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 --harmony-tostring
// Make sure we don't rely on functions patchable by monkeys.
var call = Function.prototype.call.call.bind(Function.prototype.call)
var observe = Object.observe;
-var getOwnPropertyNames = Object.getOwnPropertyNames
-var defineProperty = Object.defineProperty
+var getOwnPropertyNames = Object.getOwnPropertyNames;
+var defineProperty = Object.defineProperty;
+
+
+(function() {
+ // Test before clearing global (fails otherwise)
+ assertEquals("[object Promise]",
+ Object.prototype.toString.call(new Promise(function() {})));
+})();
+
function clear(o) {
if (o === null || (typeof o !== 'object' && typeof o !== 'function')) return
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+// Flags: --harmony-tostring
function TestStringPrototypeIterator() {
assertTrue(String.prototype.hasOwnProperty(Symbol.iterator));
assertArrayEquals(['next'],
Object.getOwnPropertyNames(StringIteratorPrototype));
assertEquals('[object String Iterator]', "" + iterator);
+ assertEquals("String Iterator", StringIteratorPrototype[Symbol.toStringTag]);
+ var desc = Object.getOwnPropertyDescriptor(
+ StringIteratorPrototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.writable);
+ assertEquals("String Iterator", desc.value);
}
TestStringIteratorPrototype();
// (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
+// Flags: --expose-gc --allow-natives-syntax --harmony-tostring
var symbols = []
assertSame("x3", Symbol.keyFor(symbol3))
}
TestRegistry()
+
+
+function TestGetOwnPropertySymbolsOnPrimitives() {
+ assertEquals(Object.getOwnPropertySymbols(true), []);
+ assertEquals(Object.getOwnPropertySymbols(5000), []);
+ assertEquals(Object.getOwnPropertySymbols("OK"), []);
+}
+TestGetOwnPropertySymbolsOnPrimitives();
assertFalse(constructor.prototype.propertyIsEnumerable(Symbol.iterator));
assertEquals(Array.prototype.entries, constructor.prototype.entries);
- assertEquals(Array.prototype.values, constructor.prototype.values);
+ assertEquals(Array.prototype[Symbol.iterator], constructor.prototype.values);
assertEquals(Array.prototype.keys, constructor.prototype.keys);
- assertEquals(Array.prototype.values, constructor.prototype[Symbol.iterator]);
+ assertEquals(Array.prototype[Symbol.iterator], constructor.prototype[Symbol.iterator]);
}
constructors.forEach(TestTypedArrayPrototype);
assertTrue(key == 'a');
break;
}
-assertFalse(%HasFastProperties(x));
+assertTrue(%HasFastProperties(x));
x.d = 4;
-assertFalse(%HasFastProperties(x));
+assertTrue(%HasFastProperties(x));
for (key in x) {
assertTrue(key == 'a');
break;
var exception = false;
try {
- // We call all functions with no parameters, which means that essential
- // parameters will have the undefined value.
- // The test for whether the "this" value is null or undefined is always
- // performed before access to the other parameters, so even if the
- // undefined value is an invalid argument value, it mustn't change
- // the result of the test.
- should_throw_on_null_and_undefined[i].call(null);
+ // We need to pass a dummy object argument ({}) to these functions because
+ // of Object.prototype.isPrototypeOf's special behavior, see issue 3483
+ // for more details.
+ should_throw_on_null_and_undefined[i].call(null, {});
} catch (e) {
exception = true;
checkExpectedMessage(e);
exception = false;
try {
- should_throw_on_null_and_undefined[i].call(undefined);
+ should_throw_on_null_and_undefined[i].call(undefined, {});
} catch (e) {
exception = true;
checkExpectedMessage(e);
exception = false;
try {
- should_throw_on_null_and_undefined[i].apply(null);
+ should_throw_on_null_and_undefined[i].apply(null, [{}]);
} catch (e) {
exception = true;
checkExpectedMessage(e);
exception = false;
try {
- should_throw_on_null_and_undefined[i].apply(undefined);
+ should_throw_on_null_and_undefined[i].apply(undefined, [{}]);
} catch (e) {
exception = true;
checkExpectedMessage(e);
// Test that we still throw when calling with thisArg null or undefined
// through an array mapping function.
-var array = [1,2,3,4,5];
+// We need to make sure that the elements of `array` are all object values,
+// see issue 3483 for more details.
+var array = [{}, [], new Number, new Map, new WeakSet];
for (var j = 0; j < mapping_functions.length; j++) {
for (var i = 0; i < should_throw_on_null_and_undefined.length; i++) {
exception = false;
create_func_double,
create_func_fast];
-for(var c = 0; c < 3; c++) {
+for(var c = 0; c < cf.length; c++) {
base_getter_test(cf[c]);
}
return this.elementAt(key) === val;
}, thisArg);
assertEquals("b", found);
+
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].find(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].find(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].find(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
// Test exceptions
return this.elementAt(key) === val;
}, thisArg);
assertEquals(1, index);
+
+ // Create a new object in each function call when receiver is a
+ // primitive value. See ECMA-262, Annex C.
+ a = [];
+ [1, 2].findIndex(function() { a.push(this) }, "");
+ assertTrue(a[0] !== a[1]);
+
+ // Do not create a new object otherwise.
+ a = [];
+ [1, 2].findIndex(function() { a.push(this) }, {});
+ assertEquals(a[0], a[1]);
+
+ // In strict mode primitive values should not be coerced to an object.
+ a = [];
+ [1, 2].findIndex(function() { 'use strict'; a.push(this); }, "");
+ assertEquals("", a[0]);
+ assertEquals(a[0], a[1]);
+
})();
// Test exceptions
--- /dev/null
+// 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: --harmony-classes
+
+(function TestBasics() {
+ var C = class C {}
+ assertEquals(typeof C, 'function');
+ assertEquals(C.__proto__, Function.prototype);
+ assertEquals(Object.prototype, Object.getPrototypeOf(C.prototype));
+ assertEquals(Function.prototype, Object.getPrototypeOf(C));
+ assertEquals('C', C.name);
+
+ class D {}
+ assertEquals(typeof D, 'function');
+ assertEquals(D.__proto__, Function.prototype);
+ assertEquals(Object.prototype, Object.getPrototypeOf(D.prototype));
+ assertEquals(Function.prototype, Object.getPrototypeOf(D));
+ assertEquals('D', D.name);
+
+ var E = class {}
+ assertEquals('', E.name);
+})();
+
+
+(function TestBasicsExtends() {
+ class C extends null {}
+ assertEquals(typeof C, 'function');
+ assertEquals(C.__proto__, Function.prototype);
+ assertEquals(null, Object.getPrototypeOf(C.prototype));
+
+ class D extends C {}
+ assertEquals(typeof D, 'function');
+ assertEquals(D.__proto__, C);
+ assertEquals(C.prototype, Object.getPrototypeOf(D.prototype));
+})();
+
+
+(function TestSideEffectInExtends() {
+ var calls = 0;
+ class C {}
+ class D extends (calls++, C) {}
+ assertEquals(1, calls);
+ assertEquals(typeof D, 'function');
+ assertEquals(D.__proto__, C);
+ assertEquals(C.prototype, Object.getPrototypeOf(D.prototype));
+})();
+
+
+(function TestInvalidExtends() {
+ assertThrows(function() {
+ class C extends 42 {}
+ }, TypeError);
+
+ assertThrows(function() {
+ // Function but its .prototype is not null or a function.
+ class C extends Math.abs {}
+ }, TypeError);
+
+ assertThrows(function() {
+ Math.abs.prototype = 42;
+ class C extends Math.abs {}
+ }, TypeError);
+ delete Math.abs.prototype;
+})();
+
+
+(function TestConstructorProperty() {
+ class C {}
+ assertEquals(C, C.prototype.constructor);
+ var descr = Object.getOwnPropertyDescriptor(C.prototype, 'constructor');
+ assertTrue(descr.configurable);
+ assertFalse(descr.enumerable);
+ assertTrue(descr.writable);
+})();
+
+
+(function TestPrototypeProperty() {
+ class C {}
+ var descr = Object.getOwnPropertyDescriptor(C, 'prototype');
+ assertFalse(descr.configurable);
+ assertFalse(descr.enumerable);
+ assertFalse(descr.writable);
+})();
+
+
+(function TestConstructor() {
+ var count = 0;
+ class C {
+ constructor() {
+ assertEquals(Object.getPrototypeOf(this), C.prototype);
+ count++;
+ }
+ }
+ assertEquals(C, C.prototype.constructor);
+ var descr = Object.getOwnPropertyDescriptor(C.prototype, 'constructor');
+ assertTrue(descr.configurable);
+ assertFalse(descr.enumerable);
+ assertTrue(descr.writable);
+
+ var c = new C();
+ assertEquals(1, count);
+ assertEquals(Object.getPrototypeOf(c), C.prototype);
+})();
+
+
+(function TestImplicitConstructor() {
+ class C {}
+ var c = new C();
+ assertEquals(Object.getPrototypeOf(c), C.prototype);
+})();
+
+
+(function TestConstructorStrict() {
+ class C {
+ constructor() {
+ assertThrows(function() {
+ nonExistingBinding = 42;
+ }, ReferenceError);
+ }
+ }
+ new C();
+})();
+
+
+(function TestSuperInConstructor() {
+ var calls = 0;
+ class B {}
+ B.prototype.x = 42;
+
+ class C extends B {
+ constructor() {
+ calls++;
+ assertEquals(42, super.x);
+ }
+ }
+
+ new C;
+ assertEquals(1, calls);
+})();
+
+
+(function TestStrictMode() {
+ class C {}
+
+ with ({a: 1}) {
+ assertEquals(1, a);
+ }
+
+ assertThrows('class C extends function B() { with ({}); return B; }() {}',
+ SyntaxError);
+
+})();
+
+
+(function TestToString() {
+ class C {}
+ assertEquals('class C {}', C.toString());
+
+ class D { constructor() { 42; } }
+ assertEquals('class D { constructor() { 42; } }', D.toString());
+
+ class E { x() { 42; } }
+ assertEquals('class E { x() { 42; } }', E.toString());
+})();
+
+
+function assertMethodDescriptor(object, name) {
+ var descr = Object.getOwnPropertyDescriptor(object, name);
+ assertTrue(descr.configurable);
+ assertTrue(descr.enumerable);
+ assertTrue(descr.writable);
+ assertEquals('function', typeof descr.value);
+ assertFalse('prototype' in descr.value);
+}
+
+
+function assertGetterDescriptor(object, name) {
+ var descr = Object.getOwnPropertyDescriptor(object, name);
+ assertTrue(descr.configurable);
+ assertTrue(descr.enumerable);
+ assertEquals('function', typeof descr.get);
+ assertEquals(undefined, descr.set);
+}
+
+
+function assertSetterDescriptor(object, name) {
+ var descr = Object.getOwnPropertyDescriptor(object, name);
+ assertTrue(descr.configurable);
+ assertTrue(descr.enumerable);
+ assertEquals(undefined, descr.get);
+ assertEquals('function', typeof descr.set);
+}
+
+
+function assertAccessorDescriptor(object, name) {
+ var descr = Object.getOwnPropertyDescriptor(object, name);
+ assertTrue(descr.configurable);
+ assertTrue(descr.enumerable);
+ assertEquals('function', typeof descr.get);
+ assertEquals('function', typeof descr.set);
+}
+
+
+(function TestMethods() {
+ class C {
+ method() { return 1; }
+ static staticMethod() { return 2; }
+ method2() { return 3; }
+ static staticMethod2() { return 4; }
+ }
+
+ assertMethodDescriptor(C.prototype, 'method');
+ assertMethodDescriptor(C.prototype, 'method2');
+ assertMethodDescriptor(C, 'staticMethod');
+ assertMethodDescriptor(C, 'staticMethod2');
+
+ assertEquals(1, new C().method());
+ assertEquals(2, C.staticMethod());
+ assertEquals(3, new C().method2());
+ assertEquals(4, C.staticMethod2());
+})();
+
+
+(function TestGetters() {
+ class C {
+ get x() { return 1; }
+ static get staticX() { return 2; }
+ get y() { return 3; }
+ static get staticY() { return 4; }
+ }
+
+ assertGetterDescriptor(C.prototype, 'x');
+ assertGetterDescriptor(C.prototype, 'y');
+ assertGetterDescriptor(C, 'staticX');
+ assertGetterDescriptor(C, 'staticY');
+
+ assertEquals(1, new C().x);
+ assertEquals(2, C.staticX);
+ assertEquals(3, new C().y);
+ assertEquals(4, C.staticY);
+})();
+
+
+
+(function TestSetters() {
+ var x, staticX, y, staticY;
+ class C {
+ set x(v) { x = v; }
+ static set staticX(v) { staticX = v; }
+ set y(v) { y = v; }
+ static set staticY(v) { staticY = v; }
+ }
+
+ assertSetterDescriptor(C.prototype, 'x');
+ assertSetterDescriptor(C.prototype, 'y');
+ assertSetterDescriptor(C, 'staticX');
+ assertSetterDescriptor(C, 'staticY');
+
+ assertEquals(1, new C().x = 1);
+ assertEquals(1, x);
+ assertEquals(2, C.staticX = 2);
+ assertEquals(2, staticX);
+ assertEquals(3, new C().y = 3);
+ assertEquals(3, y);
+ assertEquals(4, C.staticY = 4);
+ assertEquals(4, staticY);
+})();
+
+
+(function TestSideEffectsInPropertyDefine() {
+ function B() {}
+ B.prototype = {
+ constructor: B,
+ set m(v) {
+ throw Error();
+ }
+ };
+
+ class C extends B {
+ m() { return 1; }
+ }
+
+ assertEquals(1, new C().m());
+})();
+
+
+(function TestAccessors() {
+ class C {
+ constructor(x) {
+ this._x = x;
+ }
+
+ get x() { return this._x; }
+ set x(v) { this._x = v; }
+
+ static get staticX() { return this._x; }
+ static set staticX(v) { this._x = v; }
+ }
+
+ assertAccessorDescriptor(C.prototype, 'x');
+ assertAccessorDescriptor(C, 'staticX');
+
+ var c = new C(1);
+ c._x = 1;
+ assertEquals(1, c.x);
+ c.x = 2;
+ assertEquals(2, c._x);
+
+ C._x = 3;
+ assertEquals(3, C.staticX);
+ C._x = 4;
+ assertEquals(4, C.staticX );
+})();
+
+
+(function TestProto() {
+ class C {
+ __proto__() { return 1; }
+ }
+ assertMethodDescriptor(C.prototype, '__proto__');
+ assertEquals(1, new C().__proto__());
+})();
+
+
+(function TestProtoStatic() {
+ class C {
+ static __proto__() { return 1; }
+ }
+ assertMethodDescriptor(C, '__proto__');
+ assertEquals(1, C.__proto__());
+})();
+
+
+(function TestProtoAccessor() {
+ class C {
+ get __proto__() { return this._p; }
+ set __proto__(v) { this._p = v; }
+ }
+ assertAccessorDescriptor(C.prototype, '__proto__');
+ var c = new C();
+ c._p = 1;
+ assertEquals(1, c.__proto__);
+ c.__proto__ = 2;
+ assertEquals(2, c.__proto__);
+})();
+
+
+(function TestStaticProtoAccessor() {
+ class C {
+ static get __proto__() { return this._p; }
+ static set __proto__(v) { this._p = v; }
+ }
+ assertAccessorDescriptor(C, '__proto__');
+ C._p = 1;
+ assertEquals(1, C.__proto__);
+ C.__proto__ = 2;
+ assertEquals(2, C.__proto__);
+})();
+
+
+(function TestSettersOnProto() {
+ function Base() {}
+ Base.prototype = {
+ set constructor(_) {
+ assertUnreachable();
+ },
+ set m(_) {
+ assertUnreachable();
+ }
+ };
+ Object.defineProperty(Base, 'staticM', {
+ set: function() {
+ assertUnreachable();
+ }
+ });
+
+ class C extends Base {
+ m() {
+ return 1;
+ }
+ static staticM() {
+ return 2;
+ }
+ }
+
+ assertEquals(1, new C().m());
+ assertEquals(2, C.staticM());
+})();
+
+
+(function TestConstructableButNoPrototype() {
+ var Base = function() {}.bind();
+ assertThrows(function() {
+ class C extends Base {}
+ }, TypeError);
+})();
+
+
+(function TestPrototypeGetter() {
+ var calls = 0;
+ var Base = function() {}.bind();
+ Object.defineProperty(Base, 'prototype', {
+ get: function() {
+ calls++;
+ return null;
+ },
+ configurable: true
+ });
+ class C extends Base {}
+ assertEquals(1, calls);
+
+ calls = 0;
+ Object.defineProperty(Base, 'prototype', {
+ get: function() {
+ calls++;
+ return 42;
+ },
+ configurable: true
+ });
+ assertThrows(function() {
+ class C extends Base {}
+ }, TypeError);
+ assertEquals(1, calls);
+})();
+
+
+(function TestPrototypeSetter() {
+ var Base = function() {}.bind();
+ Object.defineProperty(Base, 'prototype', {
+ set: function() {
+ assertUnreachable();
+ }
+ });
+ assertThrows(function() {
+ class C extends Base {}
+ }, TypeError);
+})();
+
+
+(function TestSuperInMethods() {
+ class B {
+ method() {
+ return 1;
+ }
+ get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ method() {
+ assertEquals(2, super.x);
+ return super.method();
+ }
+ }
+ assertEquals(1, new C().method());
+})();
+
+
+(function TestSuperInGetter() {
+ class B {
+ method() {
+ return 1;
+ }
+ get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ get y() {
+ assertEquals(2, super.x);
+ return super.method();
+ }
+ }
+ assertEquals(1, new C().y);
+})();
+
+
+(function TestSuperInSetter() {
+ class B {
+ method() {
+ return 1;
+ }
+ get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ set y(v) {
+ assertEquals(3, v);
+ assertEquals(2, super.x);
+ assertEquals(1, super.method());
+ }
+ }
+ assertEquals(3, new C().y = 3);
+})();
+
+
+(function TestSuperInStaticMethods() {
+ class B {
+ static method() {
+ return 1;
+ }
+ static get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ static method() {
+ assertEquals(2, super.x);
+ return super.method();
+ }
+ }
+ assertEquals(1, C.method());
+})();
+
+
+(function TestSuperInStaticGetter() {
+ class B {
+ static method() {
+ return 1;
+ }
+ static get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ static get x() {
+ assertEquals(2, super.x);
+ return super.method();
+ }
+ }
+ assertEquals(1, C.x);
+})();
+
+
+(function TestSuperInStaticSetter() {
+ class B {
+ static method() {
+ return 1;
+ }
+ static get x() {
+ return 2;
+ }
+ }
+ class C extends B {
+ static set x(v) {
+ assertEquals(3, v);
+ assertEquals(2, super.x);
+ assertEquals(1, super.method());
+ }
+ }
+ assertEquals(3, C.x = 3);
+})();
+
+
+(function TestNumericPropertyNames() {
+ class B {
+ 1() { return 1; }
+ get 2() { return 2; }
+ set 3(_) {}
+
+ static 4() { return 4; }
+ static get 5() { return 5; }
+ static set 6(_) {}
+ }
+
+ assertMethodDescriptor(B.prototype, '1');
+ assertGetterDescriptor(B.prototype, '2');
+ assertSetterDescriptor(B.prototype, '3');
+
+ assertMethodDescriptor(B, '4');
+ assertGetterDescriptor(B, '5');
+ assertSetterDescriptor(B, '6');
+
+ class C extends B {
+ 1() { return super[1](); }
+ get 2() { return super[2]; }
+
+ static 4() { return super[4](); }
+ static get 5() { return super[5]; }
+ }
+
+ assertEquals(1, new C()[1]());
+ assertEquals(2, new C()[2]);
+ assertEquals(4, C[4]());
+ assertEquals(5, C[5]);
+})();
+
+
+/* TODO(arv): Implement
+(function TestNameBindingInConstructor() {
+ class C {
+ constructor() {
+ assertThrows(function() {
+ C = 42;
+ }, ReferenceError);
+ }
+ }
+ new C();
+})();
+*/
--- /dev/null
+// 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: --harmony-object-literals
+
+
+(function TestBasics() {
+ var x = 1;
+ var object = {x};
+ assertEquals(1, object.x);
+})();
+
+
+(function TestDescriptor() {
+ var x = 1;
+ var object = {x};
+ var descr = Object.getOwnPropertyDescriptor(object, 'x');
+ assertEquals(1, descr.value);
+ assertTrue(descr.enumerable);
+ assertTrue(descr.writable);
+ assertTrue(descr.configurable);
+})();
+
+
+(function TestNotDefined() {
+ 'use strict';
+ assertThrows(function() {
+ return {notDefined};
+ }, ReferenceError);
+})();
+
+
+(function TestLet() {
+ var let = 1;
+ var object = {let};
+ assertEquals(1, object.let);
+})();
+
+
+(function TestYieldInFunction() {
+ var yield = 1;
+ var object = {yield};
+ assertEquals(1, object.yield);
+})();
+
+
+(function TestToString() {
+ function f(x) { return {x}; }
+ assertEquals('function f(x) { return {x}; }', f.toString());
+})();
// test enters an infinite recursion which goes through the runtime and we
// overflow the system stack before the simulator stack.
-// Flags: --harmony-proxies --sim-stack-size=500
+// Flags: --harmony-proxies --sim-stack-size=500 --turbo-deoptimization
// Helper.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony --expose-debug-as=debug
+// Flags: --harmony-modules --expose-debug-as=debug
(function () { // Scope for utility functions.
escaping_function = function(object) {
assertEquals("", "abc".repeat(0));
assertEquals("abcabc", "abc".repeat(2.0));
+assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "a".repeat(37));
assertThrows('"a".repeat(-1)', RangeError);
assertThrows('"a".repeat(Number.POSITIVE_INFINITY)', RangeError);
+assertThrows('"a".repeat(Math.pow(2, 30))', RangeError);
+assertThrows('"a".repeat(Math.pow(2, 40))', RangeError);
var myobj = {
toString: function() {
}());
+(function TestSuperKeyedLoads() {
+ var x = 'x';
+ var derivedDataProperty = 'derivedDataProperty';
+ var f = 'f';
+ function Base() { }
+ function Derived() {
+ this[derivedDataProperty] = 'xxx';
+ }
+ Derived.prototype = Object.create(Base.prototype);
+
+ function fBase() { return "Base " + this.toString(); }
+
+ Base.prototype[f] = fBase.toMethod(Base.prototype);
+
+ function fDerived() {
+ assertEquals("Base this is Derived", super[f]());
+ var a = super[x];
+ assertEquals(15, a);
+ assertEquals(15, super[x]);
+ assertEquals(27, this[x]);
+
+ return "Derived"
+ }
+
+ Base.prototype[x] = 15;
+ Base.prototype.toString = function() { return "this is Base"; };
+ Derived.prototype.toString = function() { return "this is Derived"; };
+ Derived.prototype[x] = 27;
+ Derived.prototype[f] = fDerived.toMethod(Derived.prototype);
+
+ assertEquals("Base this is Base", new Base().f());
+ assertEquals("Derived", new Derived().f());
+}());
+
+
+(function TestSuperNumericKeyedLoads() {
+ var x = 1;
+ var derivedDataProperty = 2;
+ var f = 3;
+ function Base() { }
+ function Derived() {
+ this[derivedDataProperty] = 'xxx';
+ }
+ Derived.prototype = Object.create(Base.prototype);
+
+ function fBase() { return "Base " + this.toString(); }
+
+ Base.prototype[f] = fBase.toMethod(Base.prototype);
+
+ function fDerived() {
+ assertEquals("Base this is Derived", super[f]());
+ var a = super[x];
+ assertEquals(15, a);
+ assertEquals(15, super[x]);
+ assertEquals(27, this[x]);
+
+ return "Derived"
+ }
+
+ Base.prototype[x] = 15;
+ Base.prototype.toString = function() { return "this is Base"; };
+ Derived.prototype.toString = function() { return "this is Derived"; };
+ Derived.prototype[x] = 27;
+ Derived.prototype[f] = fDerived.toMethod(Derived.prototype);
+
+ assertEquals("Base this is Base", new Base()[f]());
+ assertEquals("Derived", new Derived()[f]());
+}());
+
+
(function TestSuperKeywordNonMethod() {
function f() {
super.unknown();
}());
+(function TestGetterKeyed() {
+ var x = 'x';
+ function Base() {}
+ var derived;
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ assertSame(this, derived);
+ return this._x;
+ },
+ _x: 'base'
+ };
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 'derived'
+ };
+ Derived.prototype.testGetter = function() {
+ return super[x];
+ }.toMethod(Derived.prototype);
+ Derived.prototype.testGetterStrict = function() {
+ 'use strict';
+ return super[x];
+ }.toMethod(Derived.prototype);
+ Derived.prototype.testGetterWithToString = function() {
+ var toStringCalled;
+ var o = { toString: function() {
+ toStringCalled++;
+ return 'x';
+ } };
+
+ toStringCalled = 0;
+ assertEquals('derived', super[o]);
+ assertEquals(1, toStringCalled);
+
+ var eToThrow = new Error();
+ var oThrowsInToString = { toString: function() {
+ throw eToThrow;
+ } };
+
+ var ex = null;
+ try {
+ super[oThrowsInToString];
+ } catch(e) { ex = e }
+ assertEquals(eToThrow, ex);
+
+ var oReturnsNumericString = { toString: function() {
+ return "1";
+ } };
+
+ assertEquals(undefined, super[oReturnsNumericString]);
+ assertEquals(undefined, super[1]);
+ }.toMethod(Derived.prototype);
+ derived = new Derived();
+ assertEquals('derived', derived.testGetter());
+ derived = new Derived();
+ assertEquals('derived', derived.testGetterStrict());
+ derived = new Derived();
+ derived.testGetterWithToString();
+}());
+
+
+(function TestGetterNumericKeyed() {
+ var x = 42;
+ function Base() {}
+ var derived;
+ Base.prototype = {
+ constructor: Base,
+ _x: 'base'
+ };
+
+ Object.defineProperty(Base.prototype, x, { get: function() {
+ assertSame(this, derived);
+ return this._x;
+ }});
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 'derived'
+ };
+ Derived.prototype.testGetter = function() {
+ return super[x];
+ }.toMethod(Derived.prototype);
+ Derived.prototype.testGetterStrict = function() {
+ 'use strict';
+ return super[x];
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.testGetterWithToString = function() {
+ var toStringCalled;
+ var o = { toString: function() {
+ toStringCalled++;
+ return '42';
+ } };
+
+ toStringCalled = 0;
+ assertEquals('derived', super[o]);
+ assertEquals(1, toStringCalled);
+
+ var eToThrow = new Error();
+ var oThrowsInToString = { toString: function() {
+ throw eToThrow;
+ } };
+
+ var ex = null;
+ try {
+ super[oThrowsInToString];
+ } catch(e) { ex = e }
+ assertEquals(eToThrow, ex);
+
+ var oReturnsNumericString = { toString: function() {
+ return "42";
+ } };
+
+ assertEquals('derived', super[oReturnsNumericString]);
+ assertEquals('derived', super[42]);
+ }.toMethod(Derived.prototype);
+ derived = new Derived();
+ assertEquals('derived', derived.testGetter());
+ derived = new Derived();
+ assertEquals('derived', derived.testGetterStrict());
+ derived = new Derived();
+ derived.testGetterWithToString();
+}());
+
+
(function TestSetter() {
function Base() {}
Base.prototype = {
}());
+(function TestSetterNumericKeyed() {
+ var x = 42;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ _x: 'base'
+ };
+
+ Object.defineProperty(Base.prototype, x,
+ { get: function() { return this._x; },
+ set: function(v) { this._x = v; }
+ });
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 'derived'
+ };
+ Derived.prototype.testSetter = function() {
+ assertEquals('foobar', super[x] = 'foobar');
+ assertEquals('foobarabc', super[x] += 'abc');
+ }.toMethod(Derived.prototype);
+ var d = new Derived();
+ d.testSetter();
+ assertEquals('base', Base.prototype._x);
+ assertEquals('foobarabc', d._x);
+ d._x = '';
+ Derived.prototype.testSetterStrict = function() {
+ 'use strict';
+ assertEquals('foobar', super[x] = 'foobar');
+ assertEquals('foobarabc', super[x] += 'abc');
+ }.toMethod(Derived.prototype);
+ d.testSetterStrict();
+ assertEquals('base', Base.prototype._x);
+ assertEquals('foobarabc', d._x);
+
+
+ Derived.prototype.testSetterWithToString = function() {
+ var toStringCalled;
+ var o = { toString: function() {
+ toStringCalled++;
+ return x;
+ } };
+
+ toStringCalled = 0;
+ super[o] = 'set';
+ assertEquals(1, toStringCalled);
+ assertEquals('set', this._x);
+
+ var eToThrow = new Error();
+ var oThrowsInToString = { toString: function() {
+ throw eToThrow;
+ } };
+
+ var ex = null;
+ try {
+ super[oThrowsInToString] = 'xyz';
+ } catch(e) { ex = e }
+ assertEquals(eToThrow, ex);
+ assertEquals('set', this._x);
+ }.toMethod(Derived.prototype);
+ d = new Derived();
+ d.testSetterWithToString();
+}());
+
+
+(function TestSetterKeyed() {
+ var x = 'x';
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ return this._x;
+ },
+ set x(v) {
+ this._x = v;
+ },
+ _x: 'base'
+ };
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 'derived'
+ };
+ Derived.prototype.testSetter = function() {
+ assertEquals('foobar', super[x] = 'foobar');
+ assertEquals('foobarabc', super[x] += 'abc');
+ }.toMethod(Derived.prototype);
+ var d = new Derived();
+ d.testSetter();
+ assertEquals('base', Base.prototype._x);
+ assertEquals('foobarabc', d._x);
+ d._x = '';
+ Derived.prototype.testSetterStrict = function() {
+ 'use strict';
+ assertEquals('foobar', super[x] = 'foobar');
+ assertEquals('foobarabc', super[x] += 'abc');
+ }.toMethod(Derived.prototype);
+ d.testSetterStrict();
+ assertEquals('base', Base.prototype._x);
+ assertEquals('foobarabc', d._x);
+
+
+ Derived.prototype.testSetterWithToString = function() {
+ var toStringCalled;
+ var o = { toString: function() {
+ toStringCalled++;
+ return 'x';
+ } };
+
+ toStringCalled = 0;
+ super[o] = 'set';
+ assertEquals(1, toStringCalled);
+ assertEquals('set', this._x);
+
+ var eToThrow = new Error();
+ var oThrowsInToString = { toString: function() {
+ throw eToThrow;
+ } };
+
+ var ex = null;
+ try {
+ super[oThrowsInToString] = 'xyz';
+ } catch(e) { ex = e }
+ assertEquals(eToThrow, ex);
+ assertEquals('set', this._x);
+
+ var oReturnsNumericString = { toString: function() {
+ return "1";
+ } };
+
+ assertEquals('abc', super[oReturnsNumericString] = 'abc');
+
+ assertEquals('set', this._x);
+
+ assertEquals(10, super[1] = 10);
+ }.toMethod(Derived.prototype);
+ d = new Derived();
+ d.testSetterWithToString();
+}());
+
+
+(function TestSetterDataProperties() {
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ x: 'x from Base'
+ };
+
+ function Derived() {}
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+
+ Derived.prototype.testSetter = function() {
+ assertEquals('x from Base', super.x);
+ super.x = 'data property';
+ assertEquals('x from Base', super.x);
+ assertEquals('data property', this.x);
+ }.toMethod(Derived.prototype);
+
+ new Derived().testSetter();
+}());
+
+
+(function TestKeyedSetterDataProperties() {
+ var x = 'x';
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ x: 'x from Base'
+ };
+
+ function Derived() {}
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+
+ Derived.prototype.testSetter = function() {
+ assertEquals('x from Base', super[x]);
+ super[x] = 'data property';
+ assertEquals('x from Base', super[x]);
+ assertEquals('data property', this[x]);
+ }.toMethod(Derived.prototype);
+
+ new Derived().testSetter();
+}());
+
+
+(function TestKeyedNumericSetterDataProperties() {
+ var x = 42;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ 42: 'x from Base'
+ };
+
+ function Derived() {}
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+
+ Derived.prototype.testSetter = function() {
+ assertEquals('x from Base', super[x]);
+ super[x] = 'data property';
+ assertEquals('x from Base', super[x]);
+ assertEquals('data property', this[x]);
+ }.toMethod(Derived.prototype);
+
+ new Derived().testSetter();
+}());
+
+
(function TestAccessorsOnPrimitives() {
- var getCalled = false;
- var setCalled = false;
+ var getCalled = 0;
+ var setCalled = 0;
function Base() {}
Base.prototype = {
constructor: Base,
get x() {
- getCalled = true;
+ getCalled++;
return 1;
},
set x(v) {
- setCalled = true;
+ setCalled++;
return v;
},
};
constructor: Derived,
};
Derived.prototype.testSetter = function() {
- assertTrue(42 == this);
- getCalled = false;
- setCalled = false;
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals('object', typeof this);
+ assertTrue(this instanceof Number)
+ assertEquals(42, this.valueOf());
assertEquals(1, super.x);
- assertTrue(getCalled);
- assertFalse(setCalled);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
- setCalled = false;
- getCalled = false;
assertEquals(5, super.x = 5);
- assertFalse(getCalled);
- assertTrue(setCalled);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
- getCalled = false;
- setCalled = false;
assertEquals(6, super.x += 5);
- assertTrue(getCalled);
- assertTrue(setCalled);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ super.newProperty = 15;
+ assertEquals(15, this.newProperty);
+ assertEquals(undefined, super.newProperty);
}.toMethod(Derived.prototype);
Derived.prototype.testSetterStrict = function() {
'use strict';
- assertTrue(42 == this);
- getCalled = false;
- setCalled = false;
+ getCalled = 0;
+ setCalled = 0;
+ assertTrue(42 === this);
+
assertEquals(1, super.x);
- assertTrue(getCalled);
- assertFalse(setCalled);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
- setCalled = false;
- getCalled = false;
assertEquals(5, super.x = 5);
- assertFalse(getCalled);
- assertTrue(setCalled);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
- getCalled = false;
- setCalled = false;
assertEquals(6, super.x += 5);
- assertTrue(getCalled);
- assertTrue(setCalled);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ var ex;
+ try {
+ super.newProperty = 15;
+ } catch (e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
}.toMethod(Derived.prototype);
Derived.prototype.testSetter.call(42);
function f() {
'use strict';
- assertTrue(42 == this);
+ assertTrue(42 === this);
assertEquals(String.prototype.toString, super.toString);
- var except = false;
+ var ex;
try {
super.toString();
- } catch(e) { except = true; }
- assertTrue(except);
+ } catch(e) { ex = e; }
+
+ assertTrue(ex instanceof TypeError);
}
f.toMethod(DerivedFromString.prototype).call(42);
}());
-(function TestSetterFailures() {
+(function TestKeyedAccessorsOnPrimitives() {
+ var x = 'x';
+ var newProperty = 'newProperty';
+ var toString = 'toString';
+ var getCalled = 0;
+ var setCalled = 0;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ getCalled++;
+ return 1;
+ },
+ set x(v) {
+ setCalled++;
+ return v;
+ },
+ };
+
+ function Derived() {}
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+ Derived.prototype.testSetter = function() {
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals('object', typeof this);
+ assertTrue(this instanceof Number)
+ assertEquals(42, this.valueOf());
+ assertEquals(1, super[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ assertEquals(5, super[x] = 5);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
+
+ assertEquals(6, super[x] += 5);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ super[newProperty] = 15;
+ assertEquals(15, this[newProperty]);
+ assertEquals(undefined, super[newProperty]);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.testSetterStrict = function() {
+ 'use strict';
+ getCalled = 0;
+ setCalled = 0;
+ assertTrue(42 === this);
+
+ assertEquals(1, super[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ assertEquals(5, super[x] = 5);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
+
+ assertEquals(6, super[x] += 5);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ var ex;
+ try {
+ super[newProperty] = 15;
+ } catch (e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.testSetter.call(42);
+ Derived.prototype.testSetterStrict.call(42);
+
+ function DerivedFromString() {}
+ DerivedFromString.prototype = Object.create(String.prototype);
+
+ function f() {
+ 'use strict';
+ assertTrue(42 === this);
+ assertEquals(String.prototype.toString, super[toString]);
+ var ex;
+ try {
+ super[toString]();
+ } catch(e) { ex = e; }
+
+ assertTrue(ex instanceof TypeError);
+ }
+ f.toMethod(DerivedFromString.prototype).call(42);
+}());
+
+
+(function TestNumericKeyedAccessorsOnPrimitives() {
+ var x = 42;
+ var newProperty = 43;
+ var getCalled = 0;
+ var setCalled = 0;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ };
+
+ Object.defineProperty(Base.prototype, x, {
+ get: function() {
+ getCalled++;
+ return 1;
+ },
+ set: function(v) {
+ setCalled++;
+ return v;
+ }
+ });
+
+ function Derived() {}
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+ Derived.prototype.testSetter = function() {
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals('object', typeof this);
+ assertTrue(this instanceof Number)
+ assertEquals(42, this.valueOf());
+ assertEquals(1, super[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ assertEquals(5, super[x] = 5);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
+
+ assertEquals(6, super[x] += 5);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ super[newProperty] = 15;
+ assertEquals(15, this[newProperty]);
+ assertEquals(undefined, super[newProperty]);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.testSetterStrict = function() {
+ 'use strict';
+ getCalled = 0;
+ setCalled = 0;
+ assertTrue(42 === this);
+
+ assertEquals(1, super[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ assertEquals(5, super[x] = 5);
+ assertEquals(1, getCalled);
+ assertEquals(1, setCalled);
+
+ assertEquals(6, super[x] += 5);
+ assertEquals(2, getCalled);
+ assertEquals(2, setCalled);
+
+ var ex;
+ try {
+ super[newProperty] = 15;
+ } catch (e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.testSetter.call(42);
+ Derived.prototype.testSetterStrict.call(42);
+}());
+
+
+(function TestKeyedNumericSetterOnExotics() {
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__: Base.prototype };
+
+ Derived.prototype.callSetterOnArray = function() {
+ super[42] = 1;
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.callStrictSetterOnString = function() {
+ 'use strict';
+ assertEquals('string', typeof this);
+ assertTrue('abcdef' === this);
+ var ex = null;
+ try {
+ super[5] = 'q';
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+
+ ex = null;
+ try {
+ super[1024] = 'q';
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ }.toMethod(Derived.prototype);
+
+ var x = [];
+ assertEquals(0, x.length);
+ Derived.prototype.callSetterOnArray.call(x);
+ assertEquals(43, x.length);
+ assertEquals(1, x[42]);
+
+ var s = 'abcdef';
+ Derived.prototype.callStrictSetterOnString.call(s)
+}());
+
+
+(function TestSetterUndefinedProperties() {
function Base() {}
function Derived() {}
Derived.prototype = { __proto__ : Base.prototype };
Derived.prototype.mSloppy = function () {
+ assertEquals(undefined, super.x);
+ assertEquals(undefined, this.x);
super.x = 10;
+ assertEquals(10, this.x);
assertEquals(undefined, super.x);
}.toMethod(Derived.prototype);
Derived.prototype.mStrict = function () {
- "use strict";
+ 'use strict';
+ assertEquals(undefined, super.x);
+ assertEquals(undefined, this.x);
super.x = 10;
+ assertEquals(10, this.x);
+ assertEquals(undefined, super.x);
}.toMethod(Derived.prototype);
var d = new Derived();
d.mSloppy();
- assertEquals(undefined, d.x);
+ assertEquals(10, d.x);
var d1 = new Derived();
- assertThrows(function() { d.mStrict(); }, ReferenceError);
- assertEquals(undefined, d.x);
+ d1.mStrict();
+ assertEquals(10, d.x);
+}());
+
+
+(function TestKeyedSetterUndefinedProperties() {
+ var x = 'x';
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__ : Base.prototype };
+ Derived.prototype.mSloppy = function () {
+ assertEquals(undefined, super[x]);
+ assertEquals(undefined, this[x]);
+ super[x] = 10;
+ assertEquals(10, this[x]);
+ assertEquals(undefined, super[x]);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function () {
+ 'use strict';
+ assertEquals(undefined, super[x]);
+ assertEquals(undefined, this[x]);
+ super[x] = 10;
+ assertEquals(10, this[x]);
+ assertEquals(undefined, super[x]);
+ }.toMethod(Derived.prototype);
+ var d = new Derived();
+ d.mSloppy();
+ assertEquals(10, d.x);
+ var d1 = new Derived();
+ d1.mStrict();
+ assertEquals(10, d.x);
+}());
+
+
+(function TestKeyedNumericSetterUndefinedProperties() {
+ var x = 42;
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__ : Base.prototype };
+ Derived.prototype.mSloppy = function () {
+ assertEquals(undefined, super[x]);
+ assertEquals(undefined, this[x]);
+ super[x] = 10;
+ assertEquals(10, this[x]);
+ assertEquals(undefined, super[x]);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function () {
+ 'use strict';
+ assertEquals(undefined, super[x]);
+ assertEquals(undefined, this[x]);
+ super[x] = 10;
+ assertEquals(10, this[x]);
+ assertEquals(undefined, super[x]);
+ }.toMethod(Derived.prototype);
+ var d = new Derived();
+ d.mSloppy();
+ assertEquals(10, d[x]);
+ var d1 = new Derived();
+ d1.mStrict();
+ assertEquals(10, d[x]);
+}());
+
+
+(function TestSetterCreatingOwnProperties() {
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__ : Base.prototype };
+ var setterCalled;
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(42, this.ownReadOnly);
+ super.ownReadOnly = 55;
+ assertEquals(42, this.ownReadOnly);
+
+ assertEquals(15, this.ownReadonlyAccessor);
+ super.ownReadonlyAccessor = 55;
+ assertEquals(15, this.ownReadonlyAccessor);
+
+ setterCalled = 0;
+ super.ownSetter = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(42, this.ownReadOnly);
+ var ex;
+ try {
+ super.ownReadOnly = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(42, this.ownReadOnly);
+
+ assertEquals(15, this.ownReadonlyAccessor);
+ ex = null;
+ try {
+ super.ownReadonlyAccessor = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(15, this.ownReadonlyAccessor);
+
+ setterCalled = 0;
+ super.ownSetter = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false });
+ Object.defineProperty(d, 'ownSetter',
+ { set : function() { setterCalled++; } });
+ Object.defineProperty(d, 'ownReadonlyAccessor',
+ { get : function() { return 15; }});
+ d.mSloppy();
+ d.mStrict();
+}());
+
+
+(function TestSetterInForIn() {
+ var setCalled = 0;
+ var getCalled = 0;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ getCalled++;
+ return 1;
+ },
+ set x(v) {
+ setCalled++;
+ this.x_.push(v);
+ },
+ };
+
+ function Derived() {
+ this.x_ = [];
+ }
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ };
+
+ Derived.prototype.testIter = function() {
+ setCalled = 0;
+ getCalled = 0;
+ for (super.x in [1,2,3]) {}
+ assertEquals(0, getCalled);
+ assertEquals(3, setCalled);
+ assertEquals(["0","1","2"], this.x_);
+ }.toMethod(Derived.prototype);
+
+ new Derived().testIter();
+
+ var x = 'x';
+ Derived.prototype.testIterKeyed = function() {
+ setCalled = 0;
+ getCalled = 0;
+ for (super[x] in [1,2,3]) {}
+ assertEquals(0, getCalled);
+ assertEquals(3, setCalled);
+ assertEquals(["0","1","2"], this.x_);
+
+ this.x_ = [];
+ setCalled = 0;
+ getCalled = 0;
+ var toStringCalled = 0;
+ var o = {toString: function () { toStringCalled++; return x }};
+ for (super[o] in [1,2,3]) {}
+ assertEquals(0, getCalled);
+ assertEquals(3, setCalled);
+ assertEquals(3, toStringCalled);
+ assertEquals(["0","1","2"], this.x_);
+ }.toMethod(Derived.prototype);
+
+ new Derived().testIterKeyed();
+}());
+
+
+(function TestKeyedSetterCreatingOwnProperties() {
+ var ownReadOnly = 'ownReadOnly';
+ var ownReadonlyAccessor = 'ownReadonlyAccessor';
+ var ownSetter = 'ownSetter';
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__ : Base.prototype };
+ var setterCalled;
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(42, this[ownReadOnly]);
+ super[ownReadOnly] = 55;
+ assertEquals(42, this[ownReadOnly]);
+
+ assertEquals(15, this[ownReadonlyAccessor]);
+ super[ownReadonlyAccessor] = 55;
+ assertEquals(15, this[ownReadonlyAccessor]);
+
+ setterCalled = 0;
+ super[ownSetter] = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(42, this[ownReadOnly]);
+ var ex;
+ try {
+ super[ownReadOnly] = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(42, this[ownReadOnly]);
+
+ assertEquals(15, this[ownReadonlyAccessor]);
+ ex = null;
+ try {
+ super[ownReadonlyAccessor] = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(15, this[ownReadonlyAccessor]);
+
+ setterCalled = 0;
+ super[ownSetter] = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false });
+ Object.defineProperty(d, 'ownSetter',
+ { set : function() { setterCalled++; } });
+ Object.defineProperty(d, 'ownReadonlyAccessor',
+ { get : function() { return 15; }});
+ d.mSloppy();
+ d.mStrict();
+}());
+
+
+(function TestKeyedNumericSetterCreatingOwnProperties() {
+ var ownReadOnly = 42;
+ var ownReadonlyAccessor = 43;
+ var ownSetter = 44;
+ function Base() {}
+ function Derived() {}
+ Derived.prototype = { __proto__ : Base.prototype };
+ var setterCalled;
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(42, this[ownReadOnly]);
+ super[ownReadOnly] = 55;
+ assertEquals(42, this[ownReadOnly]);
+
+ assertEquals(15, this[ownReadonlyAccessor]);
+ super[ownReadonlyAccessor] = 55;
+ assertEquals(15, this[ownReadonlyAccessor]);
+
+ setterCalled = 0;
+ super[ownSetter] = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(42, this[ownReadOnly]);
+ var ex;
+ try {
+ super[ownReadOnly] = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(42, this[ownReadOnly]);
+
+ assertEquals(15, this[ownReadonlyAccessor]);
+ ex = null;
+ try {
+ super[ownReadonlyAccessor] = 55;
+ } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(15, this[ownReadonlyAccessor]);
+
+ setterCalled = 0;
+ super[ownSetter] = 42;
+ assertEquals(1, setterCalled);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, ownReadOnly, { value : 42, writable : false });
+ Object.defineProperty(d, ownSetter,
+ { set : function() { setterCalled++; } });
+ Object.defineProperty(d, ownReadonlyAccessor,
+ { get : function() { return 15; }});
+ d.mSloppy();
+ d.mStrict();
+}());
+
+
+(function TestSetterNoProtoWalk() {
+ function Base() {}
+ function Derived() {}
+ var getCalled;
+ var setCalled;
+ Derived.prototype = {
+ __proto__ : Base.prototype,
+ get x() { getCalled++; return 42; },
+ set x(v) { setCalled++; }
+ };
+
+ Derived.prototype.mSloppy = function() {
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this.x);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this.x = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super.x = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this.x);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this.x);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this.x = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super.x = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this.x);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+(function TestKeyedSetterNoProtoWalk() {
+ var x = 'x';
+ function Base() {}
+ function Derived() {}
+ var getCalled;
+ var setCalled;
+ Derived.prototype = {
+ __proto__ : Base.prototype,
+ get x() { getCalled++; return 42; },
+ set x(v) { setCalled++; }
+ };
+
+ Derived.prototype.mSloppy = function() {
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this[x] = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super[x] = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this[x]);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this[x] = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super[x] = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this[x]);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+(function TestKeyedNumericSetterNoProtoWalk() {
+ var x = 42;
+ function Base() {}
+ function Derived() {}
+ var getCalled;
+ var setCalled;
+ Derived.prototype = {
+ __proto__ : Base.prototype,
+ };
+
+ Object.defineProperty(Derived.prototype, x, {
+ get: function() { getCalled++; return 42; },
+ set: function(v) { setCalled++; }
+ });
+
+ Derived.prototype.mSloppy = function() {
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this[x] = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super[x] = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this[x]);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ setCalled = 0;
+ getCalled = 0;
+ assertEquals(42, this[x]);
+ assertEquals(1, getCalled);
+ assertEquals(0, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ this[x] = 43;
+ assertEquals(0, getCalled);
+ assertEquals(1, setCalled);
+
+ getCalled = 0;
+ setCalled = 0;
+ super[x] = 15;
+ assertEquals(0, setCalled);
+ assertEquals(0, getCalled);
+
+ assertEquals(15, this[x]);
+ assertEquals(0, getCalled);
+ assertEquals(0, setCalled);
+
+ }.toMethod(Derived.prototype);
+
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+(function TestSetterDoesNotReconfigure() {
+ function Base() {}
+ function Derived() {}
+
+ Derived.prototype.mStrict = function (){
+ 'use strict';
+ super.nonEnumConfig = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig');
+ assertEquals(5, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super.nonEnumNonConfig = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig');
+ assertEquals(5, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mSloppy = function (){
+ super.nonEnumConfig = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig');
+ assertEquals(42, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super.nonEnumNonConfig = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig');
+ assertEquals(42, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, 'nonEnumConfig',
+ { value : 0, enumerable : false, configurable : true, writable : true });
+ Object.defineProperty(d, 'nonEnumNonConfig',
+ { value : 0, enumerable : false, configurable : false, writable : true });
+ d.mStrict();
+ d.mSloppy();
}());
-(function TestUnsupportedCases() {
- function f1(x) { return super[x]; }
- var o = {}
- assertThrows(function(){f1.toMethod(o)(x);}, ReferenceError);
- function f2() { super.x++; }
- assertThrows(function(){f2.toMethod(o)();}, ReferenceError);
+(function TestKeyedSetterDoesNotReconfigure() {
+ var nonEnumConfig = 'nonEnumConfig';
+ var nonEnumNonConfig = 'nonEnumNonConfig';
+ function Base() {}
+ function Derived() {}
+
+ Derived.prototype = { __proto__: Base.prototype };
+
+ Derived.prototype.mStrict = function (){
+ 'use strict';
+ super[nonEnumConfig] = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig);
+ assertEquals(5, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super[nonEnumNonConfig] = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig);
+ assertEquals(5, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mSloppy = function (){
+ super[nonEnumConfig] = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig);
+ assertEquals(42, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super[nonEnumNonConfig] = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig);
+ assertEquals(42, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, nonEnumConfig,
+ { value : 0, enumerable : false, configurable : true, writable : true });
+ Object.defineProperty(d, nonEnumNonConfig,
+ { value : 0, enumerable : false, configurable : false, writable : true });
+ d.mStrict();
+ d.mSloppy();
+}());
+
+
+(function TestKeyedNumericSetterDoesNotReconfigure() {
+ var nonEnumConfig = 42;
+ var nonEnumNonConfig = 43;
+ function Base() {}
+ function Derived() {}
+
+ Derived.prototype = { __proto__: Base.prototype };
+
+ Derived.prototype.mStrict = function (){
+ 'use strict';
+ super[nonEnumConfig] = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig);
+ assertEquals(5, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super[nonEnumNonConfig] = 5;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig);
+ assertEquals(5, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ Derived.prototype.mSloppy = function (){
+ super[nonEnumConfig] = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig);
+ assertEquals(42, d1.value);
+ assertTrue(d1.configurable);
+ assertFalse(d1.enumerable);
+
+ super[nonEnumNonConfig] = 42;
+ var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig);
+ assertEquals(42, d1.value);
+ assertFalse(d1.configurable);
+ assertFalse(d1.enumerable);
+ }.toMethod(Derived.prototype);
+
+ var d = new Derived();
+ Object.defineProperty(d, nonEnumConfig,
+ { value : 0, enumerable : false, configurable : true, writable : true });
+ Object.defineProperty(d, nonEnumNonConfig,
+ { value : 0, enumerable : false, configurable : false, writable : true });
+ d.mStrict();
+ d.mSloppy();
+}());
+
+
+(function TestCountOperations() {
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ return this._x;
+ },
+ set x(v) {
+ this._x = v;
+ },
+ _x: 1
+ };
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 2
+ };
+
+ Derived.prototype.testCounts = function() {
+ assertEquals(2, this._x);
+ assertEquals(2, super.x);
+ super.x++;
+ assertEquals(3, super.x);
+ ++super.x;
+ assertEquals(4, super.x);
+ assertEquals(4, super.x++);
+ assertEquals(5, super.x);
+ assertEquals(6, ++super.x);
+ assertEquals(6, super.x);
+ assertEquals(6, this._x);
+
+ super.x--;
+ assertEquals(5, super.x);
+ --super.x;
+ assertEquals(4, super.x);
+ assertEquals(4, super.x--);
+ assertEquals(3, super.x);
+ assertEquals(2, --super.x);
+ assertEquals(2, super.x);
+ assertEquals(2, this._x);
+ }.toMethod(Derived.prototype);
+ new Derived().testCounts();
+}());
+
+
+(function TestKeyedCountOperations() {
+ var x = 'x';
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ get x() {
+ return this._x;
+ },
+ set x(v) {
+ this._x = v;
+ },
+ _x: 1
+ };
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 2
+ };
+
+ Derived.prototype.testCounts = function() {
+ assertEquals(2, this._x);
+ assertEquals(2, super[x]);
+ super[x]++;
+ assertEquals(3, super[x]);
+ ++super[x];
+ assertEquals(4, super[x]);
+ assertEquals(4, super[x]++);
+ assertEquals(5, super[x]);
+ assertEquals(6, ++super[x]);
+ assertEquals(6, super[x]);
+ assertEquals(6, this._x);
+
+ super[x]--;
+ assertEquals(5, super[x]);
+ --super[x];
+ assertEquals(4, super[x]);
+ assertEquals(4, super[x]--);
+ assertEquals(3, super[x]);
+ assertEquals(2, --super[x]);
+ assertEquals(2, super[x]);
+ assertEquals(2, this._x);
+ }.toMethod(Derived.prototype);
+ new Derived().testCounts();
+}());
+
+
+(function TestKeyedNumericCountOperations() {
+ var x = 42;
+ function Base() {}
+ Base.prototype = {
+ constructor: Base,
+ _x: 1
+ };
+
+ Object.defineProperty(Base.prototype, x, {
+ get: function() { return this._x; },
+ set: function(v) { this._x = v;; }
+ });
+
+ function Derived() {}
+ Derived.__proto__ = Base;
+ Derived.prototype = {
+ __proto__: Base.prototype,
+ constructor: Derived,
+ _x: 2
+ };
+
+ Derived.prototype.testCounts = function() {
+ assertEquals(2, this._x);
+ assertEquals(2, super[x]);
+ super[x]++;
+ assertEquals(3, super[x]);
+ ++super[x];
+ assertEquals(4, super[x]);
+ assertEquals(4, super[x]++);
+ assertEquals(5, super[x]);
+ assertEquals(6, ++super[x]);
+ assertEquals(6, super[x]);
+ assertEquals(6, this._x);
+
+ super[x]--;
+ assertEquals(5, super[x]);
+ --super[x];
+ assertEquals(4, super[x]);
+ assertEquals(4, super[x]--);
+ assertEquals(3, super[x]);
+ assertEquals(2, --super[x]);
+ assertEquals(2, super[x]);
+ assertEquals(2, this._x);
+ }.toMethod(Derived.prototype);
+ new Derived().testCounts();
+}());
+
+
+(function TestSetterSuperNonWritable() {
+ function Base() {}
+ Object.defineProperty(Base.prototype, 'x', { value : 27, writable: false });
+ function Derived() {}
+
+ Derived.prototype = { __proto__: Base.prototype, constructor: Derived };
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(27, super.x);
+ assertEquals(27, this.x);
+ super.x = 10;
+ assertEquals(27, super.x);
+ assertEquals(27, this.x);
+ }.toMethod(Derived.prototype);
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(27, super.x);
+ assertEquals(27, this.x);
+ var ex = null;
+ try { super.x = 10; } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(27, super.x);
+ assertEquals(27, this.x);
+ }.toMethod(Derived.prototype);
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+(function TestSetterKeyedSuperNonWritable() {
+ var x = 'xyz';
+ function Base() {}
+ Object.defineProperty(Base.prototype, x, { value : 27, writable: false });
+ function Derived() {}
+
+ Derived.prototype = { __proto__: Base.prototype, constructor: Derived };
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ super[x] = 10;
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ }.toMethod(Derived.prototype);
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ var ex = null;
+ try { super[x] = 10; } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ }.toMethod(Derived.prototype);
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+(function TestSetterKeyedNumericSuperNonWritable() {
+ var x = 42;
+ function Base() {}
+ Object.defineProperty(Base.prototype, x, { value : 27, writable: false });
+ function Derived() {}
+
+ Derived.prototype = { __proto__: Base.prototype, constructor: Derived };
+
+ Derived.prototype.mSloppy = function() {
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ super[x] = 10;
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ }.toMethod(Derived.prototype);
+ Derived.prototype.mStrict = function() {
+ 'use strict';
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ var ex = null;
+ try { super[x] = 10; } catch(e) { ex = e; }
+ assertTrue(ex instanceof TypeError);
+ assertEquals(27, super[x]);
+ assertEquals(27, this[x]);
+ }.toMethod(Derived.prototype);
+ new Derived().mSloppy();
+ new Derived().mStrict();
+}());
+
+
+function Subclass(base, constructor) {
+ var homeObject = {
+ __proto__: base.prototype,
+ constructor: constructor
+ };
+ constructor.__proto__ = base;
+ constructor.prototype = homeObject;
+ // not doing toMethod: home object is not required for
+ // super constructor calls.
+ return constructor;
+}
+
+(function TestSuperCall() {
+ var baseCalled = 0;
+ var derivedCalled = 0;
+ var derivedDerivedCalled = 0;
+
+ function Base() {
+ baseCalled++;
+ }
+
+ var Derived = Subclass(Base, function () {
+ super();
+ derivedCalled++;
+ });
+
+ assertEquals(Base, Base.prototype.constructor);
+ assertEquals(Base.prototype, Derived.prototype.__proto__);
+
+ baseCalled = 0;
+ derivedCalled = 0;
+ new Derived();
+ assertEquals(1, baseCalled);
+ assertEquals(1, derivedCalled);
+
+ var DerivedDerived = Subclass(Derived, function () {
+ super();
+ derivedDerivedCalled++;
+ });
+
+ baseCalled = 0;
+ derivedCalled = 0;
+ derivedDerivedCalled = 0;
+ new DerivedDerived();
+ assertEquals(1, baseCalled);
+ assertEquals(1, derivedCalled);
+ assertEquals(1, derivedDerivedCalled);
+
+ function Base2(v) {
+ this.fromBase = v;
+ }
+ var Derived2 = Subclass(Base2, function (v1, v2) {
+ super(v1);
+ this.fromDerived = v2;
+ });
+
+ var d = new Derived2("base", "derived");
+ assertEquals("base", d.fromBase);
+ assertEquals("derived", d.fromDerived);
+
+ function ImplicitSubclassOfFunction() {
+ super();
+ this.x = 123;
+ }
+
+ var o = new ImplicitSubclassOfFunction();
+ assertEquals(123, o.x);
+
+ var calls = 0;
+ function G() {
+ calls++;
+ }
+ function F() {
+ super();
+ }
+ F.__proto__ = G;
+ new F();
+ assertEquals(1, calls);
+ F.__proto__ = function() {};
+ new F();
+ assertEquals(1, calls);
+}());
+
+
+(function TestNewSuper() {
+ var baseCalled = 0;
+ var derivedCalled = 0;
+
+ function Base() {
+ baseCalled++;
+ this.x = 15;
+ }
+
+
+ var Derived = Subclass(Base, function() {
+ baseCalled = 0;
+ var b = new super();
+ assertEquals(1, baseCalled)
+ assertEquals(Base.prototype, b.__proto__);
+ assertEquals(15, b.x);
+ assertEquals(undefined, this.x);
+ derivedCalled++;
+ });
+
+ derivedCalled = 0;
+ new Derived();
+ assertEquals(1, derivedCalled);
+}());
+
+
+(function TestSuperCallErrorCases() {
+ function T() {
+ super();
+ }
+ T.__proto__ = null;
+ // Spec says ReferenceError here, but for other IsCallable failures
+ // we throw TypeError.
+ // Filed https://bugs.ecmascript.org/show_bug.cgi?id=3282
+ assertThrows(function() { new T(); }, TypeError);
+
+ function T1() {
+ var b = new super();
+ }
+ T1.__proto = null;
+ assertThrows(function() { new T1(); }, TypeError);
}());
--- /dev/null
+// 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: --harmony-arrays --allow-natives-syntax
+
+var typedArrayConstructors = [
+ Uint8Array,
+ Int8Array,
+ Uint16Array,
+ Int16Array,
+ Uint32Array,
+ Int32Array,
+ Uint8ClampedArray,
+ Float32Array,
+ Float64Array];
+
+function CheckTypedArrayIsNeutered(array) {
+ assertEquals(0, array.byteLength);
+ assertEquals(0, array.byteOffset);
+ assertEquals(0, array.length);
+}
+
+function TestTypedArrayForEach(constructor) {
+ assertEquals(1, constructor.prototype.forEach.length);
+
+ var a = new constructor(2);
+ a[0] = 0;
+ a[1] = 1;
+
+ var count = 0;
+ a.forEach(function (n) { count++; });
+ assertEquals(2, count);
+
+ // Use specified object as this object when calling the function.
+ var o = { value: 42 };
+ var result = [];
+ a.forEach(function (n, index, array) { result.push(this.value); }, o);
+ assertArrayEquals([42, 42], result);
+
+ // Modify the original array.
+ count = 0;
+ a.forEach(function (n, index, array) { array[index] = n + 1; count++ });
+ assertEquals(2, count);
+ assertArrayEquals([1, 2], a);
+
+ // Check that values passed as second argument are wrapped into
+ // objects when calling into sloppy mode functions.
+ function CheckWrapping(value, wrapper) {
+ var wrappedValue = new wrapper(value);
+
+ a.forEach(function () {
+ assertEquals("object", typeof this);
+ assertEquals(wrappedValue, this);
+ }, value);
+
+ a.forEach(function () {
+ "use strict";
+ assertEquals(typeof value, typeof this);
+ assertEquals(value, this);
+ }, value);
+ }
+ CheckWrapping(true, Boolean);
+ CheckWrapping(false, Boolean);
+ CheckWrapping("xxx", String);
+ CheckWrapping(42, Number);
+ CheckWrapping(3.14, Number);
+ CheckWrapping({}, Object);
+
+ // Throw before completing iteration, only the first element
+ // should be modified when thorwing mid-way.
+ count = 0;
+ a[0] = 42;
+ a[1] = 42;
+ try {
+ a.forEach(function (n, index, array) {
+ if (count > 0) throw "meh";
+ array[index] = n + 1;
+ count++;
+ });
+ } catch (e) {
+ }
+ assertEquals(1, count);
+ assertEquals(43, a[0]);
+ assertEquals(42, a[1]);
+
+ // Neutering the buffer backing the typed array mid-way should
+ // still make .forEach() finish, and the array should keep being
+ // empty after neutering it.
+ count = 0;
+ a.forEach(function (n, index, array) {
+ if (count > 0) %ArrayBufferNeuter(array.buffer);
+ array[index] = n + 1;
+ count++;
+ });
+ assertEquals(2, count);
+ CheckTypedArrayIsNeutered(a);
+ assertEquals(undefined, a[0]);
+
+ // The method must work for typed arrays created from ArrayBuffer.
+ // The length of the ArrayBuffer is chosen so it is a multiple of
+ // all lengths of the typed array items.
+ a = new constructor(new ArrayBuffer(64));
+ count = 0;
+ a.forEach(function (n) { count++ });
+ assertEquals(a.length, count);
+
+ // Externalizing the array mid-way accessing the .buffer property
+ // should work.
+ a = new constructor(2);
+ count = 0;
+ var buffer = undefined;
+ a.forEach(function (n, index, array) {
+ if (count++ > 0)
+ buffer = array.buffer;
+ });
+ assertEquals(2, count);
+ assertTrue(!!buffer);
+ assertEquals("ArrayBuffer", %_ClassOf(buffer));
+ assertSame(buffer, a.buffer);
+
+ // The %TypedArray%.forEach() method should not work when
+ // transplanted to objects that are not typed arrays.
+ assertThrows(function () { constructor.prototype.forEach.call([1, 2, 3], function (x) {}) }, TypeError);
+ assertThrows(function () { constructor.prototype.forEach.call("abc", function (x) {}) }, TypeError);
+ assertThrows(function () { constructor.prototype.forEach.call({}, function (x) {}) }, TypeError);
+ assertThrows(function () { constructor.prototype.forEach.call(0, function (x) {}) }, TypeError);
+
+ // Method must be useable on instances of other typed arrays.
+ for (var i = 0; i < typedArrayConstructors.length; i++) {
+ count = 0;
+ a = new typedArrayConstructors[i](4);
+ constructor.prototype.forEach.call(a, function (x) { count++ });
+ assertEquals(a.length, count);
+ }
+}
+
+for (i = 0; i < typedArrayConstructors.length; i++) {
+ TestTypedArrayForEach(typedArrayConstructors[i]);
+}
// (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-tostring
+
// ArrayBuffer
function TestByteLength(param, expectedByteLength) {
var ab = new ArrayBuffer();
assertSame(0, ab.byteLength);
+ assertEquals("[object ArrayBuffer]",
+ Object.prototype.toString.call(ab));
}
TestArrayBufferCreation();
var ab = new ArrayBuffer(256*elementSize);
var a0 = new constr(30);
+ assertEquals("[object " + constr.name + "]",
+ Object.prototype.toString.call(a0));
+
assertTrue(ArrayBuffer.isView(a0));
assertSame(elementSize, a0.BYTES_PER_ELEMENT);
assertSame(30, a0.length);
assertSame(0, aNoParam.length);
assertSame(0, aNoParam.byteLength);
assertSame(0, aNoParam.byteOffset);
+
+ var a = new constr(ab, 64*elementSize, 128);
+ assertEquals("[object " + constr.name + "]",
+ Object.prototype.toString.call(a));
+ var desc = Object.getOwnPropertyDescriptor(
+ constr.prototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.enumerable);
+ assertFalse(!!desc.writable);
+ assertFalse(!!desc.set);
+ assertEquals("function", typeof desc.get);
}
TestTypedArray(Uint8Array, 1, 0xFF);
Float64Array];
function TestPropertyTypeChecks(constructor) {
- var a = new constructor();
function CheckProperty(name) {
var d = Object.getOwnPropertyDescriptor(constructor.prototype, name);
- var o = {}
+ var o = {};
assertThrows(function() {d.get.call(o);}, TypeError);
- d.get.call(a); // shouldn't throw
- for (var i = 0 ; i < typedArrayConstructors.length; i++) {
- d.get.call(new typedArrayConstructors[i](10));
+ for (var i = 0; i < typedArrayConstructors.length; i++) {
+ var ctor = typedArrayConstructors[i];
+ var a = new ctor(10);
+ if (ctor === constructor) {
+ d.get.call(a); // shouldn't throw
+ } else {
+ assertThrows(function() {d.get.call(a);}, TypeError);
+ }
}
}
CheckProperty("length");
}
-for(i = 0; i < typedArrayConstructors.lenght; i++) {
+for(i = 0; i < typedArrayConstructors.length; i++) {
TestPropertyTypeChecks(typedArrayConstructors[i]);
}
TestTypedArraySet();
+function TestTypedArraysWithIllegalIndices() {
+ var a = new Int32Array(100);
+
+ a[-10] = 10;
+ assertEquals(undefined, a[-10]);
+ a["-10"] = 10;
+ assertEquals(undefined, a["-10"]);
+
+ var s = " -10";
+ a[s] = 10;
+ assertEquals(10, a[s]);
+ var s1 = " -10 ";
+ a[s] = 10;
+ assertEquals(10, a[s]);
+
+ a["-1e2"] = 10;
+ assertEquals(10, a["-1e2"]);
+ assertEquals(undefined, a[-1e2]);
+
+ a["-0"] = 256;
+ var s2 = " -0";
+ a[s2] = 255;
+ assertEquals(undefined, a["-0"]);
+ assertEquals(255, a[s2]);
+ assertEquals(0, a[-0]);
+
+ /* Chromium bug: 424619
+ * a[-Infinity] = 50;
+ * assertEquals(undefined, a[-Infinity]);
+ */
+ a[1.5] = 10;
+ assertEquals(undefined, a[1.5]);
+ var nan = Math.sqrt(-1);
+ a[nan] = 5;
+ assertEquals(5, a[nan]);
+
+ var x = 0;
+ var y = -0;
+ assertEquals(Infinity, 1/x);
+ assertEquals(-Infinity, 1/y);
+ a[x] = 5;
+ a[y] = 27;
+ assertEquals(27, a[x]);
+ assertEquals(27, a[y]);
+}
+
+TestTypedArraysWithIllegalIndices();
+
+function TestTypedArraysWithIllegalIndicesStrict() {
+ 'use strict';
+ var a = new Int32Array(100);
+
+ a[-10] = 10;
+ assertEquals(undefined, a[-10]);
+ a["-10"] = 10;
+ assertEquals(undefined, a["-10"]);
+
+ var s = " -10";
+ a[s] = 10;
+ assertEquals(10, a[s]);
+ var s1 = " -10 ";
+ a[s] = 10;
+ assertEquals(10, a[s]);
+
+ a["-1e2"] = 10;
+ assertEquals(10, a["-1e2"]);
+ assertEquals(undefined, a[-1e2]);
+
+ a["-0"] = 256;
+ var s2 = " -0";
+ a[s2] = 255;
+ assertEquals(undefined, a["-0"]);
+ assertEquals(255, a[s2]);
+ assertEquals(0, a[-0]);
+
+ /* Chromium bug: 424619
+ * a[-Infinity] = 50;
+ * assertEquals(undefined, a[-Infinity]);
+ */
+ a[1.5] = 10;
+ assertEquals(undefined, a[1.5]);
+ var nan = Math.sqrt(-1);
+ a[nan] = 5;
+ assertEquals(5, a[nan]);
+
+ var x = 0;
+ var y = -0;
+ assertEquals(Infinity, 1/x);
+ assertEquals(-Infinity, 1/y);
+ a[x] = 5;
+ a[y] = 27;
+ assertEquals(27, a[x]);
+ assertEquals(27, a[y]);
+}
+
+TestTypedArraysWithIllegalIndicesStrict();
+
// DataView
function TestDataViewConstructor() {
var ab = new ArrayBuffer(256);
TestDataViewPropertyTypeChecks();
+
+function TestDataViewToStringTag() {
+ var a = new DataView(new ArrayBuffer(10));
+ assertEquals("[object DataView]", Object.prototype.toString.call(a));
+ var desc = Object.getOwnPropertyDescriptor(
+ DataView.prototype, Symbol.toStringTag);
+ assertTrue(desc.configurable);
+ assertFalse(desc.enumerable);
+ assertFalse(desc.writable);
+ assertEquals("DataView", desc.value);
+}
+
+
// General tests for properties
// Test property attribute [[Enumerable]]
assertArrayEquals([], props(obj));
}
TestEnumerable(ArrayBuffer, new ArrayBuffer());
-for(i = 0; i < typedArrayConstructors.lenght; i++) {
+for(i = 0; i < typedArrayConstructors.length; i++) {
TestEnumerable(typedArrayConstructors[i]);
}
TestEnumerable(DataView, new DataView(new ArrayBuffer()));
assertEquals(value, map[property]);
}
for (var i = 0; i < 20; i++) {
- TestProperty(m, i, 'val' + i);
+ TestProperty(m, 'key' + i, 'val' + i);
TestProperty(m, 'foo' + i, 'bar' + i);
}
}
TestArbitrary(new ArrayBuffer(256));
-for(i = 0; i < typedArrayConstructors.lenght; i++) {
- TestArbitary(new typedArrayConstructors[i](10));
+for(i = 0; i < typedArrayConstructors.length; i++) {
+ TestArbitrary(new typedArrayConstructors[i](10));
}
TestArbitrary(new DataView(new ArrayBuffer(256)));
# Issue 3389: deopt_every_n_garbage_collections is unsafe
'regress/regress-2653': [SKIP],
- # This test relies on --noopt-safe-uint32-operations, which is broken. See
- # issue 3487 for details.
- 'compiler/shift-shr': [SKIP],
-
##############################################################################
# TurboFan compiler failures.
'compiler/osr-assert': [PASS, NO_VARIANTS],
'regress/regress-2185-2': [PASS, NO_VARIANTS],
+ # Issue 3660: Replacing activated TurboFan frames by unoptimized code does
+ # not work, but we expect it to not crash.
+ 'debug-step-turbofan': [PASS, FAIL],
+
# Support for %GetFrameDetails is missing and requires checkpoints.
'debug-evaluate-bool-constructor': [PASS, NO_VARIANTS],
'debug-evaluate-const': [PASS, NO_VARIANTS],
# Skip endain dependent test for mips due to different typed views of the same
# array buffer.
- 'nans': [PASS, ['arch == mips', SKIP]],
+ 'nans': [PASS, ],
+
+ # This test variant makes only sense on arm.
+ 'math-floor-of-div-nosudiv': [PASS, SLOW, ['arch not in [arm, arm64, android_arm, android_arm64]', SKIP]],
+ # Too slow for slow variants.
+ 'asm/embenchen/*': [PASS, FAST_VARIANTS],
}], # ALWAYS
##############################################################################
# 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],
+ 'unicodelctest': [PASS, NO_VARIANTS],
+ 'unicodelctest-no-optimization': [PASS, NO_VARIANTS],
+
+ # Too slow for gc stress.
+ 'asm/embenchen/box2d': [SKIP],
}], # 'gc_stress == True'
##############################################################################
# Pass but take too long to run. Skip.
# Some similar tests (with fewer iterations) may be included in arm64-js
# tests.
+ 'asm/embenchen/box2d': [SKIP],
+ 'asm/embenchen/lua_binarytrees': [SKIP],
'big-object-literal': [SKIP],
'compiler/regress-arguments': [SKIP],
'compiler/regress-gvn': [SKIP],
['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],
'harmony/symbols': [SKIP],
+ 'math-floor-of-div': [PASS, TIMEOUT],
+ 'math-floor-of-div-nosudiv': [PASS, TIMEOUT],
+ 'unicodelctest': [PASS, TIMEOUT],
+ 'unicodelctest-no-optimization': [PASS, TIMEOUT],
# Issue 3219:
'getters-on-elements': [PASS, ['gc_stress == True', FAIL]],
}], # 'arch == arm64 and mode == debug and simulator_run == True'
}], # 'arch == mipsel or arch == mips'
##############################################################################
+['arch == mips', {
+ # Flaky with TF.
+ 'mirror-script': [PASS, NO_VARIANTS],
+
+ # Emscripten requires little-endian, skip all tests on MIPS EB.
+ 'asm/embenchen/*': [SKIP],
+}], # 'arch == mips'
+
+##############################################################################
['arch == mips64el', {
# Slow tests which times out in debug mode.
['system == windows', {
# TODO(mstarzinger): Too slow with turbo fan.
'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)
'debug-script-breakpoints': [PASS, FAIL],
// Flags: --allow-natives-syntax
+// Helper to determine endian - returns true on little endian platforms
+function isLittleEndian() {
+ return ((new Uint32Array((new Uint8Array([4,3,2,1])).buffer))[0])
+ == 0x01020304;
+}
// Test that both kinds of NaNs (signaling or quiet) do not signal
function TestDoubleSignalingNan() {
// NaN with signal bit set
function f() {
- var bytes = new Uint32Array([1, 0x7FF00000]);
+ if(isLittleEndian()) {
+ var bytes = new Uint32Array([1, 0x7FF00000]);
+ } else {
+ var bytes = new Uint32Array([0x7FF00000, 1]);
+ }
var doubles = new Float64Array(bytes.buffer);
assertTrue(isNaN(doubles[0]));
assertTrue(isNaN(doubles[0]*2.0));
function TestDoubleQuietNan() {
// NaN with signal bit cleared
function f() {
- var bytes = new Uint32Array([0, 0x7FF80000]);
+ if(isLittleEndian()) {
+ var bytes = new Uint32Array([0, 0x7FF80000]);
+ } else {
+ var bytes = new Uint32Array([0x7FF80000, 0]);
+ }
var doubles = new Float64Array(bytes.buffer);
assertTrue(isNaN(doubles[0]));
assertTrue(isNaN(doubles[0]*2.0));
assertSame(Array.prototype, propertyNames.__proto__);
Array.prototype.concat = savedConcat;
-try {
- Object.getOwnPropertyNames(4);
- assertTrue(false);
-} catch (e) {
- assertTrue(/on non-object/.test(e));
-}
-
-try {
- Object.getOwnPropertyNames("foo");
- assertTrue(false);
-} catch (e) {
- assertTrue(/on non-object/.test(e));
-}
+assertEquals(Object.getOwnPropertyNames(4), []);
+assertEquals(Object.getOwnPropertyNames("foo"), ["0", "1", "2", "length"]);
+assertEquals(Object.getOwnPropertyNames(true), []);
try {
Object.getOwnPropertyNames(undefined);
assertTrue(false);
} catch (e) {
- assertTrue(/on non-object/.test(e));
+ assertTrue(/Cannot convert undefined or null to object/.test(e));
}
try {
Object.getOwnPropertyNames(null);
assertTrue(false);
} catch (e) {
- assertTrue(/on non-object/.test(e));
+ assertTrue(/Cannot convert undefined or null to object/.test(e));
}
assertSame(expected, Object.is(x, y));
}
-var test_set = [ {}, [], 1/0, -1/0, "s", 0, 0/-1, null, undefined ];
-print(test_set);
+var test_set = [ {}, [], Infinity, -Infinity, "s", "ã‚¢", 0, 0/-1, null,
+ undefined, true, false, Symbol("foo"), NaN ];
for (var i = 0; i < test_set.length; i++) {
for (var j = 0; j < test_set.length; j++) {
if (i == j) {
--- /dev/null
+// 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.
+
+// Test that the parser throws on unmatched surrogates.
+assertThrows("var \uD801\uABCD;", SyntaxError);
+assertThrows("'\\u000\uD801\uABCD'", SyntaxError);
for (var i = 0; i < 10; ++i ){
a[i] = i;
}
- a[5000000] = 256;
+ a[200000] = 256;
return %NormalizeElements(a);
}
var sparse_object_array = new Object;
var js_array = new Array(10);
var sparse_js_array = [];
- sparse_js_array.length = 5000001;
+ sparse_js_array.length = 200001;
init_array(object_array);
init_array(js_array);
var sparse_object_array = new Object;
var js_array = new Array(10);
var sparse_js_array = %NormalizeElements([]);
- sparse_js_array.length = 5000001;
+ sparse_js_array.length = 200001;
+ assertTrue(%HasDictionaryElements(sparse_js_array));
init_array(object_array);
init_array(js_array);
--- /dev/null
+// 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: --harmony-scoping
+
+'use strict';
+
+// Top-level code
+let s = 0;
+let f = [undefined, undefined, undefined]
+for (const x of [1,2,3]) {
+ s += x;
+ f[x-1] = function() { return x; }
+}
+assertEquals(6, s);
+assertEquals(1, f[0]());
+assertEquals(2, f[1]());
+assertEquals(3, f[2]());
+
+let x = 1;
+s = 0;
+for (const x of [x, x+1, x+2]) {
+ s += x;
+}
+assertEquals(6, s);
+
+s = 0;
+var q = 1;
+for (const q of [q, q+1, q+2]) {
+ s += q;
+}
+assertEquals(6, s);
+
+let z = 1;
+s = 0;
+for (const x = 1; z < 2; z++) {
+ s += x + z;
+}
+assertEquals(2, s);
+
+
+s = "";
+for (const x in [1,2,3]) {
+ s += x;
+}
+assertEquals("012", s);
+
+assertThrows(function() { for(const x in [1,2,3]) { x++ } }, SyntaxError);
+
+// Function scope
+(function() {
+ let s = 0;
+ for (const x of [1,2,3]) {
+ s += x;
+ }
+ assertEquals(6, s);
+
+ let x = 1;
+ s = 0;
+ for (const x of [x, x+1, x+2]) {
+ s += x;
+ }
+ assertEquals(6, s);
+
+ s = 0;
+ var q = 1;
+ for (const q of [q, q+1, q+2]) {
+ s += q;
+ }
+ assertEquals(6, s);
+
+ s = "";
+ for (const x in [1,2,3]) {
+ s += x;
+ }
+ assertEquals("012", s);
+}());
--- /dev/null
+// 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.
+
+a = [1];
+Object.defineProperty(a, "1", {writable:false, configurable:false, value: 100});
+assertThrows("a.unshift(4);", TypeError);
+assertEquals([1, 100, 100], a);
+var desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.writable);
+assertEquals(false, desc.configurable);
+
+a = [1];
+var g = function() { return 100; };
+Object.defineProperty(a, "1", {get:g});
+assertThrows("a.unshift(0);", TypeError);
+assertEquals([1, 100, 100], a);
+desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.configurable);
+assertEquals(g, desc.get);
+
+a = [1];
+var c = 0;
+var s = function(v) { c += 1; };
+Object.defineProperty(a, "1", {set:s});
+a.unshift(10);
+assertEquals([10, undefined, undefined], a);
+assertEquals(1, c);
+desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.configurable);
+assertEquals(s, desc.set);
+
+a = [1];
+Object.defineProperty(a, "1", {configurable:false, value:10});
+assertThrows("a.splice(1,1);", TypeError);
+assertEquals([1, 10], a);
+desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.configurable);
+
+a = [0,1,2,3,4,5,6];
+Object.defineProperty(a, "3", {configurable:false, writable:false, value:3});
+assertThrows("a.splice(1,4);", TypeError);
+assertEquals([0,5,6,3,,,,], a);
+desc = Object.getOwnPropertyDescriptor(a, "3");
+assertEquals(false, desc.configurable);
+assertEquals(false, desc.writable);
+
+a = [0,1,2,3,4,5,6];
+Object.defineProperty(a, "5", {configurable:false, value:5});
+assertThrows("a.splice(1,4);", TypeError);
+assertEquals([0,5,6,3,4,5,,], a);
+desc = Object.getOwnPropertyDescriptor(a, "5");
+assertEquals(false, desc.configurable);
+
+a = [1,2,3,,5];
+Object.defineProperty(a, "1", {configurable:false, writable:true, value:2});
+assertEquals(1, a.shift());
+assertEquals([2,3,,5], a);
+desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.configurable);
+assertEquals(true, desc.writable);
+assertThrows("a.shift();", TypeError);
+assertEquals([3,3,,5], a);
+desc = Object.getOwnPropertyDescriptor(a, "1");
+assertEquals(false, desc.configurable);
+assertEquals(true, desc.writable);
+
+a = [1,2,3];
+Object.defineProperty(a, "2", {configurable:false, value:3});
+assertThrows("a.pop();", TypeError);
+assertEquals([1,2,3], a);
+desc = Object.getOwnPropertyDescriptor(a, "2");
+assertEquals(false, desc.configurable);
--- /dev/null
+// 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.
+
+function timezone(tz) {
+ var str = (new Date(2014, 0, 10)).toString();
+ if (tz == "CET") {
+ return str == "Fri Jan 10 2014 00:00:00 GMT+0100 (CET)";
+ }
+ if (tz == "BRT") {
+ return str == "Fri Jan 10 2014 00:00:00 GMT-0200 (BRST)";
+ }
+ if (tz == "PST") {
+ return str == "Fri Jan 10 2014 00:00:00 GMT-0800 (PST)";
+ }
+ return false;
+}
+
+if (timezone("CET")) {
+ assertEquals("Sat Mar 29 2014 22:59:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 29, 22, 59)).toString());
+ assertEquals("Sat, 29 Mar 2014 21:59:00 GMT",
+ (new Date(2014, 2, 29, 22, 59)).toUTCString());
+ assertEquals("Sat Mar 29 2014 23:00:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 29, 23, 0)).toString());
+ assertEquals("Sat, 29 Mar 2014 22:00:00 GMT",
+ (new Date(2014, 2, 29, 23, 0)).toUTCString());
+ assertEquals("Sat Mar 29 2014 23:59:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 29, 23, 59)).toString());
+ assertEquals("Sat, 29 Mar 2014 22:59:00 GMT",
+ (new Date(2014, 2, 29, 23, 59)).toUTCString());
+ assertEquals("Sun Mar 30 2014 00:00:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 30, 0, 0)).toString());
+ assertEquals("Sat, 29 Mar 2014 23:00:00 GMT",
+ (new Date(2014, 2, 30, 0, 0)).toUTCString());
+ assertEquals("Sun Mar 30 2014 00:59:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 30, 0, 59)).toString());
+ assertEquals("Sat, 29 Mar 2014 23:59:00 GMT",
+ (new Date(2014, 2, 30, 0, 59)).toUTCString());
+ assertEquals("Sun Mar 30 2014 01:00:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 30, 1, 0)).toString());
+ assertEquals("Sun, 30 Mar 2014 00:00:00 GMT",
+ (new Date(2014, 2, 30, 1, 0)).toUTCString());
+ assertEquals("Sun Mar 30 2014 01:59:00 GMT+0100 (CET)",
+ (new Date(2014, 2, 30, 1, 59)).toString());
+ assertEquals("Sun, 30 Mar 2014 00:59:00 GMT",
+ (new Date(2014, 2, 30, 1, 59)).toUTCString());
+ assertEquals("Sun Mar 30 2014 03:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 2, 30, 2, 0)).toString());
+ assertEquals("Sun, 30 Mar 2014 01:00:00 GMT",
+ (new Date(2014, 2, 30, 2, 0)).toUTCString());
+ assertEquals("Sun Mar 30 2014 03:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 2, 30, 2, 59)).toString());
+ assertEquals("Sun, 30 Mar 2014 01:59:00 GMT",
+ (new Date(2014, 2, 30, 2, 59)).toUTCString());
+ assertEquals("Sun Mar 30 2014 03:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 2, 30, 3, 0)).toString());
+ assertEquals("Sun, 30 Mar 2014 01:00:00 GMT",
+ (new Date(2014, 2, 30, 3, 0)).toUTCString());
+ assertEquals("Sun Mar 30 2014 03:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 2, 30, 3, 59)).toString());
+ assertEquals("Sun, 30 Mar 2014 01:59:00 GMT",
+ (new Date(2014, 2, 30, 3, 59)).toUTCString());
+ assertEquals("Sun Mar 30 2014 04:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 2, 30, 4, 0)).toString());
+ assertEquals("Sun, 30 Mar 2014 02:00:00 GMT",
+ (new Date(2014, 2, 30, 4, 0)).toUTCString());
+ assertEquals("Sat Oct 25 2014 22:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 25, 22, 59)).toString());
+ assertEquals("Sat, 25 Oct 2014 20:59:00 GMT",
+ (new Date(2014, 9, 25, 22, 59)).toUTCString());
+ assertEquals("Sat Oct 25 2014 23:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 25, 23, 0)).toString());
+ assertEquals("Sat, 25 Oct 2014 21:00:00 GMT",
+ (new Date(2014, 9, 25, 23, 0)).toUTCString());
+ assertEquals("Sat Oct 25 2014 23:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 25, 23, 59)).toString());
+ assertEquals("Sat, 25 Oct 2014 21:59:00 GMT",
+ (new Date(2014, 9, 25, 23, 59)).toUTCString());
+ assertEquals("Sun Oct 26 2014 00:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 0, 0)).toString());
+ assertEquals("Sat, 25 Oct 2014 22:00:00 GMT",
+ (new Date(2014, 9, 26, 0, 0)).toUTCString());
+ assertEquals("Sun Oct 26 2014 00:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 0, 59)).toString());
+ assertEquals("Sat, 25 Oct 2014 22:59:00 GMT",
+ (new Date(2014, 9, 26, 0, 59)).toUTCString());
+ assertEquals("Sun Oct 26 2014 01:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 1, 0)).toString());
+ assertEquals("Sat, 25 Oct 2014 23:00:00 GMT",
+ (new Date(2014, 9, 26, 1, 0)).toUTCString());
+ assertEquals("Sun Oct 26 2014 01:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 1, 59)).toString());
+ assertEquals("Sat, 25 Oct 2014 23:59:00 GMT",
+ (new Date(2014, 9, 26, 1, 59)).toUTCString());
+ assertEquals("Sun Oct 26 2014 02:00:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 2, 0)).toString());
+ assertEquals("Sun, 26 Oct 2014 00:00:00 GMT",
+ (new Date(2014, 9, 26, 2, 0)).toUTCString());
+ assertEquals("Sun Oct 26 2014 02:59:00 GMT+0200 (CEST)",
+ (new Date(2014, 9, 26, 2, 59)).toString());
+ assertEquals("Sun, 26 Oct 2014 00:59:00 GMT",
+ (new Date(2014, 9, 26, 2, 59)).toUTCString());
+ assertEquals("Sun Oct 26 2014 03:00:00 GMT+0100 (CET)",
+ (new Date(2014, 9, 26, 3, 0)).toString());
+ assertEquals("Sun, 26 Oct 2014 02:00:00 GMT",
+ (new Date(2014, 9, 26, 3, 0)).toUTCString());
+ assertEquals("Sun Oct 26 2014 03:59:00 GMT+0100 (CET)",
+ (new Date(2014, 9, 26, 3, 59)).toString());
+ assertEquals("Sun, 26 Oct 2014 02:59:00 GMT",
+ (new Date(2014, 9, 26, 3, 59)).toUTCString());
+ assertEquals("Sun Oct 26 2014 04:00:00 GMT+0100 (CET)",
+ (new Date(2014, 9, 26, 4, 0)).toString());
+ assertEquals("Sun, 26 Oct 2014 03:00:00 GMT",
+ (new Date(2014, 9, 26, 4, 0)).toUTCString());
+}
+
+if (timezone("BRT")) {
+ assertEquals("Sat Oct 18 2014 22:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 9, 18, 22, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 01:59:00 GMT",
+ (new Date(2014, 9, 18, 22, 59)).toUTCString());
+ assertEquals("Sat Oct 18 2014 23:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 9, 18, 23, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 02:00:00 GMT",
+ (new Date(2014, 9, 18, 23, 0)).toUTCString());
+ assertEquals("Sat Oct 18 2014 23:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 9, 18, 23, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 02:59:00 GMT",
+ (new Date(2014, 9, 18, 23, 59)).toUTCString());
+ assertEquals("Sun Oct 19 2014 01:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 0, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 03:00:00 GMT",
+ (new Date(2014, 9, 19, 0, 0)).toUTCString());
+ assertEquals("Sun Oct 19 2014 01:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 0, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 03:59:00 GMT",
+ (new Date(2014, 9, 19, 0, 59)).toUTCString());
+ assertEquals("Sun Oct 19 2014 01:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 1, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 03:00:00 GMT",
+ (new Date(2014, 9, 19, 1, 0)).toUTCString());
+ assertEquals("Sun Oct 19 2014 01:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 1, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 03:59:00 GMT",
+ (new Date(2014, 9, 19, 1, 59)).toUTCString());
+ assertEquals("Sun Oct 19 2014 02:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 2, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 04:00:00 GMT",
+ (new Date(2014, 9, 19, 2, 0)).toUTCString());
+ assertEquals("Sun Oct 19 2014 02:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 2, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 04:59:00 GMT",
+ (new Date(2014, 9, 19, 2, 59)).toUTCString());
+ assertEquals("Sun Oct 19 2014 03:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 3, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 05:00:00 GMT",
+ (new Date(2014, 9, 19, 3, 0)).toUTCString());
+ assertEquals("Sun Oct 19 2014 03:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 3, 59)).toString());
+ assertEquals("Sun, 19 Oct 2014 05:59:00 GMT",
+ (new Date(2014, 9, 19, 3, 59)).toUTCString());
+ assertEquals("Sun Oct 19 2014 04:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 9, 19, 4, 0)).toString());
+ assertEquals("Sun, 19 Oct 2014 06:00:00 GMT",
+ (new Date(2014, 9, 19, 4, 0)).toUTCString());
+ assertEquals("Sat Feb 15 2014 22:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 1, 15, 22, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 00:59:00 GMT",
+ (new Date(2014, 1, 15, 22, 59)).toUTCString());
+ assertEquals("Sat Feb 15 2014 23:00:00 GMT-0200 (BRST)",
+ (new Date(2014, 1, 15, 23, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 01:00:00 GMT",
+ (new Date(2014, 1, 15, 23, 0)).toUTCString());
+ assertEquals("Sat Feb 15 2014 23:59:00 GMT-0200 (BRST)",
+ (new Date(2014, 1, 15, 23, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 01:59:00 GMT",
+ (new Date(2014, 1, 15, 23, 59)).toUTCString());
+ assertEquals("Sun Feb 16 2014 00:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 0, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 03:00:00 GMT",
+ (new Date(2014, 1, 16, 0, 0)).toUTCString());
+ assertEquals("Sun Feb 16 2014 00:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 0, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 03:59:00 GMT",
+ (new Date(2014, 1, 16, 0, 59)).toUTCString());
+ assertEquals("Sun Feb 16 2014 01:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 1, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 04:00:00 GMT",
+ (new Date(2014, 1, 16, 1, 0)).toUTCString());
+ assertEquals("Sun Feb 16 2014 01:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 1, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 04:59:00 GMT",
+ (new Date(2014, 1, 16, 1, 59)).toUTCString());
+ assertEquals("Sun Feb 16 2014 02:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 2, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 05:00:00 GMT",
+ (new Date(2014, 1, 16, 2, 0)).toUTCString());
+ assertEquals("Sun Feb 16 2014 02:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 2, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 05:59:00 GMT",
+ (new Date(2014, 1, 16, 2, 59)).toUTCString());
+ assertEquals("Sun Feb 16 2014 03:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 3, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 06:00:00 GMT",
+ (new Date(2014, 1, 16, 3, 0)).toUTCString());
+ assertEquals("Sun Feb 16 2014 03:59:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 3, 59)).toString());
+ assertEquals("Sun, 16 Feb 2014 06:59:00 GMT",
+ (new Date(2014, 1, 16, 3, 59)).toUTCString());
+ assertEquals("Sun Feb 16 2014 04:00:00 GMT-0300 (BRT)",
+ (new Date(2014, 1, 16, 4, 0)).toString());
+ assertEquals("Sun, 16 Feb 2014 07:00:00 GMT",
+ (new Date(2014, 1, 16, 4, 0)).toUTCString());
+}
+
+if (timezone("PST")) {
+ assertEquals("Sat Mar 08 2014 22:59:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 8, 22, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 06:59:00 GMT",
+ (new Date(2014, 2, 8, 22, 59)).toUTCString());
+ assertEquals("Sat Mar 08 2014 23:00:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 8, 23, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 07:00:00 GMT",
+ (new Date(2014, 2, 8, 23, 0)).toUTCString());
+ assertEquals("Sat Mar 08 2014 23:59:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 8, 23, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 07:59:00 GMT",
+ (new Date(2014, 2, 8, 23, 59)).toUTCString());
+ assertEquals("Sun Mar 09 2014 00:00:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 9, 0, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 08:00:00 GMT",
+ (new Date(2014, 2, 9, 0, 0)).toUTCString());
+ assertEquals("Sun Mar 09 2014 00:59:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 9, 0, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 08:59:00 GMT",
+ (new Date(2014, 2, 9, 0, 59)).toUTCString());
+ assertEquals("Sun Mar 09 2014 01:00:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 9, 1, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 09:00:00 GMT",
+ (new Date(2014, 2, 9, 1, 0)).toUTCString());
+ assertEquals("Sun Mar 09 2014 01:59:00 GMT-0800 (PST)",
+ (new Date(2014, 2, 9, 1, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 09:59:00 GMT",
+ (new Date(2014, 2, 9, 1, 59)).toUTCString());
+ assertEquals("Sun Mar 09 2014 03:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 2, 9, 2, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 10:00:00 GMT",
+ (new Date(2014, 2, 9, 2, 0)).toUTCString());
+ assertEquals("Sun Mar 09 2014 03:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 2, 9, 2, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 10:59:00 GMT",
+ (new Date(2014, 2, 9, 2, 59)).toUTCString());
+ assertEquals("Sun Mar 09 2014 03:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 2, 9, 3, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 10:00:00 GMT",
+ (new Date(2014, 2, 9, 3, 0)).toUTCString());
+ assertEquals("Sun Mar 09 2014 03:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 2, 9, 3, 59)).toString());
+ assertEquals("Sun, 09 Mar 2014 10:59:00 GMT",
+ (new Date(2014, 2, 9, 3, 59)).toUTCString());
+ assertEquals("Sun Mar 09 2014 04:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 2, 9, 4, 0)).toString());
+ assertEquals("Sun, 09 Mar 2014 11:00:00 GMT",
+ (new Date(2014, 2, 9, 4, 0)).toUTCString());
+ assertEquals("Sat Nov 01 2014 22:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 1, 22, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 05:59:00 GMT",
+ (new Date(2014, 10, 1, 22, 59)).toUTCString());
+ assertEquals("Sat Nov 01 2014 23:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 1, 23, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 06:00:00 GMT",
+ (new Date(2014, 10, 1, 23, 0)).toUTCString());
+ assertEquals("Sat Nov 01 2014 23:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 1, 23, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 06:59:00 GMT",
+ (new Date(2014, 10, 1, 23, 59)).toUTCString());
+ assertEquals("Sun Nov 02 2014 00:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 2, 0, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 07:00:00 GMT",
+ (new Date(2014, 10, 2, 0, 0)).toUTCString());
+ assertEquals("Sun Nov 02 2014 00:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 2, 0, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 07:59:00 GMT",
+ (new Date(2014, 10, 2, 0, 59)).toUTCString());
+ assertEquals("Sun Nov 02 2014 01:00:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 2, 1, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 08:00:00 GMT",
+ (new Date(2014, 10, 2, 1, 0)).toUTCString());
+ assertEquals("Sun Nov 02 2014 01:59:00 GMT-0700 (PDT)",
+ (new Date(2014, 10, 2, 1, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 08:59:00 GMT",
+ (new Date(2014, 10, 2, 1, 59)).toUTCString());
+ assertEquals("Sun Nov 02 2014 02:00:00 GMT-0800 (PST)",
+ (new Date(2014, 10, 2, 2, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 10:00:00 GMT",
+ (new Date(2014, 10, 2, 2, 0)).toUTCString());
+ assertEquals("Sun Nov 02 2014 02:59:00 GMT-0800 (PST)",
+ (new Date(2014, 10, 2, 2, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 10:59:00 GMT",
+ (new Date(2014, 10, 2, 2, 59)).toUTCString());
+ assertEquals("Sun Nov 02 2014 03:00:00 GMT-0800 (PST)",
+ (new Date(2014, 10, 2, 3, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 11:00:00 GMT",
+ (new Date(2014, 10, 2, 3, 0)).toUTCString());
+ assertEquals("Sun Nov 02 2014 03:59:00 GMT-0800 (PST)",
+ (new Date(2014, 10, 2, 3, 59)).toString());
+ assertEquals("Sun, 02 Nov 2014 11:59:00 GMT",
+ (new Date(2014, 10, 2, 3, 59)).toUTCString());
+ assertEquals("Sun Nov 02 2014 04:00:00 GMT-0800 (PST)",
+ (new Date(2014, 10, 2, 4, 0)).toString());
+ assertEquals("Sun, 02 Nov 2014 12:00:00 GMT",
+ (new Date(2014, 10, 2, 4, 0)).toUTCString());
+}
-// Copyright 2013 the V8 project authors. All rights reserved.
+// 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:
// (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 is to ensure that we do not support 0b and 0o in Number when
-// the --harmony-numeric-literals flag is not set.
-
-
-function TestOctalLiteralUsingNumberFunction() {
- assertEquals(NaN, Number('0o0'));
-}
-TestOctalLiteralUsingNumberFunction();
-
-
-function TestBinaryLiteralUsingNumberFunction() {
- assertEquals(NaN, Number('0b0'));
-}
-TestBinaryLiteralUsingNumberFunction();
+assertFalse(Object.prototype.isPrototypeOf.call());
+assertFalse(Object.prototype.isPrototypeOf.call(null, 1));
+assertFalse(Object.prototype.isPrototypeOf.call(undefined, 1));
--- /dev/null
+// 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.
+
+var a = [1];
+var getterValue = 2;
+var endIndex = 0xffff;
+Object.defineProperty(a, endIndex, {
+ get: function() {
+ this[1] = 3;
+ return getterValue;
+ },
+ set: function(val) {
+ getterValue = val;
+ },
+ configurable: true,
+ enumerable: true
+});
+a.reverse();
+assertFalse(a.hasOwnProperty(1));
+assertEquals(3, a[endIndex-1]);
--- /dev/null
+// 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.
+
+var a = [];
+var endIndex = 0xffff;
+a[endIndex] = 3;
+Object.defineProperty(a, 0, { get: function() { this[1] = 2; return 1; } });
+assertEquals('123', a.join(''));
+delete a[1]; // reset the array
+assertEquals('1,2,', a.join().slice(0, 4));
--- /dev/null
+// 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.
+
+function newArrayWithGetter() {
+ var arr = [1, 2, 3];
+ Object.defineProperty(arr, '1', {
+ get: function() { delete this[1]; return undefined; },
+ configurable: true
+ });
+ return arr;
+}
+
+var a = newArrayWithGetter();
+var s = a.slice(1);
+assertTrue('0' in s);
+
+// Sparse case should hit the same code as above due to presence of the getter.
+a = newArrayWithGetter();
+a[0xffff] = 4;
+s = a.slice(1);
+assertTrue('0' in s);
+
+a = newArrayWithGetter();
+a.shift();
+assertTrue('0' in a);
+
+a = newArrayWithGetter();
+a.unshift(0);
+assertTrue('2' in a);
--- /dev/null
+// 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 --noalways-opt
+
+var calls = 0;
+
+function callsFReceiver(o) {
+ return [].f.call(new Number(o.m), 1, 2, 3);
+}
+
+// For the HConstant
+Array.prototype.f = function() {
+ calls++;
+ return +this;
+};
+
+
+var o1 = {m: 1};
+var o2 = {a: 0, m:1};
+
+var r1 = callsFReceiver(o1);
+callsFReceiver(o1);
+%OptimizeFunctionOnNextCall(callsFReceiver);
+var r2 = callsFReceiver(o1);
+assertOptimized(callsFReceiver);
+callsFReceiver(o2);
+assertUnoptimized(callsFReceiver);
+var r3 = callsFReceiver(o1);
+
+assertEquals(1, r1);
+assertTrue(r1 === r2);
+assertTrue(r2 === r3);
+
+r1 = callsFReceiver(o1);
+callsFReceiver(o1);
+%OptimizeFunctionOnNextCall(callsFReceiver);
+r2 = callsFReceiver(o1);
+callsFReceiver(o2);
+r3 = callsFReceiver(o1);
+
+assertEquals(1, r1);
+assertTrue(r1 === r2);
+assertTrue(r2 === r3);
+
+assertEquals(10, calls);
--- /dev/null
+// 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: --stack-size=100 --turbo-deoptimization
+
+var a = [];
+
+Object.observe(a, function() {});
+
+function f(a, x) {
+ a.length = x;
+ f(a, x + 1);
+}
+
+assertThrows(function() { f(a, 1); }, RangeError);
--- /dev/null
+// 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: --stack-size=100
+
+var a = [];
+
+Array.observe(a, function() {});
+
+function f(a, x) {
+ a.length = x;
+ f(a, x + 1);
+}
+
+assertThrows(function() { f(a, 1); }, RangeError);
--- /dev/null
+// Copyright 2012 the V8 project 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 o = {
+ f: function(x) {
+ var a = x + 1;
+ o = 1;
+ }
+}
+
+function sentinel() {}
+
+var Debug = debug.Debug;
+
+Debug.setListener(function() {});
+
+var script = Debug.findScript(sentinel);
+
+// Used in Debug.setScriptBreakPointById.
+var p = Debug.findScriptSourcePosition(script, 9, 0);
+var q = Debug.setBreakPointByScriptIdAndPosition(script.id, p).actual_position;
+var r = Debug.setBreakPointByScriptIdAndPosition(script.id, q).actual_position;
+
+assertEquals(q, r);
+
+function assertLocation(p, l, c) {
+ var location = script.locationFromPosition(p, false);
+ assertEquals(l, location.line);
+ assertEquals(c, location.column);
+}
+
+assertLocation(p, 9, 0);
+assertLocation(q, 9, 4);
+assertLocation(r, 9, 4);
--- /dev/null
+// 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.
+
+Object.defineProperty(Array.prototype, '0', {
+ get: function() { return false; },
+});
+var a = [1, 2, 3];
+assertEquals(a, a.slice());
+assertEquals([3], a.splice(2, 1));
+
+a = [1, 2, 3];
+a[0xffff] = 4;
+// nulling the prototype lets us stay in the sparse case; otherwise the
+// getter on Array.prototype would force us into the non-sparse code.
+a.__proto__ = null;
+assertEquals(a, Array.prototype.slice.call(a));
+assertEquals([3], Array.prototype.splice.call(a, 2, 1));
--- /dev/null
+// 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.
+
+var array = new Int8Array(10);
+array[/\u007d\u00fc\u0043/] = 1.499
+assertEquals(1.499, array[/\u007d\u00fc\u0043/]);
// (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: --turbo-deoptimization
+
for (var i = 0; i < 10000; i++) {
try {
var object = { };
--- /dev/null
+// 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 --always-opt
+// Flags: --turbo-filter=* --turbo-deoptimization
+
+function assertEquals() {}
+
+function f(o) {
+ if (o.setterProperty = 0) {
+ return 1;
+ }
+ return 2;
+}
+
+function deopt() { %DeoptimizeFunction(f); }
+
+assertEquals(2,
+ f(Object.defineProperty({}, "setterProperty", { set: deopt })));
Object.defineProperty(o, "foo", { set: setter, configurable: true });
Object.defineProperty(o2, "foo", { set: setter, configurable: true });
-assertTrue(%HaveSameMap(o, o2));
+// TODO(ishell): this should eventually become assertTrue().
+assertFalse(%HaveSameMap(o, o2));
--- /dev/null
+// 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
+
+Debug = debug.Debug;
+var exception = null;
+var error_count = 0;
+
+function f() {
+ return 0; // Break
+}
+
+function listener(event, exec_state, event_data, data) {
+ if (event != Debug.DebugEvent.Break) return;
+ try {
+ if (exec_state.frame(0).sourceLineText().indexOf("Break") <0) {
+ error_count++;
+ }
+ exec_state.prepareStep(Debug.StepAction.StepIn, 2);
+ f(); // We should not break in this call of f().
+ } catch (e) {
+ print(e + e.stack);
+ exception = e;
+ }
+}
+
+Debug.setListener(listener);
+
+debugger; // Break
+f();
+
+Debug.setListener(null); // Break
+
+assertNull(exception);
+assertEquals(0, error_count);
--- /dev/null
+// 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-gc
+
+%GetScript('v8/gc');
%OptimizeFunctionOnNextCall(__f_6);
__f_6();
function __f_7(__v_7) {
- __v_7.push(Infinity);
+ __v_7.pop();
}
--- /dev/null
+// 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
+
+function foo(x) {
+ var k = "value";
+ return x[k] = 1;
+}
+var obj = {};
+Object.defineProperty(obj, "value", {set: function(x) { throw "nope"; }});
+try { foo(obj); } catch(e) {}
+try { foo(obj); } catch(e) {}
+%OptimizeFunctionOnNextCall(foo);
+try { foo(obj); } catch(e) {}
+
+function bar(x) {
+ var k = "value";
+ return (x[k] = 1) ? "ok" : "nope";
+}
+var obj2 = {};
+Object.defineProperty(obj2, "value",
+ {set: function(x) { throw "nope"; return true; } });
+
+try { bar(obj2); } catch(e) {}
+try { bar(obj2); } catch(e) {}
+%OptimizeFunctionOnNextCall(bar);
+try { bar(obj2); } catch(e) {}
// Flags: --allow-natives-syntax
-var o = {};
-%SetHiddenProperty(o, "test", 1);
-// Create non-internalized ""
-var empty = "a".substring(1, 1);
-assertEquals(undefined, o[empty]);
+var json = '{"a":{"c":2.1,"d":0},"b":{"c":7,"1024":8}}';
+var data = JSON.parse(json);
+
+data.b.c++;
--- /dev/null
+// 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
+
+(function outer() {
+ var C = (function C_() {
+ var y = 1;
+ function CC() {
+ this.x = 0;
+ }
+ CC.prototype.f = function CCf() {
+ this.x += y;
+ return this.x;
+ };
+ return CC;
+ })();
+
+ var c = new C(0);
+})
+
+function sentinel() {}
+
+Debug = debug.Debug;
+
+var script = Debug.findScript(sentinel);
+var line = 14;
+var line_start = Debug.findScriptSourcePosition(script, line, 0);
+var line_end = Debug.findScriptSourcePosition(script, line + 1, 0) - 1;
+var actual = Debug.setBreakPointByScriptIdAndPosition(
+ script.id, line_start).actual_position;
+// Make sure the actual break position is within the line where we set
+// the break point.
+assertTrue(line_start <= actual);
+assertTrue(actual <= line_end);
--- /dev/null
+// 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
+
+function load(a, i) {
+ return a[i];
+}
+
+load([]);
+load(0);
+load("x", 0);
+%OptimizeFunctionOnNextCall(load);
+load([], 0);
--- /dev/null
+// 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.
+
+
+var correct_result = "This is the correct result.";
+
+function foo(recursion_depth) {
+ if (recursion_depth > 0) return foo(recursion_depth - 1);
+ return new String(correct_result, 1, 2, 3, 4, 5, 6);
+}
+
+// Roll our own non-strict assertEquals replacement.
+function test(i) {
+ var actual = foo(i);
+ if (correct_result != actual) {
+ var msg = "Expected \"" + correct_result + "\", found " + actual;
+ throw new MjsUnitAssertionError(msg);
+ }
+}
+
+test(1);
+test(1);
+test(10);
+test(100);
--- /dev/null
+// 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.
+
+try {
+ var src = "return " + Array(12000).join("src,") + "src";
+ var fun = Function(src);
+ assertEquals(src, fun());
+} catch (e) {
+ // Some architectures throw a RangeError, that is fine.
+ assertInstanceof(e, RangeError);
+}
--- /dev/null
+// 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
+
+function foo() { return 1; };
+var o1 = {};
+o1.foo = foo;
+
+var json = '{"foo": {"x": 1}}';
+var o2 = JSON.parse(json);
+var o3 = JSON.parse(json);
+assertTrue(%HaveSameMap(o2, o3));
--- /dev/null
+// 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.
+
+(function f() {
+ try {
+ throw 1;
+ } catch (e) {
+ var a = 0;
+ var b = 0;
+ var c = 0;
+ var x = 1;
+ var result = eval('eval("x")').toString();
+ assertEquals("1", result);
+ }
+ var x = 2;
+ var result = eval('eval("x")').toString();
+ assertEquals("2", result);
+})();
--- /dev/null
+// 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.
+
+var arr = [1, 2];
+Object.defineProperty(arr, 0xfffe, {
+ value: 3,
+ configurable: true,
+ writable: true,
+ enumerable: false
+});
+arr[0xffff] = 4;
+arr.shift();
+var desc = Object.getOwnPropertyDescriptor(arr, 0xfffe);
+assertEquals(4, desc.value);
+assertFalse(desc.enumerable);
--- /dev/null
+// 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.
+
+// --serialize-toplevel --cache=code
+
+var caught = false;
+try {
+ parseInt() = 0;
+} catch(e) {
+ caught = true;
+}
+assertTrue(caught);
var foo = [];
foo[0] = "bar";
assertEquals(["bar"], foo);
+
+var a;
+var b = 1;
+a = [2]; // STORE_IC
+a[0] = a[0] + 1; // KEYED_STORE_IC, KEYED_LOAD_IC, BINARY_OP_IC
+assertTrue(a[0] > b); // CALL_IC, COMPARE_IC
+b = b == null; // COMPARE_NIL_IC
+b = b || Boolean(''); // TO_BOOLEAN_IC
+assertFalse(b);
var values = [3, 3.5, true];
-for(var c = 0; c < 3; c++) {
- for(var s = 0; s < 3; s++) {
+for(var c = 0; c < cf.length; c++) {
+ for(var s = 0; s < values.length; s++) {
base_setter_test(cf[c], 0, values[s]);
base_setter_test(cf[c], 1, values[s]);
}
assertEquals(0.8211418015898941, Math.tan(11/16));
assertEquals(-0.8211418015898941, Math.tan(-11/16));
assertEquals(0.41421356237309503, Math.tan(Math.PI / 8));
+// crbug/427468
+assertEquals(0.7993357819992383, Math.tan(0.6743358));
// Tests for Math.sin.
assertEquals(0.479425538604203, Math.sin(0.5));
// (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: --turbo-deoptimization
+
function CheckStrictMode(code, exception) {
assertDoesNotThrow(code);
assertThrows("'use strict';\n" + code, exception);
// Based on LayoutTests/fast/js/Object-keys.html
-assertThrows(function () { Object.keys(2) }, TypeError);
-assertThrows(function () { Object.keys("foo") }, TypeError);
+assertEquals(Object.keys(2), []);
+assertEquals(Object.keys("foo"), ["0", "1", "2"]);
assertThrows(function () { Object.keys(null) }, TypeError);
assertThrows(function () { Object.keys(undefined) }, TypeError);
4 30.8% Shared libraries
2 15.4% Unaccounted
+ [C++ entry points]:
+ ticks cpp total name
+ 2 40.0% 15.4% v8::internal::Runtime_Math_exp(v8::internal::Arguments)
+ 1 20.0% 7.7% v8::internal::JSObject::LookupOwnRealNamedProperty(v8::internal::String*, v8::internal::LookupResult*)
+ 1 20.0% 7.7% v8::internal::HashTable<v8::internal::StringDictionaryShape, v8::internal::String*>::FindEntry(v8::internal::String*)
+ 1 20.0% 7.7% exp
+
[Bottom up (heavy) profile]:
Note: percentage shows a share of a particular caller in the total
amount of its parent calls.
0 0.0% 0.0% GC
0 0.0% Shared libraries
+ [C++ entry points]:
+ ticks cpp total name
+
[Bottom up (heavy) profile]:
Note: percentage shows a share of a particular caller in the total
amount of its parent calls.
0 0.0% 0.0% GC
0 0.0% Shared libraries
+ [C++ entry points]:
+ ticks cpp total name
+
[Bottom up (heavy) profile]:
Note: percentage shows a share of a particular caller in the total
amount of its parent calls.
0 0.0% 0.0% GC
4 36.4% Shared libraries
+ [C++ entry points]:
+ ticks cpp total name
+ 2 40.0% 18.2% v8::internal::Runtime_Math_exp(v8::internal::Arguments)
+ 1 20.0% 9.1% v8::internal::JSObject::LookupOwnRealNamedProperty(v8::internal::String*, v8::internal::LookupResult*)
+ 1 20.0% 9.1% v8::internal::HashTable<v8::internal::StringDictionaryShape, v8::internal::String*>::FindEntry(v8::internal::String*)
+ 1 20.0% 9.1% exp
+
[Bottom up (heavy) profile]:
Note: percentage shows a share of a particular caller in the total
amount of its parent calls.
4 30.8% Shared libraries
2 15.4% Unaccounted
+ [C++ entry points]:
+ ticks cpp total name
+ 2 40.0% 15.4% v8::internal::Runtime_Math_exp(v8::internal::Arguments)
+ 1 20.0% 7.7% v8::internal::JSObject::LookupOwnRealNamedProperty(v8::internal::String*, v8::internal::LookupResult*)
+ 1 20.0% 7.7% v8::internal::HashTable<v8::internal::StringDictionaryShape, v8::internal::String*>::FindEntry(v8::internal::String*)
+ 1 20.0% 7.7% exp
+
[Bottom up (heavy) profile]:
Note: percentage shows a share of a particular caller in the total
amount of its parent calls.
--- /dev/null
+// 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.
+
+var x = 1;
+function foo(object) {
+ with(object) {
+ x;
+ }
+ return 100;
+}
+
+assertEquals(100,foo("str"));
assertTrue(!z && typeof z == 'undefined');
if (false) { var z; }
assertTrue(!z && typeof z == 'undefined');
+
+assertThrows("var \u2E2F;", SyntaxError);
+assertThrows("var \\u2E2F;", SyntaxError);
+
+assertDoesNotThrow("var \u2118;");
+assertDoesNotThrow("var \\u2118;");
+assertDoesNotThrow("var \u212E;");
+assertDoesNotThrow("var \\u212E;");
+assertDoesNotThrow("var \u309B;");
+assertDoesNotThrow("var \\u309B;");
+assertDoesNotThrow("var \u309C;");
+assertDoesNotThrow("var \\u309C;");
+
+assertDoesNotThrow("var $\u00B7;");
+assertDoesNotThrow("var $\u0387;");
+assertDoesNotThrow("var $\u1369;");
+assertDoesNotThrow("var $\u1370;");
+assertDoesNotThrow("var $\u1371;");
+assertDoesNotThrow("var $\u19DA;");
'js1_5/GC/regress-348532': [SKIP],
+ # Runs for too long: huge array with getters and setters. As it says
+ # in the test: "This test will probably run out of memory".
+ 'js1_5/extensions/regress-345967': [SKIP],
+
+
##################### FLAKY TESTS #####################
# These tests time out in debug mode but pass in product mode
# Test that depends on timer resolution. Fails every now and then
# if we're unlucky enough to get a context switch at a bad time.
- 'js1_5/extensions/regress-363258': [PASS, FAIL],
+ # TODO(mstarzinger): Switch off TF on windows due to timeouts.
+ 'js1_5/extensions/regress-363258': [PASS, FAIL, ['system == windows', NO_VARIANTS]],
# Test that assumes specific runtime for a regexp, flaky in debug mode.
'js1_5/extensions/regress-311792-01': [FAIL_OK],
'js1_5/extensions/regress-312278': [FAIL_OK],
'js1_5/extensions/regress-313630': [FAIL_OK],
- 'js1_5/extensions/regress-313763': [FAIL_OK],
'js1_5/extensions/regress-313803': [FAIL_OK],
'js1_5/extensions/regress-314874': [FAIL_OK],
'js1_5/extensions/regress-322957': [FAIL_OK],
'js1_5/extensions/regress-336409-1': [FAIL_OK],
'js1_5/extensions/regress-336409-2': [FAIL_OK],
'js1_5/extensions/regress-336410-2': [FAIL_OK],
- 'js1_5/extensions/regress-341956-01': [FAIL_OK],
- 'js1_5/extensions/regress-345967': [FAIL_OK],
'js1_5/extensions/regress-346494-01': [FAIL_OK],
'js1_5/extensions/regress-346494': [FAIL_OK],
'js1_5/extensions/regress-347306-02': [FAIL_OK],
+++ /dev/null
-{
- "path": ["."],
- "main": "run.js",
- "flags": ["--harmony-collections"],
- "run_count": 5,
- "units": "score",
- "results_regexp": "^%s\\-Collections\\(Score\\): (.+)$",
- "total": true,
- "tests": [
- {"name": "Map"},
- {"name": "Set"},
- {"name": "WeakMap"},
- {"name": "WeakSet"}
- ]
-}
+++ /dev/null
-// 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.
-
-
-var MapBenchmark = new BenchmarkSuite('Map', [1000], [
- new Benchmark('Set', false, false, 0, MapSet),
- new Benchmark('Has', false, false, 0, MapHas, MapSetup, MapTearDown),
- new Benchmark('Get', false, false, 0, MapGet, MapSetup, MapTearDown),
- new Benchmark('Delete', false, false, 0, MapDelete, MapSetup, MapTearDown),
- new Benchmark('ForEach', false, false, 0, MapForEach, MapSetup, MapTearDown),
-]);
-
-
-var map;
-var N = 10;
-
-
-function MapSetup() {
- map = new Map;
- for (var i = 0; i < N; i++) {
- map.set(i, i);
- }
-}
-
-
-function MapTearDown() {
- map = null;
-}
-
-
-function MapSet() {
- MapSetup();
- MapTearDown();
-}
-
-
-function MapHas() {
- for (var i = 0; i < N; i++) {
- if (!map.has(i)) {
- throw new Error();
- }
- }
- for (var i = N; i < 2 * N; i++) {
- if (map.has(i)) {
- throw new Error();
- }
- }
-}
-
-
-function MapGet() {
- for (var i = 0; i < N; i++) {
- if (map.get(i) !== i) {
- throw new Error();
- }
- }
- for (var i = N; i < 2 * N; i++) {
- if (map.get(i) !== undefined) {
- throw new Error();
- }
- }
-}
-
-
-function MapDelete() {
- // This is run more than once per setup so we will end up deleting items
- // more than once. Therefore, we do not the return value of delete.
- for (var i = 0; i < N; i++) {
- map.delete(i);
- }
-}
-
-
-function MapForEach() {
- map.forEach(function(v, k) {
- if (v !== k) {
- throw new Error();
- }
- });
-}
+++ /dev/null
-// 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.
-
-
-var SetBenchmark = new BenchmarkSuite('Set', [1000], [
- new Benchmark('Add', false, false, 0, SetAdd),
- new Benchmark('Has', false, false, 0, SetHas, SetSetup, SetTearDown),
- new Benchmark('Delete', false, false, 0, SetDelete, SetSetup, SetTearDown),
- new Benchmark('ForEach', false, false, 0, SetForEach, SetSetup, SetTearDown),
-]);
-
-
-var set;
-var N = 10;
-
-
-function SetSetup() {
- set = new Set;
- for (var i = 0; i < N; i++) {
- set.add(i);
- }
-}
-
-
-function SetTearDown() {
- map = null;
-}
-
-
-function SetAdd() {
- SetSetup();
- SetTearDown();
-}
-
-
-function SetHas() {
- for (var i = 0; i < N; i++) {
- if (!set.has(i)) {
- throw new Error();
- }
- }
- for (var i = N; i < 2 * N; i++) {
- if (set.has(i)) {
- throw new Error();
- }
- }
-}
-
-
-function SetDelete() {
- // This is run more than once per setup so we will end up deleting items
- // more than once. Therefore, we do not the return value of delete.
- for (var i = 0; i < N; i++) {
- set.delete(i);
- }
-}
-
-
-function SetForEach() {
- set.forEach(function(v, k) {
- if (v !== k) {
- throw new Error();
- }
- });
-}
https://github.com/tc39/test262
-at hash 9bd6686 (2014/08/25 revision) as 'data' in this directory. Using later
+at hash 61113db (2014/10/23 revision) as 'data' in this directory. Using later
version may be possible but the tests are only known to pass (and indeed run)
with that revision.
git clone https://github.com/tc39/test262 data
cd data
- git checkout 9bd6686
+ git checkout 61113db
If you do update to a newer revision you may have to change the test
harness adapter code since it uses internal functionality from the
[ALWAYS, {
############################### BUGS ###################################
- '15.5.4.9_CE': [['no_i18n', SKIP]],
-
# BUG(v8:3455)
'11.2.3_b': [FAIL],
'12.2.3_b': [FAIL],
+ # Unicode canonicalization is not available with i18n turned off.
+ '15.5.4.9_CE': [['no_i18n', SKIP]],
+
###################### NEEDS INVESTIGATION #######################
# Possibly same cause as S8.5_A2.1, below: floating-point tests.
###################### MISSING ES6 FEATURES #######################
+ # Array.fill (currently requires --harmony-arrays)
+ 'S22.1.3.6_T1': [FAIL],
+
+ # Array.find (currently requires --harmony-arrays)
+ 'S22.1.2.3_T1': [FAIL],
+ 'S22.1.2.3_T2': [FAIL],
+ 'Array.prototype.find_empty-array-undefined': [FAIL],
+ 'Array.prototype.find_length-property': [FAIL],
+ 'Array.prototype.find_modify-after-start': [FAIL],
+ 'Array.prototype.find_non-returning-predicate': [FAIL],
+ 'Array.prototype.find_predicate-arguments': [FAIL],
+ 'Array.prototype.find_push-after-start': [FAIL],
+ 'Array.prototype.find_remove-after-start': [FAIL],
+ 'Array.prototype.find_return-found-value': [FAIL],
+ 'Array.prototype.find_skip-empty': [FAIL],
+ 'Array.prototype.find_this-defined': [FAIL],
+ 'Array.prototype.find_this-is-object': [FAIL],
+ 'Array.prototype.find_this-undefined': [FAIL],
+
# Array.from
'S22.1.2.1_T1': [FAIL],
'S22.1.2.1_T2': [FAIL],
# '11.1.5_4-4-d-3': [FAIL],
# '11.1.5_4-4-d-4': [FAIL],
+ # ES6 does ToObject for Object.prototype.getOwnPropertyNames
+ '15.2.3.4-1': [FAIL],
+ '15.2.3.4-1-4': [FAIL],
+ '15.2.3.4-1-5': [FAIL],
+
# ES6 allows block-local functions.
'Sbp_A1_T1': [FAIL],
'Sbp_A2_T1': [FAIL],
# Test262 Bug: https://bugs.ecmascript.org/show_bug.cgi?id=596
'bug_596_1': [PASS, FAIL_OK],
+ # Tests do not return boolean.
+ '15.2.3.14-1-1': [PASS, FAIL_OK],
+ '15.2.3.14-1-2': [PASS, FAIL_OK],
+ '15.2.3.14-1-3': [PASS, FAIL_OK],
+
############################ SKIPPED TESTS #############################
# These tests take a looong time to run in debug mode.
from testrunner.local import utils
from testrunner.objects import testcase
-TEST_262_ARCHIVE_REVISION = "9bd6686" # This is the 2014-08-25 revision.
-TEST_262_ARCHIVE_MD5 = "0f5928b391864890d5a397f8cdc82705"
+TEST_262_ARCHIVE_REVISION = "61113db" # This is the 2014-10-23 revision.
+TEST_262_ARCHIVE_MD5 = "261e69b4a97a4bfc18225cf3938daf50"
TEST_262_URL = "https://github.com/tc39/test262/tarball/%s"
TEST_262_HARNESS_FILES = ["sta.js"]
with open(archive_name, "rb") as f:
for chunk in iter(lambda: f.read(8192), ""):
md5.update(chunk)
+ print "MD5 hash is %s" % md5.hexdigest()
if md5.hexdigest() != TEST_262_ARCHIVE_MD5:
os.remove(archive_name)
- raise Exception("Hash mismatch of test data file")
+ print "MD5 expected %s" % TEST_262_ARCHIVE_MD5
+ raise Exception("MD5 hash mismatch of test data file")
archive = tarfile.open(archive_name, "r:gz")
if sys.platform in ("win32", "cygwin"):
# Magic incantation to allow longer path names on Windows.
'S15.9.3.1_A5_T5': [PASS, FAIL_OK],
'S15.9.3.1_A5_T6': [PASS, FAIL_OK],
+ # ObjectKeys() no longer throws TypeError when passed a primitive value which
+ # is not null or undefined (per ES6).
+ '15.2.3.14-1-1': [FAIL_OK],
+ '15.2.3.14-1-2': [FAIL_OK],
+ '15.2.3.14-1-3': [FAIL_OK],
+
+ # Object.getOwnPropertyNames(O) no longer throws when passed a primitive value.
+ '15.2.3.4-1-4': [FAIL_OK],
+ '15.2.3.4-1-5': [FAIL_OK],
+ '15.2.3.4-1': [FAIL_OK],
+
############################ SKIPPED TESTS #############################
# These tests take a looong time to run in debug mode.
--- /dev/null
+include_rules = [
+ "+src",
+ "+testing"
+]
}
+TEST(Bits, CountPopulation64) {
+ EXPECT_EQ(0u, CountPopulation64(0));
+ EXPECT_EQ(1u, CountPopulation64(1));
+ EXPECT_EQ(2u, CountPopulation64(0x8000000000000001));
+ EXPECT_EQ(8u, CountPopulation64(0x11111111));
+ EXPECT_EQ(16u, CountPopulation64(0xf0f0f0f0));
+ EXPECT_EQ(24u, CountPopulation64(0xfff0f0ff));
+ EXPECT_EQ(32u, CountPopulation64(0xffffffff));
+ EXPECT_EQ(16u, CountPopulation64(0x1111111111111111));
+ EXPECT_EQ(32u, CountPopulation64(0xf0f0f0f0f0f0f0f0));
+ EXPECT_EQ(48u, CountPopulation64(0xfff0f0fffff0f0ff));
+ EXPECT_EQ(64u, CountPopulation64(0xffffffffffffffff));
+}
+
+
TEST(Bits, CountLeadingZeros32) {
EXPECT_EQ(32u, CountLeadingZeros32(0));
EXPECT_EQ(31u, CountLeadingZeros32(1));
}
+TEST(Bits, CountLeadingZeros64) {
+ EXPECT_EQ(64u, CountLeadingZeros64(0));
+ EXPECT_EQ(63u, CountLeadingZeros64(1));
+ TRACED_FORRANGE(uint32_t, shift, 0, 63) {
+ EXPECT_EQ(63u - shift, CountLeadingZeros64(V8_UINT64_C(1) << shift));
+ }
+ EXPECT_EQ(36u, CountLeadingZeros64(0x0f0f0f0f));
+ EXPECT_EQ(4u, CountLeadingZeros64(0x0f0f0f0f00000000));
+}
+
+
TEST(Bits, CountTrailingZeros32) {
EXPECT_EQ(32u, CountTrailingZeros32(0));
EXPECT_EQ(31u, CountTrailingZeros32(0x80000000));
}
+TEST(Bits, CountTrailingZeros64) {
+ EXPECT_EQ(64u, CountTrailingZeros64(0));
+ EXPECT_EQ(63u, CountTrailingZeros64(0x8000000000000000));
+ TRACED_FORRANGE(uint32_t, shift, 0, 63) {
+ EXPECT_EQ(shift, CountTrailingZeros64(V8_UINT64_C(1) << shift));
+ }
+ EXPECT_EQ(4u, CountTrailingZeros64(0xf0f0f0f0));
+ EXPECT_EQ(36u, CountTrailingZeros64(0xf0f0f0f000000000));
+}
+
+
TEST(Bits, IsPowerOfTwo32) {
EXPECT_FALSE(IsPowerOfTwo32(0U));
TRACED_FORRANGE(uint32_t, shift, 0, 31) {
}
}
+
+TEST(Bits, SignedMulHigh32) {
+ EXPECT_EQ(0, SignedMulHigh32(0, 0));
+ TRACED_FORRANGE(int32_t, i, 1, 50) {
+ TRACED_FORRANGE(int32_t, j, 1, i) { EXPECT_EQ(0, SignedMulHigh32(i, j)); }
+ }
+ EXPECT_EQ(-1073741824, SignedMulHigh32(std::numeric_limits<int32_t>::max(),
+ std::numeric_limits<int32_t>::min()));
+ EXPECT_EQ(-1073741824, SignedMulHigh32(std::numeric_limits<int32_t>::min(),
+ std::numeric_limits<int32_t>::max()));
+ EXPECT_EQ(1, SignedMulHigh32(1024 * 1024 * 1024, 4));
+ EXPECT_EQ(2, SignedMulHigh32(8 * 1024, 1024 * 1024));
+}
+
+
+TEST(Bits, SignedMulHighAndAdd32) {
+ TRACED_FORRANGE(int32_t, i, 1, 50) {
+ EXPECT_EQ(i, SignedMulHighAndAdd32(0, 0, i));
+ TRACED_FORRANGE(int32_t, j, 1, i) {
+ EXPECT_EQ(i, SignedMulHighAndAdd32(j, j, i));
+ }
+ EXPECT_EQ(i + 1, SignedMulHighAndAdd32(1024 * 1024 * 1024, 4, i));
+ }
+}
+
+
+TEST(Bits, SignedDiv32) {
+ EXPECT_EQ(std::numeric_limits<int32_t>::min(),
+ SignedDiv32(std::numeric_limits<int32_t>::min(), -1));
+ EXPECT_EQ(std::numeric_limits<int32_t>::max(),
+ SignedDiv32(std::numeric_limits<int32_t>::max(), 1));
+ TRACED_FORRANGE(int32_t, i, 0, 50) {
+ EXPECT_EQ(0, SignedDiv32(i, 0));
+ TRACED_FORRANGE(int32_t, j, 1, i) {
+ EXPECT_EQ(1, SignedDiv32(j, j));
+ EXPECT_EQ(i / j, SignedDiv32(i, j));
+ EXPECT_EQ(-i / j, SignedDiv32(i, -j));
+ }
+ }
+}
+
+
+TEST(Bits, SignedMod32) {
+ EXPECT_EQ(0, SignedMod32(std::numeric_limits<int32_t>::min(), -1));
+ EXPECT_EQ(0, SignedMod32(std::numeric_limits<int32_t>::max(), 1));
+ TRACED_FORRANGE(int32_t, i, 0, 50) {
+ EXPECT_EQ(0, SignedMod32(i, 0));
+ TRACED_FORRANGE(int32_t, j, 1, i) {
+ EXPECT_EQ(0, SignedMod32(j, j));
+ EXPECT_EQ(i % j, SignedMod32(i, j));
+ EXPECT_EQ(i % j, SignedMod32(i, -j));
+ }
+ }
+}
+
+
+TEST(Bits, UnsignedDiv32) {
+ TRACED_FORRANGE(uint32_t, i, 0, 50) {
+ EXPECT_EQ(0u, UnsignedDiv32(i, 0));
+ TRACED_FORRANGE(uint32_t, j, i + 1, 100) {
+ EXPECT_EQ(1u, UnsignedDiv32(j, j));
+ EXPECT_EQ(i / j, UnsignedDiv32(i, j));
+ }
+ }
+}
+
+
+TEST(Bits, UnsignedMod32) {
+ TRACED_FORRANGE(uint32_t, i, 0, 50) {
+ EXPECT_EQ(0u, UnsignedMod32(i, 0));
+ TRACED_FORRANGE(uint32_t, j, i + 1, 100) {
+ EXPECT_EQ(0u, UnsignedMod32(j, j));
+ EXPECT_EQ(i % j, UnsignedMod32(i, j));
+ }
+ }
+}
+
} // namespace bits
} // namespace base
} // namespace v8
#include "src/base/division-by-constant.h"
+#include <stdint.h>
+
#include <ostream> // NOLINT
#include "testing/gtest-support.h"
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "include/v8stdint.h"
+#include <stdint.h>
#include "src/base/flags.h"
#include "testing/gtest/include/gtest/gtest.h"
--- /dev/null
+// 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/base/functional.h"
+
+#include <limits>
+#include <set>
+
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace base {
+
+TEST(FunctionalTest, HashBool) {
+ hash<bool> h, h1, h2;
+ EXPECT_EQ(h1(true), h2(true));
+ EXPECT_EQ(h1(false), h2(false));
+ EXPECT_NE(h(true), h(false));
+}
+
+
+TEST(FunctionalTest, HashFloatZero) {
+ hash<float> h;
+ EXPECT_EQ(h(0.0f), h(-0.0f));
+}
+
+
+TEST(FunctionalTest, HashDoubleZero) {
+ hash<double> h;
+ EXPECT_EQ(h(0.0), h(-0.0));
+}
+
+
+template <typename T>
+class FunctionalTest : public TestWithRandomNumberGenerator {};
+
+typedef ::testing::Types<signed char, unsigned char,
+ short, // NOLINT(runtime/int)
+ unsigned short, // NOLINT(runtime/int)
+ int, unsigned int, long, // NOLINT(runtime/int)
+ unsigned long, // NOLINT(runtime/int)
+ long long, // NOLINT(runtime/int)
+ unsigned long long, // NOLINT(runtime/int)
+ int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
+ int64_t, uint64_t, float, double> FunctionalTypes;
+
+TYPED_TEST_CASE(FunctionalTest, FunctionalTypes);
+
+
+TYPED_TEST(FunctionalTest, EqualToImpliesSameHashCode) {
+ hash<TypeParam> h;
+ std::equal_to<TypeParam> e;
+ TypeParam values[32];
+ this->rng()->NextBytes(values, sizeof(values));
+ TRACED_FOREACH(TypeParam, v1, values) {
+ TRACED_FOREACH(TypeParam, v2, values) {
+ if (e(v1, v2)) EXPECT_EQ(h(v1), h(v2));
+ }
+ }
+}
+
+
+TYPED_TEST(FunctionalTest, HashEqualsHashValue) {
+ for (int i = 0; i < 128; ++i) {
+ TypeParam v;
+ this->rng()->NextBytes(&v, sizeof(v));
+ hash<TypeParam> h;
+ EXPECT_EQ(h(v), hash_value(v));
+ }
+}
+
+
+TYPED_TEST(FunctionalTest, HashIsStateless) {
+ hash<TypeParam> h1, h2;
+ for (int i = 0; i < 128; ++i) {
+ TypeParam v;
+ this->rng()->NextBytes(&v, sizeof(v));
+ EXPECT_EQ(h1(v), h2(v));
+ }
+}
+
+
+TYPED_TEST(FunctionalTest, HashIsOkish) {
+ std::set<TypeParam> vs;
+ for (size_t i = 0; i < 128; ++i) {
+ TypeParam v;
+ this->rng()->NextBytes(&v, sizeof(v));
+ vs.insert(v);
+ }
+ std::set<size_t> hs;
+ for (const auto& v : vs) {
+ hash<TypeParam> h;
+ hs.insert(h(v));
+ }
+ EXPECT_LE(vs.size() / 4u, hs.size());
+}
+
+
+TYPED_TEST(FunctionalTest, HashValueArrayUsesHashRange) {
+ TypeParam values[128];
+ this->rng()->NextBytes(&values, sizeof(values));
+ EXPECT_EQ(hash_range(values, values + arraysize(values)), hash_value(values));
+}
+
+
+TYPED_TEST(FunctionalTest, BitEqualTo) {
+ bit_equal_to<TypeParam> pred;
+ for (size_t i = 0; i < 128; ++i) {
+ TypeParam v1, v2;
+ this->rng()->NextBytes(&v1, sizeof(v1));
+ this->rng()->NextBytes(&v2, sizeof(v2));
+ EXPECT_PRED2(pred, v1, v1);
+ EXPECT_PRED2(pred, v2, v2);
+ EXPECT_EQ(memcmp(&v1, &v2, sizeof(TypeParam)) == 0, pred(v1, v2));
+ }
+}
+
+
+TYPED_TEST(FunctionalTest, BitEqualToImpliesSameBitHash) {
+ bit_hash<TypeParam> h;
+ bit_equal_to<TypeParam> e;
+ TypeParam values[32];
+ this->rng()->NextBytes(&values, sizeof(values));
+ TRACED_FOREACH(TypeParam, v1, values) {
+ TRACED_FOREACH(TypeParam, v2, values) {
+ if (e(v1, v2)) EXPECT_EQ(h(v1), h(v2));
+ }
+ }
+}
+
+
+namespace {
+
+struct Foo {
+ int x;
+ double y;
+};
+
+
+size_t hash_value(Foo const& v) { return hash_combine(v.x, v.y); }
+
+} // namespace
+
+
+TEST(FunctionalTest, HashUsesArgumentDependentLookup) {
+ const int kIntValues[] = {std::numeric_limits<int>::min(), -1, 0, 1, 42,
+ std::numeric_limits<int>::max()};
+ const double kDoubleValues[] = {
+ std::numeric_limits<double>::min(), -1, -0, 0, 1,
+ std::numeric_limits<double>::max()};
+ TRACED_FOREACH(int, x, kIntValues) {
+ TRACED_FOREACH(double, y, kDoubleValues) {
+ hash<Foo> h;
+ Foo foo = {x, y};
+ EXPECT_EQ(hash_combine(x, y), h(foo));
+ }
+ }
+}
+
+
+TEST(FunctionalTest, BitEqualToFloat) {
+ bit_equal_to<float> pred;
+ EXPECT_FALSE(pred(0.0f, -0.0f));
+ EXPECT_FALSE(pred(-0.0f, 0.0f));
+ float const qNaN = std::numeric_limits<float>::quiet_NaN();
+ float const sNaN = std::numeric_limits<float>::signaling_NaN();
+ EXPECT_PRED2(pred, qNaN, qNaN);
+ EXPECT_PRED2(pred, sNaN, sNaN);
+}
+
+
+TEST(FunctionalTest, BitHashFloatDifferentForZeroAndMinusZero) {
+ bit_hash<float> h;
+ EXPECT_NE(h(0.0f), h(-0.0f));
+}
+
+
+TEST(FunctionalTest, BitEqualToDouble) {
+ bit_equal_to<double> pred;
+ EXPECT_FALSE(pred(0.0, -0.0));
+ EXPECT_FALSE(pred(-0.0, 0.0));
+ double const qNaN = std::numeric_limits<double>::quiet_NaN();
+ double const sNaN = std::numeric_limits<double>::signaling_NaN();
+ EXPECT_PRED2(pred, qNaN, qNaN);
+ EXPECT_PRED2(pred, sNaN, sNaN);
+}
+
+
+TEST(FunctionalTest, BitHashDoubleDifferentForZeroAndMinusZero) {
+ bit_hash<double> h;
+ EXPECT_NE(h(0.0), h(-0.0));
+}
+
+} // namespace base
+} // namespace v8
--- /dev/null
+// 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/char-predicates.h"
+#include "src/unicode.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace internal {
+
+TEST(CharPredicatesTest, WhiteSpace) {
+ // As of Unicode 6.3.0, \u180E is no longer a white space. We still consider
+ // it to be one though, since JS recognizes all white spaces in Unicode 5.1.
+ EXPECT_TRUE(WhiteSpace::Is(0x0009));
+ EXPECT_TRUE(WhiteSpace::Is(0x000B));
+ EXPECT_TRUE(WhiteSpace::Is(0x000C));
+ EXPECT_TRUE(WhiteSpace::Is(' '));
+ EXPECT_TRUE(WhiteSpace::Is(0x00A0));
+ EXPECT_TRUE(WhiteSpace::Is(0x180E));
+ EXPECT_TRUE(WhiteSpace::Is(0xFEFF));
+}
+
+
+TEST(CharPredicatesTest, WhiteSpaceOrLineTerminator) {
+ // As of Unicode 6.3.0, \u180E is no longer a white space. We still consider
+ // it to be one though, since JS recognizes all white spaces in Unicode 5.1.
+ // White spaces
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x0009));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x000B));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x000C));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(' '));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x00A0));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x180E));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0xFEFF));
+ // Line terminators
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x000A));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x000D));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x2028));
+ EXPECT_TRUE(WhiteSpaceOrLineTerminator::Is(0x2029));
+}
+
+
+TEST(CharPredicatesTest, IdentifierStart) {
+ EXPECT_TRUE(IdentifierStart::Is('$'));
+ EXPECT_TRUE(IdentifierStart::Is('_'));
+ EXPECT_TRUE(IdentifierStart::Is('\\'));
+
+ // http://www.unicode.org/reports/tr31/
+ // Other_ID_Start
+ EXPECT_TRUE(IdentifierStart::Is(0x2118));
+ EXPECT_TRUE(IdentifierStart::Is(0x212E));
+ EXPECT_TRUE(IdentifierStart::Is(0x309B));
+ EXPECT_TRUE(IdentifierStart::Is(0x309C));
+
+ // Issue 2892:
+ // \u2E2F has the Pattern_Syntax property, excluding it from ID_Start.
+ EXPECT_FALSE(unibrow::ID_Start::Is(0x2E2F));
+}
+
+
+TEST(CharPredicatesTest, IdentifierPart) {
+ EXPECT_TRUE(IdentifierPart::Is('$'));
+ EXPECT_TRUE(IdentifierPart::Is('_'));
+ EXPECT_TRUE(IdentifierPart::Is('\\'));
+ EXPECT_TRUE(IdentifierPart::Is(0x200C));
+ EXPECT_TRUE(IdentifierPart::Is(0x200D));
+
+ // http://www.unicode.org/reports/tr31/
+ // Other_ID_Start
+ EXPECT_TRUE(IdentifierPart::Is(0x2118));
+ EXPECT_TRUE(IdentifierPart::Is(0x212E));
+ EXPECT_TRUE(IdentifierPart::Is(0x309B));
+ EXPECT_TRUE(IdentifierPart::Is(0x309C));
+
+ // Other_ID_Continue
+ EXPECT_TRUE(IdentifierPart::Is(0x00B7));
+ EXPECT_TRUE(IdentifierPart::Is(0x0387));
+ EXPECT_TRUE(IdentifierPart::Is(0x1369));
+ EXPECT_TRUE(IdentifierPart::Is(0x1370));
+ EXPECT_TRUE(IdentifierPart::Is(0x1371));
+ EXPECT_TRUE(IdentifierPart::Is(0x19DA));
+
+ // Issue 2892:
+ // \u2E2F has the Pattern_Syntax property, excluding it from ID_Start.
+ EXPECT_FALSE(IdentifierPart::Is(0x2E2F));
+}
+
+
+#ifdef V8_I18N_SUPPORT
+TEST(CharPredicatesTest, SupplementaryPlaneIdentifiers) {
+ // Both ID_Start and ID_Continue.
+ EXPECT_TRUE(IdentifierStart::Is(0x10403)); // Category Lu
+ EXPECT_TRUE(IdentifierPart::Is(0x10403));
+ EXPECT_TRUE(IdentifierStart::Is(0x1043C)); // Category Ll
+ EXPECT_TRUE(IdentifierPart::Is(0x1043C));
+ EXPECT_TRUE(IdentifierStart::Is(0x16F9C)); // Category Lm
+ EXPECT_TRUE(IdentifierPart::Is(0x16F9C));
+ EXPECT_TRUE(IdentifierStart::Is(0x10048)); // Category Lo
+ EXPECT_TRUE(IdentifierPart::Is(0x10048));
+ EXPECT_TRUE(IdentifierStart::Is(0x1014D)); // Category Nl
+ EXPECT_TRUE(IdentifierPart::Is(0x1014D));
+
+ // Only ID_Continue.
+ EXPECT_FALSE(IdentifierStart::Is(0x101FD)); // Category Mn
+ EXPECT_TRUE(IdentifierPart::Is(0x101FD));
+ EXPECT_FALSE(IdentifierStart::Is(0x11002)); // Category Mc
+ EXPECT_TRUE(IdentifierPart::Is(0x11002));
+ EXPECT_FALSE(IdentifierStart::Is(0x104A9)); // Category Nd
+ EXPECT_TRUE(IdentifierPart::Is(0x104A9));
+
+ // Neither.
+ EXPECT_FALSE(IdentifierStart::Is(0x10111)); // Category No
+ EXPECT_FALSE(IdentifierPart::Is(0x10111));
+ EXPECT_FALSE(IdentifierStart::Is(0x1F4A9)); // Category So
+ EXPECT_FALSE(IdentifierPart::Is(0x1F4A9));
+}
+#endif // V8_I18N_SUPPORT
+
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/instruction-selector-unittest.h"
+#include <limits>
+
+#include "test/unittests/compiler/instruction-selector-unittest.h"
namespace v8 {
namespace internal {
// Immediates (random subset).
static const int32_t kImmediates[] = {
- -2147483617, -2147483606, -2113929216, -2080374784, -1996488704,
- -1879048192, -1459617792, -1358954496, -1342177265, -1275068414,
- -1073741818, -1073741777, -855638016, -805306368, -402653184,
- -268435444, -16777216, 0, 35, 61,
- 105, 116, 171, 245, 255,
- 692, 1216, 1248, 1520, 1600,
- 1888, 3744, 4080, 5888, 8384,
- 9344, 9472, 9792, 13312, 15040,
- 15360, 20736, 22272, 23296, 32000,
- 33536, 37120, 45824, 47872, 56320,
- 59392, 65280, 72704, 101376, 147456,
- 161792, 164864, 167936, 173056, 195584,
- 209920, 212992, 356352, 655360, 704512,
- 716800, 851968, 901120, 1044480, 1523712,
- 2572288, 3211264, 3588096, 3833856, 3866624,
- 4325376, 5177344, 6488064, 7012352, 7471104,
- 14090240, 16711680, 19398656, 22282240, 28573696,
- 30408704, 30670848, 43253760, 54525952, 55312384,
- 56623104, 68157440, 115343360, 131072000, 187695104,
- 188743680, 195035136, 197132288, 203423744, 218103808,
- 267386880, 268435470, 285212672, 402653185, 415236096,
- 595591168, 603979776, 603979778, 629145600, 1073741835,
- 1073741855, 1073741861, 1073741884, 1157627904, 1476395008,
- 1476395010, 1610612741, 2030043136, 2080374785, 2097152000};
+ std::numeric_limits<int32_t>::min(), -2147483617, -2147483606, -2113929216,
+ -2080374784, -1996488704, -1879048192, -1459617792,
+ -1358954496, -1342177265, -1275068414, -1073741818,
+ -1073741777, -855638016, -805306368, -402653184,
+ -268435444, -16777216, 0, 35,
+ 61, 105, 116, 171,
+ 245, 255, 692, 1216,
+ 1248, 1520, 1600, 1888,
+ 3744, 4080, 5888, 8384,
+ 9344, 9472, 9792, 13312,
+ 15040, 15360, 20736, 22272,
+ 23296, 32000, 33536, 37120,
+ 45824, 47872, 56320, 59392,
+ 65280, 72704, 101376, 147456,
+ 161792, 164864, 167936, 173056,
+ 195584, 209920, 212992, 356352,
+ 655360, 704512, 716800, 851968,
+ 901120, 1044480, 1523712, 2572288,
+ 3211264, 3588096, 3833856, 3866624,
+ 4325376, 5177344, 6488064, 7012352,
+ 7471104, 14090240, 16711680, 19398656,
+ 22282240, 28573696, 30408704, 30670848,
+ 43253760, 54525952, 55312384, 56623104,
+ 68157440, 115343360, 131072000, 187695104,
+ 188743680, 195035136, 197132288, 203423744,
+ 218103808, 267386880, 268435470, 285212672,
+ 402653185, 415236096, 595591168, 603979776,
+ 603979778, 629145600, 1073741835, 1073741855,
+ 1073741861, 1073741884, 1157627904, 1476395008,
+ 1476395010, 1610612741, 2030043136, 2080374785,
+ 2097152000};
} // namespace
std::ostream& operator<<(std::ostream& os, const MemoryAccess& memacc) {
- OStringStream ost;
- ost << memacc.type;
- return os << ost.c_str();
+ return os << memacc.type;
}
// -----------------------------------------------------------------------------
+// Comparisons.
+
+
+namespace {
+
+struct Comparison {
+ Constructor constructor;
+ const char* constructor_name;
+ FlagsCondition flags_condition;
+ FlagsCondition negated_flags_condition;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const Comparison& cmp) {
+ return os << cmp.constructor_name;
+}
+
+
+const Comparison kComparisons[] = {
+ {&RawMachineAssembler::Word32Equal, "Word32Equal", kEqual, kNotEqual},
+ {&RawMachineAssembler::Int32LessThan, "Int32LessThan", kSignedLessThan,
+ kSignedGreaterThanOrEqual},
+ {&RawMachineAssembler::Int32LessThanOrEqual, "Int32LessThanOrEqual",
+ kSignedLessThanOrEqual, kSignedGreaterThan},
+ {&RawMachineAssembler::Uint32LessThan, "Uint32LessThan", kUnsignedLessThan,
+ kUnsignedGreaterThanOrEqual},
+ {&RawMachineAssembler::Uint32LessThanOrEqual, "Uint32LessThanOrEqual",
+ kUnsignedLessThanOrEqual, kUnsignedGreaterThan}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<Comparison>
+ InstructionSelectorComparisonTest;
+
+
+TEST_P(InstructionSelectorComparisonTest, Parameters) {
+ const Comparison& cmp = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const r = (m.*cmp.constructor)(p0, p1);
+ m.Return(r);
+ Stream const s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(r), s.ToVreg(s[0]->OutputAt(0)));
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.flags_condition, s[0]->flags_condition());
+}
+
+
+TEST_P(InstructionSelectorComparisonTest, Word32EqualWithZero) {
+ {
+ const Comparison& cmp = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const r =
+ m.Word32Equal((m.*cmp.constructor)(p0, p1), m.Int32Constant(0));
+ m.Return(r);
+ Stream const s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(r), s.ToVreg(s[0]->OutputAt(0)));
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.negated_flags_condition, s[0]->flags_condition());
+ }
+ {
+ const Comparison& cmp = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const r =
+ m.Word32Equal(m.Int32Constant(0), (m.*cmp.constructor)(p0, p1));
+ m.Return(r);
+ Stream const s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(r), s.ToVreg(s[0]->OutputAt(0)));
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.negated_flags_condition, s[0]->flags_condition());
+ }
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorComparisonTest,
+ ::testing::ValuesIn(kComparisons));
+
+
+// -----------------------------------------------------------------------------
// Miscellaneous.
TEST_F(InstructionSelectorTest, Int32AddWithInt32Mul) {
{
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
- m.Return(
- m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const p2 = m.Parameter(2);
+ Node* const n = m.Int32Add(p0, m.Int32Mul(p1, p2));
+ m.Return(n);
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArmMla, s[0]->arch_opcode());
- EXPECT_EQ(3U, s[0]->InputCount());
- EXPECT_EQ(1U, s[0]->OutputCount());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p2), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(2)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
}
{
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
- m.Return(
- m.Int32Add(m.Int32Mul(m.Parameter(1), m.Parameter(2)), m.Parameter(0)));
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const p2 = m.Parameter(2);
+ Node* const n = m.Int32Add(m.Int32Mul(p1, p2), p0);
+ m.Return(n);
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArmMla, s[0]->arch_opcode());
- EXPECT_EQ(3U, s[0]->InputCount());
- EXPECT_EQ(1U, s[0]->OutputCount());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p2), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(2)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
}
}
+TEST_F(InstructionSelectorTest, Int32AddWithInt32MulHigh) {
+ {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const p2 = m.Parameter(2);
+ Node* const n = m.Int32Add(p0, m.Int32MulHigh(p1, p2));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmSmmla, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p2), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(2)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ }
+ {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const p2 = m.Parameter(2);
+ Node* const n = m.Int32Add(m.Int32MulHigh(p1, p2), p0);
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmSmmla, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p2), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(2)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Int32SubWithInt32Mul) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
+ m.Return(
+ m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(kArmMul, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kArmSub, s[1]->arch_opcode());
+ ASSERT_EQ(2U, s[1]->InputCount());
+ EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(1)));
+}
+
+
+TEST_F(InstructionSelectorTest, Int32SubWithInt32MulForMLS) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
+ m.Return(
+ m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
+ Stream s = m.Build(MLS);
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmMls, s[0]->arch_opcode());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(3U, s[0]->InputCount());
+}
+
+
TEST_F(InstructionSelectorTest, Int32DivWithParameters) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
m.Return(m.Int32Div(m.Parameter(0), m.Parameter(1)));
}
-TEST_F(InstructionSelectorTest, Int32SubWithInt32Mul) {
- StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
- m.Return(
- m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
+TEST_F(InstructionSelectorTest, Int32MulHighWithParameters) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Int32MulHigh(p0, p1);
+ m.Return(n);
Stream s = m.Build();
- ASSERT_EQ(2U, s.size());
- EXPECT_EQ(kArmMul, s[0]->arch_opcode());
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArmSmmul, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
ASSERT_EQ(1U, s[0]->OutputCount());
- EXPECT_EQ(kArmSub, s[1]->arch_opcode());
- ASSERT_EQ(2U, s[1]->InputCount());
- EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(1)));
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
}
-TEST_F(InstructionSelectorTest, Int32SubWithInt32MulForMLS) {
- StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
- m.Return(
- m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
- Stream s = m.Build(MLS);
+TEST_F(InstructionSelectorTest, Uint32MulHighWithParameters) {
+ StreamBuilder m(this, kMachUint32, kMachUint32, kMachUint32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Uint32MulHigh(p0, p1);
+ m.Return(n);
+ Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(kArmMls, s[0]->arch_opcode());
- EXPECT_EQ(1U, s[0]->OutputCount());
- EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(kArmUmull, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(2U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->OutputAt(1)));
}
-TEST_F(InstructionSelectorTest, Int32UDivWithParameters) {
+TEST_F(InstructionSelectorTest, Uint32DivWithParameters) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- m.Return(m.Int32UDiv(m.Parameter(0), m.Parameter(1)));
+ m.Return(m.Uint32Div(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build();
ASSERT_EQ(4U, s.size());
EXPECT_EQ(kArmVcvtF64U32, s[0]->arch_opcode());
}
-TEST_F(InstructionSelectorTest, Int32UDivWithParametersForSUDIV) {
+TEST_F(InstructionSelectorTest, Uint32DivWithParametersForSUDIV) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- m.Return(m.Int32UDiv(m.Parameter(0), m.Parameter(1)));
+ m.Return(m.Uint32Div(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build(SUDIV);
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
}
-TEST_F(InstructionSelectorTest, Int32UModWithParameters) {
+TEST_F(InstructionSelectorTest, Uint32ModWithParameters) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
+ m.Return(m.Uint32Mod(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build();
ASSERT_EQ(6U, s.size());
EXPECT_EQ(kArmVcvtF64U32, s[0]->arch_opcode());
}
-TEST_F(InstructionSelectorTest, Int32UModWithParametersForSUDIV) {
+TEST_F(InstructionSelectorTest, Uint32ModWithParametersForSUDIV) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
+ m.Return(m.Uint32Mod(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build(SUDIV);
ASSERT_EQ(3U, s.size());
EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
}
-TEST_F(InstructionSelectorTest, Int32UModWithParametersForSUDIVAndMLS) {
+TEST_F(InstructionSelectorTest, Uint32ModWithParametersForSUDIVAndMLS) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
- m.Return(m.Int32UMod(m.Parameter(0), m.Parameter(1)));
+ m.Return(m.Uint32Mod(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build(MLS, SUDIV);
ASSERT_EQ(2U, s.size());
EXPECT_EQ(kArmUdiv, s[0]->arch_opcode());
TEST_F(InstructionSelectorTest, Word32AndWithBfcImmediateForARMv7) {
TRACED_FORRANGE(int32_t, lsb, 0, 31) {
- TRACED_FORRANGE(int32_t, width, 1, (32 - lsb) - 1) {
+ TRACED_FORRANGE(int32_t, width, 9, (32 - lsb) - 1) {
StreamBuilder m(this, kMachInt32, kMachInt32);
m.Return(m.Word32And(
m.Parameter(0),
}
}
TRACED_FORRANGE(int32_t, lsb, 0, 31) {
- TRACED_FORRANGE(int32_t, width, 1, (32 - lsb) - 1) {
+ TRACED_FORRANGE(int32_t, width, 9, (32 - lsb) - 1) {
StreamBuilder m(this, kMachInt32, kMachInt32);
m.Return(
m.Word32And(m.Int32Constant(~((0xffffffffu >> (32 - width)) << lsb)),
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <list>
-
-#include "src/compiler/instruction-selector-unittest.h"
+#include "test/unittests/compiler/instruction-selector-unittest.h"
namespace v8 {
namespace internal {
}
+struct Shift {
+ MachInst2 mi;
+ AddressingMode mode;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const Shift& shift) {
+ return os << shift.mi;
+}
+
+
// Helper to build Int32Constant or Int64Constant depending on the given
// machine type.
Node* BuildConstant(InstructionSelectorTest::StreamBuilder& m, MachineType type,
// ARM64 logical immediates: contiguous set bits, rotated about a power of two
// sized block. The block is then duplicated across the word. Below is a random
// subset of the 32-bit immediates.
-static const uint32_t kLogicalImmediates[] = {
+static const uint32_t kLogical32Immediates[] = {
0x00000002, 0x00000003, 0x00000070, 0x00000080, 0x00000100, 0x000001c0,
0x00000300, 0x000007e0, 0x00003ffc, 0x00007fc0, 0x0003c000, 0x0003f000,
0x0003ffc0, 0x0003fff8, 0x0007ff00, 0x0007ffe0, 0x000e0000, 0x001e0000,
0xfffff807, 0xfffff9ff, 0xfffffc0f, 0xfffffeff};
+// Random subset of 64-bit logical immediates.
+static const uint64_t kLogical64Immediates[] = {
+ 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
+ 0x0000000000000070, 0x0000000000000080, 0x0000000000000100,
+ 0x00000000000001c0, 0x0000000000000300, 0x0000000000000600,
+ 0x00000000000007e0, 0x0000000000003ffc, 0x0000000000007fc0,
+ 0x0000000600000000, 0x0000003ffffffffc, 0x000000f000000000,
+ 0x000001f800000000, 0x0003fc0000000000, 0x0003fc000003fc00,
+ 0x0003ffffffc00000, 0x0003ffffffffffc0, 0x0006000000060000,
+ 0x003ffffffffc0000, 0x0180018001800180, 0x01f801f801f801f8,
+ 0x0600000000000000, 0x1000000010000000, 0x1000100010001000,
+ 0x1010101010101010, 0x1111111111111111, 0x1f001f001f001f00,
+ 0x1f1f1f1f1f1f1f1f, 0x1ffffffffffffffe, 0x3ffc3ffc3ffc3ffc,
+ 0x5555555555555555, 0x7f7f7f7f7f7f7f7f, 0x8000000000000000,
+ 0x8000001f8000001f, 0x8181818181818181, 0x9999999999999999,
+ 0x9fff9fff9fff9fff, 0xaaaaaaaaaaaaaaaa, 0xdddddddddddddddd,
+ 0xe0000000000001ff, 0xf800000000000000, 0xf8000000000001ff,
+ 0xf807f807f807f807, 0xfefefefefefefefe, 0xfffefffefffefffe,
+ 0xfffff807fffff807, 0xfffff9fffffff9ff, 0xfffffc0ffffffc0f,
+ 0xfffffc0fffffffff, 0xfffffefffffffeff, 0xfffffeffffffffff,
+ 0xffffff8000000000, 0xfffffffefffffffe, 0xffffffffefffffff,
+ 0xfffffffff9ffffff, 0xffffffffff800000, 0xffffffffffffc0ff,
+ 0xfffffffffffffffe};
+
+
// ARM64 arithmetic instructions.
-static const MachInst2 kAddSubInstructions[] = {
- {&RawMachineAssembler::Int32Add, "Int32Add", kArm64Add32, kMachInt32},
- {&RawMachineAssembler::Int64Add, "Int64Add", kArm64Add, kMachInt64},
- {&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Sub32, kMachInt32},
- {&RawMachineAssembler::Int64Sub, "Int64Sub", kArm64Sub, kMachInt64}};
+struct AddSub {
+ MachInst2 mi;
+ ArchOpcode negate_arch_opcode;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const AddSub& op) {
+ return os << op.mi;
+}
+
+
+static const AddSub kAddSubInstructions[] = {
+ {{&RawMachineAssembler::Int32Add, "Int32Add", kArm64Add32, kMachInt32},
+ kArm64Sub32},
+ {{&RawMachineAssembler::Int64Add, "Int64Add", kArm64Add, kMachInt64},
+ kArm64Sub},
+ {{&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Sub32, kMachInt32},
+ kArm64Add32},
+ {{&RawMachineAssembler::Int64Sub, "Int64Sub", kArm64Sub, kMachInt64},
+ kArm64Add}};
// ARM64 Add/Sub immediates: 12-bit immediate optionally shifted by 12.
static const MachInst2 kDPFlagSetInstructions[] = {
{&RawMachineAssembler::Word32And, "Word32And", kArm64Tst32, kMachInt32},
{&RawMachineAssembler::Int32Add, "Int32Add", kArm64Cmn32, kMachInt32},
- {&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Cmp32, kMachInt32}};
+ {&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Cmp32, kMachInt32},
+ {&RawMachineAssembler::Word64And, "Word64And", kArm64Tst, kMachInt64}};
// ARM64 arithmetic with overflow instructions.
// ARM64 shift instructions.
-static const MachInst2 kShiftInstructions[] = {
- {&RawMachineAssembler::Word32Shl, "Word32Shl", kArm64Shl32, kMachInt32},
- {&RawMachineAssembler::Word64Shl, "Word64Shl", kArm64Shl, kMachInt64},
- {&RawMachineAssembler::Word32Shr, "Word32Shr", kArm64Shr32, kMachInt32},
- {&RawMachineAssembler::Word64Shr, "Word64Shr", kArm64Shr, kMachInt64},
- {&RawMachineAssembler::Word32Sar, "Word32Sar", kArm64Sar32, kMachInt32},
- {&RawMachineAssembler::Word64Sar, "Word64Sar", kArm64Sar, kMachInt64},
- {&RawMachineAssembler::Word32Ror, "Word32Ror", kArm64Ror32, kMachInt32},
- {&RawMachineAssembler::Word64Ror, "Word64Ror", kArm64Ror, kMachInt64}};
+static const Shift kShiftInstructions[] = {
+ {{&RawMachineAssembler::Word32Shl, "Word32Shl", kArm64Lsl32, kMachInt32},
+ kMode_Operand2_R_LSL_I},
+ {{&RawMachineAssembler::Word64Shl, "Word64Shl", kArm64Lsl, kMachInt64},
+ kMode_Operand2_R_LSL_I},
+ {{&RawMachineAssembler::Word32Shr, "Word32Shr", kArm64Lsr32, kMachInt32},
+ kMode_Operand2_R_LSR_I},
+ {{&RawMachineAssembler::Word64Shr, "Word64Shr", kArm64Lsr, kMachInt64},
+ kMode_Operand2_R_LSR_I},
+ {{&RawMachineAssembler::Word32Sar, "Word32Sar", kArm64Asr32, kMachInt32},
+ kMode_Operand2_R_ASR_I},
+ {{&RawMachineAssembler::Word64Sar, "Word64Sar", kArm64Asr, kMachInt64},
+ kMode_Operand2_R_ASR_I},
+ {{&RawMachineAssembler::Word32Ror, "Word32Ror", kArm64Ror32, kMachInt32},
+ kMode_Operand2_R_ROR_I},
+ {{&RawMachineAssembler::Word64Ror, "Word64Ror", kArm64Ror, kMachInt64},
+ kMode_Operand2_R_ROR_I}};
// ARM64 Mul/Div instructions.
{&RawMachineAssembler::Int64Mul, "Int64Mul", kArm64Mul, kMachInt64},
{&RawMachineAssembler::Int32Div, "Int32Div", kArm64Idiv32, kMachInt32},
{&RawMachineAssembler::Int64Div, "Int64Div", kArm64Idiv, kMachInt64},
- {&RawMachineAssembler::Int32UDiv, "Int32UDiv", kArm64Udiv32, kMachInt32},
- {&RawMachineAssembler::Int64UDiv, "Int64UDiv", kArm64Udiv, kMachInt64}};
+ {&RawMachineAssembler::Uint32Div, "Uint32Div", kArm64Udiv32, kMachInt32},
+ {&RawMachineAssembler::Uint64Div, "Uint64Div", kArm64Udiv, kMachInt64}};
// ARM64 FP arithmetic instructions.
// TODO(all): Add support for testing 64-bit immediates.
if (type == kMachInt32) {
// Immediate on the right.
- TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
+ TRACED_FOREACH(int32_t, imm, kLogical32Immediates) {
StreamBuilder m(this, type, type);
m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
Stream s = m.Build();
}
// Immediate on the left; all logical ops should commute.
- TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
+ TRACED_FOREACH(int32_t, imm, kLogical32Immediates) {
StreamBuilder m(this, type, type);
m.Return((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)));
Stream s = m.Build();
}
+TEST_P(InstructionSelectorLogicalTest, ShiftByImmediate) {
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test 64-bit shifted operands with 64-bit instructions.
+ if (shift.mi.machine_type != type) continue;
+
+ TRACED_FORRANGE(int, imm, 0, ((type == kMachInt32) ? 31 : 63)) {
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.constructor)(
+ m.Parameter(0),
+ (m.*shift.mi.constructor)(m.Parameter(1),
+ BuildConstant(m, type, imm))));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, 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());
+ }
+
+ TRACED_FORRANGE(int, imm, 0, ((type == kMachInt32) ? 31 : 63)) {
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.constructor)(
+ (m.*shift.mi.constructor)(m.Parameter(1),
+ BuildConstant(m, type, imm)),
+ m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, 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());
+ }
+ }
+}
+
+
INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorLogicalTest,
::testing::ValuesIn(kLogicalInstructions));
// -----------------------------------------------------------------------------
// Add and Sub instructions.
-typedef InstructionSelectorTestWithParam<MachInst2>
- InstructionSelectorAddSubTest;
+typedef InstructionSelectorTestWithParam<AddSub> InstructionSelectorAddSubTest;
TEST_P(InstructionSelectorAddSubTest, Parameter) {
- const MachInst2 dpi = GetParam();
- const MachineType type = dpi.machine_type;
+ const AddSub dpi = GetParam();
+ const MachineType type = dpi.mi.machine_type;
StreamBuilder m(this, type, type, type);
- m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+ m.Return((m.*dpi.mi.constructor)(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(dpi.mi.arch_opcode, s[0]->arch_opcode());
EXPECT_EQ(2U, s[0]->InputCount());
EXPECT_EQ(1U, s[0]->OutputCount());
}
TEST_P(InstructionSelectorAddSubTest, ImmediateOnRight) {
- const MachInst2 dpi = GetParam();
- const MachineType type = dpi.machine_type;
+ const AddSub dpi = GetParam();
+ const MachineType type = dpi.mi.machine_type;
TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
StreamBuilder m(this, type, type);
- m.Return((m.*dpi.constructor)(m.Parameter(0), BuildConstant(m, type, imm)));
+ m.Return(
+ (m.*dpi.mi.constructor)(m.Parameter(0), BuildConstant(m, type, imm)));
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(dpi.mi.arch_opcode, s[0]->arch_opcode());
ASSERT_EQ(2U, s[0]->InputCount());
EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
}
-TEST_P(InstructionSelectorAddSubTest, ImmediateOnLeft) {
- const MachInst2 dpi = GetParam();
- const MachineType type = dpi.machine_type;
-
+TEST_P(InstructionSelectorAddSubTest, NegImmediateOnRight) {
+ const AddSub dpi = GetParam();
+ const MachineType type = dpi.mi.machine_type;
TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ if (imm == 0) continue;
StreamBuilder m(this, type, type);
- m.Return((m.*dpi.constructor)(BuildConstant(m, type, imm), m.Parameter(0)));
+ m.Return(
+ (m.*dpi.mi.constructor)(m.Parameter(0), BuildConstant(m, type, -imm)));
Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.negate_arch_opcode, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+}
+
- // Add can support an immediate on the left by commuting, but Sub can't
- // commute. We test zero-on-left Sub later.
- if (strstr(dpi.constructor_name, "Add") != NULL) {
+TEST_P(InstructionSelectorAddSubTest, ShiftByImmediateOnRight) {
+ const AddSub dpi = GetParam();
+ const MachineType type = dpi.mi.machine_type;
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test 64-bit shifted operands with 64-bit instructions.
+ if (shift.mi.machine_type != type) continue;
+
+ if ((shift.mi.arch_opcode == kArm64Ror32) ||
+ (shift.mi.arch_opcode == kArm64Ror)) {
+ // Not supported by add/sub instructions.
+ continue;
+ }
+
+ TRACED_FORRANGE(int, imm, 0, ((type == kMachInt32) ? 31 : 63)) {
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.mi.constructor)(
+ m.Parameter(0),
+ (m.*shift.mi.constructor)(m.Parameter(1),
+ BuildConstant(m, type, imm))));
+ Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
- ASSERT_EQ(2U, s[0]->InputCount());
- EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
- EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
+ EXPECT_EQ(dpi.mi.arch_opcode, 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());
}
}
::testing::ValuesIn(kAddSubInstructions));
+TEST_F(InstructionSelectorTest, AddImmediateOnLeft) {
+ {
+ // 32-bit add.
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Int32Constant(imm), m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Add32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+ }
+ {
+ // 64-bit add.
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Int64Add(m.Int64Constant(imm), m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Add, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+ }
+}
+
+
TEST_F(InstructionSelectorTest, SubZeroOnLeft) {
// Subtraction with zero on the left maps to Neg.
{
}
+TEST_F(InstructionSelectorTest, AddNegImmediateOnLeft) {
+ {
+ // 32-bit add.
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ if (imm == 0) continue;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Int32Add(m.Int32Constant(-imm), m.Parameter(0)));
+ Stream s = m.Build();
+
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Sub32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+ }
+ {
+ // 64-bit add.
+ TRACED_FOREACH(int32_t, imm, kAddSubImmediates) {
+ if (imm == 0) continue;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Int64Add(m.Int64Constant(-imm), m.Parameter(0)));
+ Stream s = m.Build();
+
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Sub, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt64(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, AddShiftByImmediateOnLeft) {
+ // 32-bit add.
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test relevant shifted operands.
+ if (shift.mi.machine_type != kMachInt32) continue;
+ if (shift.mi.arch_opcode == kArm64Ror32) continue;
+
+ TRACED_FORRANGE(int, imm, 0, 31) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ m.Return((m.Int32Add)(
+ (m.*shift.mi.constructor)(m.Parameter(1), m.Int32Constant(imm)),
+ m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Add32, 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());
+ }
+ }
+
+ // 64-bit add.
+ TRACED_FOREACH(Shift, shift, kShiftInstructions) {
+ // Only test relevant shifted operands.
+ if (shift.mi.machine_type != kMachInt64) continue;
+ if (shift.mi.arch_opcode == kArm64Ror) continue;
+
+ TRACED_FORRANGE(int, imm, 0, 63) {
+ StreamBuilder m(this, kMachInt64, kMachInt64, kMachInt64);
+ m.Return((m.Int64Add)(
+ (m.*shift.mi.constructor)(m.Parameter(1), m.Int64Constant(imm)),
+ m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Add, 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());
+ }
+ }
+}
+
+
// -----------------------------------------------------------------------------
// Data processing controlled branches.
::testing::ValuesIn(kDPFlagSetInstructions));
-TEST_F(InstructionSelectorTest, AndBranchWithImmediateOnRight) {
- TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
+TEST_F(InstructionSelectorTest, Word32AndBranchWithImmediateOnRight) {
+ TRACED_FOREACH(int32_t, imm, kLogical32Immediates) {
+ // Skip the cases where the instruction selector would use tbz/tbnz.
+ if (base::bits::CountPopulation32(imm) == 1) continue;
+
StreamBuilder m(this, kMachInt32, kMachInt32);
MLabel a, b;
m.Branch(m.Word32And(m.Parameter(0), m.Int32Constant(imm)), &a, &b);
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArm64Tst32, s[0]->arch_opcode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word64AndBranchWithImmediateOnRight) {
+ TRACED_FOREACH(int64_t, imm, kLogical64Immediates) {
+ // Skip the cases where the instruction selector would use tbz/tbnz.
+ if (base::bits::CountPopulation64(imm) == 1) continue;
+
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(m.Word64And(m.Parameter(0), m.Int64Constant(imm)), &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(kArm64Tst, s[0]->arch_opcode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
EXPECT_EQ(kNotEqual, s[0]->flags_condition());
}
}
-TEST_F(InstructionSelectorTest, AndBranchWithImmediateOnLeft) {
- TRACED_FOREACH(int32_t, imm, kLogicalImmediates) {
+TEST_F(InstructionSelectorTest, Word32AndBranchWithImmediateOnLeft) {
+ TRACED_FOREACH(int32_t, imm, kLogical32Immediates) {
+ // Skip the cases where the instruction selector would use tbz/tbnz.
+ if (base::bits::CountPopulation32(imm) == 1) continue;
+
StreamBuilder m(this, kMachInt32, kMachInt32);
MLabel a, b;
m.Branch(m.Word32And(m.Int32Constant(imm), m.Parameter(0)), &a, &b);
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
EXPECT_EQ(kArm64Tst32, s[0]->arch_opcode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ ASSERT_LE(1U, s[0]->InputCount());
+ EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
+ EXPECT_EQ(kNotEqual, s[0]->flags_condition());
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word64AndBranchWithImmediateOnLeft) {
+ TRACED_FOREACH(int64_t, imm, kLogical64Immediates) {
+ // Skip the cases where the instruction selector would use tbz/tbnz.
+ if (base::bits::CountPopulation64(imm) == 1) continue;
+
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(m.Word64And(m.Int64Constant(imm), m.Parameter(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(kArm64Tst, s[0]->arch_opcode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
ASSERT_LE(1U, s[0]->InputCount());
EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
EXPECT_EQ(kNotEqual, s[0]->flags_condition());
}
+TEST_F(InstructionSelectorTest, Word32AndBranchWithOneBitMaskOnRight) {
+ TRACED_FORRANGE(int, bit, 0, 31) {
+ uint32_t mask = 1 << bit;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ MLabel a, b;
+ m.Branch(m.Word32And(m.Parameter(0), m.Int32Constant(mask)), &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(kArm64Tbnz32, s[0]->arch_opcode());
+ 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, kMachInt32, kMachInt32);
+ MLabel a, b;
+ m.Branch(
+ m.Word32BinaryNot(m.Word32And(m.Parameter(0), m.Int32Constant(mask))),
+ &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(kArm64Tbz32, s[0]->arch_opcode());
+ 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, Word32AndBranchWithOneBitMaskOnLeft) {
+ TRACED_FORRANGE(int, bit, 0, 31) {
+ uint32_t mask = 1 << bit;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ MLabel a, b;
+ m.Branch(m.Word32And(m.Int32Constant(mask), m.Parameter(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(kArm64Tbnz32, s[0]->arch_opcode());
+ 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, kMachInt32, kMachInt32);
+ MLabel a, b;
+ m.Branch(
+ m.Word32BinaryNot(m.Word32And(m.Int32Constant(mask), m.Parameter(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(kArm64Tbz32, s[0]->arch_opcode());
+ 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, Word64AndBranchWithOneBitMaskOnRight) {
+ TRACED_FORRANGE(int, bit, 0, 63) {
+ uint64_t mask = 1L << bit;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(m.Word64And(m.Parameter(0), m.Int64Constant(mask)), &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(kArm64Tbnz, s[0]->arch_opcode());
+ 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 = 1L << bit;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(
+ m.Word64BinaryNot(m.Word64And(m.Parameter(0), m.Int64Constant(mask))),
+ &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(kArm64Tbz, s[0]->arch_opcode());
+ 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, Word64AndBranchWithOneBitMaskOnLeft) {
+ TRACED_FORRANGE(int, bit, 0, 63) {
+ uint64_t mask = 1L << bit;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(m.Word64And(m.Int64Constant(mask), m.Parameter(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(kArm64Tbnz, s[0]->arch_opcode());
+ 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 = 1L << bit;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ MLabel a, b;
+ m.Branch(
+ m.Word64BinaryNot(m.Word64And(m.Int64Constant(mask), m.Parameter(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(kArm64Tbz, s[0]->arch_opcode());
+ EXPECT_EQ(4U, s[0]->InputCount());
+ EXPECT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(bit, s.ToInt64(s[0]->InputAt(1)));
+ }
+}
+
+
// -----------------------------------------------------------------------------
// Add and subtract instructions with overflow.
// Shift instructions.
-typedef InstructionSelectorTestWithParam<MachInst2>
- InstructionSelectorShiftTest;
+typedef InstructionSelectorTestWithParam<Shift> InstructionSelectorShiftTest;
TEST_P(InstructionSelectorShiftTest, Parameter) {
- const MachInst2 dpi = GetParam();
- const MachineType type = dpi.machine_type;
+ const Shift shift = GetParam();
+ const MachineType type = shift.mi.machine_type;
StreamBuilder m(this, type, type, type);
- m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+ m.Return((m.*shift.mi.constructor)(m.Parameter(0), m.Parameter(1)));
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(shift.mi.arch_opcode, s[0]->arch_opcode());
EXPECT_EQ(2U, s[0]->InputCount());
EXPECT_EQ(1U, s[0]->OutputCount());
}
TEST_P(InstructionSelectorShiftTest, Immediate) {
- const MachInst2 dpi = GetParam();
- const MachineType type = dpi.machine_type;
+ const Shift shift = GetParam();
+ const MachineType type = shift.mi.machine_type;
TRACED_FORRANGE(int32_t, imm, 0, (ElementSizeOf(type) * 8) - 1) {
StreamBuilder m(this, type, type);
- m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
+ m.Return((m.*shift.mi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
Stream s = m.Build();
ASSERT_EQ(1U, s.size());
- EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(shift.mi.arch_opcode, s[0]->arch_opcode());
EXPECT_EQ(2U, s[0]->InputCount());
EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
std::ostream& operator<<(std::ostream& os, const MemoryAccess& memacc) {
- OStringStream ost;
- ost << memacc.type;
- return os << ost.c_str();
+ return os << memacc.type;
}
} // namespace
static const MemoryAccess kMemoryAccesses[] = {
- {kMachInt8, kArm64Ldrsb, kArm64Strb,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 257, 258, 1000, 1001,
- 2121, 2442, 4093, 4094, 4095}},
- {kMachUint8, kArm64Ldrb, kArm64Strb,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 257, 258, 1000, 1001,
- 2121, 2442, 4093, 4094, 4095}},
- {kMachInt16, kArm64Ldrsh, kArm64Strh,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 258, 260, 4096, 4098,
- 4100, 4242, 6786, 8188, 8190}},
- {kMachUint16, kArm64Ldrh, kArm64Strh,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 258, 260, 4096, 4098,
- 4100, 4242, 6786, 8188, 8190}},
- {kMachInt32, kArm64LdrW, kArm64StrW,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192,
- 8196, 3276, 3280, 16376, 16380}},
- {kMachUint32, kArm64LdrW, kArm64StrW,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192,
- 8196, 3276, 3280, 16376, 16380}},
- {kMachInt64, kArm64Ldr, kArm64Str,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192,
- 8200, 16384, 16392, 32752, 32760}},
- {kMachUint64, kArm64Ldr, kArm64Str,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192,
- 8200, 16384, 16392, 32752, 32760}},
- {kMachFloat32, kArm64LdrS, kArm64StrS,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192,
- 8196, 3276, 3280, 16376, 16380}},
- {kMachFloat64, kArm64LdrD, kArm64StrD,
- {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192,
- 8200, 16384, 16392, 32752, 32760}}};
+ {kMachInt8,
+ kArm64Ldrsb,
+ kArm64Strb,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 257, 258, 1000, 1001, 2121,
+ 2442, 4093, 4094, 4095}},
+ {kMachUint8,
+ kArm64Ldrb,
+ kArm64Strb,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 257, 258, 1000, 1001, 2121,
+ 2442, 4093, 4094, 4095}},
+ {kMachInt16,
+ kArm64Ldrsh,
+ kArm64Strh,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 258, 260, 4096, 4098, 4100,
+ 4242, 6786, 8188, 8190}},
+ {kMachUint16,
+ kArm64Ldrh,
+ kArm64Strh,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 258, 260, 4096, 4098, 4100,
+ 4242, 6786, 8188, 8190}},
+ {kMachInt32,
+ kArm64LdrW,
+ kArm64StrW,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192, 8196,
+ 3276, 3280, 16376, 16380}},
+ {kMachUint32,
+ kArm64LdrW,
+ kArm64StrW,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192, 8196,
+ 3276, 3280, 16376, 16380}},
+ {kMachInt64,
+ kArm64Ldr,
+ kArm64Str,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192, 8200,
+ 16384, 16392, 32752, 32760}},
+ {kMachUint64,
+ kArm64Ldr,
+ kArm64Str,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192, 8200,
+ 16384, 16392, 32752, 32760}},
+ {kMachFloat32,
+ kArm64LdrS,
+ kArm64StrS,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 260, 4096, 4100, 8192, 8196,
+ 3276, 3280, 16376, 16380}},
+ {kMachFloat64,
+ kArm64LdrD,
+ kArm64StrD,
+ {-256, -255, -3, -2, -1, 0, 1, 2, 3, 255, 256, 264, 4096, 4104, 8192, 8200,
+ 16384, 16392, 32752, 32760}}};
typedef InstructionSelectorTestWithParam<MemoryAccess>
}
}
+
+TEST_F(InstructionSelectorTest, Word32ShrWithWord32AndWithImmediate) {
+ TRACED_FORRANGE(int32_t, lsb, 1, 31) {
+ TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
+ uint32_t jnk = rng()->NextInt();
+ jnk >>= 32 - lsb;
+ uint32_t msk = ((0xffffffffu >> (32 - width)) << lsb) | jnk;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32Shr(m.Word32And(m.Parameter(0), m.Int32Constant(msk)),
+ m.Int32Constant(lsb)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx32, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
+ }
+ }
+ TRACED_FORRANGE(int32_t, lsb, 1, 31) {
+ TRACED_FORRANGE(int32_t, width, 1, 32 - lsb) {
+ uint32_t jnk = rng()->NextInt();
+ jnk >>= 32 - lsb;
+ uint32_t msk = ((0xffffffffu >> (32 - width)) << lsb) | jnk;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32Shr(m.Word32And(m.Int32Constant(msk), m.Parameter(0)),
+ m.Int32Constant(lsb)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx32, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
+ }
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word64ShrWithWord64AndWithImmediate) {
+ TRACED_FORRANGE(int32_t, lsb, 1, 63) {
+ TRACED_FORRANGE(int32_t, width, 1, 64 - lsb) {
+ uint64_t jnk = rng()->NextInt64();
+ jnk >>= 64 - lsb;
+ uint64_t msk =
+ ((V8_UINT64_C(0xffffffffffffffff) >> (64 - width)) << lsb) | jnk;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Word64Shr(m.Word64And(m.Parameter(0), m.Int64Constant(msk)),
+ m.Int64Constant(lsb)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt64(s[0]->InputAt(1)));
+ EXPECT_EQ(width, s.ToInt64(s[0]->InputAt(2)));
+ }
+ }
+ TRACED_FORRANGE(int32_t, lsb, 1, 63) {
+ TRACED_FORRANGE(int32_t, width, 1, 64 - lsb) {
+ uint64_t jnk = rng()->NextInt64();
+ jnk >>= 64 - lsb;
+ uint64_t msk =
+ ((V8_UINT64_C(0xffffffffffffffff) >> (64 - width)) << lsb) | jnk;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Word64Shr(m.Word64And(m.Int64Constant(msk), m.Parameter(0)),
+ m.Int64Constant(lsb)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt64(s[0]->InputAt(1)));
+ EXPECT_EQ(width, s.ToInt64(s[0]->InputAt(2)));
+ }
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word32AndWithImmediateWithWord32Shr) {
+ TRACED_FORRANGE(int32_t, lsb, 1, 31) {
+ TRACED_FORRANGE(int32_t, width, 1, 31) {
+ uint32_t msk = (1 << width) - 1;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32And(m.Word32Shr(m.Parameter(0), m.Int32Constant(lsb)),
+ m.Int32Constant(msk)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx32, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
+ int32_t actual_width = (lsb + width > 32) ? (32 - lsb) : width;
+ EXPECT_EQ(actual_width, s.ToInt32(s[0]->InputAt(2)));
+ }
+ }
+ TRACED_FORRANGE(int32_t, lsb, 1, 31) {
+ TRACED_FORRANGE(int32_t, width, 1, 31) {
+ uint32_t msk = (1 << width) - 1;
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32And(m.Int32Constant(msk),
+ m.Word32Shr(m.Parameter(0), m.Int32Constant(lsb))));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx32, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
+ int32_t actual_width = (lsb + width > 32) ? (32 - lsb) : width;
+ EXPECT_EQ(actual_width, s.ToInt32(s[0]->InputAt(2)));
+ }
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word64AndWithImmediateWithWord64Shr) {
+ TRACED_FORRANGE(int64_t, lsb, 1, 63) {
+ TRACED_FORRANGE(int64_t, width, 1, 63) {
+ uint64_t msk = (V8_UINT64_C(1) << width) - 1;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Word64And(m.Word64Shr(m.Parameter(0), m.Int64Constant(lsb)),
+ m.Int64Constant(msk)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt64(s[0]->InputAt(1)));
+ int64_t actual_width = (lsb + width > 64) ? (64 - lsb) : width;
+ EXPECT_EQ(actual_width, s.ToInt64(s[0]->InputAt(2)));
+ }
+ }
+ TRACED_FORRANGE(int64_t, lsb, 1, 63) {
+ TRACED_FORRANGE(int64_t, width, 1, 63) {
+ uint64_t msk = (V8_UINT64_C(1) << width) - 1;
+ StreamBuilder m(this, kMachInt64, kMachInt64);
+ m.Return(m.Word64And(m.Int64Constant(msk),
+ m.Word64Shr(m.Parameter(0), m.Int64Constant(lsb))));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kArm64Ubfx, s[0]->arch_opcode());
+ ASSERT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(lsb, s.ToInt64(s[0]->InputAt(1)));
+ int64_t actual_width = (lsb + width > 64) ? (64 - lsb) : width;
+ EXPECT_EQ(actual_width, s.ToInt64(s[0]->InputAt(2)));
+ }
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Int32MulHighWithParameters) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Int32MulHigh(p0, p1);
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(kArm64Smull, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kArm64Asr, s[1]->arch_opcode());
+ ASSERT_EQ(2U, s[1]->InputCount());
+ EXPECT_EQ(s.ToVreg(s[0]->Output()), s.ToVreg(s[1]->InputAt(0)));
+ EXPECT_EQ(32, s.ToInt64(s[1]->InputAt(1)));
+ ASSERT_EQ(1U, s[1]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[1]->Output()));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "src/code-stubs.h"
#include "src/compiler/change-lowering.h"
-#include "src/compiler/compiler-test-utils.h"
-#include "src/compiler/graph-unittest.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/simplified-operator.h"
-#include "src/compiler/typer.h"
+#include "test/unittests/compiler/compiler-test-utils.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
#include "testing/gmock-support.h"
using testing::_;
namespace internal {
namespace compiler {
-// TODO(bmeurer): Find a new home for these functions.
-inline std::ostream& operator<<(std::ostream& os, const MachineType& type) {
- OStringStream ost;
- ost << type;
- return os << ost.c_str();
-}
-
-
class ChangeLoweringTest : public GraphTest {
public:
ChangeLoweringTest() : simplified_(zone()) {}
}
Reduction Reduce(Node* node) {
- Typer typer(zone());
MachineOperatorBuilder machine(WordRepresentation());
JSOperatorBuilder javascript(zone());
- JSGraph jsgraph(graph(), common(), &javascript, &typer, &machine);
+ JSGraph jsgraph(graph(), common(), &javascript, &machine);
CompilationInfo info(isolate(), zone());
- Linkage linkage(&info);
+ Linkage linkage(zone(), &info);
ChangeLowering reducer(&jsgraph, &linkage);
return reducer.Reduce(node);
}
Matcher<Node*> IsAllocateHeapNumber(const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher) {
- return IsCall(
- _, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
- CEntryStub(isolate(), 1).GetCode())),
- IsExternalConstant(ExternalReference(
- Runtime::FunctionForId(Runtime::kAllocateHeapNumber), isolate())),
- IsInt32Constant(0), IsNumberConstant(0.0), effect_matcher,
- control_matcher);
+ return IsCall(_, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
+ AllocateHeapNumberStub(isolate()).GetCode())),
+ IsNumberConstant(0.0), effect_matcher, control_matcher);
+ }
+ Matcher<Node*> IsLoadHeapNumber(const Matcher<Node*>& value_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return IsLoad(kMachFloat64, value_matcher,
+ IsIntPtrConstant(HeapNumberValueOffset()), graph()->start(),
+ control_matcher);
+ }
+ Matcher<Node*> IsIntPtrConstant(int value) {
+ return Is32() ? IsInt32Constant(value) : IsInt64Constant(value);
}
Matcher<Node*> IsWordEqual(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher) {
Node* node = graph()->NewNode(simplified()->ChangeBitToBool(), val);
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
-
- Node* phi = reduction.replacement();
- Capture<Node*> branch;
- EXPECT_THAT(phi,
- IsPhi(static_cast<MachineType>(kTypeBool | kRepTagged),
- IsTrueConstant(), IsFalseConstant(),
- IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
- IsBranch(val, graph()->start()))),
- IsIfFalse(CaptureEq(&branch)))));
+ EXPECT_THAT(reduction.replacement(),
+ IsSelect(static_cast<MachineType>(kTypeBool | kRepTagged), val,
+ IsTrueConstant(), IsFalseConstant()));
}
IsFinish(
AllOf(CaptureEq(&heap_number),
IsAllocateHeapNumber(IsValueEffect(val), graph()->start())),
- IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
- IsInt32Constant(HeapNumberValueOffset()), val,
+ IsStore(StoreRepresentation(kMachFloat64, kNoWriteBarrier),
+ CaptureEq(&heap_number),
+ IsIntPtrConstant(HeapNumberValueOffset()), val,
CaptureEq(&heap_number), graph()->start())));
}
EXPECT_THAT(
phi,
IsPhi(kMachAnyTagged,
- IsFinish(
- AllOf(CaptureEq(&heap_number),
- IsAllocateHeapNumber(_, CaptureEq(&if_true))),
- IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
- IsInt32Constant(HeapNumberValueOffset()),
- IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
- CaptureEq(&if_true))),
+ IsFinish(AllOf(CaptureEq(&heap_number),
+ IsAllocateHeapNumber(_, CaptureEq(&if_true))),
+ IsStore(StoreRepresentation(kMachFloat64, kNoWriteBarrier),
+ CaptureEq(&heap_number),
+ IsIntPtrConstant(HeapNumberValueOffset()),
+ IsChangeInt32ToFloat64(val),
+ CaptureEq(&heap_number), CaptureEq(&if_true))),
IsProjection(
0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
EXPECT_THAT(
phi,
IsPhi(
- kMachFloat64,
- IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true))),
+ kMachFloat64, IsLoadHeapNumber(val, CaptureEq(&if_true)),
IsChangeInt32ToFloat64(
IsWord32Sar(val, IsInt32Constant(SmiShiftAmount()))),
IsMerge(
EXPECT_THAT(
phi,
IsPhi(kMachInt32,
- IsChangeFloat64ToInt32(IsLoad(
- kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true)))),
+ IsChangeFloat64ToInt32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
IsIfFalse(AllOf(
EXPECT_THAT(
phi,
IsPhi(kMachUint32,
- IsChangeFloat64ToUint32(IsLoad(
- kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true)))),
+ IsChangeFloat64ToUint32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
IsIfFalse(AllOf(
phi,
IsPhi(
kMachAnyTagged, IsWord32Shl(val, IsInt32Constant(SmiShiftAmount())),
- IsFinish(
- AllOf(CaptureEq(&heap_number),
- IsAllocateHeapNumber(_, CaptureEq(&if_false))),
- IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
- IsInt32Constant(HeapNumberValueOffset()),
- IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
- CaptureEq(&if_false))),
+ IsFinish(AllOf(CaptureEq(&heap_number),
+ IsAllocateHeapNumber(_, CaptureEq(&if_false))),
+ IsStore(StoreRepresentation(kMachFloat64, kNoWriteBarrier),
+ CaptureEq(&heap_number),
+ IsInt32Constant(HeapNumberValueOffset()),
+ IsChangeUint32ToFloat64(val),
+ CaptureEq(&heap_number), CaptureEq(&if_false))),
IsMerge(
IsIfTrue(AllOf(CaptureEq(&branch),
IsBranch(IsUint32LessThanOrEqual(
EXPECT_THAT(reduction.replacement(),
IsWord64Shl(IsChangeInt32ToInt64(val),
- IsInt32Constant(SmiShiftAmount())));
+ IsInt64Constant(SmiShiftAmount())));
}
EXPECT_THAT(
phi,
IsPhi(
- kMachFloat64,
- IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true))),
+ kMachFloat64, IsLoadHeapNumber(val, CaptureEq(&if_true)),
IsChangeInt32ToFloat64(IsTruncateInt64ToInt32(
- IsWord64Sar(val, IsInt32Constant(SmiShiftAmount())))),
+ IsWord64Sar(val, IsInt64Constant(SmiShiftAmount())))),
IsMerge(
AllOf(CaptureEq(&if_true),
IsIfTrue(AllOf(
CaptureEq(&branch),
- IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
+ IsBranch(IsWord64And(val, IsInt64Constant(kSmiTagMask)),
graph()->start())))),
IsIfFalse(CaptureEq(&branch)))));
}
EXPECT_THAT(
phi,
IsPhi(kMachInt32,
- IsChangeFloat64ToInt32(IsLoad(
- kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true)))),
+ IsChangeFloat64ToInt32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
IsTruncateInt64ToInt32(
- IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
+ IsWord64Sar(val, IsInt64Constant(SmiShiftAmount()))),
IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
IsIfFalse(AllOf(
CaptureEq(&branch),
- IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
+ IsBranch(IsWord64And(val, IsInt64Constant(kSmiTagMask)),
graph()->start()))))));
}
EXPECT_THAT(
phi,
IsPhi(kMachUint32,
- IsChangeFloat64ToUint32(IsLoad(
- kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
- IsControlEffect(CaptureEq(&if_true)))),
+ IsChangeFloat64ToUint32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
IsTruncateInt64ToInt32(
- IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
+ IsWord64Sar(val, IsInt64Constant(SmiShiftAmount()))),
IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
IsIfFalse(AllOf(
CaptureEq(&branch),
- IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
+ IsBranch(IsWord64And(val, IsInt64Constant(kSmiTagMask)),
graph()->start()))))));
}
phi,
IsPhi(
kMachAnyTagged, IsWord64Shl(IsChangeUint32ToUint64(val),
- IsInt32Constant(SmiShiftAmount())),
- IsFinish(
- AllOf(CaptureEq(&heap_number),
- IsAllocateHeapNumber(_, CaptureEq(&if_false))),
- IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
- IsInt32Constant(HeapNumberValueOffset()),
- IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
- CaptureEq(&if_false))),
+ IsInt64Constant(SmiShiftAmount())),
+ IsFinish(AllOf(CaptureEq(&heap_number),
+ IsAllocateHeapNumber(_, CaptureEq(&if_false))),
+ IsStore(StoreRepresentation(kMachFloat64, kNoWriteBarrier),
+ CaptureEq(&heap_number),
+ IsInt64Constant(HeapNumberValueOffset()),
+ IsChangeUint32ToFloat64(val),
+ CaptureEq(&heap_number), CaptureEq(&if_false))),
IsMerge(
IsIfTrue(AllOf(CaptureEq(&branch),
IsBranch(IsUint32LessThanOrEqual(
--- /dev/null
+// 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/common-operator.h"
+
+#include <limits>
+
+#include "src/compiler/operator-properties-inl.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+
+// -----------------------------------------------------------------------------
+// Shared operators.
+
+
+namespace {
+
+struct SharedOperator {
+ const Operator* (CommonOperatorBuilder::*constructor)();
+ IrOpcode::Value opcode;
+ Operator::Properties properties;
+ int value_input_count;
+ int effect_input_count;
+ int control_input_count;
+ int effect_output_count;
+ int control_output_count;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const SharedOperator& fop) {
+ return os << IrOpcode::Mnemonic(fop.opcode);
+}
+
+
+const SharedOperator kSharedOperators[] = {
+#define SHARED(Name, properties, value_input_count, effect_input_count, \
+ control_input_count, effect_output_count, control_output_count) \
+ { \
+ &CommonOperatorBuilder::Name, IrOpcode::k##Name, properties, \
+ value_input_count, effect_input_count, control_input_count, \
+ effect_output_count, control_output_count \
+ }
+ SHARED(Dead, Operator::kFoldable, 0, 0, 0, 0, 1),
+ SHARED(End, Operator::kFoldable, 0, 0, 1, 0, 0),
+ SHARED(IfTrue, Operator::kFoldable, 0, 0, 1, 0, 1),
+ SHARED(IfFalse, Operator::kFoldable, 0, 0, 1, 0, 1),
+ SHARED(Throw, Operator::kFoldable, 1, 1, 1, 0, 1),
+ SHARED(Return, Operator::kNoProperties, 1, 1, 1, 0, 1)
+#undef SHARED
+};
+
+
+class CommonSharedOperatorTest
+ : public TestWithZone,
+ public ::testing::WithParamInterface<SharedOperator> {};
+
+} // namespace
+
+
+TEST_P(CommonSharedOperatorTest, InstancesAreGloballyShared) {
+ const SharedOperator& sop = GetParam();
+ CommonOperatorBuilder common1(zone());
+ CommonOperatorBuilder common2(zone());
+ EXPECT_EQ((common1.*sop.constructor)(), (common2.*sop.constructor)());
+}
+
+
+TEST_P(CommonSharedOperatorTest, NumberOfInputsAndOutputs) {
+ CommonOperatorBuilder common(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (common.*sop.constructor)();
+
+ EXPECT_EQ(sop.value_input_count, op->ValueInputCount());
+ EXPECT_EQ(sop.effect_input_count, op->EffectInputCount());
+ EXPECT_EQ(sop.control_input_count, op->ControlInputCount());
+ EXPECT_EQ(
+ sop.value_input_count + sop.effect_input_count + sop.control_input_count,
+ OperatorProperties::GetTotalInputCount(op));
+
+ EXPECT_EQ(0, op->ValueOutputCount());
+ EXPECT_EQ(sop.effect_output_count, op->EffectOutputCount());
+ EXPECT_EQ(sop.control_output_count, op->ControlOutputCount());
+}
+
+
+TEST_P(CommonSharedOperatorTest, OpcodeIsCorrect) {
+ CommonOperatorBuilder common(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (common.*sop.constructor)();
+ EXPECT_EQ(sop.opcode, op->opcode());
+}
+
+
+TEST_P(CommonSharedOperatorTest, Properties) {
+ CommonOperatorBuilder common(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (common.*sop.constructor)();
+ EXPECT_EQ(sop.properties, op->properties());
+}
+
+
+INSTANTIATE_TEST_CASE_P(CommonOperatorTest, CommonSharedOperatorTest,
+ ::testing::ValuesIn(kSharedOperators));
+
+
+// -----------------------------------------------------------------------------
+// Other operators.
+
+
+namespace {
+
+class CommonOperatorTest : public TestWithZone {
+ public:
+ CommonOperatorTest() : common_(zone()) {}
+ virtual ~CommonOperatorTest() {}
+
+ CommonOperatorBuilder* common() { return &common_; }
+
+ private:
+ CommonOperatorBuilder common_;
+};
+
+
+const int kArguments[] = {1, 5, 6, 42, 100, 10000, 65000};
+
+
+const float kFloatValues[] = {-std::numeric_limits<float>::infinity(),
+ std::numeric_limits<float>::min(),
+ -1.0f,
+ -0.0f,
+ 0.0f,
+ 1.0f,
+ std::numeric_limits<float>::max(),
+ std::numeric_limits<float>::infinity(),
+ std::numeric_limits<float>::quiet_NaN(),
+ std::numeric_limits<float>::signaling_NaN()};
+
+
+const double kDoubleValues[] = {-std::numeric_limits<double>::infinity(),
+ std::numeric_limits<double>::min(),
+ -1.0,
+ -0.0,
+ 0.0,
+ 1.0,
+ std::numeric_limits<double>::max(),
+ std::numeric_limits<double>::infinity(),
+ std::numeric_limits<double>::quiet_NaN(),
+ std::numeric_limits<double>::signaling_NaN()};
+
+
+const BranchHint kHints[] = {BranchHint::kNone, BranchHint::kTrue,
+ BranchHint::kFalse};
+
+} // namespace
+
+
+TEST_F(CommonOperatorTest, Branch) {
+ TRACED_FOREACH(BranchHint, hint, kHints) {
+ const Operator* const op = common()->Branch(hint);
+ EXPECT_EQ(IrOpcode::kBranch, op->opcode());
+ EXPECT_EQ(Operator::kFoldable, op->properties());
+ EXPECT_EQ(hint, BranchHintOf(op));
+ EXPECT_EQ(1, op->ValueInputCount());
+ EXPECT_EQ(0, op->EffectInputCount());
+ EXPECT_EQ(1, op->ControlInputCount());
+ EXPECT_EQ(2, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ValueOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(2, op->ControlOutputCount());
+ }
+}
+
+
+TEST_F(CommonOperatorTest, Select) {
+ static const MachineType kTypes[] = {
+ kMachInt8, kMachUint8, kMachInt16, kMachUint16,
+ kMachInt32, kMachUint32, kMachInt64, kMachUint64,
+ kMachFloat32, kMachFloat64, kMachAnyTagged};
+ TRACED_FOREACH(MachineType, type, kTypes) {
+ TRACED_FOREACH(BranchHint, hint, kHints) {
+ const Operator* const op = common()->Select(type, hint);
+ EXPECT_EQ(IrOpcode::kSelect, op->opcode());
+ EXPECT_EQ(Operator::kPure, op->properties());
+ EXPECT_EQ(type, SelectParametersOf(op).type());
+ EXPECT_EQ(hint, SelectParametersOf(op).hint());
+ EXPECT_EQ(3, op->ValueInputCount());
+ EXPECT_EQ(0, op->EffectInputCount());
+ EXPECT_EQ(0, op->ControlInputCount());
+ EXPECT_EQ(3, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(1, op->ValueOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
+ }
+ }
+}
+
+
+TEST_F(CommonOperatorTest, Float32Constant) {
+ TRACED_FOREACH(float, value, kFloatValues) {
+ const Operator* op = common()->Float32Constant(value);
+ EXPECT_PRED2(base::bit_equal_to<float>(), value, OpParameter<float>(op));
+ EXPECT_EQ(0, op->ValueInputCount());
+ EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(1, op->ValueOutputCount());
+ }
+ TRACED_FOREACH(float, v1, kFloatValues) {
+ TRACED_FOREACH(float, v2, kFloatValues) {
+ const Operator* op1 = common()->Float32Constant(v1);
+ const Operator* op2 = common()->Float32Constant(v2);
+ EXPECT_EQ(bit_cast<uint32_t>(v1) == bit_cast<uint32_t>(v2),
+ op1->Equals(op2));
+ }
+ }
+}
+
+
+TEST_F(CommonOperatorTest, Float64Constant) {
+ TRACED_FOREACH(double, value, kFloatValues) {
+ const Operator* op = common()->Float64Constant(value);
+ EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op));
+ EXPECT_EQ(0, op->ValueInputCount());
+ EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(1, op->ValueOutputCount());
+ }
+ TRACED_FOREACH(double, v1, kFloatValues) {
+ TRACED_FOREACH(double, v2, kFloatValues) {
+ const Operator* op1 = common()->Float64Constant(v1);
+ const Operator* op2 = common()->Float64Constant(v2);
+ EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2),
+ op1->Equals(op2));
+ }
+ }
+}
+
+
+TEST_F(CommonOperatorTest, NumberConstant) {
+ TRACED_FOREACH(double, value, kFloatValues) {
+ const Operator* op = common()->NumberConstant(value);
+ EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op));
+ EXPECT_EQ(0, op->ValueInputCount());
+ EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(1, op->ValueOutputCount());
+ }
+ TRACED_FOREACH(double, v1, kFloatValues) {
+ TRACED_FOREACH(double, v2, kFloatValues) {
+ const Operator* op1 = common()->NumberConstant(v1);
+ const Operator* op2 = common()->NumberConstant(v2);
+ EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2),
+ op1->Equals(op2));
+ }
+ }
+}
+
+
+TEST_F(CommonOperatorTest, ValueEffect) {
+ TRACED_FOREACH(int, arguments, kArguments) {
+ const Operator* op = common()->ValueEffect(arguments);
+ EXPECT_EQ(arguments, op->ValueInputCount());
+ EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ValueOutputCount());
+ }
+}
+
+
+TEST_F(CommonOperatorTest, Finish) {
+ TRACED_FOREACH(int, arguments, kArguments) {
+ const Operator* op = common()->Finish(arguments);
+ EXPECT_EQ(1, op->ValueInputCount());
+ EXPECT_EQ(arguments, op->EffectInputCount());
+ EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(0, op->ControlOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(1, op->ValueOutputCount());
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_COMPILER_COMPILER_TEST_UTILS_H_
-#define V8_COMPILER_COMPILER_TEST_UTILS_H_
+#ifndef V8_UNITTESTS_COMPILER_COMPILER_TEST_UTILS_H_
+#define V8_UNITTESTS_COMPILER_COMPILER_TEST_UTILS_H_
#include "testing/gtest/include/gtest/gtest.h"
} // namespace internal
} // namespace v8
-#endif // V8_COMPILER_COMPILER_TEST_UTILS_H_
+#endif // V8_UNITTESTS_COMPILER_COMPILER_TEST_UTILS_H_
--- /dev/null
+// 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/common-operator.h"
+#include "src/compiler/diamond.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::AllOf;
+using testing::Capture;
+using testing::CaptureEq;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class DiamondTest : public GraphTest {
+ public:
+ DiamondTest() : GraphTest(5) {}
+};
+
+
+TEST_F(DiamondTest, SimpleDiamond) {
+ Node* p = Parameter(0);
+ Diamond d(graph(), common(), p);
+ EXPECT_THAT(d.branch, IsBranch(p, graph()->start()));
+ EXPECT_THAT(d.if_true, IsIfTrue(d.branch));
+ EXPECT_THAT(d.if_false, IsIfFalse(d.branch));
+ EXPECT_THAT(d.merge, IsMerge(d.if_true, d.if_false));
+}
+
+
+TEST_F(DiamondTest, DiamondChainDiamond) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ Diamond d0(graph(), common(), p0);
+ Diamond d1(graph(), common(), p1);
+ d1.Chain(d0);
+ EXPECT_THAT(d1.branch, IsBranch(p1, d0.merge));
+ EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
+}
+
+
+TEST_F(DiamondTest, DiamondChainNode) {
+ Node* p1 = Parameter(1);
+ Diamond d1(graph(), common(), p1);
+ Node* other = graph()->NewNode(common()->Merge(0));
+ d1.Chain(other);
+ EXPECT_THAT(d1.branch, IsBranch(p1, other));
+}
+
+
+TEST_F(DiamondTest, DiamondChainN) {
+ Node* params[5] = {Parameter(0), Parameter(1), Parameter(2), Parameter(3),
+ Parameter(4)};
+ Diamond d[5] = {Diamond(graph(), common(), params[0]),
+ Diamond(graph(), common(), params[1]),
+ Diamond(graph(), common(), params[2]),
+ Diamond(graph(), common(), params[3]),
+ Diamond(graph(), common(), params[4])};
+
+ for (int i = 1; i < 5; i++) {
+ d[i].Chain(d[i - 1]);
+ EXPECT_THAT(d[i].branch, IsBranch(params[i], d[i - 1].merge));
+ }
+}
+
+
+TEST_F(DiamondTest, DiamondNested_true) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ Diamond d0(graph(), common(), p0);
+ Diamond d1(graph(), common(), p1);
+
+ d1.Nest(d0, true);
+
+ EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
+ EXPECT_THAT(d0.if_true, IsIfTrue(d0.branch));
+ EXPECT_THAT(d0.if_false, IsIfFalse(d0.branch));
+ EXPECT_THAT(d0.merge, IsMerge(d1.merge, d0.if_false));
+
+ EXPECT_THAT(d1.branch, IsBranch(p1, d0.if_true));
+ EXPECT_THAT(d1.if_true, IsIfTrue(d1.branch));
+ EXPECT_THAT(d1.if_false, IsIfFalse(d1.branch));
+ EXPECT_THAT(d1.merge, IsMerge(d1.if_true, d1.if_false));
+}
+
+
+TEST_F(DiamondTest, DiamondNested_false) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ Diamond d0(graph(), common(), p0);
+ Diamond d1(graph(), common(), p1);
+
+ d1.Nest(d0, false);
+
+ EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
+ EXPECT_THAT(d0.if_true, IsIfTrue(d0.branch));
+ EXPECT_THAT(d0.if_false, IsIfFalse(d0.branch));
+ EXPECT_THAT(d0.merge, IsMerge(d0.if_true, d1.merge));
+
+ EXPECT_THAT(d1.branch, IsBranch(p1, d0.if_false));
+ EXPECT_THAT(d1.if_true, IsIfTrue(d1.branch));
+ EXPECT_THAT(d1.if_false, IsIfFalse(d1.branch));
+ EXPECT_THAT(d1.merge, IsMerge(d1.if_true, d1.if_false));
+}
+
+
+TEST_F(DiamondTest, DiamondPhis) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ Node* p2 = Parameter(2);
+ Diamond d(graph(), common(), p0);
+
+ MachineType types[] = {kMachAnyTagged, kMachUint32, kMachInt32};
+
+ for (size_t i = 0; i < arraysize(types); i++) {
+ Node* phi = d.Phi(types[i], p1, p2);
+
+ EXPECT_THAT(d.branch, IsBranch(p0, graph()->start()));
+ EXPECT_THAT(d.if_true, IsIfTrue(d.branch));
+ EXPECT_THAT(d.if_false, IsIfFalse(d.branch));
+ EXPECT_THAT(d.merge, IsMerge(d.if_true, d.if_false));
+ EXPECT_THAT(phi, IsPhi(types[i], p1, p2, d.merge));
+ }
+}
+
+
+TEST_F(DiamondTest, DiamondEffectPhis) {
+ Node* p0 = Parameter(0);
+ Node* p1 = Parameter(1);
+ Node* p2 = Parameter(2);
+ Diamond d(graph(), common(), p0);
+
+ Node* phi = d.EffectPhi(p1, p2);
+
+ EXPECT_THAT(d.branch, IsBranch(p0, graph()->start()));
+ EXPECT_THAT(d.if_true, IsIfTrue(d.branch));
+ EXPECT_THAT(d.if_false, IsIfFalse(d.branch));
+ EXPECT_THAT(d.merge, IsMerge(d.if_true, d.if_false));
+ EXPECT_THAT(phi, IsEffectPhi(p1, p2, d.merge));
+}
+
+
+TEST_F(DiamondTest, BranchHint) {
+ Diamond dn(graph(), common(), Parameter(0));
+ CHECK(BranchHint::kNone == BranchHintOf(dn.branch->op()));
+
+ Diamond dt(graph(), common(), Parameter(0), BranchHint::kTrue);
+ CHECK(BranchHint::kTrue == BranchHintOf(dt.branch->op()));
+
+ Diamond df(graph(), common(), Parameter(0), BranchHint::kFalse);
+ CHECK(BranchHint::kFalse == BranchHintOf(df.branch->op()));
+}
+
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#include "src/compiler/graph.h"
#include "src/compiler/graph-reducer.h"
#include "src/compiler/operator.h"
-#include "src/test/test-utils.h"
+#include "test/unittests/test-utils.h"
#include "testing/gmock/include/gmock/gmock.h"
using testing::_;
namespace internal {
namespace compiler {
+struct TestOperator : public Operator {
+ TestOperator(Operator::Opcode opcode, Operator::Properties properties,
+ size_t value_in, size_t value_out)
+ : Operator(opcode, properties, "TestOp", value_in, 0, 0, value_out, 0,
+ 0) {}
+};
+
+
namespace {
-SimpleOperator OP0(0, Operator::kNoWrite, 0, 1, "op0");
-SimpleOperator OP1(1, Operator::kNoProperties, 1, 1, "op1");
+TestOperator OP0(0, Operator::kNoWrite, 0, 1);
+TestOperator OP1(1, Operator::kNoProperties, 1, 1);
struct MockReducer : public Reducer {
--- /dev/null
+// 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 "test/unittests/compiler/graph-unittest.h"
+
+#include <ostream> // NOLINT(readability/streams)
+
+#include "src/compiler/node-properties-inl.h"
+#include "test/unittests/compiler/node-test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+GraphTest::GraphTest(int num_parameters) : common_(zone()), graph_(zone()) {
+ graph()->SetStart(graph()->NewNode(common()->Start(num_parameters)));
+}
+
+
+GraphTest::~GraphTest() {}
+
+
+Node* GraphTest::Parameter(int32_t index) {
+ return graph()->NewNode(common()->Parameter(index), graph()->start());
+}
+
+
+Node* GraphTest::Float32Constant(volatile float value) {
+ return graph()->NewNode(common()->Float32Constant(value));
+}
+
+
+Node* GraphTest::Float64Constant(volatile double value) {
+ return graph()->NewNode(common()->Float64Constant(value));
+}
+
+
+Node* GraphTest::Int32Constant(int32_t value) {
+ return graph()->NewNode(common()->Int32Constant(value));
+}
+
+
+Node* GraphTest::Int64Constant(int64_t value) {
+ return graph()->NewNode(common()->Int64Constant(value));
+}
+
+
+Node* GraphTest::NumberConstant(volatile double value) {
+ return graph()->NewNode(common()->NumberConstant(value));
+}
+
+
+Node* GraphTest::HeapConstant(const Handle<HeapObject>& value) {
+ return HeapConstant(Unique<HeapObject>::CreateUninitialized(value));
+}
+
+
+Node* GraphTest::HeapConstant(const Unique<HeapObject>& value) {
+ Node* node = graph()->NewNode(common()->HeapConstant(value));
+ Type* type = Type::Constant(value.handle(), zone());
+ NodeProperties::SetBounds(node, Bounds(type));
+ return node;
+}
+
+
+Node* GraphTest::FalseConstant() {
+ return HeapConstant(
+ Unique<HeapObject>::CreateImmovable(factory()->false_value()));
+}
+
+
+Node* GraphTest::TrueConstant() {
+ return HeapConstant(
+ Unique<HeapObject>::CreateImmovable(factory()->true_value()));
+}
+
+
+Node* GraphTest::UndefinedConstant() {
+ return HeapConstant(
+ Unique<HeapObject>::CreateImmovable(factory()->undefined_value()));
+}
+
+
+Matcher<Node*> GraphTest::IsFalseConstant() {
+ return IsHeapConstant(
+ Unique<HeapObject>::CreateImmovable(factory()->false_value()));
+}
+
+
+Matcher<Node*> GraphTest::IsTrueConstant() {
+ return IsHeapConstant(
+ Unique<HeapObject>::CreateImmovable(factory()->true_value()));
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_UNITTESTS_COMPILER_GRAPH_UNITTEST_H_
+#define V8_UNITTESTS_COMPILER_GRAPH_UNITTEST_H_
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/graph.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/typer.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+template <class T>
+class Handle;
+class HeapObject;
+template <class T>
+class Unique;
+
+namespace compiler {
+
+using ::testing::Matcher;
+
+
+class GraphTest : public TestWithContext, public TestWithZone {
+ public:
+ explicit GraphTest(int parameters = 1);
+ virtual ~GraphTest();
+
+ protected:
+ Node* Parameter(int32_t index);
+ Node* Float32Constant(volatile float value);
+ Node* Float64Constant(volatile double value);
+ Node* Int32Constant(int32_t value);
+ Node* Uint32Constant(uint32_t value) {
+ return Int32Constant(bit_cast<int32_t>(value));
+ }
+ Node* Int64Constant(int64_t value);
+ Node* NumberConstant(volatile double value);
+ Node* HeapConstant(const Handle<HeapObject>& value);
+ Node* HeapConstant(const Unique<HeapObject>& value);
+ Node* FalseConstant();
+ Node* TrueConstant();
+ Node* UndefinedConstant();
+
+ Matcher<Node*> IsFalseConstant();
+ Matcher<Node*> IsTrueConstant();
+
+ CommonOperatorBuilder* common() { return &common_; }
+ Graph* graph() { return &graph_; }
+
+ private:
+ CommonOperatorBuilder common_;
+ Graph graph_;
+};
+
+
+class TypedGraphTest : public GraphTest {
+ public:
+ explicit TypedGraphTest(int parameters = 1)
+ : GraphTest(parameters), typer_(graph(), MaybeHandle<Context>()) {}
+
+ protected:
+ Typer* typer() { return &typer_; }
+
+ private:
+ Typer typer_;
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_UNITTESTS_COMPILER_GRAPH_UNITTEST_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/instruction-selector-unittest.h"
+#include "test/unittests/compiler/instruction-selector-unittest.h"
namespace v8 {
namespace internal {
// -----------------------------------------------------------------------------
// Better left operand for commutative binops
+
TEST_F(InstructionSelectorTest, BetterLeftOperandTestAddBinop) {
StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
Node* param1 = m.Parameter(0);
EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
ASSERT_EQ(2U, s[0]->InputCount());
ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
- EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(param2), s.ToVreg(s[0]->InputAt(0)));
}
EXPECT_EQ(kIA32Imul, s[0]->arch_opcode());
ASSERT_EQ(2U, s[0]->InputCount());
ASSERT_TRUE(s[0]->InputAt(0)->IsUnallocated());
- EXPECT_EQ(param2->id(), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(param2), s.ToVreg(s[0]->InputAt(0)));
+}
+
+
+// -----------------------------------------------------------------------------
+// Conversions.
+
+
+TEST_F(InstructionSelectorTest, ChangeUint32ToFloat64WithParameter) {
+ StreamBuilder m(this, kMachFloat64, kMachUint32);
+ m.Return(m.ChangeUint32ToFloat64(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kSSEUint32ToFloat64, s[0]->arch_opcode());
}
// -----------------------------------------------------------------------------
// Loads and stores
+
namespace {
struct MemoryAccess {
std::ostream& operator<<(std::ostream& os, const MemoryAccess& memacc) {
- OStringStream ost;
- ost << memacc.type;
- return os << ost.c_str();
+ return os << memacc.type;
}
if (base == 0) {
ASSERT_EQ(1U, s[0]->InputCount());
} else {
- ASSERT_EQ(2U, s[0]->InputCount());
- ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
- EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
}
EXPECT_EQ(1U, s[0]->OutputCount());
}
if (index == 0) {
ASSERT_EQ(1U, s[0]->InputCount());
} else {
- ASSERT_EQ(2U, s[0]->InputCount());
- ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
- EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
}
EXPECT_EQ(1U, s[0]->OutputCount());
}
if (base == 0) {
ASSERT_EQ(2U, s[0]->InputCount());
} else {
- ASSERT_EQ(3U, s[0]->InputCount());
- ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
- EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(3U, s[0]->InputCount());
+ ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(base, s.ToInt32(s[0]->InputAt(1)));
}
EXPECT_EQ(0U, s[0]->OutputCount());
}
// -----------------------------------------------------------------------------
// AddressingMode for loads and stores.
+
class AddressingModeUnitTest : public InstructionSelectorTest {
public:
AddressingModeUnitTest() : m(NULL) { Reset(); }
TEST_F(AddressingModeUnitTest, AddressingMode_M1) {
Node* base = null_ptr;
Node* index = index_reg;
- Run(base, index, kMode_MR);
+ Run(base, index, kMode_M1);
}
TEST_F(AddressingModeUnitTest, AddressingMode_MN) {
- AddressingMode expected[] = {kMode_MR, kMode_M2, kMode_M4, kMode_M8};
+ AddressingMode expected[] = {kMode_M1, kMode_M2, kMode_M4, kMode_M8};
for (size_t i = 0; i < arraysize(scales); ++i) {
Reset();
Node* base = null_ptr;
TEST_F(AddressingModeUnitTest, AddressingMode_M1I) {
Node* base = null_ptr;
Node* index = m->Int32Add(index_reg, non_zero);
- Run(base, index, kMode_MRI);
+ Run(base, index, kMode_M1I);
}
TEST_F(AddressingModeUnitTest, AddressingMode_MNI) {
- AddressingMode expected[] = {kMode_MRI, kMode_M2I, kMode_M4I, kMode_M8I};
+ AddressingMode expected[] = {kMode_M1I, kMode_M2I, kMode_M4I, kMode_M8I};
for (size_t i = 0; i < arraysize(scales); ++i) {
Reset();
Node* base = null_ptr;
}
}
+
+// -----------------------------------------------------------------------------
+// Multiplication.
+
+
+namespace {
+
+struct MultParam {
+ int value;
+ bool lea_expected;
+ AddressingMode addressing_mode;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const MultParam& m) {
+ return os << m.value << "." << m.lea_expected << "." << m.addressing_mode;
+}
+
+
+const MultParam kMultParams[] = {{-1, false, kMode_None},
+ {0, false, kMode_None},
+ {1, true, kMode_M1},
+ {2, true, kMode_M2},
+ {3, true, kMode_MR2},
+ {4, true, kMode_M4},
+ {5, true, kMode_MR4},
+ {6, false, kMode_None},
+ {7, false, kMode_None},
+ {8, true, kMode_M8},
+ {9, true, kMode_MR8},
+ {10, false, kMode_None},
+ {11, false, kMode_None}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<MultParam> InstructionSelectorMultTest;
+
+
+static unsigned InputCountForLea(AddressingMode mode) {
+ switch (mode) {
+ case kMode_MR1I:
+ case kMode_MR2I:
+ case kMode_MR4I:
+ case kMode_MR8I:
+ return 3U;
+ case kMode_M1I:
+ case kMode_M2I:
+ case kMode_M4I:
+ case kMode_M8I:
+ return 2U;
+ case kMode_MR1:
+ case kMode_MR2:
+ case kMode_MR4:
+ case kMode_MR8:
+ return 2U;
+ case kMode_M1:
+ case kMode_M2:
+ case kMode_M4:
+ case kMode_M8:
+ return 1U;
+ default:
+ UNREACHABLE();
+ return 0U;
+ }
+}
+
+
+static AddressingMode AddressingModeForAddMult(const MultParam& m) {
+ switch (m.addressing_mode) {
+ case kMode_MR1:
+ return kMode_MR1I;
+ case kMode_MR2:
+ return kMode_MR2I;
+ case kMode_MR4:
+ return kMode_MR4I;
+ case kMode_MR8:
+ return kMode_MR8I;
+ case kMode_M1:
+ return kMode_M1I;
+ case kMode_M2:
+ return kMode_M2I;
+ case kMode_M4:
+ return kMode_M4I;
+ case kMode_M8:
+ return kMode_M8I;
+ default:
+ UNREACHABLE();
+ return kMode_None;
+ }
+}
+
+
+TEST_P(InstructionSelectorMultTest, Mult32) {
+ const MultParam m_param = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ Node* param = m.Parameter(0);
+ Node* mult = m.Int32Mul(param, m.Int32Constant(m_param.value));
+ m.Return(mult);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(m_param.addressing_mode, s[0]->addressing_mode());
+ if (m_param.lea_expected) {
+ EXPECT_EQ(kIA32Lea, s[0]->arch_opcode());
+ ASSERT_EQ(InputCountForLea(s[0]->addressing_mode()), s[0]->InputCount());
+ } else {
+ EXPECT_EQ(kIA32Imul, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ }
+ EXPECT_EQ(s.ToVreg(param), s.ToVreg(s[0]->InputAt(0)));
+}
+
+
+TEST_P(InstructionSelectorMultTest, MultAdd32) {
+ TRACED_FOREACH(int32_t, imm, kImmediates) {
+ const MultParam m_param = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ Node* param = m.Parameter(0);
+ Node* mult = m.Int32Add(m.Int32Mul(param, m.Int32Constant(m_param.value)),
+ m.Int32Constant(imm));
+ m.Return(mult);
+ Stream s = m.Build();
+ if (m_param.lea_expected) {
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kIA32Lea, s[0]->arch_opcode());
+ EXPECT_EQ(AddressingModeForAddMult(m_param), s[0]->addressing_mode());
+ unsigned input_count = InputCountForLea(s[0]->addressing_mode());
+ ASSERT_EQ(input_count, s[0]->InputCount());
+ ASSERT_EQ(InstructionOperand::IMMEDIATE,
+ s[0]->InputAt(input_count - 1)->kind());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(input_count - 1)));
+ } else {
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(kIA32Imul, s[0]->arch_opcode());
+ EXPECT_EQ(kIA32Add, s[1]->arch_opcode());
+ }
+ }
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorMultTest,
+ ::testing::ValuesIn(kMultParams));
+
+
+TEST_F(InstructionSelectorTest, Int32MulHigh) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Int32MulHigh(p0, p1);
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kIA32ImulHigh, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_TRUE(s.IsFixed(s[0]->InputAt(0), eax));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_TRUE(!s.IsUsedAtStart(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ EXPECT_TRUE(s.IsFixed(s[0]->OutputAt(0), edx));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/instruction-selector-unittest.h"
+#include "test/unittests/compiler/instruction-selector-unittest.h"
-#include "src/compiler/compiler-test-utils.h"
+#include "src/compiler/graph-inl.h"
#include "src/flags.h"
+#include "test/unittests/compiler/compiler-test-utils.h"
namespace v8 {
namespace internal {
Schedule* schedule = Export();
if (FLAG_trace_turbo) {
OFStream out(stdout);
- out << "=== Schedule before instruction selection ===" << endl << *schedule;
+ out << "=== Schedule before instruction selection ===" << std::endl
+ << *schedule;
}
EXPECT_NE(0, graph()->NodeCount());
- CompilationInfo info(test_->isolate(), test_->zone());
- Linkage linkage(&info, call_descriptor());
- InstructionSequence sequence(&linkage, graph(), schedule);
+ int initial_node_count = graph()->NodeCount();
+ Linkage linkage(test_->zone(), call_descriptor());
+ InstructionBlocks* instruction_blocks =
+ InstructionSequence::InstructionBlocksFor(test_->zone(), schedule);
+ InstructionSequence sequence(test_->zone(), instruction_blocks);
SourcePositionTable source_position_table(graph());
- InstructionSelector selector(&sequence, &source_position_table, features);
+ InstructionSelector selector(test_->zone(), graph(), &linkage, &sequence,
+ schedule, &source_position_table, features);
selector.SelectInstructions();
if (FLAG_trace_turbo) {
OFStream out(stdout);
- out << "=== Code sequence after instruction selection ===" << endl
- << sequence;
+ PrintableInstructionSequence printable = {
+ RegisterConfiguration::ArchDefault(), &sequence};
+ out << "=== Code sequence after instruction selection ===" << std::endl
+ << printable;
}
Stream s;
+ // Map virtual registers.
+ {
+ const NodeToVregMap& node_map = selector.GetNodeMapForTesting();
+ for (int i = 0; i < initial_node_count; ++i) {
+ if (node_map[i] != InstructionSelector::kNodeUnmapped) {
+ s.virtual_registers_.insert(std::make_pair(i, node_map[i]));
+ }
+ }
+ }
std::set<int> virtual_registers;
for (InstructionSequence::const_iterator i = sequence.begin();
i != sequence.end(); ++i) {
}
+int InstructionSelectorTest::Stream::ToVreg(const Node* node) const {
+ VirtualRegisters::const_iterator i = virtual_registers_.find(node->id());
+ CHECK(i != virtual_registers_.end());
+ return i->second;
+}
+
+
+bool InstructionSelectorTest::Stream::IsFixed(const InstructionOperand* operand,
+ Register reg) const {
+ if (!operand->IsUnallocated()) return false;
+ const UnallocatedOperand* unallocated = UnallocatedOperand::cast(operand);
+ if (!unallocated->HasFixedRegisterPolicy()) return false;
+ const int index = Register::ToAllocationIndex(reg);
+ return unallocated->fixed_register_index() == index;
+}
+
+
+bool InstructionSelectorTest::Stream::IsSameAsFirst(
+ const InstructionOperand* operand) const {
+ if (!operand->IsUnallocated()) return false;
+ const UnallocatedOperand* unallocated = UnallocatedOperand::cast(operand);
+ return unallocated->HasSameAsInputPolicy();
+}
+
+
+bool InstructionSelectorTest::Stream::IsUsedAtStart(
+ const InstructionOperand* operand) const {
+ if (!operand->IsUnallocated()) return false;
+ const UnallocatedOperand* unallocated = UnallocatedOperand::cast(operand);
+ return unallocated->IsUsedAtStart();
+}
+
+
// -----------------------------------------------------------------------------
// Return.
Node* param = m.Parameter(0);
m.Return(param);
Stream s = m.Build(kAllInstructions);
- EXPECT_TRUE(s.IsDouble(param->id()));
+ EXPECT_TRUE(s.IsDouble(param));
}
Node* param = m.Parameter(0);
m.Return(param);
Stream s = m.Build(kAllInstructions);
- EXPECT_TRUE(s.IsReference(param->id()));
+ EXPECT_TRUE(s.IsReference(param));
}
EXPECT_EQ(kArchNop, s[0]->arch_opcode());
ASSERT_EQ(1U, s[0]->OutputCount());
ASSERT_TRUE(s[0]->Output()->IsUnallocated());
- EXPECT_EQ(param->id(), s.ToVreg(s[0]->Output()));
+ EXPECT_EQ(s.ToVreg(param), s.ToVreg(s[0]->Output()));
EXPECT_EQ(kArchNop, s[1]->arch_opcode());
ASSERT_EQ(1U, s[1]->InputCount());
ASSERT_TRUE(s[1]->InputAt(0)->IsUnallocated());
- EXPECT_EQ(param->id(), s.ToVreg(s[1]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(param), s.ToVreg(s[1]->InputAt(0)));
ASSERT_EQ(1U, s[1]->OutputCount());
ASSERT_TRUE(s[1]->Output()->IsUnallocated());
EXPECT_TRUE(UnallocatedOperand::cast(s[1]->Output())->HasSameAsInputPolicy());
- EXPECT_EQ(finish->id(), s.ToVreg(s[1]->Output()));
- EXPECT_TRUE(s.IsReference(finish->id()));
+ EXPECT_EQ(s.ToVreg(finish), s.ToVreg(s[1]->Output()));
+ EXPECT_TRUE(s.IsReference(finish));
}
Node* phi = m.Phi(type, param0, param1);
m.Return(phi);
Stream s = m.Build(kAllInstructions);
- EXPECT_EQ(s.IsDouble(phi->id()), s.IsDouble(param0->id()));
- EXPECT_EQ(s.IsDouble(phi->id()), s.IsDouble(param1->id()));
+ EXPECT_EQ(s.IsDouble(phi), s.IsDouble(param0));
+ EXPECT_EQ(s.IsDouble(phi), s.IsDouble(param1));
}
Node* phi = m.Phi(type, param0, param1);
m.Return(phi);
Stream s = m.Build(kAllInstructions);
- EXPECT_EQ(s.IsReference(phi->id()), s.IsReference(param0->id()));
- EXPECT_EQ(s.IsReference(phi->id()), s.IsReference(param1->id()));
+ EXPECT_EQ(s.IsReference(phi), s.IsReference(param0));
+ EXPECT_EQ(s.IsReference(phi), s.IsReference(param1));
}
Node* context_dummy = m.Int32Constant(0);
Node* state_node = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id, kPushOutput), parameters,
- locals, stack, context_dummy, m.UndefinedConstant());
+ m.common()->FrameState(JS_FRAME, bailout_id,
+ OutputFrameStateCombine::Push()),
+ parameters, locals, stack, context_dummy, m.UndefinedConstant());
Node* call = m.CallJS0(function_node, receiver, context, state_node);
m.Return(call);
// Build frame state for the state before the call.
Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(43));
- Node* locals = m.NewNode(m.common()->StateValues(1), m.Int32Constant(44));
- Node* stack = m.NewNode(m.common()->StateValues(1), m.Int32Constant(45));
+ Node* locals = m.NewNode(m.common()->StateValues(1), m.Float64Constant(0.5));
+ Node* stack = m.NewNode(m.common()->StateValues(1), m.UndefinedConstant());
Node* context_sentinel = m.Int32Constant(0);
Node* frame_state_before = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
+ m.common()->FrameState(JS_FRAME, bailout_id_before,
+ OutputFrameStateCombine::Push()),
parameters, locals, stack, context_sentinel, m.UndefinedConstant());
// Build the call.
FrameStateDescriptor* desc_before =
s.GetFrameStateDescriptor(deopt_id_before);
EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
- EXPECT_EQ(kPushOutput, desc_before->state_combine());
+ EXPECT_EQ(OutputFrameStateCombine::kPushOutput,
+ desc_before->state_combine().kind());
EXPECT_EQ(1u, desc_before->parameters_count());
EXPECT_EQ(1u, desc_before->locals_count());
EXPECT_EQ(1u, desc_before->stack_count());
EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(2)));
- EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(3)));
- EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(4)));
- EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(5)));
+ EXPECT_EQ(0, s.ToInt32(call_instr->InputAt(3))); // This should be a context.
+ // We inserted 0 here.
+ EXPECT_EQ(0.5, s.ToFloat64(call_instr->InputAt(4)));
+ EXPECT_TRUE(s.ToHeapObject(call_instr->InputAt(5))->IsUndefined());
+ EXPECT_EQ(kMachInt32, desc_before->GetType(0));
+ EXPECT_EQ(kMachAnyTagged, desc_before->GetType(1)); // context is always
+ // tagged/any.
+ EXPECT_EQ(kMachFloat64, desc_before->GetType(2));
+ EXPECT_EQ(kMachAnyTagged, desc_before->GetType(3));
// Function.
- EXPECT_EQ(function_node->id(), s.ToVreg(call_instr->InputAt(6)));
+ EXPECT_EQ(s.ToVreg(function_node), s.ToVreg(call_instr->InputAt(6)));
// Context.
- EXPECT_EQ(context->id(), s.ToVreg(call_instr->InputAt(7)));
+ EXPECT_EQ(s.ToVreg(context), s.ToVreg(call_instr->InputAt(7)));
EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
Node* parameters = m.NewNode(m.common()->StateValues(1), m.Int32Constant(63));
Node* locals = m.NewNode(m.common()->StateValues(1), m.Int32Constant(64));
Node* stack = m.NewNode(m.common()->StateValues(1), m.Int32Constant(65));
- Node* frame_state_parent = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_parent, kIgnoreOutput),
- parameters, locals, stack, context, m.UndefinedConstant());
+ Node* frame_state_parent =
+ m.NewNode(m.common()->FrameState(JS_FRAME, bailout_id_parent,
+ OutputFrameStateCombine::Ignore()),
+ parameters, locals, stack, context, m.UndefinedConstant());
Node* context2 = m.Int32Constant(46);
Node* parameters2 =
m.NewNode(m.common()->StateValues(1), m.Int32Constant(43));
- Node* locals2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(44));
- Node* stack2 = m.NewNode(m.common()->StateValues(1), m.Int32Constant(45));
- Node* frame_state_before = m.NewNode(
- m.common()->FrameState(JS_FRAME, bailout_id_before, kPushOutput),
- parameters2, locals2, stack2, context2, frame_state_parent);
+ Node* locals2 =
+ m.NewNode(m.common()->StateValues(1), m.Float64Constant(0.25));
+ Node* stack2 = m.NewNode(m.common()->StateValues(2), m.Int32Constant(44),
+ m.Int32Constant(45));
+ Node* frame_state_before =
+ m.NewNode(m.common()->FrameState(JS_FRAME, bailout_id_before,
+ OutputFrameStateCombine::Push()),
+ parameters2, locals2, stack2, context2, frame_state_parent);
// Build the call.
Node* call = m.CallFunctionStub0(function_node, receiver, context2,
size_t num_operands =
1 + // Code object.
1 + // Frame state deopt id
- 4 + // One input for each value in frame state + context.
+ 5 + // One input for each value in frame state + context.
4 + // One input for each value in the parent frame state + context.
1 + // Function.
1; // Context.
int32_t deopt_id_before = s.ToInt32(call_instr->InputAt(1));
FrameStateDescriptor* desc_before =
s.GetFrameStateDescriptor(deopt_id_before);
+ FrameStateDescriptor* desc_before_outer = desc_before->outer_state();
EXPECT_EQ(bailout_id_before, desc_before->bailout_id());
- EXPECT_EQ(1u, desc_before->parameters_count());
- EXPECT_EQ(1u, desc_before->locals_count());
- EXPECT_EQ(1u, desc_before->stack_count());
+ EXPECT_EQ(1u, desc_before_outer->parameters_count());
+ EXPECT_EQ(1u, desc_before_outer->locals_count());
+ EXPECT_EQ(1u, desc_before_outer->stack_count());
+ // Values from parent environment.
EXPECT_EQ(63, s.ToInt32(call_instr->InputAt(2)));
+ EXPECT_EQ(kMachInt32, desc_before_outer->GetType(0));
// Context:
EXPECT_EQ(66, s.ToInt32(call_instr->InputAt(3)));
+ EXPECT_EQ(kMachAnyTagged, desc_before_outer->GetType(1));
EXPECT_EQ(64, s.ToInt32(call_instr->InputAt(4)));
+ EXPECT_EQ(kMachInt32, desc_before_outer->GetType(2));
EXPECT_EQ(65, s.ToInt32(call_instr->InputAt(5)));
- // Values from parent environment should follow.
+ EXPECT_EQ(kMachInt32, desc_before_outer->GetType(3));
+ // Values from the nested frame.
+ EXPECT_EQ(1u, desc_before->parameters_count());
+ EXPECT_EQ(1u, desc_before->locals_count());
+ EXPECT_EQ(2u, desc_before->stack_count());
EXPECT_EQ(43, s.ToInt32(call_instr->InputAt(6)));
+ EXPECT_EQ(kMachInt32, desc_before->GetType(0));
EXPECT_EQ(46, s.ToInt32(call_instr->InputAt(7)));
- EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(8)));
- EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(9)));
+ EXPECT_EQ(kMachAnyTagged, desc_before->GetType(1));
+ EXPECT_EQ(0.25, s.ToFloat64(call_instr->InputAt(8)));
+ EXPECT_EQ(kMachFloat64, desc_before->GetType(2));
+ EXPECT_EQ(44, s.ToInt32(call_instr->InputAt(9)));
+ EXPECT_EQ(kMachInt32, desc_before->GetType(3));
+ EXPECT_EQ(45, s.ToInt32(call_instr->InputAt(10)));
+ EXPECT_EQ(kMachInt32, desc_before->GetType(4));
// Function.
- EXPECT_EQ(function_node->id(), s.ToVreg(call_instr->InputAt(10)));
+ EXPECT_EQ(s.ToVreg(function_node), s.ToVreg(call_instr->InputAt(11)));
// Context.
- EXPECT_EQ(context2->id(), s.ToVreg(call_instr->InputAt(11)));
+ EXPECT_EQ(s.ToVreg(context2), s.ToVreg(call_instr->InputAt(12)));
// Continuation.
EXPECT_EQ(kArchRet, s[index++]->arch_opcode());
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
-#define V8_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
+#ifndef V8_UNITTESTS_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
+#define V8_UNITTESTS_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
#include <deque>
#include <set>
#include "src/base/utils/random-number-generator.h"
#include "src/compiler/instruction-selector.h"
#include "src/compiler/raw-machine-assembler.h"
-#include "src/test/test-utils.h"
+#include "src/macro-assembler.h"
+#include "test/unittests/test-utils.h"
namespace v8 {
namespace internal {
bool IsDouble(const InstructionOperand* operand) const {
return IsDouble(ToVreg(operand));
}
- bool IsDouble(int virtual_register) const {
- return doubles_.find(virtual_register) != doubles_.end();
- }
+
+ bool IsDouble(const Node* node) const { return IsDouble(ToVreg(node)); }
bool IsInteger(const InstructionOperand* operand) const {
return IsInteger(ToVreg(operand));
}
- bool IsInteger(int virtual_register) const {
- return !IsDouble(virtual_register) && !IsReference(virtual_register);
- }
+
+ bool IsInteger(const Node* node) const { return IsInteger(ToVreg(node)); }
bool IsReference(const InstructionOperand* operand) const {
return IsReference(ToVreg(operand));
}
- bool IsReference(int virtual_register) const {
- return references_.find(virtual_register) != references_.end();
+
+ bool IsReference(const Node* node) const {
+ return IsReference(ToVreg(node));
}
float ToFloat32(const InstructionOperand* operand) const {
return ToConstant(operand).ToFloat32();
}
+ double ToFloat64(const InstructionOperand* operand) const {
+ return ToConstant(operand).ToFloat64();
+ }
+
int32_t ToInt32(const InstructionOperand* operand) const {
return ToConstant(operand).ToInt32();
}
return ToConstant(operand).ToInt64();
}
+ Handle<HeapObject> ToHeapObject(const InstructionOperand* operand) const {
+ return ToConstant(operand).ToHeapObject();
+ }
+
int ToVreg(const InstructionOperand* operand) const {
if (operand->IsConstant()) return operand->index();
EXPECT_EQ(InstructionOperand::UNALLOCATED, operand->kind());
return UnallocatedOperand::cast(operand)->virtual_register();
}
+ int ToVreg(const Node* node) const;
+
+ bool IsFixed(const InstructionOperand* operand, Register reg) const;
+ bool IsSameAsFirst(const InstructionOperand* operand) const;
+ bool IsUsedAtStart(const InstructionOperand* operand) const;
+
FrameStateDescriptor* GetFrameStateDescriptor(int deoptimization_id) {
EXPECT_LT(deoptimization_id, GetFrameStateDescriptorCount());
return deoptimization_entries_[deoptimization_id];
}
private:
+ bool IsDouble(int virtual_register) const {
+ return doubles_.find(virtual_register) != doubles_.end();
+ }
+
+ bool IsInteger(int virtual_register) const {
+ return !IsDouble(virtual_register) && !IsReference(virtual_register);
+ }
+
+ bool IsReference(int virtual_register) const {
+ return references_.find(virtual_register) != references_.end();
+ }
+
Constant ToConstant(const InstructionOperand* operand) const {
ConstantMap::const_iterator i;
if (operand->IsConstant()) {
friend class StreamBuilder;
typedef std::map<int, Constant> ConstantMap;
+ typedef std::map<NodeId, int> VirtualRegisters;
ConstantMap constants_;
ConstantMap immediates_;
std::deque<Instruction*> instructions_;
std::set<int> doubles_;
std::set<int> references_;
+ VirtualRegisters virtual_registers_;
std::deque<FrameStateDescriptor*> deoptimization_entries_;
};
} // namespace internal
} // namespace v8
-#endif // V8_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
+#endif // V8_UNITTESTS_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
--- /dev/null
+// 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/js-builtin-reducer.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/typer.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::Capture;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class JSBuiltinReducerTest : public TypedGraphTest {
+ public:
+ JSBuiltinReducerTest() : javascript_(zone()) {}
+
+ protected:
+ Reduction Reduce(Node* node, MachineOperatorBuilder::Flags flags =
+ MachineOperatorBuilder::Flag::kNoFlags) {
+ MachineOperatorBuilder machine(kMachPtr, flags);
+ JSGraph jsgraph(graph(), common(), javascript(), &machine);
+ JSBuiltinReducer reducer(&jsgraph);
+ return reducer.Reduce(node);
+ }
+
+ Node* Parameter(Type* t, int32_t index = 0) {
+ Node* n = graph()->NewNode(common()->Parameter(index), graph()->start());
+ NodeProperties::SetBounds(n, Bounds(Type::None(), t));
+ return n;
+ }
+
+ Handle<JSFunction> MathFunction(const char* name) {
+ Handle<Object> m =
+ JSObject::GetProperty(isolate()->global_object(),
+ isolate()->factory()->NewStringFromAsciiChecked(
+ "Math")).ToHandleChecked();
+ Handle<JSFunction> f = Handle<JSFunction>::cast(
+ JSObject::GetProperty(
+ m, isolate()->factory()->NewStringFromAsciiChecked(name))
+ .ToHandleChecked());
+ return f;
+ }
+
+ JSOperatorBuilder* javascript() { return &javascript_; }
+
+ private:
+ JSOperatorBuilder javascript_;
+};
+
+
+namespace {
+
+// TODO(mstarzinger): Find a common place and unify with test-js-typed-lowering.
+Type* const kNumberTypes[] = {
+ Type::UnsignedSmall(), Type::OtherSignedSmall(), Type::OtherUnsigned31(),
+ Type::OtherUnsigned32(), Type::OtherSigned32(), Type::SignedSmall(),
+ Type::Signed32(), Type::Unsigned32(), Type::Integral32(),
+ Type::MinusZero(), Type::NaN(), Type::OtherNumber(),
+ Type::OrderedNumber(), Type::Number()};
+
+} // namespace
+
+
+// -----------------------------------------------------------------------------
+// Math.abs
+
+
+TEST_F(JSBuiltinReducerTest, MathAbs) {
+ Handle<JSFunction> f = MathFunction("abs");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call);
+
+ if (t0->Is(Type::Unsigned32())) {
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), p0);
+ } else {
+ Capture<Node*> branch;
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsSelect(kMachNone, IsNumberLessThan(IsNumberConstant(0), p0),
+ p0, IsNumberSubtract(IsNumberConstant(0), p0)));
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.sqrt
+
+
+TEST_F(JSBuiltinReducerTest, MathSqrt) {
+ Handle<JSFunction> f = MathFunction("sqrt");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsFloat64Sqrt(p0));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.max
+
+
+TEST_F(JSBuiltinReducerTest, MathMax0) {
+ Handle<JSFunction> f = MathFunction("max");
+
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(2, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant());
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsNumberConstant(-V8_INFINITY));
+}
+
+
+TEST_F(JSBuiltinReducerTest, MathMax1) {
+ Handle<JSFunction> f = MathFunction("max");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), p0);
+ }
+}
+
+
+TEST_F(JSBuiltinReducerTest, MathMax2) {
+ Handle<JSFunction> f = MathFunction("max");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ TRACED_FOREACH(Type*, t1, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* p1 = Parameter(t1, 1);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call = graph()->NewNode(
+ javascript()->CallFunction(4, NO_CALL_FUNCTION_FLAGS), fun,
+ UndefinedConstant(), p0, p1);
+ Reduction r = Reduce(call);
+
+ if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsSelect(kMachNone, IsNumberLessThan(p1, p0), p1, p0));
+ } else {
+ ASSERT_FALSE(r.Changed());
+ EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
+ }
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.imul
+
+
+TEST_F(JSBuiltinReducerTest, MathImul) {
+ Handle<JSFunction> f = MathFunction("imul");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ TRACED_FOREACH(Type*, t1, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* p1 = Parameter(t1, 1);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call = graph()->NewNode(
+ javascript()->CallFunction(4, NO_CALL_FUNCTION_FLAGS), fun,
+ UndefinedConstant(), p0, p1);
+ Reduction r = Reduce(call);
+
+ if (t0->Is(Type::Integral32()) && t1->Is(Type::Integral32())) {
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Mul(p0, p1));
+ } else {
+ ASSERT_FALSE(r.Changed());
+ EXPECT_EQ(IrOpcode::kJSCallFunction, call->opcode());
+ }
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.fround
+
+
+TEST_F(JSBuiltinReducerTest, MathFround) {
+ Handle<JSFunction> f = MathFunction("fround");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsTruncateFloat64ToFloat32(p0));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.floor
+
+
+TEST_F(JSBuiltinReducerTest, MathFloorAvailable) {
+ Handle<JSFunction> f = MathFunction("floor");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call, MachineOperatorBuilder::Flag::kFloat64Floor);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsFloat64Floor(p0));
+ }
+}
+
+
+TEST_F(JSBuiltinReducerTest, MathFloorUnavailable) {
+ Handle<JSFunction> f = MathFunction("floor");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call, MachineOperatorBuilder::Flag::kNoFlags);
+
+ ASSERT_FALSE(r.Changed());
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Math.ceil
+
+
+TEST_F(JSBuiltinReducerTest, MathCeilAvailable) {
+ Handle<JSFunction> f = MathFunction("ceil");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call, MachineOperatorBuilder::Flag::kFloat64Ceil);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsFloat64Ceil(p0));
+ }
+}
+
+
+TEST_F(JSBuiltinReducerTest, MathCeilUnavailable) {
+ Handle<JSFunction> f = MathFunction("ceil");
+
+ TRACED_FOREACH(Type*, t0, kNumberTypes) {
+ Node* p0 = Parameter(t0, 0);
+ Node* fun = HeapConstant(Unique<HeapObject>::CreateUninitialized(f));
+ Node* call =
+ graph()->NewNode(javascript()->CallFunction(3, NO_CALL_FUNCTION_FLAGS),
+ fun, UndefinedConstant(), p0);
+ Reduction r = Reduce(call, MachineOperatorBuilder::Flag::kNoFlags);
+
+ ASSERT_FALSE(r.Changed());
+ }
+}
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/js-operator.h"
+#include "src/compiler/operator-properties-inl.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// -----------------------------------------------------------------------------
+// Shared operators.
+
+namespace {
+
+struct SharedOperator {
+ const Operator* (JSOperatorBuilder::*constructor)();
+ IrOpcode::Value opcode;
+ Operator::Properties properties;
+ int value_input_count;
+ int frame_state_input_count;
+ int effect_input_count;
+ int control_input_count;
+ int value_output_count;
+ int effect_output_count;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const SharedOperator& sop) {
+ return os << IrOpcode::Mnemonic(sop.opcode);
+}
+
+
+const SharedOperator kSharedOperators[] = {
+#define SHARED(Name, properties, value_input_count, frame_state_input_count, \
+ effect_input_count, control_input_count, value_output_count, \
+ effect_output_count) \
+ { \
+ &JSOperatorBuilder::Name, IrOpcode::kJS##Name, properties, \
+ value_input_count, frame_state_input_count, effect_input_count, \
+ control_input_count, value_output_count, effect_output_count \
+ }
+ SHARED(Equal, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(NotEqual, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(StrictEqual, Operator::kPure, 2, 0, 0, 0, 1, 0),
+ SHARED(StrictNotEqual, Operator::kPure, 2, 0, 0, 0, 1, 0),
+ SHARED(LessThan, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(GreaterThan, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(LessThanOrEqual, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(GreaterThanOrEqual, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(BitwiseOr, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(BitwiseXor, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(BitwiseAnd, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(ShiftLeft, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(ShiftRight, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(ShiftRightLogical, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Add, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Subtract, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Multiply, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Divide, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Modulus, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(UnaryNot, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(ToBoolean, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(ToNumber, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(ToString, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(ToName, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(ToObject, Operator::kNoProperties, 1, 1, 1, 1, 1, 1),
+ SHARED(Yield, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(Create, Operator::kEliminatable, 0, 0, 1, 1, 1, 1),
+ SHARED(HasProperty, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(TypeOf, Operator::kPure, 1, 0, 0, 0, 1, 0),
+ SHARED(InstanceOf, Operator::kNoProperties, 2, 1, 1, 1, 1, 1),
+ SHARED(Debugger, Operator::kNoProperties, 0, 0, 1, 1, 0, 1),
+ SHARED(CreateFunctionContext, Operator::kNoProperties, 1, 0, 1, 1, 1, 1),
+ SHARED(CreateWithContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1),
+ SHARED(CreateBlockContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1),
+ SHARED(CreateModuleContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1),
+ SHARED(CreateGlobalContext, Operator::kNoProperties, 2, 0, 1, 1, 1, 1)
+#undef SHARED
+};
+
+} // namespace
+
+
+class JSSharedOperatorTest
+ : public TestWithZone,
+ public ::testing::WithParamInterface<SharedOperator> {};
+
+
+TEST_P(JSSharedOperatorTest, InstancesAreGloballyShared) {
+ const SharedOperator& sop = GetParam();
+ JSOperatorBuilder javascript1(zone());
+ JSOperatorBuilder javascript2(zone());
+ EXPECT_EQ((javascript1.*sop.constructor)(), (javascript2.*sop.constructor)());
+}
+
+
+TEST_P(JSSharedOperatorTest, NumberOfInputsAndOutputs) {
+ JSOperatorBuilder javascript(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (javascript.*sop.constructor)();
+
+ const int context_input_count = 1;
+ // TODO(jarin): Get rid of this hack.
+ const int frame_state_input_count =
+ FLAG_turbo_deoptimization ? sop.frame_state_input_count : 0;
+ EXPECT_EQ(sop.value_input_count, op->ValueInputCount());
+ EXPECT_EQ(context_input_count, OperatorProperties::GetContextInputCount(op));
+ EXPECT_EQ(frame_state_input_count,
+ OperatorProperties::GetFrameStateInputCount(op));
+ EXPECT_EQ(sop.effect_input_count, op->EffectInputCount());
+ EXPECT_EQ(sop.control_input_count, op->ControlInputCount());
+ EXPECT_EQ(sop.value_input_count + context_input_count +
+ frame_state_input_count + sop.effect_input_count +
+ sop.control_input_count,
+ OperatorProperties::GetTotalInputCount(op));
+
+ EXPECT_EQ(sop.value_output_count, op->ValueOutputCount());
+ EXPECT_EQ(sop.effect_output_count, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
+}
+
+
+TEST_P(JSSharedOperatorTest, OpcodeIsCorrect) {
+ JSOperatorBuilder javascript(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (javascript.*sop.constructor)();
+ EXPECT_EQ(sop.opcode, op->opcode());
+}
+
+
+TEST_P(JSSharedOperatorTest, Properties) {
+ JSOperatorBuilder javascript(zone());
+ const SharedOperator& sop = GetParam();
+ const Operator* op = (javascript.*sop.constructor)();
+ EXPECT_EQ(sop.properties, op->properties());
+}
+
+
+INSTANTIATE_TEST_CASE_P(JSOperatorTest, JSSharedOperatorTest,
+ ::testing::ValuesIn(kSharedOperators));
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/access-builder.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/js-operator.h"
+#include "src/compiler/js-typed-lowering.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/typer.h"
+#include "test/unittests/compiler/compiler-test-utils.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+namespace {
+
+const ExternalArrayType kExternalArrayTypes[] = {
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) kExternal##Type##Array,
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+#undef TYPED_ARRAY_CASE
+};
+
+
+const StrictMode kStrictModes[] = {SLOPPY, STRICT};
+
+} // namespace
+
+
+class JSTypedLoweringTest : public TypedGraphTest {
+ public:
+ JSTypedLoweringTest() : TypedGraphTest(3), javascript_(zone()) {}
+ virtual ~JSTypedLoweringTest() {}
+
+ protected:
+ Reduction Reduce(Node* node) {
+ MachineOperatorBuilder machine;
+ JSGraph jsgraph(graph(), common(), javascript(), &machine);
+ JSTypedLowering reducer(&jsgraph);
+ return reducer.Reduce(node);
+ }
+
+ Node* Parameter(Type* type, int index = 0) {
+ Node* node = graph()->NewNode(common()->Parameter(index), graph()->start());
+ NodeProperties::SetBounds(node, Bounds(Type::None(), type));
+ return node;
+ }
+
+ Handle<JSArrayBuffer> NewArrayBuffer(void* bytes, size_t byte_length) {
+ Handle<JSArrayBuffer> buffer = factory()->NewJSArrayBuffer();
+ Runtime::SetupArrayBuffer(isolate(), buffer, true, bytes, byte_length);
+ return buffer;
+ }
+
+ Matcher<Node*> IsIntPtrConstant(intptr_t value) {
+ return sizeof(value) == 4 ? IsInt32Constant(static_cast<int32_t>(value))
+ : IsInt64Constant(static_cast<int64_t>(value));
+ }
+
+ JSOperatorBuilder* javascript() { return &javascript_; }
+
+ private:
+ JSOperatorBuilder javascript_;
+};
+
+
+// -----------------------------------------------------------------------------
+// JSToBoolean
+
+
+TEST_F(JSTypedLoweringTest, JSToBooleanWithString) {
+ Node* input = Parameter(Type::String());
+ Node* context = UndefinedConstant();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+
+ Reduction r = Reduce(graph()->NewNode(javascript()->ToBoolean(), input,
+ context, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsBooleanNot(IsNumberEqual(
+ IsLoadField(AccessBuilder::ForStringLength(), input,
+ graph()->start(), graph()->start()),
+ IsNumberConstant(0))));
+}
+
+
+TEST_F(JSTypedLoweringTest, JSToBooleanWithOrderedNumberAndBoolean) {
+ Node* p0 = Parameter(Type::OrderedNumber(), 0);
+ Node* p1 = Parameter(Type::Boolean(), 1);
+ Node* context = UndefinedConstant();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+
+ Reduction r = Reduce(graph()->NewNode(
+ javascript()->ToBoolean(),
+ graph()->NewNode(common()->Phi(kMachAnyTagged, 2), p0, p1, control),
+ context, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsPhi(kMachAnyTagged,
+ IsBooleanNot(IsNumberEqual(p0, IsNumberConstant(0))), p1, control));
+}
+
+
+// -----------------------------------------------------------------------------
+// JSLoadProperty
+
+
+TEST_F(JSTypedLoweringTest, JSLoadPropertyFromExternalTypedArray) {
+ const size_t kLength = 17;
+ double backing_store[kLength];
+ Handle<JSArrayBuffer> buffer =
+ NewArrayBuffer(backing_store, sizeof(backing_store));
+ VectorSlotPair feedback(Handle<TypeFeedbackVector>::null(),
+ FeedbackVectorICSlot::Invalid());
+ TRACED_FOREACH(ExternalArrayType, type, kExternalArrayTypes) {
+ Handle<JSTypedArray> array =
+ factory()->NewJSTypedArray(type, buffer, 0, kLength);
+
+ Node* key = Parameter(Type::Integral32());
+ Node* base = HeapConstant(array);
+ Node* context = UndefinedConstant();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* node = graph()->NewNode(javascript()->LoadProperty(feedback), base,
+ key, context);
+ if (FLAG_turbo_deoptimization) {
+ node->AppendInput(zone(), UndefinedConstant());
+ }
+ node->AppendInput(zone(), effect);
+ node->AppendInput(zone(), control);
+ Reduction r = Reduce(node);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsLoadElement(
+ AccessBuilder::ForTypedArrayElement(type, true),
+ IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+ key, IsNumberConstant(array->length()->Number()), effect));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// JSStoreProperty
+
+
+TEST_F(JSTypedLoweringTest, JSStorePropertyToExternalTypedArray) {
+ const size_t kLength = 17;
+ double backing_store[kLength];
+ Handle<JSArrayBuffer> buffer =
+ NewArrayBuffer(backing_store, sizeof(backing_store));
+ TRACED_FOREACH(ExternalArrayType, type, kExternalArrayTypes) {
+ TRACED_FOREACH(StrictMode, strict_mode, kStrictModes) {
+ Handle<JSTypedArray> array =
+ factory()->NewJSTypedArray(type, buffer, 0, kLength);
+
+ Node* key = Parameter(Type::Integral32());
+ Node* base = HeapConstant(array);
+ Node* value = Parameter(Type::Any());
+ Node* context = UndefinedConstant();
+ Node* effect = graph()->start();
+ Node* control = graph()->start();
+ Node* node = graph()->NewNode(javascript()->StoreProperty(strict_mode),
+ base, key, value, context);
+ if (FLAG_turbo_deoptimization) {
+ node->AppendInput(zone(), UndefinedConstant());
+ }
+ node->AppendInput(zone(), effect);
+ node->AppendInput(zone(), control);
+ Reduction r = Reduce(node);
+
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStoreElement(
+ AccessBuilder::ForTypedArrayElement(type, true),
+ IsIntPtrConstant(bit_cast<intptr_t>(&backing_store[0])),
+ key, IsNumberConstant(array->length()->Number()), value,
+ effect, control));
+ }
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/base/bits.h"
+#include "src/base/division-by-constant.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/machine-operator-reducer.h"
+#include "src/compiler/typer.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::AllOf;
+using testing::Capture;
+using testing::CaptureEq;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class MachineOperatorReducerTest : public TypedGraphTest {
+ public:
+ explicit MachineOperatorReducerTest(int num_parameters = 2)
+ : TypedGraphTest(num_parameters) {}
+
+ protected:
+ Reduction Reduce(Node* node) {
+ JSOperatorBuilder javascript(zone());
+ JSGraph jsgraph(graph(), common(), &javascript, &machine_);
+ MachineOperatorReducer reducer(&jsgraph);
+ return reducer.Reduce(node);
+ }
+
+ Matcher<Node*> IsTruncatingDiv(const Matcher<Node*>& dividend_matcher,
+ const int32_t divisor) {
+ base::MagicNumbersForDivision<uint32_t> const mag =
+ base::SignedDivisionByConstant(bit_cast<uint32_t>(divisor));
+ int32_t const multiplier = bit_cast<int32_t>(mag.multiplier);
+ int32_t const shift = bit_cast<int32_t>(mag.shift);
+ Matcher<Node*> quotient_matcher =
+ IsInt32MulHigh(dividend_matcher, IsInt32Constant(multiplier));
+ if (divisor > 0 && multiplier < 0) {
+ quotient_matcher = IsInt32Add(quotient_matcher, dividend_matcher);
+ } else if (divisor < 0 && multiplier > 0) {
+ quotient_matcher = IsInt32Sub(quotient_matcher, dividend_matcher);
+ }
+ if (shift) {
+ quotient_matcher = IsWord32Sar(quotient_matcher, IsInt32Constant(shift));
+ }
+ return IsInt32Add(quotient_matcher,
+ IsWord32Shr(dividend_matcher, IsInt32Constant(31)));
+ }
+
+ MachineOperatorBuilder* machine() { return &machine_; }
+
+ private:
+ MachineOperatorBuilder machine_;
+};
+
+
+template <typename T>
+class MachineOperatorReducerTestWithParam
+ : public MachineOperatorReducerTest,
+ public ::testing::WithParamInterface<T> {
+ public:
+ explicit MachineOperatorReducerTestWithParam(int num_parameters = 2)
+ : MachineOperatorReducerTest(num_parameters) {}
+ virtual ~MachineOperatorReducerTestWithParam() {}
+};
+
+
+namespace {
+
+const float kFloat32Values[] = {
+ -std::numeric_limits<float>::infinity(), -2.70497e+38f, -1.4698e+37f,
+ -1.22813e+35f, -1.20555e+35f, -1.34584e+34f,
+ -1.0079e+32f, -6.49364e+26f, -3.06077e+25f,
+ -1.46821e+25f, -1.17658e+23f, -1.9617e+22f,
+ -2.7357e+20f, -1.48708e+13f, -1.89633e+12f,
+ -4.66622e+11f, -2.22581e+11f, -1.45381e+10f,
+ -1.3956e+09f, -1.32951e+09f, -1.30721e+09f,
+ -1.19756e+09f, -9.26822e+08f, -6.35647e+08f,
+ -4.00037e+08f, -1.81227e+08f, -5.09256e+07f,
+ -964300.0f, -192446.0f, -28455.0f,
+ -27194.0f, -26401.0f, -20575.0f,
+ -17069.0f, -9167.0f, -960.178f,
+ -113.0f, -62.0f, -15.0f,
+ -7.0f, -0.0256635f, -4.60374e-07f,
+ -3.63759e-10f, -4.30175e-14f, -5.27385e-15f,
+ -1.48084e-15f, -1.05755e-19f, -3.2995e-21f,
+ -1.67354e-23f, -1.11885e-23f, -1.78506e-30f,
+ -5.07594e-31f, -3.65799e-31f, -1.43718e-34f,
+ -1.27126e-38f, -0.0f, 0.0f,
+ 1.17549e-38f, 1.56657e-37f, 4.08512e-29f,
+ 3.31357e-28f, 6.25073e-22f, 4.1723e-13f,
+ 1.44343e-09f, 5.27004e-08f, 9.48298e-08f,
+ 5.57888e-07f, 4.89988e-05f, 0.244326f,
+ 12.4895f, 19.0f, 47.0f,
+ 106.0f, 538.324f, 564.536f,
+ 819.124f, 7048.0f, 12611.0f,
+ 19878.0f, 20309.0f, 797056.0f,
+ 1.77219e+09f, 1.51116e+11f, 4.18193e+13f,
+ 3.59167e+16f, 3.38211e+19f, 2.67488e+20f,
+ 1.78831e+21f, 9.20914e+21f, 8.35654e+23f,
+ 1.4495e+24f, 5.94015e+25f, 4.43608e+30f,
+ 2.44502e+33f, 2.61152e+33f, 1.38178e+37f,
+ 1.71306e+37f, 3.31899e+38f, 3.40282e+38f,
+ std::numeric_limits<float>::infinity()};
+
+
+const double kFloat64Values[] = {
+ -V8_INFINITY, -4.23878e+275, -5.82632e+265, -6.60355e+220, -6.26172e+212,
+ -2.56222e+211, -4.82408e+201, -1.84106e+157, -1.63662e+127, -1.55772e+100,
+ -1.67813e+72, -2.3382e+55, -3.179e+30, -1.441e+09, -1.0647e+09,
+ -7.99361e+08, -5.77375e+08, -2.20984e+08, -32757, -13171,
+ -9970, -3984, -107, -105, -92,
+ -77, -61, -0.000208163, -1.86685e-06, -1.17296e-10,
+ -9.26358e-11, -5.08004e-60, -1.74753e-65, -1.06561e-71, -5.67879e-79,
+ -5.78459e-130, -2.90989e-171, -7.15489e-243, -3.76242e-252, -1.05639e-263,
+ -4.40497e-267, -2.19666e-273, -4.9998e-276, -5.59821e-278, -2.03855e-282,
+ -5.99335e-283, -7.17554e-284, -3.11744e-309, -0.0, 0.0,
+ 2.22507e-308, 1.30127e-270, 7.62898e-260, 4.00313e-249, 3.16829e-233,
+ 1.85244e-228, 2.03544e-129, 1.35126e-110, 1.01182e-106, 5.26333e-94,
+ 1.35292e-90, 2.85394e-83, 1.78323e-77, 5.4967e-57, 1.03207e-25,
+ 4.57401e-25, 1.58738e-05, 2, 125, 2310,
+ 9636, 14802, 17168, 28945, 29305,
+ 4.81336e+07, 1.41207e+08, 4.65962e+08, 1.40499e+09, 2.12648e+09,
+ 8.80006e+30, 1.4446e+45, 1.12164e+54, 2.48188e+89, 6.71121e+102,
+ 3.074e+112, 4.9699e+152, 5.58383e+166, 4.30654e+172, 7.08824e+185,
+ 9.6586e+214, 2.028e+223, 6.63277e+243, 1.56192e+261, 1.23202e+269,
+ 5.72883e+289, 8.5798e+290, 1.40256e+294, 1.79769e+308, V8_INFINITY};
+
+
+const int32_t kInt32Values[] = {
+ std::numeric_limits<int32_t>::min(), -1914954528, -1698749618,
+ -1578693386, -1577976073, -1573998034,
+ -1529085059, -1499540537, -1299205097,
+ -1090814845, -938186388, -806828902,
+ -750927650, -520676892, -513661538,
+ -453036354, -433622833, -282638793,
+ -28375, -27788, -22770,
+ -18806, -14173, -11956,
+ -11200, -10212, -8160,
+ -3751, -2758, -1522,
+ -121, -120, -118,
+ -117, -106, -84,
+ -80, -74, -59,
+ -52, -48, -39,
+ -35, -17, -11,
+ -10, -9, -7,
+ -5, 0, 9,
+ 12, 17, 23,
+ 29, 31, 33,
+ 35, 40, 47,
+ 55, 56, 62,
+ 64, 67, 68,
+ 69, 74, 79,
+ 84, 89, 90,
+ 97, 104, 118,
+ 124, 126, 127,
+ 7278, 17787, 24136,
+ 24202, 25570, 26680,
+ 30242, 32399, 420886487,
+ 642166225, 821912648, 822577803,
+ 851385718, 1212241078, 1411419304,
+ 1589626102, 1596437184, 1876245816,
+ 1954730266, 2008792749, 2045320228,
+ std::numeric_limits<int32_t>::max()};
+
+
+const int64_t kInt64Values[] = {
+ std::numeric_limits<int64_t>::min(), V8_INT64_C(-8974392461363618006),
+ V8_INT64_C(-8874367046689588135), V8_INT64_C(-8269197512118230839),
+ V8_INT64_C(-8146091527100606733), V8_INT64_C(-7550917981466150848),
+ V8_INT64_C(-7216590251577894337), V8_INT64_C(-6464086891160048440),
+ V8_INT64_C(-6365616494908257190), V8_INT64_C(-6305630541365849726),
+ V8_INT64_C(-5982222642272245453), V8_INT64_C(-5510103099058504169),
+ V8_INT64_C(-5496838675802432701), V8_INT64_C(-4047626578868642657),
+ V8_INT64_C(-4033755046900164544), V8_INT64_C(-3554299241457877041),
+ V8_INT64_C(-2482258764588614470), V8_INT64_C(-1688515425526875335),
+ V8_INT64_C(-924784137176548532), V8_INT64_C(-725316567157391307),
+ V8_INT64_C(-439022654781092241), V8_INT64_C(-105545757668917080),
+ V8_INT64_C(-2088319373), V8_INT64_C(-2073699916),
+ V8_INT64_C(-1844949911), V8_INT64_C(-1831090548),
+ V8_INT64_C(-1756711933), V8_INT64_C(-1559409497),
+ V8_INT64_C(-1281179700), V8_INT64_C(-1211513985),
+ V8_INT64_C(-1182371520), V8_INT64_C(-785934753),
+ V8_INT64_C(-767480697), V8_INT64_C(-705745662),
+ V8_INT64_C(-514362436), V8_INT64_C(-459916580),
+ V8_INT64_C(-312328082), V8_INT64_C(-302949707),
+ V8_INT64_C(-285499304), V8_INT64_C(-125701262),
+ V8_INT64_C(-95139843), V8_INT64_C(-32768),
+ V8_INT64_C(-27542), V8_INT64_C(-23600),
+ V8_INT64_C(-18582), V8_INT64_C(-17770),
+ V8_INT64_C(-9086), V8_INT64_C(-9010),
+ V8_INT64_C(-8244), V8_INT64_C(-2890),
+ V8_INT64_C(-103), V8_INT64_C(-34),
+ V8_INT64_C(-27), V8_INT64_C(-25),
+ V8_INT64_C(-9), V8_INT64_C(-7),
+ V8_INT64_C(0), V8_INT64_C(2),
+ V8_INT64_C(38), V8_INT64_C(58),
+ V8_INT64_C(65), V8_INT64_C(93),
+ V8_INT64_C(111), V8_INT64_C(1003),
+ V8_INT64_C(1267), V8_INT64_C(12797),
+ V8_INT64_C(23122), V8_INT64_C(28200),
+ V8_INT64_C(30888), V8_INT64_C(42648848),
+ V8_INT64_C(116836693), V8_INT64_C(263003643),
+ V8_INT64_C(571039860), V8_INT64_C(1079398689),
+ V8_INT64_C(1145196402), V8_INT64_C(1184846321),
+ V8_INT64_C(1758281648), V8_INT64_C(1859991374),
+ V8_INT64_C(1960251588), V8_INT64_C(2042443199),
+ V8_INT64_C(296220586027987448), V8_INT64_C(1015494173071134726),
+ V8_INT64_C(1151237951914455318), V8_INT64_C(1331941174616854174),
+ V8_INT64_C(2022020418667972654), V8_INT64_C(2450251424374977035),
+ V8_INT64_C(3668393562685561486), V8_INT64_C(4858229301215502171),
+ V8_INT64_C(4919426235170669383), V8_INT64_C(5034286595330341762),
+ V8_INT64_C(5055797915536941182), V8_INT64_C(6072389716149252074),
+ V8_INT64_C(6185309910199801210), V8_INT64_C(6297328311011094138),
+ V8_INT64_C(6932372858072165827), V8_INT64_C(8483640924987737210),
+ V8_INT64_C(8663764179455849203), V8_INT64_C(8877197042645298254),
+ V8_INT64_C(8901543506779157333), std::numeric_limits<int64_t>::max()};
+
+
+const uint32_t kUint32Values[] = {
+ 0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
+ 0x273a798e, 0x187937a3, 0xece3af83, 0x5495a16b, 0x0b668ecc, 0x11223344,
+ 0x0000009e, 0x00000043, 0x0000af73, 0x0000116b, 0x00658ecc, 0x002b3b4c,
+ 0x88776655, 0x70000000, 0x07200000, 0x7fffffff, 0x56123761, 0x7fffff00,
+ 0x761c4761, 0x80000000, 0x88888888, 0xa0000000, 0xdddddddd, 0xe0000000,
+ 0xeeeeeeee, 0xfffffffd, 0xf0000000, 0x007fffff, 0x003fffff, 0x001fffff,
+ 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff,
+ 0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff};
+
+} // namespace
+
+
+// -----------------------------------------------------------------------------
+// Unary operators
+
+
+namespace {
+
+struct UnaryOperator {
+ const Operator* (MachineOperatorBuilder::*constructor)();
+ const char* constructor_name;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const UnaryOperator& unop) {
+ return os << unop.constructor_name;
+}
+
+
+static const UnaryOperator kUnaryOperators[] = {
+ {&MachineOperatorBuilder::ChangeInt32ToFloat64, "ChangeInt32ToFloat64"},
+ {&MachineOperatorBuilder::ChangeUint32ToFloat64, "ChangeUint32ToFloat64"},
+ {&MachineOperatorBuilder::ChangeFloat64ToInt32, "ChangeFloat64ToInt32"},
+ {&MachineOperatorBuilder::ChangeFloat64ToUint32, "ChangeFloat64ToUint32"},
+ {&MachineOperatorBuilder::ChangeInt32ToInt64, "ChangeInt32ToInt64"},
+ {&MachineOperatorBuilder::ChangeUint32ToUint64, "ChangeUint32ToUint64"},
+ {&MachineOperatorBuilder::TruncateFloat64ToInt32, "TruncateFloat64ToInt32"},
+ {&MachineOperatorBuilder::TruncateInt64ToInt32, "TruncateInt64ToInt32"}};
+
+} // namespace
+
+
+typedef MachineOperatorReducerTestWithParam<UnaryOperator>
+ MachineUnaryOperatorReducerTest;
+
+
+TEST_P(MachineUnaryOperatorReducerTest, Parameter) {
+ const UnaryOperator unop = GetParam();
+ Reduction reduction =
+ Reduce(graph()->NewNode((machine()->*unop.constructor)(), Parameter(0)));
+ EXPECT_FALSE(reduction.Changed());
+}
+
+
+INSTANTIATE_TEST_CASE_P(MachineOperatorReducerTest,
+ MachineUnaryOperatorReducerTest,
+ ::testing::ValuesIn(kUnaryOperators));
+
+
+// -----------------------------------------------------------------------------
+// ChangeFloat64ToFloat32
+
+
+TEST_F(MachineOperatorReducerTest, ChangeFloat64ToFloat32WithConstant) {
+ TRACED_FOREACH(float, x, kFloat32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat32ToFloat64(), Float32Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat64Constant(x));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeFloat64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest,
+ ChangeFloat64ToInt32WithChangeInt32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, ChangeFloat64ToInt32WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToInt32(), Float64Constant(FastI2D(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt32Constant(x));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeFloat64ToUint32
+
+
+TEST_F(MachineOperatorReducerTest,
+ ChangeFloat64ToUint32WithChangeUint32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToUint32(),
+ graph()->NewNode(machine()->ChangeUint32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, ChangeFloat64ToUint32WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToUint32(), Float64Constant(FastUI2D(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt32Constant(bit_cast<int32_t>(x)));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeInt32ToFloat64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeInt32ToFloat64WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), Int32Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastI2D(x)));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeInt32ToInt64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeInt32ToInt64WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->ChangeInt32ToInt64(), Int32Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt64Constant(x));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeUint32ToFloat64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeUint32ToFloat64WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction =
+ Reduce(graph()->NewNode(machine()->ChangeUint32ToFloat64(),
+ Int32Constant(bit_cast<int32_t>(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastUI2D(x)));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// ChangeUint32ToUint64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeUint32ToUint64WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction =
+ Reduce(graph()->NewNode(machine()->ChangeUint32ToUint64(),
+ Int32Constant(bit_cast<int32_t>(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+ IsInt64Constant(bit_cast<int64_t>(static_cast<uint64_t>(x))));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// TruncateFloat64ToFloat32
+
+
+TEST_F(MachineOperatorReducerTest,
+ TruncateFloat64ToFloat32WithChangeFloat32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToFloat32(),
+ graph()->NewNode(machine()->ChangeFloat32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateFloat64ToFloat32WithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToFloat32(), Float64Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat32Constant(DoubleToFloat32(x)));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// TruncateFloat64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest,
+ TruncateFloat64ToInt32WithChangeInt32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateFloat64ToInt32WithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToInt32(), Float64Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(x)));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateFloat64ToInt32WithPhi) {
+ Node* const p0 = Parameter(0);
+ Node* const p1 = Parameter(1);
+ Node* const merge = graph()->start();
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToInt32(),
+ graph()->NewNode(common()->Phi(kMachFloat64, 2), p0, p1, merge)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+ IsPhi(kMachInt32, IsTruncateFloat64ToInt32(p0),
+ IsTruncateFloat64ToInt32(p1), merge));
+}
+
+
+// -----------------------------------------------------------------------------
+// TruncateInt64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest, TruncateInt64ToInt32WithChangeInt32ToInt64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateInt64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToInt64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateInt64ToInt32WithConstant) {
+ TRACED_FOREACH(int64_t, x, kInt64Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->TruncateInt64ToInt32(), Int64Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+ IsInt32Constant(bit_cast<int32_t>(
+ static_cast<uint32_t>(bit_cast<uint64_t>(x)))));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Word32And
+
+
+TEST_F(MachineOperatorReducerTest, Word32AndWithWord32AndWithConstant) {
+ Node* const p0 = Parameter(0);
+
+ TRACED_FOREACH(int32_t, k, kInt32Values) {
+ TRACED_FOREACH(int32_t, l, kInt32Values) {
+ if (k == 0 || k == -1 || l == 0 || l == -1) continue;
+
+ // (x & K) & L => x & (K & L)
+ Reduction const r1 = Reduce(graph()->NewNode(
+ machine()->Word32And(),
+ graph()->NewNode(machine()->Word32And(), p0, Int32Constant(k)),
+ Int32Constant(l)));
+ ASSERT_TRUE(r1.Changed());
+ EXPECT_THAT(r1.replacement(), IsWord32And(p0, IsInt32Constant(k & l)));
+
+ // (K & x) & L => x & (K & L)
+ Reduction const r2 = Reduce(graph()->NewNode(
+ machine()->Word32And(),
+ graph()->NewNode(machine()->Word32And(), Int32Constant(k), p0),
+ Int32Constant(l)));
+ ASSERT_TRUE(r2.Changed());
+ EXPECT_THAT(r2.replacement(), IsWord32And(p0, IsInt32Constant(k & l)));
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Word32Xor
+
+
+TEST_F(MachineOperatorReducerTest, Word32XorWithWord32XorAndMinusOne) {
+ Node* const p0 = Parameter(0);
+
+ // (x ^ -1) ^ -1 => x
+ Reduction r1 = Reduce(graph()->NewNode(
+ machine()->Word32Xor(),
+ graph()->NewNode(machine()->Word32Xor(), p0, Int32Constant(-1)),
+ Int32Constant(-1)));
+ ASSERT_TRUE(r1.Changed());
+ EXPECT_EQ(r1.replacement(), p0);
+
+ // -1 ^ (x ^ -1) => x
+ Reduction r2 = Reduce(graph()->NewNode(
+ machine()->Word32Xor(), Int32Constant(-1),
+ graph()->NewNode(machine()->Word32Xor(), p0, Int32Constant(-1))));
+ ASSERT_TRUE(r2.Changed());
+ EXPECT_EQ(r2.replacement(), p0);
+
+ // (-1 ^ x) ^ -1 => x
+ Reduction r3 = Reduce(graph()->NewNode(
+ machine()->Word32Xor(),
+ graph()->NewNode(machine()->Word32Xor(), Int32Constant(-1), p0),
+ Int32Constant(-1)));
+ ASSERT_TRUE(r3.Changed());
+ EXPECT_EQ(r3.replacement(), p0);
+
+ // -1 ^ (-1 ^ x) => x
+ Reduction r4 = Reduce(graph()->NewNode(
+ machine()->Word32Xor(), Int32Constant(-1),
+ graph()->NewNode(machine()->Word32Xor(), Int32Constant(-1), p0)));
+ ASSERT_TRUE(r4.Changed());
+ EXPECT_EQ(r4.replacement(), p0);
+}
+
+
+// -----------------------------------------------------------------------------
+// Word32Ror
+
+
+TEST_F(MachineOperatorReducerTest, ReduceToWord32RorWithParameters) {
+ Node* value = Parameter(0);
+ Node* shift = Parameter(1);
+ Node* shl = graph()->NewNode(machine()->Word32Shl(), value, shift);
+ Node* shr = graph()->NewNode(
+ machine()->Word32Shr(), value,
+ graph()->NewNode(machine()->Int32Sub(), Int32Constant(32), shift));
+
+ // (x << y) | (x >> (32 - y)) => x ror y
+ Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
+ Reduction reduction1 = Reduce(node1);
+ EXPECT_TRUE(reduction1.Changed());
+ EXPECT_EQ(reduction1.replacement(), node1);
+ EXPECT_THAT(reduction1.replacement(), IsWord32Ror(value, shift));
+
+ // (x >> (32 - y)) | (x << y) => x ror y
+ Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
+ Reduction reduction2 = Reduce(node2);
+ EXPECT_TRUE(reduction2.Changed());
+ EXPECT_EQ(reduction2.replacement(), node2);
+ EXPECT_THAT(reduction2.replacement(), IsWord32Ror(value, shift));
+}
+
+
+TEST_F(MachineOperatorReducerTest, ReduceToWord32RorWithConstant) {
+ Node* value = Parameter(0);
+ TRACED_FORRANGE(int32_t, k, 0, 31) {
+ Node* shl =
+ graph()->NewNode(machine()->Word32Shl(), value, Int32Constant(k));
+ Node* shr =
+ graph()->NewNode(machine()->Word32Shr(), value, Int32Constant(32 - k));
+
+ // (x << K) | (x >> ((32 - K) - y)) => x ror K
+ Node* node1 = graph()->NewNode(machine()->Word32Or(), shl, shr);
+ Reduction reduction1 = Reduce(node1);
+ EXPECT_TRUE(reduction1.Changed());
+ EXPECT_EQ(reduction1.replacement(), node1);
+ EXPECT_THAT(reduction1.replacement(),
+ IsWord32Ror(value, IsInt32Constant(k)));
+
+ // (x >> (32 - K)) | (x << K) => x ror K
+ Node* node2 = graph()->NewNode(machine()->Word32Or(), shr, shl);
+ Reduction reduction2 = Reduce(node2);
+ EXPECT_TRUE(reduction2.Changed());
+ EXPECT_EQ(reduction2.replacement(), node2);
+ EXPECT_THAT(reduction2.replacement(),
+ IsWord32Ror(value, IsInt32Constant(k)));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Word32RorWithZeroShift) {
+ Node* value = Parameter(0);
+ Node* node =
+ graph()->NewNode(machine()->Word32Ror(), value, Int32Constant(0));
+ Reduction reduction = Reduce(node);
+ EXPECT_TRUE(reduction.Changed());
+ EXPECT_EQ(reduction.replacement(), value);
+}
+
+
+TEST_F(MachineOperatorReducerTest, Word32RorWithConstants) {
+ TRACED_FOREACH(int32_t, x, kUint32Values) {
+ TRACED_FORRANGE(int32_t, y, 0, 31) {
+ Node* node = graph()->NewNode(machine()->Word32Ror(), Int32Constant(x),
+ Int32Constant(y));
+ Reduction reduction = Reduce(node);
+ EXPECT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+ IsInt32Constant(base::bits::RotateRight32(x, y)));
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Word32Shl
+
+
+TEST_F(MachineOperatorReducerTest, Word32ShlWithZeroShift) {
+ Node* p0 = Parameter(0);
+ Node* node = graph()->NewNode(machine()->Word32Shl(), p0, Int32Constant(0));
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(p0, r.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, Word32ShlWithWord32Sar) {
+ Node* p0 = Parameter(0);
+ TRACED_FORRANGE(int32_t, x, 1, 31) {
+ Node* node = graph()->NewNode(
+ machine()->Word32Shl(),
+ graph()->NewNode(machine()->Word32Sar(), p0, Int32Constant(x)),
+ Int32Constant(x));
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
+ EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Word32ShlWithWord32Shr) {
+ Node* p0 = Parameter(0);
+ TRACED_FORRANGE(int32_t, x, 1, 31) {
+ Node* node = graph()->NewNode(
+ machine()->Word32Shl(),
+ graph()->NewNode(machine()->Word32Shr(), p0, Int32Constant(x)),
+ Int32Constant(x));
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ int32_t m = bit_cast<int32_t>(~((1U << x) - 1U));
+ EXPECT_THAT(r.replacement(), IsWord32And(p0, IsInt32Constant(m)));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Int32Div
+
+
+TEST_F(MachineOperatorReducerTest, Int32DivWithConstant) {
+ Node* const p0 = Parameter(0);
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(0), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(r.replacement(), p0);
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(-1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Sub(IsInt32Constant(0), p0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(2), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsWord32Sar(IsInt32Add(IsWord32Shr(p0, IsInt32Constant(31)), p0),
+ IsInt32Constant(1)));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(-2), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsInt32Sub(
+ IsInt32Constant(0),
+ IsWord32Sar(IsInt32Add(IsWord32Shr(p0, IsInt32Constant(31)), p0),
+ IsInt32Constant(1))));
+ }
+ TRACED_FORRANGE(int32_t, shift, 2, 30) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Int32Div(), p0,
+ Int32Constant(1 << shift), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsWord32Sar(IsInt32Add(IsWord32Shr(IsWord32Sar(p0, IsInt32Constant(31)),
+ IsInt32Constant(32 - shift)),
+ p0),
+ IsInt32Constant(shift)));
+ }
+ TRACED_FORRANGE(int32_t, shift, 2, 31) {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0,
+ Uint32Constant(bit_cast<uint32_t, int32_t>(-1) << shift),
+ graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsInt32Sub(
+ IsInt32Constant(0),
+ IsWord32Sar(
+ IsInt32Add(IsWord32Shr(IsWord32Sar(p0, IsInt32Constant(31)),
+ IsInt32Constant(32 - shift)),
+ p0),
+ IsInt32Constant(shift))));
+ }
+ TRACED_FOREACH(int32_t, divisor, kInt32Values) {
+ if (divisor < 0) {
+ if (base::bits::IsPowerOfTwo32(-divisor)) continue;
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Sub(IsInt32Constant(0),
+ IsTruncatingDiv(p0, -divisor)));
+ } else if (divisor > 0) {
+ if (base::bits::IsPowerOfTwo32(divisor)) continue;
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Div(), p0, Int32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsTruncatingDiv(p0, divisor));
+ }
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Int32DivWithParameters) {
+ Node* const p0 = Parameter(0);
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Int32Div(), p0, p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsWord32Equal(IsWord32Equal(p0, IsInt32Constant(0)), IsInt32Constant(0)));
+}
+
+
+// -----------------------------------------------------------------------------
+// Uint32Div
+
+
+TEST_F(MachineOperatorReducerTest, Uint32DivWithConstant) {
+ Node* const p0 = Parameter(0);
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Div(), Int32Constant(0), p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Div(), p0, Int32Constant(0), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Div(), p0, Int32Constant(1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(r.replacement(), p0);
+ }
+ TRACED_FOREACH(uint32_t, dividend, kUint32Values) {
+ TRACED_FOREACH(uint32_t, divisor, kUint32Values) {
+ Reduction const r = Reduce(
+ graph()->NewNode(machine()->Uint32Div(), Uint32Constant(dividend),
+ Uint32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Constant(bit_cast<int32_t>(
+ base::bits::UnsignedDiv32(dividend, divisor))));
+ }
+ }
+ TRACED_FORRANGE(uint32_t, shift, 1, 31) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Uint32Div(), p0,
+ Uint32Constant(1u << shift), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsWord32Shr(p0, IsInt32Constant(bit_cast<int32_t>(shift))));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Uint32DivWithParameters) {
+ Node* const p0 = Parameter(0);
+ Reduction const r = Reduce(
+ graph()->NewNode(machine()->Uint32Div(), p0, p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsWord32Equal(IsWord32Equal(p0, IsInt32Constant(0)), IsInt32Constant(0)));
+}
+
+
+// -----------------------------------------------------------------------------
+// Int32Mod
+
+
+TEST_F(MachineOperatorReducerTest, Int32ModWithConstant) {
+ Node* const p0 = Parameter(0);
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), Int32Constant(0), p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), p0, Int32Constant(0), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), p0, Int32Constant(1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), p0, Int32Constant(-1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ TRACED_FOREACH(int32_t, dividend, kInt32Values) {
+ TRACED_FOREACH(int32_t, divisor, kInt32Values) {
+ Reduction const r = Reduce(
+ graph()->NewNode(machine()->Int32Mod(), Int32Constant(dividend),
+ Int32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Constant(base::bits::SignedMod32(dividend, divisor)));
+ }
+ }
+ TRACED_FORRANGE(int32_t, shift, 1, 30) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Int32Mod(), p0,
+ Int32Constant(1 << shift), graph()->start()));
+ int32_t const mask = (1 << shift) - 1;
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsSelect(kMachInt32, IsInt32LessThan(p0, IsInt32Constant(0)),
+ IsInt32Sub(IsInt32Constant(0),
+ IsWord32And(IsInt32Sub(IsInt32Constant(0), p0),
+ IsInt32Constant(mask))),
+ IsWord32And(p0, IsInt32Constant(mask))));
+ }
+ TRACED_FORRANGE(int32_t, shift, 1, 31) {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), p0,
+ Uint32Constant(bit_cast<uint32_t, int32_t>(-1) << shift),
+ graph()->start()));
+ int32_t const mask = bit_cast<int32_t, uint32_t>((1U << shift) - 1);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsSelect(kMachInt32, IsInt32LessThan(p0, IsInt32Constant(0)),
+ IsInt32Sub(IsInt32Constant(0),
+ IsWord32And(IsInt32Sub(IsInt32Constant(0), p0),
+ IsInt32Constant(mask))),
+ IsWord32And(p0, IsInt32Constant(mask))));
+ }
+ TRACED_FOREACH(int32_t, divisor, kInt32Values) {
+ if (divisor == 0 || base::bits::IsPowerOfTwo32(Abs(divisor))) continue;
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Int32Mod(), p0, Int32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Sub(p0, IsInt32Mul(IsTruncatingDiv(p0, Abs(divisor)),
+ IsInt32Constant(Abs(divisor)))));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Int32ModWithParameters) {
+ Node* const p0 = Parameter(0);
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Int32Mod(), p0, p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+}
+
+
+// -----------------------------------------------------------------------------
+// Uint32Mod
+
+
+TEST_F(MachineOperatorReducerTest, Uint32ModWithConstant) {
+ Node* const p0 = Parameter(0);
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Mod(), p0, Int32Constant(0), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Mod(), Int32Constant(0), p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ {
+ Reduction const r = Reduce(graph()->NewNode(
+ machine()->Uint32Mod(), p0, Int32Constant(1), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+ }
+ TRACED_FOREACH(uint32_t, dividend, kUint32Values) {
+ TRACED_FOREACH(uint32_t, divisor, kUint32Values) {
+ Reduction const r = Reduce(
+ graph()->NewNode(machine()->Uint32Mod(), Uint32Constant(dividend),
+ Uint32Constant(divisor), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Constant(bit_cast<int32_t>(
+ base::bits::UnsignedMod32(dividend, divisor))));
+ }
+ }
+ TRACED_FORRANGE(uint32_t, shift, 1, 31) {
+ Reduction const r =
+ Reduce(graph()->NewNode(machine()->Uint32Mod(), p0,
+ Uint32Constant(1u << shift), graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsWord32And(p0, IsInt32Constant(
+ bit_cast<int32_t>((1u << shift) - 1u))));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Uint32ModWithParameters) {
+ Node* const p0 = Parameter(0);
+ Reduction const r = Reduce(
+ graph()->NewNode(machine()->Uint32Mod(), p0, p0, graph()->start()));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+}
+
+
+// -----------------------------------------------------------------------------
+// Int32AddWithOverflow
+
+
+TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithZero) {
+ Node* p0 = Parameter(0);
+ {
+ Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(),
+ Int32Constant(0), p0);
+
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+
+ r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(p0, r.replacement());
+ }
+ {
+ Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), p0,
+ Int32Constant(0));
+
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+
+ r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(p0, r.replacement());
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, Int32AddWithOverflowWithConstant) {
+ 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));
+
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Constant(base::bits::SignedAddOverflow32(x, y, &z)));
+
+ r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(z));
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Int32SubWithOverflow
+
+
+TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithZero) {
+ Node* p0 = Parameter(0);
+ Node* add =
+ graph()->NewNode(machine()->Int32SubWithOverflow(), p0, Int32Constant(0));
+
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(0));
+
+ r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_EQ(p0, r.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, Int32SubWithOverflowWithConstant) {
+ 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));
+
+ Reduction r = Reduce(graph()->NewNode(common()->Projection(1), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsInt32Constant(base::bits::SignedSubOverflow32(x, y, &z)));
+
+ r = Reduce(graph()->NewNode(common()->Projection(0), add));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsInt32Constant(z));
+ }
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Uint32LessThan
+
+
+TEST_F(MachineOperatorReducerTest, Uint32LessThanWithWord32Sar) {
+ Node* const p0 = Parameter(0);
+ TRACED_FORRANGE(uint32_t, shift, 1, 3) {
+ const uint32_t limit = (kMaxInt >> shift) - 1;
+ Node* const node = graph()->NewNode(
+ machine()->Uint32LessThan(),
+ graph()->NewNode(machine()->Word32Sar(), p0, Uint32Constant(shift)),
+ Uint32Constant(limit));
+
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsUint32LessThan(
+ p0, IsInt32Constant(bit_cast<int32_t>(limit << shift))));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Float64Mul
+
+
+TEST_F(MachineOperatorReducerTest, Float64MulWithMinusOne) {
+ Node* const p0 = Parameter(0);
+ {
+ Reduction r = Reduce(
+ graph()->NewNode(machine()->Float64Mul(), p0, Float64Constant(-1.0)));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsFloat64Sub(IsFloat64Constant(-0.0), p0));
+ }
+ {
+ Reduction r = Reduce(
+ graph()->NewNode(machine()->Float64Mul(), Float64Constant(-1.0), p0));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsFloat64Sub(IsFloat64Constant(-0.0), p0));
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// Store
+
+
+TEST_F(MachineOperatorReducerTest, StoreRepWord8WithWord32And) {
+ const StoreRepresentation rep(kRepWord8, kNoWriteBarrier);
+ Node* const base = Parameter(0);
+ Node* const index = Parameter(1);
+ Node* const value = Parameter(2);
+ Node* const effect = graph()->start();
+ Node* const control = graph()->start();
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Node* const node =
+ graph()->NewNode(machine()->Store(rep), base, index,
+ graph()->NewNode(machine()->Word32And(), value,
+ Uint32Constant(x | 0xffu)),
+ effect, control);
+
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStore(rep, base, index, value, effect, control));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, StoreRepWord8WithWord32SarAndWord32Shl) {
+ const StoreRepresentation rep(kRepWord8, kNoWriteBarrier);
+ Node* const base = Parameter(0);
+ Node* const index = Parameter(1);
+ Node* const value = Parameter(2);
+ Node* const effect = graph()->start();
+ Node* const control = graph()->start();
+ TRACED_FORRANGE(int32_t, x, 1, 24) {
+ Node* const node = graph()->NewNode(
+ machine()->Store(rep), base, index,
+ graph()->NewNode(
+ machine()->Word32Sar(),
+ graph()->NewNode(machine()->Word32Shl(), value, Int32Constant(x)),
+ Int32Constant(x)),
+ effect, control);
+
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStore(rep, base, index, value, effect, control));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, StoreRepWord16WithWord32And) {
+ const StoreRepresentation rep(kRepWord16, kNoWriteBarrier);
+ Node* const base = Parameter(0);
+ Node* const index = Parameter(1);
+ Node* const value = Parameter(2);
+ Node* const effect = graph()->start();
+ Node* const control = graph()->start();
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Node* const node =
+ graph()->NewNode(machine()->Store(rep), base, index,
+ graph()->NewNode(machine()->Word32And(), value,
+ Uint32Constant(x | 0xffffu)),
+ effect, control);
+
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStore(rep, base, index, value, effect, control));
+ }
+}
+
+
+TEST_F(MachineOperatorReducerTest, StoreRepWord16WithWord32SarAndWord32Shl) {
+ const StoreRepresentation rep(kRepWord16, kNoWriteBarrier);
+ Node* const base = Parameter(0);
+ Node* const index = Parameter(1);
+ Node* const value = Parameter(2);
+ Node* const effect = graph()->start();
+ Node* const control = graph()->start();
+ TRACED_FORRANGE(int32_t, x, 1, 16) {
+ Node* const node = graph()->NewNode(
+ machine()->Store(rep), base, index,
+ graph()->NewNode(
+ machine()->Word32Sar(),
+ graph()->NewNode(machine()->Word32Shl(), value, Int32Constant(x)),
+ Int32Constant(x)),
+ effect, control);
+
+ Reduction r = Reduce(node);
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStore(rep, base, index, value, effect, control));
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#if GTEST_HAS_COMBINE
-// TODO(bmeurer): Find a new home for these.
-inline std::ostream& operator<<(std::ostream& os, const MachineType& type) {
- OStringStream ost;
- ost << type;
- return os << ost.c_str();
-}
-inline std::ostream& operator<<(std::ostream& os,
- const WriteBarrierKind& write_barrier_kind) {
- OStringStream ost;
- ost << write_barrier_kind;
- return os << ost.c_str();
-}
-
-
template <typename T>
class MachineOperatorTestWithParam
: public ::testing::TestWithParam< ::testing::tuple<MachineType, T> > {
MachineOperatorBuilder machine(type());
const Operator* op = machine.Load(GetParam());
- EXPECT_EQ(2, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
- EXPECT_EQ(3, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(2, op->ValueInputCount());
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(1, op->ControlInputCount());
+ EXPECT_EQ(4, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(1, op->ValueOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
MachineOperatorBuilder machine(type());
const Operator* op = machine.Store(GetParam());
- EXPECT_EQ(3, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
+ EXPECT_EQ(3, op->ValueInputCount());
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(1, op->ControlInputCount());
EXPECT_EQ(5, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(0, op->ValueOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
const Operator* (MachineOperatorBuilder::*constructor)();
IrOpcode::Value opcode;
int value_input_count;
+ int control_input_count;
int value_output_count;
};
const PureOperator kPureOperators[] = {
-#define PURE(Name, input_count, output_count) \
- { \
- &MachineOperatorBuilder::Name, IrOpcode::k##Name, input_count, \
- output_count \
+#define PURE(Name, value_input_count, control_input_count, value_output_count) \
+ { \
+ &MachineOperatorBuilder::Name, IrOpcode::k##Name, value_input_count, \
+ control_input_count, value_output_count \
}
- PURE(Word32And, 2, 1), PURE(Word32Or, 2, 1),
- PURE(Word32Xor, 2, 1), PURE(Word32Shl, 2, 1),
- PURE(Word32Shr, 2, 1), PURE(Word32Sar, 2, 1),
- PURE(Word32Ror, 2, 1), PURE(Word32Equal, 2, 1),
- PURE(Word64And, 2, 1), PURE(Word64Or, 2, 1),
- PURE(Word64Xor, 2, 1), PURE(Word64Shl, 2, 1),
- PURE(Word64Shr, 2, 1), PURE(Word64Sar, 2, 1),
- PURE(Word64Ror, 2, 1), PURE(Word64Equal, 2, 1),
- PURE(Int32Add, 2, 1), PURE(Int32AddWithOverflow, 2, 2),
- PURE(Int32Sub, 2, 1), PURE(Int32SubWithOverflow, 2, 2),
- PURE(Int32Mul, 2, 1), PURE(Int32Div, 2, 1),
- PURE(Int32UDiv, 2, 1), PURE(Int32Mod, 2, 1),
- PURE(Int32UMod, 2, 1), PURE(Int32LessThan, 2, 1),
- PURE(Int32LessThanOrEqual, 2, 1), PURE(Uint32LessThan, 2, 1),
- PURE(Uint32LessThanOrEqual, 2, 1), PURE(Int64Add, 2, 1),
- PURE(Int64Sub, 2, 1), PURE(Int64Mul, 2, 1),
- PURE(Int64Div, 2, 1), PURE(Int64UDiv, 2, 1),
- PURE(Int64Mod, 2, 1), PURE(Int64UMod, 2, 1),
- PURE(Int64LessThan, 2, 1), PURE(Int64LessThanOrEqual, 2, 1),
- PURE(ChangeFloat32ToFloat64, 1, 1), PURE(ChangeFloat64ToInt32, 1, 1),
- PURE(ChangeFloat64ToUint32, 1, 1), PURE(ChangeInt32ToInt64, 1, 1),
- PURE(ChangeUint32ToFloat64, 1, 1), PURE(ChangeUint32ToUint64, 1, 1),
- PURE(TruncateFloat64ToFloat32, 1, 1), PURE(TruncateFloat64ToInt32, 1, 1),
- PURE(TruncateInt64ToInt32, 1, 1), PURE(Float64Add, 2, 1),
- PURE(Float64Sub, 2, 1), PURE(Float64Mul, 2, 1),
- PURE(Float64Div, 2, 1), PURE(Float64Mod, 2, 1),
- PURE(Float64Sqrt, 1, 1), PURE(Float64Equal, 2, 1),
- PURE(Float64LessThan, 2, 1), PURE(Float64LessThanOrEqual, 2, 1)
+ PURE(Word32And, 2, 0, 1), PURE(Word32Or, 2, 0, 1), PURE(Word32Xor, 2, 0, 1),
+ PURE(Word32Shl, 2, 0, 1), PURE(Word32Shr, 2, 0, 1),
+ PURE(Word32Sar, 2, 0, 1), PURE(Word32Ror, 2, 0, 1),
+ PURE(Word32Equal, 2, 0, 1), PURE(Word64And, 2, 0, 1),
+ PURE(Word64Or, 2, 0, 1), PURE(Word64Xor, 2, 0, 1), PURE(Word64Shl, 2, 0, 1),
+ PURE(Word64Shr, 2, 0, 1), PURE(Word64Sar, 2, 0, 1),
+ 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), PURE(Uint32Div, 2, 1, 1), PURE(Int32Mod, 2, 1, 1),
+ PURE(Uint32Mod, 2, 1, 1), PURE(Int32LessThan, 2, 0, 1),
+ PURE(Int32LessThanOrEqual, 2, 0, 1), PURE(Uint32LessThan, 2, 0, 1),
+ PURE(Uint32LessThanOrEqual, 2, 0, 1), PURE(Int64Add, 2, 0, 1),
+ PURE(Int64Sub, 2, 0, 1), PURE(Int64Mul, 2, 0, 1), PURE(Int64Div, 2, 0, 1),
+ PURE(Uint64Div, 2, 0, 1), PURE(Int64Mod, 2, 0, 1), PURE(Uint64Mod, 2, 0, 1),
+ PURE(Int64LessThan, 2, 0, 1), PURE(Int64LessThanOrEqual, 2, 0, 1),
+ PURE(Uint64LessThan, 2, 0, 1), PURE(ChangeFloat32ToFloat64, 1, 0, 1),
+ PURE(ChangeFloat64ToInt32, 1, 0, 1), PURE(ChangeFloat64ToUint32, 1, 0, 1),
+ PURE(ChangeInt32ToInt64, 1, 0, 1), PURE(ChangeUint32ToFloat64, 1, 0, 1),
+ PURE(ChangeUint32ToUint64, 1, 0, 1),
+ PURE(TruncateFloat64ToFloat32, 1, 0, 1),
+ PURE(TruncateFloat64ToInt32, 1, 0, 1), PURE(TruncateInt64ToInt32, 1, 0, 1),
+ PURE(Float64Add, 2, 0, 1), PURE(Float64Sub, 2, 0, 1),
+ PURE(Float64Mul, 2, 0, 1), PURE(Float64Div, 2, 0, 1),
+ PURE(Float64Mod, 2, 0, 1), PURE(Float64Sqrt, 1, 0, 1),
+ PURE(Float64Equal, 2, 0, 1), PURE(Float64LessThan, 2, 0, 1),
+ PURE(Float64LessThanOrEqual, 2, 0, 1), PURE(LoadStackPointer, 0, 0, 1),
+ PURE(Float64Floor, 1, 0, 1), PURE(Float64Ceil, 1, 0, 1),
+ PURE(Float64RoundTruncate, 1, 0, 1), PURE(Float64RoundTiesAway, 1, 0, 1)
#undef PURE
};
const PureOperator& pop = GetParam();
const Operator* op = (machine.*pop.constructor)();
- EXPECT_EQ(pop.value_input_count, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
- EXPECT_EQ(pop.value_input_count, OperatorProperties::GetTotalInputCount(op));
+ EXPECT_EQ(pop.value_input_count, op->ValueInputCount());
+ EXPECT_EQ(0, op->EffectInputCount());
+ EXPECT_EQ(pop.control_input_count, op->ControlInputCount());
+ EXPECT_EQ(pop.value_input_count + pop.control_input_count,
+ OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(pop.value_output_count,
- OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(pop.value_output_count, op->ValueOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
EXPECT_EQ(machine.Int32Sub(), machine.IntSub());
EXPECT_EQ(machine.Int32Mul(), machine.IntMul());
EXPECT_EQ(machine.Int32Div(), machine.IntDiv());
- EXPECT_EQ(machine.Int32UDiv(), machine.IntUDiv());
+ EXPECT_EQ(machine.Uint32Div(), machine.UintDiv());
EXPECT_EQ(machine.Int32Mod(), machine.IntMod());
- EXPECT_EQ(machine.Int32UMod(), machine.IntUMod());
+ EXPECT_EQ(machine.Uint32Mod(), machine.UintMod());
EXPECT_EQ(machine.Int32LessThan(), machine.IntLessThan());
EXPECT_EQ(machine.Int32LessThanOrEqual(), machine.IntLessThanOrEqual());
}
EXPECT_EQ(machine.Int64Sub(), machine.IntSub());
EXPECT_EQ(machine.Int64Mul(), machine.IntMul());
EXPECT_EQ(machine.Int64Div(), machine.IntDiv());
- EXPECT_EQ(machine.Int64UDiv(), machine.IntUDiv());
+ EXPECT_EQ(machine.Uint64Div(), machine.UintDiv());
EXPECT_EQ(machine.Int64Mod(), machine.IntMod());
- EXPECT_EQ(machine.Int64UMod(), machine.IntUMod());
+ EXPECT_EQ(machine.Uint64Mod(), machine.UintMod());
EXPECT_EQ(machine.Int64LessThan(), machine.IntLessThan());
EXPECT_EQ(machine.Int64LessThanOrEqual(), machine.IntLessThanOrEqual());
}
--- /dev/null
+paul.lind@imgtec.com
+gergely.kis@imgtec.com
+akos.palfi@imgtec.com
+balazs.kilvady@imgtec.com
+dusan.milosavljevic@imgtec.com
--- /dev/null
+// 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 "test/unittests/compiler/instruction-selector-unittest.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+namespace {
+
+template <typename T>
+struct MachInst {
+ T constructor;
+ const char* constructor_name;
+ ArchOpcode arch_opcode;
+ MachineType machine_type;
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const MachInst<T>& mi) {
+ return os << mi.constructor_name;
+}
+
+typedef MachInst<Node* (RawMachineAssembler::*)(Node*)> MachInst1;
+typedef MachInst<Node* (RawMachineAssembler::*)(Node*, Node*)> MachInst2;
+
+// To avoid duplicated code IntCmp helper structure
+// is created. It contains MachInst2 with two nodes and expected_size
+// because different cmp instructions have different size.
+struct IntCmp {
+ MachInst2 mi;
+ uint32_t expected_size;
+};
+
+struct FPCmp {
+ MachInst2 mi;
+ FlagsCondition cond;
+};
+
+const FPCmp kFPCmpInstructions[] = {
+ {{&RawMachineAssembler::Float64Equal, "Float64Equal", kMipsCmpD,
+ kMachFloat64},
+ kUnorderedEqual},
+ {{&RawMachineAssembler::Float64LessThan, "Float64LessThan", kMipsCmpD,
+ kMachFloat64},
+ kUnorderedLessThan},
+ {{&RawMachineAssembler::Float64LessThanOrEqual, "Float64LessThanOrEqual",
+ kMipsCmpD, kMachFloat64},
+ kUnorderedLessThanOrEqual},
+ {{&RawMachineAssembler::Float64GreaterThan, "Float64GreaterThan", kMipsCmpD,
+ kMachFloat64},
+ kUnorderedLessThan},
+ {{&RawMachineAssembler::Float64GreaterThanOrEqual,
+ "Float64GreaterThanOrEqual", kMipsCmpD, kMachFloat64},
+ kUnorderedLessThanOrEqual}};
+
+struct Conversion {
+ // The machine_type field in MachInst1 represents the destination type.
+ MachInst1 mi;
+ MachineType src_machine_type;
+};
+
+
+// ----------------------------------------------------------------------------
+// Logical instructions.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kLogicalInstructions[] = {
+ {&RawMachineAssembler::WordAnd, "WordAnd", kMipsAnd, kMachInt16},
+ {&RawMachineAssembler::WordOr, "WordOr", kMipsOr, kMachInt16},
+ {&RawMachineAssembler::WordXor, "WordXor", kMipsXor, kMachInt16},
+ {&RawMachineAssembler::Word32And, "Word32And", kMipsAnd, kMachInt32},
+ {&RawMachineAssembler::Word32Or, "Word32Or", kMipsOr, kMachInt32},
+ {&RawMachineAssembler::Word32Xor, "Word32Xor", kMipsXor, kMachInt32}};
+
+
+// ----------------------------------------------------------------------------
+// Shift instructions.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kShiftInstructions[] = {
+ {&RawMachineAssembler::WordShl, "WordShl", kMipsShl, kMachInt16},
+ {&RawMachineAssembler::WordShr, "WordShr", kMipsShr, kMachInt16},
+ {&RawMachineAssembler::WordSar, "WordSar", kMipsSar, kMachInt16},
+ {&RawMachineAssembler::WordRor, "WordRor", kMipsRor, kMachInt16},
+ {&RawMachineAssembler::Word32Shl, "Word32Shl", kMipsShl, kMachInt32},
+ {&RawMachineAssembler::Word32Shr, "Word32Shr", kMipsShr, kMachInt32},
+ {&RawMachineAssembler::Word32Sar, "Word32Sar", kMipsSar, kMachInt32},
+ {&RawMachineAssembler::Word32Ror, "Word32Ror", kMipsRor, kMachInt32}};
+
+
+// ----------------------------------------------------------------------------
+// MUL/DIV instructions.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kMulDivInstructions[] = {
+ {&RawMachineAssembler::Int32Mul, "Int32Mul", kMipsMul, kMachInt32},
+ {&RawMachineAssembler::Int32Div, "Int32Div", kMipsDiv, kMachInt32},
+ {&RawMachineAssembler::Uint32Div, "Uint32Div", kMipsDivU, kMachUint32},
+ {&RawMachineAssembler::Float64Mul, "Float64Mul", kMipsMulD, kMachFloat64},
+ {&RawMachineAssembler::Float64Div, "Float64Div", kMipsDivD, kMachFloat64}};
+
+
+// ----------------------------------------------------------------------------
+// MOD instructions.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kModInstructions[] = {
+ {&RawMachineAssembler::Int32Mod, "Int32Mod", kMipsMod, kMachInt32},
+ {&RawMachineAssembler::Uint32Mod, "Int32UMod", kMipsModU, kMachInt32},
+ {&RawMachineAssembler::Float64Mod, "Float64Mod", kMipsModD, kMachFloat64}};
+
+
+// ----------------------------------------------------------------------------
+// Arithmetic FPU instructions.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kFPArithInstructions[] = {
+ {&RawMachineAssembler::Float64Add, "Float64Add", kMipsAddD, kMachFloat64},
+ {&RawMachineAssembler::Float64Sub, "Float64Sub", kMipsSubD, kMachFloat64}};
+
+
+// ----------------------------------------------------------------------------
+// IntArithTest instructions, two nodes.
+// ----------------------------------------------------------------------------
+
+
+const MachInst2 kAddSubInstructions[] = {
+ {&RawMachineAssembler::Int32Add, "Int32Add", kMipsAdd, kMachInt32},
+ {&RawMachineAssembler::Int32Sub, "Int32Sub", kMipsSub, kMachInt32},
+ {&RawMachineAssembler::Int32AddWithOverflow, "Int32AddWithOverflow",
+ kMipsAddOvf, kMachInt32},
+ {&RawMachineAssembler::Int32SubWithOverflow, "Int32SubWithOverflow",
+ kMipsSubOvf, kMachInt32}};
+
+
+// ----------------------------------------------------------------------------
+// IntArithTest instructions, one node.
+// ----------------------------------------------------------------------------
+
+
+const MachInst1 kAddSubOneInstructions[] = {
+ {&RawMachineAssembler::Int32Neg, "Int32Neg", kMipsSub, kMachInt32},
+ // TODO(dusmil): check this ...
+ // {&RawMachineAssembler::WordEqual , "WordEqual" , kMipsTst, kMachInt32}
+};
+
+
+// ----------------------------------------------------------------------------
+// Arithmetic compare instructions.
+// ----------------------------------------------------------------------------
+
+
+const IntCmp kCmpInstructions[] = {
+ {{&RawMachineAssembler::WordEqual, "WordEqual", kMipsCmp, kMachInt16}, 1U},
+ {{&RawMachineAssembler::WordNotEqual, "WordNotEqual", kMipsCmp, kMachInt16},
+ 1U},
+ {{&RawMachineAssembler::Word32Equal, "Word32Equal", kMipsCmp, kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Word32NotEqual, "Word32NotEqual", kMipsCmp,
+ kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Int32LessThan, "Int32LessThan", kMipsCmp,
+ kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Int32LessThanOrEqual, "Int32LessThanOrEqual",
+ kMipsCmp, kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Int32GreaterThan, "Int32GreaterThan", kMipsCmp,
+ kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Int32GreaterThanOrEqual, "Int32GreaterThanOrEqual",
+ kMipsCmp, kMachInt32},
+ 1U},
+ {{&RawMachineAssembler::Uint32LessThan, "Uint32LessThan", kMipsCmp,
+ kMachUint32},
+ 1U},
+ {{&RawMachineAssembler::Uint32LessThanOrEqual, "Uint32LessThanOrEqual",
+ kMipsCmp, kMachUint32},
+ 1U}};
+
+
+// ----------------------------------------------------------------------------
+// Conversion instructions.
+// ----------------------------------------------------------------------------
+
+const Conversion kConversionInstructions[] = {
+ // Conversion instructions are related to machine_operator.h:
+ // FPU conversions:
+ // Convert representation of integers between float64 and int32/uint32.
+ // The precise rounding mode and handling of out of range inputs are *not*
+ // defined for these operators, since they are intended only for use with
+ // integers.
+ // mips instruction: cvt_d_w
+ {{&RawMachineAssembler::ChangeInt32ToFloat64, "ChangeInt32ToFloat64",
+ kMipsCvtDW, kMachFloat64},
+ kMachInt32},
+
+ // mips instruction: cvt_d_uw
+ {{&RawMachineAssembler::ChangeUint32ToFloat64, "ChangeUint32ToFloat64",
+ kMipsCvtDUw, kMachFloat64},
+ kMachInt32},
+
+ // mips instruction: trunc_w_d
+ {{&RawMachineAssembler::ChangeFloat64ToInt32, "ChangeFloat64ToInt32",
+ kMipsTruncWD, kMachFloat64},
+ kMachInt32},
+
+ // mips instruction: trunc_uw_d
+ {{&RawMachineAssembler::ChangeFloat64ToUint32, "ChangeFloat64ToUint32",
+ kMipsTruncUwD, kMachFloat64},
+ kMachInt32}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<FPCmp> InstructionSelectorFPCmpTest;
+
+
+TEST_P(InstructionSelectorFPCmpTest, Parameter) {
+ const FPCmp cmp = GetParam();
+ StreamBuilder m(this, kMachInt32, cmp.mi.machine_type, cmp.mi.machine_type);
+ m.Return((m.*cmp.mi.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(cmp.mi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(cmp.cond, s[0]->flags_condition());
+}
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorFPCmpTest,
+ ::testing::ValuesIn(kFPCmpInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Arithmetic compare instructions integers.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<IntCmp> InstructionSelectorCmpTest;
+
+
+TEST_P(InstructionSelectorCmpTest, Parameter) {
+ const IntCmp cmp = GetParam();
+ const MachineType type = cmp.mi.machine_type;
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*cmp.mi.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(cmp.expected_size, s.size());
+ EXPECT_EQ(cmp.mi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorCmpTest,
+ ::testing::ValuesIn(kCmpInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Shift instructions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2>
+ InstructionSelectorShiftTest;
+
+
+TEST_P(InstructionSelectorShiftTest, Immediate) {
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ TRACED_FORRANGE(int32_t, imm, 0, (ElementSizeOf(type) * 8) - 1) {
+ StreamBuilder m(this, type, type);
+ m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
+ EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorShiftTest,
+ ::testing::ValuesIn(kShiftInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Logical instructions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2>
+ InstructionSelectorLogicalTest;
+
+
+TEST_P(InstructionSelectorLogicalTest, Parameter) {
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorLogicalTest,
+ ::testing::ValuesIn(kLogicalInstructions));
+
+
+// ----------------------------------------------------------------------------
+// MUL/DIV instructions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2>
+ InstructionSelectorMulDivTest;
+
+
+TEST_P(InstructionSelectorMulDivTest, Parameter) {
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorMulDivTest,
+ ::testing::ValuesIn(kMulDivInstructions));
+
+
+// ----------------------------------------------------------------------------
+// MOD instructions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2> InstructionSelectorModTest;
+
+
+TEST_P(InstructionSelectorModTest, Parameter) {
+ const MachInst2 dpi = GetParam();
+ const MachineType type = dpi.machine_type;
+ StreamBuilder m(this, type, type, type);
+ m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorModTest,
+ ::testing::ValuesIn(kModInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Floating point instructions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2>
+ InstructionSelectorFPArithTest;
+
+
+TEST_P(InstructionSelectorFPArithTest, Parameter) {
+ const MachInst2 fpa = GetParam();
+ StreamBuilder m(this, fpa.machine_type, fpa.machine_type, fpa.machine_type);
+ m.Return((m.*fpa.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(fpa.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorFPArithTest,
+ ::testing::ValuesIn(kFPArithInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Integer arithmetic.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst2>
+ InstructionSelectorIntArithTwoTest;
+
+
+TEST_P(InstructionSelectorIntArithTwoTest, Parameter) {
+ const MachInst2 intpa = GetParam();
+ StreamBuilder m(this, intpa.machine_type, intpa.machine_type,
+ intpa.machine_type);
+ m.Return((m.*intpa.constructor)(m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(intpa.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorIntArithTwoTest,
+ ::testing::ValuesIn(kAddSubInstructions));
+
+
+// ----------------------------------------------------------------------------
+// One node.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MachInst1>
+ InstructionSelectorIntArithOneTest;
+
+
+TEST_P(InstructionSelectorIntArithOneTest, Parameter) {
+ const MachInst1 intpa = GetParam();
+ StreamBuilder m(this, intpa.machine_type, intpa.machine_type,
+ intpa.machine_type);
+ m.Return((m.*intpa.constructor)(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(intpa.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorIntArithOneTest,
+ ::testing::ValuesIn(kAddSubOneInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Conversions.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<Conversion>
+ InstructionSelectorConversionTest;
+
+
+TEST_P(InstructionSelectorConversionTest, Parameter) {
+ const Conversion conv = GetParam();
+ StreamBuilder m(this, conv.mi.machine_type, conv.src_machine_type);
+ m.Return((m.*conv.mi.constructor)(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(conv.mi.arch_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorConversionTest,
+ ::testing::ValuesIn(kConversionInstructions));
+
+
+// ----------------------------------------------------------------------------
+// Loads and stores.
+// ----------------------------------------------------------------------------
+
+namespace {
+
+struct MemoryAccess {
+ MachineType type;
+ ArchOpcode load_opcode;
+ ArchOpcode store_opcode;
+};
+
+
+static const MemoryAccess kMemoryAccesses[] = {
+ {kMachInt8, kMipsLb, kMipsSb},
+ {kMachUint8, kMipsLbu, kMipsSb},
+ {kMachInt16, kMipsLh, kMipsSh},
+ {kMachUint16, kMipsLhu, kMipsSh},
+ {kMachInt32, kMipsLw, kMipsSw},
+ {kRepFloat32, kMipsLwc1, kMipsSwc1},
+ {kRepFloat64, kMipsLdc1, kMipsSdc1}};
+
+
+struct MemoryAccessImm {
+ MachineType type;
+ ArchOpcode load_opcode;
+ ArchOpcode store_opcode;
+ bool (InstructionSelectorTest::Stream::*val_predicate)(
+ const InstructionOperand*) const;
+ const int32_t immediates[40];
+};
+
+
+std::ostream& operator<<(std::ostream& os, const MemoryAccessImm& acc) {
+ return os << acc.type;
+}
+
+
+struct MemoryAccessImm1 {
+ MachineType type;
+ ArchOpcode load_opcode;
+ ArchOpcode store_opcode;
+ bool (InstructionSelectorTest::Stream::*val_predicate)(
+ const InstructionOperand*) const;
+ const int32_t immediates[5];
+};
+
+
+std::ostream& operator<<(std::ostream& os, const MemoryAccessImm1& acc) {
+ return os << acc.type;
+}
+
+
+// ----------------------------------------------------------------------------
+// Loads and stores immediate values.
+// ----------------------------------------------------------------------------
+
+
+const MemoryAccessImm kMemoryAccessesImm[] = {
+ {kMachInt8,
+ kMipsLb,
+ kMipsSb,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachUint8,
+ kMipsLbu,
+ kMipsSb,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachInt16,
+ kMipsLh,
+ kMipsSh,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachUint16,
+ kMipsLhu,
+ kMipsSh,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachInt32,
+ kMipsLw,
+ kMipsSw,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachFloat32,
+ kMipsLwc1,
+ kMipsSwc1,
+ &InstructionSelectorTest::Stream::IsDouble,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}},
+ {kMachFloat64,
+ kMipsLdc1,
+ kMipsSdc1,
+ &InstructionSelectorTest::Stream::IsDouble,
+ {-4095, -3340, -3231, -3224, -3088, -1758, -1203, -123, -117, -91, -89,
+ -87, -86, -82, -44, -23, -3, 0, 7, 10, 39, 52, 69, 71, 91, 92, 107, 109,
+ 115, 124, 286, 655, 1362, 1569, 2587, 3067, 3096, 3462, 3510, 4095}}};
+
+
+const MemoryAccessImm1 kMemoryAccessImmMoreThan16bit[] = {
+ {kMachInt8,
+ kMipsLb,
+ kMipsSb,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachInt8,
+ kMipsLbu,
+ kMipsSb,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachInt16,
+ kMipsLh,
+ kMipsSh,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachInt16,
+ kMipsLhu,
+ kMipsSh,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachInt32,
+ kMipsLw,
+ kMipsSw,
+ &InstructionSelectorTest::Stream::IsInteger,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachFloat32,
+ kMipsLwc1,
+ kMipsSwc1,
+ &InstructionSelectorTest::Stream::IsDouble,
+ {-65000, -55000, 32777, 55000, 65000}},
+ {kMachFloat64,
+ kMipsLdc1,
+ kMipsSdc1,
+ &InstructionSelectorTest::Stream::IsDouble,
+ {-65000, -55000, 32777, 55000, 65000}}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<MemoryAccess>
+ InstructionSelectorMemoryAccessTest;
+
+
+TEST_P(InstructionSelectorMemoryAccessTest, LoadWithParameters) {
+ const MemoryAccess memacc = GetParam();
+ StreamBuilder m(this, memacc.type, kMachPtr, kMachInt32);
+ m.Return(m.Load(memacc.type, m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.load_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_MRI, s[0]->addressing_mode());
+}
+
+
+TEST_P(InstructionSelectorMemoryAccessTest, StoreWithParameters) {
+ const MemoryAccess memacc = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachPtr, kMachInt32, memacc.type);
+ m.Store(memacc.type, m.Parameter(0), m.Parameter(1));
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.store_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_MRI, s[0]->addressing_mode());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorMemoryAccessTest,
+ ::testing::ValuesIn(kMemoryAccesses));
+
+
+// ----------------------------------------------------------------------------
+// Load immediate.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MemoryAccessImm>
+ InstructionSelectorMemoryAccessImmTest;
+
+
+TEST_P(InstructionSelectorMemoryAccessImmTest, LoadWithImmediateIndex) {
+ const MemoryAccessImm memacc = GetParam();
+ TRACED_FOREACH(int32_t, index, memacc.immediates) {
+ StreamBuilder m(this, memacc.type, kMachPtr);
+ m.Return(m.Load(memacc.type, m.Parameter(0), m.Int32Constant(index)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.load_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_MRI, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ ASSERT_EQ(InstructionOperand::IMMEDIATE, s[0]->InputAt(1)->kind());
+ EXPECT_EQ(index, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_TRUE((s.*memacc.val_predicate)(s[0]->Output()));
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+// Store immediate.
+// ----------------------------------------------------------------------------
+
+
+TEST_P(InstructionSelectorMemoryAccessImmTest, StoreWithImmediateIndex) {
+ const MemoryAccessImm memacc = GetParam();
+ TRACED_FOREACH(int32_t, index, memacc.immediates) {
+ StreamBuilder m(this, kMachInt32, kMachPtr, memacc.type);
+ m.Store(memacc.type, m.Parameter(0), m.Int32Constant(index),
+ m.Parameter(1));
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.store_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_MRI, 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)));
+ EXPECT_EQ(0U, s[0]->OutputCount());
+ }
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorMemoryAccessImmTest,
+ ::testing::ValuesIn(kMemoryAccessesImm));
+
+
+// ----------------------------------------------------------------------------
+// Load/store offsets more than 16 bits.
+// ----------------------------------------------------------------------------
+
+
+typedef InstructionSelectorTestWithParam<MemoryAccessImm1>
+ InstructionSelectorMemoryAccessImmMoreThan16bitTest;
+
+
+TEST_P(InstructionSelectorMemoryAccessImmMoreThan16bitTest,
+ LoadWithImmediateIndex) {
+ const MemoryAccessImm1 memacc = GetParam();
+ TRACED_FOREACH(int32_t, index, memacc.immediates) {
+ StreamBuilder m(this, memacc.type, kMachPtr);
+ m.Return(m.Load(memacc.type, m.Parameter(0), m.Int32Constant(index)));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ // kMipsAdd is expected opcode.
+ // size more than 16 bits wide.
+ EXPECT_EQ(kMipsAdd, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_None, s[0]->addressing_mode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+}
+
+
+TEST_P(InstructionSelectorMemoryAccessImmMoreThan16bitTest,
+ StoreWithImmediateIndex) {
+ const MemoryAccessImm1 memacc = GetParam();
+ TRACED_FOREACH(int32_t, index, memacc.immediates) {
+ StreamBuilder m(this, kMachInt32, kMachPtr, memacc.type);
+ m.Store(memacc.type, m.Parameter(0), m.Int32Constant(index),
+ m.Parameter(1));
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ // kMipsAdd is expected opcode
+ // size more than 16 bits wide
+ EXPECT_EQ(kMipsAdd, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_None, s[0]->addressing_mode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ }
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorMemoryAccessImmMoreThan16bitTest,
+ ::testing::ValuesIn(kMemoryAccessImmMoreThan16bit));
+
+
+// ----------------------------------------------------------------------------
+// kMipsTst testing.
+// ----------------------------------------------------------------------------
+
+
+TEST_F(InstructionSelectorTest, Word32EqualWithZero) {
+ {
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32Equal(m.Parameter(0), m.Int32Constant(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kMipsCmp, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_None, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ }
+ {
+ StreamBuilder m(this, kMachInt32, kMachInt32);
+ m.Return(m.Word32Equal(m.Int32Constant(0), m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kMipsCmp, s[0]->arch_opcode());
+ EXPECT_EQ(kMode_None, s[0]->addressing_mode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(kFlags_set, s[0]->flags_mode());
+ EXPECT_EQ(kEqual, s[0]->flags_condition());
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/graph-unittest.h"
-
-#include <ostream> // NOLINT(readability/streams)
+#include "test/unittests/compiler/node-test-utils.h"
#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/simplified-operator.h"
using testing::_;
using testing::MakeMatcher;
namespace v8 {
namespace internal {
-
-// TODO(bmeurer): Find a new home for these functions.
-template <typename T>
-inline std::ostream& operator<<(std::ostream& os, const Unique<T>& value) {
- return os << *value.handle();
-}
-inline std::ostream& operator<<(std::ostream& os,
- const ExternalReference& value) {
- OStringStream ost;
- compiler::StaticParameterTraits<ExternalReference>::PrintTo(ost, value);
- return os << ost.c_str();
-}
-
namespace compiler {
-GraphTest::GraphTest(int num_parameters) : common_(zone()), graph_(zone()) {
- graph()->SetStart(graph()->NewNode(common()->Start(num_parameters)));
-}
-
-
-GraphTest::~GraphTest() {}
-
-
-Node* GraphTest::Parameter(int32_t index) {
- return graph()->NewNode(common()->Parameter(index), graph()->start());
-}
-
-
-Node* GraphTest::Float32Constant(volatile float value) {
- return graph()->NewNode(common()->Float32Constant(value));
-}
-
-
-Node* GraphTest::Float64Constant(volatile double value) {
- return graph()->NewNode(common()->Float64Constant(value));
-}
-
-
-Node* GraphTest::Int32Constant(int32_t value) {
- return graph()->NewNode(common()->Int32Constant(value));
-}
-
-
-Node* GraphTest::Int64Constant(int64_t value) {
- return graph()->NewNode(common()->Int64Constant(value));
-}
-
-
-Node* GraphTest::NumberConstant(volatile double value) {
- return graph()->NewNode(common()->NumberConstant(value));
-}
-
-
-Node* GraphTest::HeapConstant(const Unique<HeapObject>& value) {
- return graph()->NewNode(common()->HeapConstant(value));
-}
-
-
-Node* GraphTest::FalseConstant() {
- return HeapConstant(
- Unique<HeapObject>::CreateImmovable(factory()->false_value()));
-}
-
-
-Node* GraphTest::TrueConstant() {
- return HeapConstant(
- Unique<HeapObject>::CreateImmovable(factory()->true_value()));
-}
-
-
-Matcher<Node*> GraphTest::IsFalseConstant() {
- return IsHeapConstant(
- Unique<HeapObject>::CreateImmovable(factory()->false_value()));
-}
-
-
-Matcher<Node*> GraphTest::IsTrueConstant() {
- return IsHeapConstant(
- Unique<HeapObject>::CreateImmovable(factory()->true_value()));
-}
-
namespace {
template <typename T>
*os << "is a " << IrOpcode::Mnemonic(opcode_) << " node";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
if (node == NULL) {
*listener << "which is NULL";
return false;
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
"control0", control0_matcher_, listener) &&
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node),
"control", control_matcher_, listener));
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<T>(node), "value", value_matcher_,
listener));
};
+class IsSelectMatcher FINAL : public NodeMatcher {
+ public:
+ IsSelectMatcher(const Matcher<MachineType>& type_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& value2_matcher)
+ : NodeMatcher(IrOpcode::kSelect),
+ type_matcher_(type_matcher),
+ value0_matcher_(value0_matcher),
+ value1_matcher_(value1_matcher),
+ value2_matcher_(value2_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << " whose type (";
+ type_matcher_.DescribeTo(os);
+ *os << "), value0 (";
+ value0_matcher_.DescribeTo(os);
+ *os << "), value1 (";
+ value1_matcher_.DescribeTo(os);
+ *os << ") and value2 (";
+ value2_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
+ type_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
+ "value0", value0_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
+ "value1", value1_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
+ "value2", value2_matcher_, listener));
+ }
+
+ private:
+ const Matcher<MachineType> type_matcher_;
+ const Matcher<Node*> value0_matcher_;
+ const Matcher<Node*> value1_matcher_;
+ const Matcher<Node*> value2_matcher_;
+};
+
+
class IsPhiMatcher FINAL : public NodeMatcher {
public:
IsPhiMatcher(const Matcher<MachineType>& type_matcher,
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
type_matcher_, listener) &&
};
+class IsEffectPhiMatcher FINAL : public NodeMatcher {
+ public:
+ IsEffectPhiMatcher(const Matcher<Node*>& effect0_matcher,
+ const Matcher<Node*>& effect1_matcher,
+ const Matcher<Node*>& control_matcher)
+ : NodeMatcher(IrOpcode::kEffectPhi),
+ effect0_matcher_(effect0_matcher),
+ effect1_matcher_(effect1_matcher),
+ control_matcher_(control_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << "), effect0 (";
+ effect0_matcher_.DescribeTo(os);
+ *os << "), effect1 (";
+ effect1_matcher_.DescribeTo(os);
+ *os << ") and control (";
+ control_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 0),
+ "effect0", effect0_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 1),
+ "effect1", effect1_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
+ }
+
+ private:
+ const Matcher<Node*> effect0_matcher_;
+ const Matcher<Node*> effect1_matcher_;
+ const Matcher<Node*> control_matcher_;
+};
+
+
class IsProjectionMatcher FINAL : public NodeMatcher {
public:
IsProjectionMatcher(const Matcher<size_t>& index_matcher,
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<size_t>(node), "index",
index_matcher_, listener) &&
};
-class IsCallMatcher FINAL : public NodeMatcher {
+class IsCall2Matcher FINAL : public NodeMatcher {
public:
- IsCallMatcher(const Matcher<CallDescriptor*>& descriptor_matcher,
- const Matcher<Node*>& value0_matcher,
- const Matcher<Node*>& value1_matcher,
- const Matcher<Node*>& value2_matcher,
- const Matcher<Node*>& value3_matcher,
- const Matcher<Node*>& effect_matcher,
- const Matcher<Node*>& control_matcher)
+ IsCall2Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
+ : NodeMatcher(IrOpcode::kCall),
+ descriptor_matcher_(descriptor_matcher),
+ value0_matcher_(value0_matcher),
+ value1_matcher_(value1_matcher),
+ effect_matcher_(effect_matcher),
+ control_matcher_(control_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << " whose value0 (";
+ value0_matcher_.DescribeTo(os);
+ *os << ") and value1 (";
+ value1_matcher_.DescribeTo(os);
+ *os << ") and effect (";
+ effect_matcher_.DescribeTo(os);
+ *os << ") and control (";
+ control_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
+ "descriptor", descriptor_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
+ "value0", value0_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
+ "value1", value1_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+ effect_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
+ }
+
+ private:
+ const Matcher<CallDescriptor*> descriptor_matcher_;
+ const Matcher<Node*> value0_matcher_;
+ const Matcher<Node*> value1_matcher_;
+ const Matcher<Node*> effect_matcher_;
+ const Matcher<Node*> control_matcher_;
+};
+
+
+class IsCall4Matcher FINAL : public NodeMatcher {
+ public:
+ IsCall4Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& value2_matcher,
+ const Matcher<Node*>& value3_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
: NodeMatcher(IrOpcode::kCall),
descriptor_matcher_(descriptor_matcher),
value0_matcher_(value0_matcher),
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
"descriptor", descriptor_matcher_, listener) &&
};
+class IsLoadFieldMatcher FINAL : public NodeMatcher {
+ public:
+ IsLoadFieldMatcher(const Matcher<FieldAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
+ : NodeMatcher(IrOpcode::kLoadField),
+ access_matcher_(access_matcher),
+ base_matcher_(base_matcher),
+ effect_matcher_(effect_matcher),
+ control_matcher_(control_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << " whose access (";
+ access_matcher_.DescribeTo(os);
+ *os << "), base (";
+ base_matcher_.DescribeTo(os);
+ *os << "), effect (";
+ effect_matcher_.DescribeTo(os);
+ *os << ") and control (";
+ control_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
+ access_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
+ base_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+ effect_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
+ }
+
+ private:
+ const Matcher<FieldAccess> access_matcher_;
+ const Matcher<Node*> base_matcher_;
+ const Matcher<Node*> effect_matcher_;
+ const Matcher<Node*> control_matcher_;
+};
+
+
+class IsLoadElementMatcher FINAL : public NodeMatcher {
+ public:
+ IsLoadElementMatcher(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& effect_matcher)
+ : NodeMatcher(IrOpcode::kLoadElement),
+ access_matcher_(access_matcher),
+ base_matcher_(base_matcher),
+ index_matcher_(index_matcher),
+ length_matcher_(length_matcher),
+ effect_matcher_(effect_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << " whose access (";
+ access_matcher_.DescribeTo(os);
+ *os << "), base (";
+ base_matcher_.DescribeTo(os);
+ *os << "), index (";
+ index_matcher_.DescribeTo(os);
+ *os << "), length (";
+ length_matcher_.DescribeTo(os);
+ *os << ") and effect (";
+ effect_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
+ access_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
+ base_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
+ "index", index_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
+ "length", length_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+ effect_matcher_, listener));
+ }
+
+ private:
+ const Matcher<ElementAccess> access_matcher_;
+ const Matcher<Node*> base_matcher_;
+ const Matcher<Node*> index_matcher_;
+ const Matcher<Node*> length_matcher_;
+ const Matcher<Node*> effect_matcher_;
+};
+
+
+class IsStoreElementMatcher FINAL : public NodeMatcher {
+ public:
+ IsStoreElementMatcher(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& value_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
+ : NodeMatcher(IrOpcode::kStoreElement),
+ access_matcher_(access_matcher),
+ base_matcher_(base_matcher),
+ index_matcher_(index_matcher),
+ length_matcher_(length_matcher),
+ value_matcher_(value_matcher),
+ effect_matcher_(effect_matcher),
+ control_matcher_(control_matcher) {}
+
+ virtual void DescribeTo(std::ostream* os) const OVERRIDE {
+ NodeMatcher::DescribeTo(os);
+ *os << " whose access (";
+ access_matcher_.DescribeTo(os);
+ *os << "), base (";
+ base_matcher_.DescribeTo(os);
+ *os << "), index (";
+ index_matcher_.DescribeTo(os);
+ *os << "), length (";
+ length_matcher_.DescribeTo(os);
+ *os << "), value (";
+ value_matcher_.DescribeTo(os);
+ *os << "), effect (";
+ effect_matcher_.DescribeTo(os);
+ *os << ") and control (";
+ control_matcher_.DescribeTo(os);
+ *os << ")";
+ }
+
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
+ return (NodeMatcher::MatchAndExplain(node, listener) &&
+ PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
+ access_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
+ base_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
+ "index", index_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
+ "length", length_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3),
+ "value", value_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+ effect_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
+ }
+
+ private:
+ const Matcher<ElementAccess> access_matcher_;
+ const Matcher<Node*> base_matcher_;
+ const Matcher<Node*> index_matcher_;
+ const Matcher<Node*> length_matcher_;
+ const Matcher<Node*> value_matcher_;
+ const Matcher<Node*> effect_matcher_;
+ const Matcher<Node*> control_matcher_;
+};
+
+
class IsLoadMatcher FINAL : public NodeMatcher {
public:
IsLoadMatcher(const Matcher<LoadRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
- const Matcher<Node*>& effect_matcher)
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher)
: NodeMatcher(IrOpcode::kLoad),
rep_matcher_(rep_matcher),
base_matcher_(base_matcher),
index_matcher_(index_matcher),
- effect_matcher_(effect_matcher) {}
+ effect_matcher_(effect_matcher),
+ control_matcher_(control_matcher) {}
virtual void DescribeTo(std::ostream* os) const OVERRIDE {
NodeMatcher::DescribeTo(os);
base_matcher_.DescribeTo(os);
*os << "), index (";
index_matcher_.DescribeTo(os);
- *os << ") and effect (";
+ *os << "), effect (";
effect_matcher_.DescribeTo(os);
+ *os << ") and control (";
+ control_matcher_.DescribeTo(os);
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<LoadRepresentation>(node), "rep",
rep_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
"index", index_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
- effect_matcher_, listener));
+ effect_matcher_, listener) &&
+ PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+ "control", control_matcher_, listener));
}
private:
const Matcher<Node*> base_matcher_;
const Matcher<Node*> index_matcher_;
const Matcher<Node*> effect_matcher_;
+ const Matcher<Node*> control_matcher_;
};
class IsStoreMatcher FINAL : public NodeMatcher {
public:
- IsStoreMatcher(const Matcher<MachineType>& type_matcher,
- const Matcher<WriteBarrierKind> write_barrier_matcher,
+ IsStoreMatcher(const Matcher<StoreRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
const Matcher<Node*>& value_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher)
: NodeMatcher(IrOpcode::kStore),
- type_matcher_(type_matcher),
- write_barrier_matcher_(write_barrier_matcher),
+ rep_matcher_(rep_matcher),
base_matcher_(base_matcher),
index_matcher_(index_matcher),
value_matcher_(value_matcher),
virtual void DescribeTo(std::ostream* os) const OVERRIDE {
NodeMatcher::DescribeTo(os);
- *os << " whose type (";
- type_matcher_.DescribeTo(os);
- *os << "), write barrier (";
- write_barrier_matcher_.DescribeTo(os);
+ *os << " whose rep (";
+ rep_matcher_.DescribeTo(os);
*os << "), base (";
base_matcher_.DescribeTo(os);
*os << "), index (";
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
- PrintMatchAndExplain(
- OpParameter<StoreRepresentation>(node).machine_type(), "type",
- type_matcher_, listener) &&
- PrintMatchAndExplain(
- OpParameter<StoreRepresentation>(node).write_barrier_kind(),
- "write barrier", write_barrier_matcher_, listener) &&
+ PrintMatchAndExplain(OpParameter<StoreRepresentation>(node), "rep",
+ rep_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
base_matcher_, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
}
private:
- const Matcher<MachineType> type_matcher_;
- const Matcher<WriteBarrierKind> write_barrier_matcher_;
+ const Matcher<StoreRepresentation> rep_matcher_;
const Matcher<Node*> base_matcher_;
const Matcher<Node*> index_matcher_;
const Matcher<Node*> value_matcher_;
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
lhs_matcher_, listener) &&
*os << ")";
}
- virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
- OVERRIDE {
+ virtual bool MatchAndExplain(Node* node,
+ MatchResultListener* listener) const OVERRIDE {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"input", input_matcher_, listener));
}
-Matcher<Node*> IsControlEffect(const Matcher<Node*>& control_matcher) {
- return MakeMatcher(
- new IsControl1Matcher(IrOpcode::kControlEffect, control_matcher));
-}
-
-
Matcher<Node*> IsValueEffect(const Matcher<Node*>& value_matcher) {
return MakeMatcher(new IsUnopMatcher(IrOpcode::kValueEffect, value_matcher));
}
}
+Matcher<Node*> IsSelect(const Matcher<MachineType>& type_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& value2_matcher) {
+ return MakeMatcher(new IsSelectMatcher(type_matcher, value0_matcher,
+ value1_matcher, value2_matcher));
+}
+
+
Matcher<Node*> IsPhi(const Matcher<MachineType>& type_matcher,
const Matcher<Node*>& value0_matcher,
const Matcher<Node*>& value1_matcher,
}
+Matcher<Node*> IsEffectPhi(const Matcher<Node*>& effect0_matcher,
+ const Matcher<Node*>& effect1_matcher,
+ const Matcher<Node*>& merge_matcher) {
+ return MakeMatcher(
+ new IsEffectPhiMatcher(effect0_matcher, effect1_matcher, merge_matcher));
+}
+
+
Matcher<Node*> IsProjection(const Matcher<size_t>& index_matcher,
const Matcher<Node*>& base_matcher) {
return MakeMatcher(new IsProjectionMatcher(index_matcher, base_matcher));
Matcher<Node*> IsCall(const Matcher<CallDescriptor*>& descriptor_matcher,
const Matcher<Node*>& value0_matcher,
const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return MakeMatcher(new IsCall2Matcher(descriptor_matcher, value0_matcher,
+ value1_matcher, effect_matcher,
+ control_matcher));
+}
+
+
+Matcher<Node*> IsCall(const Matcher<CallDescriptor*>& descriptor_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
const Matcher<Node*>& value2_matcher,
const Matcher<Node*>& value3_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher) {
- return MakeMatcher(new IsCallMatcher(
+ return MakeMatcher(new IsCall4Matcher(
descriptor_matcher, value0_matcher, value1_matcher, value2_matcher,
value3_matcher, effect_matcher, control_matcher));
}
+Matcher<Node*> IsLoadField(const Matcher<FieldAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return MakeMatcher(new IsLoadFieldMatcher(access_matcher, base_matcher,
+ effect_matcher, control_matcher));
+}
+
+
+Matcher<Node*> IsLoadElement(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& effect_matcher) {
+ return MakeMatcher(new IsLoadElementMatcher(access_matcher, base_matcher,
+ index_matcher, length_matcher,
+ effect_matcher));
+}
+
+
+Matcher<Node*> IsStoreElement(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& value_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return MakeMatcher(new IsStoreElementMatcher(
+ access_matcher, base_matcher, index_matcher, length_matcher,
+ value_matcher, effect_matcher, control_matcher));
+}
+
+
Matcher<Node*> IsLoad(const Matcher<LoadRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
- const Matcher<Node*>& effect_matcher) {
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
return MakeMatcher(new IsLoadMatcher(rep_matcher, base_matcher, index_matcher,
- effect_matcher));
+ effect_matcher, control_matcher));
}
-Matcher<Node*> IsStore(const Matcher<MachineType>& type_matcher,
- const Matcher<WriteBarrierKind>& write_barrier_matcher,
+Matcher<Node*> IsStore(const Matcher<StoreRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
const Matcher<Node*>& value_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher) {
- return MakeMatcher(new IsStoreMatcher(
- type_matcher, write_barrier_matcher, base_matcher, index_matcher,
- value_matcher, effect_matcher, control_matcher));
+ return MakeMatcher(new IsStoreMatcher(rep_matcher, base_matcher,
+ index_matcher, value_matcher,
+ effect_matcher, control_matcher));
}
return MakeMatcher( \
new IsBinopMatcher(IrOpcode::k##Name, lhs_matcher, rhs_matcher)); \
}
+IS_BINOP_MATCHER(NumberEqual)
IS_BINOP_MATCHER(NumberLessThan)
IS_BINOP_MATCHER(NumberSubtract)
+IS_BINOP_MATCHER(NumberMultiply)
IS_BINOP_MATCHER(Word32And)
IS_BINOP_MATCHER(Word32Sar)
IS_BINOP_MATCHER(Word32Shl)
+IS_BINOP_MATCHER(Word32Shr)
IS_BINOP_MATCHER(Word32Ror)
IS_BINOP_MATCHER(Word32Equal)
IS_BINOP_MATCHER(Word64And)
IS_BINOP_MATCHER(Word64Shl)
IS_BINOP_MATCHER(Word64Equal)
IS_BINOP_MATCHER(Int32AddWithOverflow)
+IS_BINOP_MATCHER(Int32Add)
+IS_BINOP_MATCHER(Int32Sub)
IS_BINOP_MATCHER(Int32Mul)
+IS_BINOP_MATCHER(Int32MulHigh)
+IS_BINOP_MATCHER(Int32LessThan)
+IS_BINOP_MATCHER(Uint32LessThan)
IS_BINOP_MATCHER(Uint32LessThanOrEqual)
+IS_BINOP_MATCHER(Float64Sub)
#undef IS_BINOP_MATCHER
Matcher<Node*> Is##Name(const Matcher<Node*>& input_matcher) { \
return MakeMatcher(new IsUnopMatcher(IrOpcode::k##Name, input_matcher)); \
}
+IS_UNOP_MATCHER(BooleanNot)
IS_UNOP_MATCHER(ChangeFloat64ToInt32)
IS_UNOP_MATCHER(ChangeFloat64ToUint32)
IS_UNOP_MATCHER(ChangeInt32ToFloat64)
IS_UNOP_MATCHER(TruncateFloat64ToInt32)
IS_UNOP_MATCHER(TruncateInt64ToInt32)
IS_UNOP_MATCHER(Float64Sqrt)
+IS_UNOP_MATCHER(Float64Floor)
+IS_UNOP_MATCHER(Float64Ceil)
+IS_UNOP_MATCHER(Float64RoundTruncate)
+IS_UNOP_MATCHER(Float64RoundTiesAway)
#undef IS_UNOP_MATCHER
} // namespace compiler
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_COMPILER_GRAPH_UNITTEST_H_
-#define V8_COMPILER_GRAPH_UNITTEST_H_
+#ifndef V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
+#define V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
-#include "src/compiler/common-operator.h"
-#include "src/compiler/graph.h"
#include "src/compiler/machine-operator.h"
-#include "src/test/test-utils.h"
+#include "src/compiler/machine-type.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace v8 {
namespace internal {
// Forward declarations.
+class ExternalReference;
class HeapObject;
template <class T>
class Unique;
namespace compiler {
-using ::testing::Matcher;
-
-
-class GraphTest : public TestWithContext, public TestWithZone {
- public:
- explicit GraphTest(int parameters = 1);
- virtual ~GraphTest();
-
- protected:
- Node* Parameter(int32_t index);
- Node* Float32Constant(volatile float value);
- Node* Float64Constant(volatile double value);
- Node* Int32Constant(int32_t value);
- Node* Int64Constant(int64_t value);
- Node* NumberConstant(volatile double value);
- Node* HeapConstant(const Unique<HeapObject>& value);
- Node* FalseConstant();
- Node* TrueConstant();
-
- Matcher<Node*> IsFalseConstant();
- Matcher<Node*> IsTrueConstant();
+// Forward declarations.
+class CallDescriptor;
+struct ElementAccess;
+struct FieldAccess;
+class Node;
- CommonOperatorBuilder* common() { return &common_; }
- Graph* graph() { return &graph_; }
- private:
- CommonOperatorBuilder common_;
- Graph graph_;
-};
+using ::testing::Matcher;
Matcher<Node*> IsBranch(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& control1_matcher);
Matcher<Node*> IsIfTrue(const Matcher<Node*>& control_matcher);
Matcher<Node*> IsIfFalse(const Matcher<Node*>& control_matcher);
-Matcher<Node*> IsControlEffect(const Matcher<Node*>& control_matcher);
Matcher<Node*> IsValueEffect(const Matcher<Node*>& value_matcher);
Matcher<Node*> IsFinish(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& effect_matcher);
Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher);
Matcher<Node*> IsInt64Constant(const Matcher<int64_t>& value_matcher);
Matcher<Node*> IsNumberConstant(const Matcher<double>& value_matcher);
+Matcher<Node*> IsSelect(const Matcher<MachineType>& type_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& value2_matcher);
Matcher<Node*> IsPhi(const Matcher<MachineType>& type_matcher,
const Matcher<Node*>& value0_matcher,
const Matcher<Node*>& value1_matcher,
const Matcher<Node*>& merge_matcher);
+Matcher<Node*> IsEffectPhi(const Matcher<Node*>& effect0_matcher,
+ const Matcher<Node*>& effect1_matcher,
+ const Matcher<Node*>& merge_matcher);
Matcher<Node*> IsProjection(const Matcher<size_t>& index_matcher,
const Matcher<Node*>& base_matcher);
Matcher<Node*> IsCall(const Matcher<CallDescriptor*>& descriptor_matcher,
const Matcher<Node*>& value0_matcher,
const Matcher<Node*>& value1_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
+Matcher<Node*> IsCall(const Matcher<CallDescriptor*>& descriptor_matcher,
+ const Matcher<Node*>& value0_matcher,
+ const Matcher<Node*>& value1_matcher,
const Matcher<Node*>& value2_matcher,
const Matcher<Node*>& value3_matcher,
const Matcher<Node*>& effect_matcher,
const Matcher<Node*>& control_matcher);
+Matcher<Node*> IsBooleanNot(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberEqual(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsNumberLessThan(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsNumberSubtract(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsNumberMultiply(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsLoadField(const Matcher<FieldAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
+Matcher<Node*> IsLoadElement(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& effect_matcher);
+Matcher<Node*> IsStoreElement(const Matcher<ElementAccess>& access_matcher,
+ const Matcher<Node*>& base_matcher,
+ const Matcher<Node*>& index_matcher,
+ const Matcher<Node*>& length_matcher,
+ const Matcher<Node*>& value_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
Matcher<Node*> IsLoad(const Matcher<LoadRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
- const Matcher<Node*>& effect_matcher);
-Matcher<Node*> IsStore(const Matcher<MachineType>& type_matcher,
- const Matcher<WriteBarrierKind>& write_barrier_matcher,
+ const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher);
+Matcher<Node*> IsStore(const Matcher<StoreRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
const Matcher<Node*>& index_matcher,
const Matcher<Node*>& value_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsWord32Shl(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsWord32Shr(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsWord32Ror(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsWord32Equal(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsInt32AddWithOverflow(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsInt32Add(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsInt32Sub(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsInt32Mul(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsInt32MulHigh(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsInt32LessThan(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
+Matcher<Node*> IsUint32LessThan(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsUint32LessThanOrEqual(const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsChangeFloat64ToInt32(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsTruncateFloat64ToFloat32(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsTruncateFloat64ToInt32(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsTruncateInt64ToInt32(const Matcher<Node*>& input_matcher);
+Matcher<Node*> IsFloat64Sub(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher);
Matcher<Node*> IsFloat64Sqrt(const Matcher<Node*>& input_matcher);
+Matcher<Node*> IsFloat64Floor(const Matcher<Node*>& input_matcher);
+Matcher<Node*> IsFloat64Ceil(const Matcher<Node*>& input_matcher);
+Matcher<Node*> IsFloat64RoundTruncate(const Matcher<Node*>& input_matcher);
+Matcher<Node*> IsFloat64RoundTiesAway(const Matcher<Node*>& input_matcher);
-} // namespace compiler
-} // namespace internal
-} // namespace v8
+} // namespace compiler
+} // namespace internal
+} // namespace v8
-#endif // V8_COMPILER_GRAPH_UNITTEST_H_
+#endif // V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
--- /dev/null
+// 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/base/utils/random-number-generator.h"
+#include "src/compiler/register-allocator.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+typedef BasicBlock::RpoNumber Rpo;
+
+namespace {
+
+static const char*
+ general_register_names_[RegisterConfiguration::kMaxGeneralRegisters];
+static const char*
+ double_register_names_[RegisterConfiguration::kMaxDoubleRegisters];
+static char register_names_[10 * (RegisterConfiguration::kMaxGeneralRegisters +
+ RegisterConfiguration::kMaxDoubleRegisters)];
+
+
+static void InitializeRegisterNames() {
+ char* loc = register_names_;
+ for (int i = 0; i < RegisterConfiguration::kMaxGeneralRegisters; ++i) {
+ general_register_names_[i] = loc;
+ loc += base::OS::SNPrintF(loc, 100, "gp_%d", i);
+ *loc++ = 0;
+ }
+ for (int i = 0; i < RegisterConfiguration::kMaxDoubleRegisters; ++i) {
+ double_register_names_[i] = loc;
+ loc += base::OS::SNPrintF(loc, 100, "fp_%d", i) + 1;
+ *loc++ = 0;
+ }
+}
+
+enum BlockCompletionType { kFallThrough, kBranch, kJump };
+
+struct BlockCompletion {
+ BlockCompletionType type_;
+ int vreg_;
+ int offset_0_;
+ int offset_1_;
+};
+
+static const int kInvalidJumpOffset = kMinInt;
+
+BlockCompletion FallThrough() {
+ BlockCompletion completion = {kFallThrough, -1, 1, kInvalidJumpOffset};
+ return completion;
+}
+
+
+BlockCompletion Jump(int offset) {
+ BlockCompletion completion = {kJump, -1, offset, kInvalidJumpOffset};
+ return completion;
+}
+
+
+BlockCompletion Branch(int vreg, int left_offset, int right_offset) {
+ BlockCompletion completion = {kBranch, vreg, left_offset, right_offset};
+ return completion;
+}
+
+} // namespace
+
+
+class RegisterAllocatorTest : public TestWithZone {
+ public:
+ static const int kDefaultNRegs = 4;
+
+ RegisterAllocatorTest()
+ : num_general_registers_(kDefaultNRegs),
+ num_double_registers_(kDefaultNRegs),
+ instruction_blocks_(zone()),
+ current_block_(nullptr),
+ is_last_block_(false) {
+ InitializeRegisterNames();
+ }
+
+ void SetNumRegs(int num_general_registers, int num_double_registers) {
+ CHECK(instruction_blocks_.empty());
+ num_general_registers_ = num_general_registers;
+ num_double_registers_ = num_double_registers;
+ }
+
+ RegisterConfiguration* config() {
+ if (config_.is_empty()) {
+ config_.Reset(new RegisterConfiguration(
+ num_general_registers_, num_double_registers_, num_double_registers_,
+ general_register_names_, double_register_names_));
+ }
+ return config_.get();
+ }
+
+ Frame* frame() {
+ if (frame_.is_empty()) {
+ frame_.Reset(new Frame());
+ }
+ return frame_.get();
+ }
+
+ InstructionSequence* sequence() {
+ if (sequence_.is_empty()) {
+ sequence_.Reset(new InstructionSequence(zone(), &instruction_blocks_));
+ }
+ return sequence_.get();
+ }
+
+ RegisterAllocator* allocator() {
+ if (allocator_.is_empty()) {
+ allocator_.Reset(
+ new RegisterAllocator(config(), zone(), frame(), sequence()));
+ }
+ return allocator_.get();
+ }
+
+ void StartLoop(int loop_blocks) {
+ CHECK(current_block_ == nullptr);
+ if (!loop_blocks_.empty()) {
+ CHECK(!loop_blocks_.back().loop_header_.IsValid());
+ }
+ LoopData loop_data = {Rpo::Invalid(), loop_blocks};
+ loop_blocks_.push_back(loop_data);
+ }
+
+ void EndLoop() {
+ CHECK(current_block_ == nullptr);
+ CHECK(!loop_blocks_.empty());
+ CHECK_EQ(0, loop_blocks_.back().expected_blocks_);
+ loop_blocks_.pop_back();
+ }
+
+ void StartLastBlock() {
+ CHECK(!is_last_block_);
+ is_last_block_ = true;
+ NewBlock();
+ }
+
+ void StartBlock() {
+ CHECK(!is_last_block_);
+ NewBlock();
+ }
+
+ void EndBlock(BlockCompletion completion = FallThrough()) {
+ completions_.push_back(completion);
+ switch (completion.type_) {
+ case kFallThrough:
+ if (is_last_block_) break;
+ // TODO(dcarney): we don't emit this after returns.
+ EmitFallThrough();
+ break;
+ case kJump:
+ EmitJump();
+ break;
+ case kBranch:
+ EmitBranch(completion.vreg_);
+ break;
+ }
+ CHECK(current_block_ != nullptr);
+ sequence()->EndBlock(current_block_->rpo_number());
+ current_block_ = nullptr;
+ }
+
+ void Allocate() {
+ CHECK_EQ(nullptr, current_block_);
+ CHECK(is_last_block_);
+ WireBlocks();
+ if (FLAG_trace_alloc || FLAG_trace_turbo) {
+ OFStream os(stdout);
+ PrintableInstructionSequence printable = {config(), sequence()};
+ os << "Before: " << std::endl << printable << std::endl;
+ }
+ allocator()->Allocate();
+ if (FLAG_trace_alloc || FLAG_trace_turbo) {
+ OFStream os(stdout);
+ PrintableInstructionSequence printable = {config(), sequence()};
+ os << "After: " << std::endl << printable << std::endl;
+ }
+ }
+
+ int NewReg() { return sequence()->NextVirtualRegister(); }
+
+ int Parameter() {
+ int vreg = NewReg();
+ InstructionOperand* outputs[1]{UseRegister(vreg)};
+ Emit(kArchNop, 1, outputs);
+ return vreg;
+ }
+
+ Instruction* Return(int vreg) {
+ InstructionOperand* inputs[1]{UseRegister(vreg)};
+ return Emit(kArchRet, 0, nullptr, 1, inputs);
+ }
+
+ PhiInstruction* Phi(int vreg) {
+ PhiInstruction* phi = new (zone()) PhiInstruction(zone(), NewReg());
+ phi->operands().push_back(vreg);
+ current_block_->AddPhi(phi);
+ return phi;
+ }
+
+ int DefineConstant(int32_t imm = 0) {
+ int virtual_register = NewReg();
+ sequence()->AddConstant(virtual_register, Constant(imm));
+ InstructionOperand* outputs[1]{
+ ConstantOperand::Create(virtual_register, zone())};
+ Emit(kArchNop, 1, outputs);
+ return virtual_register;
+ }
+
+ ImmediateOperand* Immediate(int32_t imm = 0) {
+ int index = sequence()->AddImmediate(Constant(imm));
+ return ImmediateOperand::Create(index, zone());
+ }
+
+ Instruction* EmitFRI(int output_vreg, int input_vreg_0) {
+ InstructionOperand* outputs[1]{DefineSameAsFirst(output_vreg)};
+ InstructionOperand* inputs[2]{UseRegister(input_vreg_0), Immediate()};
+ return Emit(kArchNop, 1, outputs, 2, inputs);
+ }
+
+ Instruction* EmitFRU(int output_vreg, int input_vreg_0, int input_vreg_1) {
+ InstructionOperand* outputs[1]{DefineSameAsFirst(output_vreg)};
+ InstructionOperand* inputs[2]{UseRegister(input_vreg_0), Use(input_vreg_1)};
+ return Emit(kArchNop, 1, outputs, 2, inputs);
+ }
+
+ Instruction* EmitRRR(int output_vreg, int input_vreg_0, int input_vreg_1) {
+ InstructionOperand* outputs[1]{UseRegister(output_vreg)};
+ InstructionOperand* inputs[2]{UseRegister(input_vreg_0),
+ UseRegister(input_vreg_1)};
+ return Emit(kArchNop, 1, outputs, 2, inputs);
+ }
+
+ private:
+ InstructionOperand* Unallocated(int vreg,
+ UnallocatedOperand::ExtendedPolicy policy) {
+ UnallocatedOperand* op = new (zone()) UnallocatedOperand(policy);
+ op->set_virtual_register(vreg);
+ return op;
+ }
+
+ InstructionOperand* Unallocated(int vreg,
+ UnallocatedOperand::ExtendedPolicy policy,
+ UnallocatedOperand::Lifetime lifetime) {
+ UnallocatedOperand* op = new (zone()) UnallocatedOperand(policy, lifetime);
+ op->set_virtual_register(vreg);
+ return op;
+ }
+
+ InstructionOperand* UseRegister(int vreg) {
+ return Unallocated(vreg, UnallocatedOperand::MUST_HAVE_REGISTER);
+ }
+
+ InstructionOperand* DefineSameAsFirst(int vreg) {
+ return Unallocated(vreg, UnallocatedOperand::SAME_AS_FIRST_INPUT);
+ }
+
+ InstructionOperand* Use(int vreg) {
+ return Unallocated(vreg, UnallocatedOperand::NONE,
+ UnallocatedOperand::USED_AT_START);
+ }
+
+ void EmitBranch(int vreg) {
+ InstructionOperand* inputs[4]{UseRegister(vreg), Immediate(), Immediate(),
+ Immediate()};
+ InstructionCode opcode = kArchJmp | FlagsModeField::encode(kFlags_branch) |
+ FlagsConditionField::encode(kEqual);
+ Instruction* instruction =
+ NewInstruction(opcode, 0, nullptr, 4, inputs)->MarkAsControl();
+ sequence()->AddInstruction(instruction);
+ }
+
+ void EmitFallThrough() {
+ Instruction* instruction =
+ NewInstruction(kArchNop, 0, nullptr)->MarkAsControl();
+ sequence()->AddInstruction(instruction);
+ }
+
+ void EmitJump() {
+ InstructionOperand* inputs[1]{Immediate()};
+ Instruction* instruction =
+ NewInstruction(kArchJmp, 0, nullptr, 1, inputs)->MarkAsControl();
+ sequence()->AddInstruction(instruction);
+ }
+
+ Instruction* NewInstruction(InstructionCode code, size_t outputs_size,
+ InstructionOperand** outputs,
+ size_t inputs_size = 0,
+ InstructionOperand* *inputs = nullptr,
+ size_t temps_size = 0,
+ InstructionOperand* *temps = nullptr) {
+ CHECK_NE(nullptr, current_block_);
+ return Instruction::New(zone(), code, outputs_size, outputs, inputs_size,
+ inputs, temps_size, temps);
+ }
+
+ Instruction* Emit(InstructionCode code, size_t outputs_size,
+ InstructionOperand** outputs, size_t inputs_size = 0,
+ InstructionOperand* *inputs = nullptr,
+ size_t temps_size = 0,
+ InstructionOperand* *temps = nullptr) {
+ Instruction* instruction = NewInstruction(
+ code, outputs_size, outputs, inputs_size, inputs, temps_size, temps);
+ sequence()->AddInstruction(instruction);
+ return instruction;
+ }
+
+ InstructionBlock* NewBlock() {
+ CHECK(current_block_ == nullptr);
+ BasicBlock::Id block_id =
+ BasicBlock::Id::FromSize(instruction_blocks_.size());
+ Rpo rpo = Rpo::FromInt(block_id.ToInt());
+ Rpo loop_header = Rpo::Invalid();
+ Rpo loop_end = Rpo::Invalid();
+ if (!loop_blocks_.empty()) {
+ auto& loop_data = loop_blocks_.back();
+ // This is a loop header.
+ if (!loop_data.loop_header_.IsValid()) {
+ loop_end = Rpo::FromInt(block_id.ToInt() + loop_data.expected_blocks_);
+ loop_data.expected_blocks_--;
+ loop_data.loop_header_ = rpo;
+ } else {
+ // This is a loop body.
+ CHECK_NE(0, loop_data.expected_blocks_);
+ // TODO(dcarney): handle nested loops.
+ loop_data.expected_blocks_--;
+ loop_header = loop_data.loop_header_;
+ }
+ }
+ // Construct instruction block.
+ InstructionBlock* instruction_block = new (zone()) InstructionBlock(
+ zone(), block_id, rpo, rpo, loop_header, loop_end, false);
+ instruction_blocks_.push_back(instruction_block);
+ current_block_ = instruction_block;
+ sequence()->StartBlock(rpo);
+ return instruction_block;
+ }
+
+ void WireBlocks() {
+ CHECK(instruction_blocks_.size() == completions_.size());
+ size_t offset = 0;
+ size_t size = instruction_blocks_.size();
+ for (const auto& completion : completions_) {
+ switch (completion.type_) {
+ case kFallThrough:
+ if (offset == size - 1) break;
+ // Fallthrough.
+ case kJump:
+ WireBlock(offset, completion.offset_0_);
+ break;
+ case kBranch:
+ WireBlock(offset, completion.offset_0_);
+ WireBlock(offset, completion.offset_1_);
+ break;
+ }
+ ++offset;
+ }
+ }
+
+ void WireBlock(size_t block_offset, int jump_offset) {
+ size_t target_block_offset =
+ block_offset + static_cast<size_t>(jump_offset);
+ CHECK(block_offset < instruction_blocks_.size());
+ CHECK(target_block_offset < instruction_blocks_.size());
+ InstructionBlock* block = instruction_blocks_[block_offset];
+ InstructionBlock* target = instruction_blocks_[target_block_offset];
+ block->successors().push_back(target->rpo_number());
+ target->predecessors().push_back(block->rpo_number());
+ }
+
+ struct LoopData {
+ Rpo loop_header_;
+ int expected_blocks_;
+ };
+ typedef std::vector<LoopData> LoopBlocks;
+ typedef std::vector<BlockCompletion> Completions;
+
+ SmartPointer<RegisterConfiguration> config_;
+ SmartPointer<Frame> frame_;
+ SmartPointer<RegisterAllocator> allocator_;
+ SmartPointer<InstructionSequence> sequence_;
+ int num_general_registers_;
+ int num_double_registers_;
+
+ // Block building state.
+ InstructionBlocks instruction_blocks_;
+ Completions completions_;
+ LoopBlocks loop_blocks_;
+ InstructionBlock* current_block_;
+ bool is_last_block_;
+};
+
+
+TEST_F(RegisterAllocatorTest, CanAllocateThreeRegisters) {
+ StartLastBlock();
+ int a_reg = Parameter();
+ int b_reg = Parameter();
+ int c_reg = NewReg();
+ Instruction* res = EmitRRR(c_reg, a_reg, b_reg);
+ Return(c_reg);
+ EndBlock();
+
+ Allocate();
+
+ ASSERT_TRUE(res->OutputAt(0)->IsRegister());
+}
+
+
+TEST_F(RegisterAllocatorTest, SimpleLoop) {
+ // i = K;
+ // while(true) { i++ }
+
+ StartBlock();
+ int i_reg = DefineConstant();
+ EndBlock();
+
+ {
+ StartLoop(1);
+
+ StartLastBlock();
+ PhiInstruction* phi = Phi(i_reg);
+ int ipp = NewReg();
+ EmitFRU(ipp, phi->virtual_register(), DefineConstant());
+ phi->operands().push_back(ipp);
+ EndBlock(Jump(0));
+
+ EndLoop();
+ }
+
+ Allocate();
+}
+
+
+TEST_F(RegisterAllocatorTest, SimpleBranch) {
+ // return i ? K1 : K2
+ StartBlock();
+ int i_reg = DefineConstant();
+ EndBlock(Branch(i_reg, 1, 2));
+
+ StartBlock();
+ Return(DefineConstant());
+ EndBlock();
+
+ StartLastBlock();
+ Return(DefineConstant());
+ EndBlock();
+
+ Allocate();
+}
+
+
+TEST_F(RegisterAllocatorTest, RegressionPhisNeedTooManyRegisters) {
+ const size_t kNumRegs = 3;
+ const size_t kParams = kNumRegs + 1;
+ int parameters[kParams];
+
+ // Override number of registers.
+ SetNumRegs(kNumRegs, kNumRegs);
+
+ // Initial block.
+ StartBlock();
+ int constant = DefineConstant();
+ for (size_t i = 0; i < arraysize(parameters); ++i) {
+ parameters[i] = DefineConstant();
+ }
+ EndBlock();
+
+ PhiInstruction* phis[kParams];
+ {
+ StartLoop(2);
+
+ // Loop header.
+ StartBlock();
+
+ for (size_t i = 0; i < arraysize(parameters); ++i) {
+ phis[i] = Phi(parameters[i]);
+ }
+
+ // Perform some computations.
+ // something like phi[i] += const
+ for (size_t i = 0; i < arraysize(parameters); ++i) {
+ int result = NewReg();
+ EmitFRU(result, phis[i]->virtual_register(), constant);
+ phis[i]->operands().push_back(result);
+ }
+
+ EndBlock(Branch(DefineConstant(), 1, 2));
+
+ // Jump back to loop header.
+ StartBlock();
+ EndBlock(Jump(-1));
+
+ EndLoop();
+ }
+
+ // End block.
+ StartLastBlock();
+
+ // Return sum.
+ Return(DefineConstant());
+ EndBlock();
+
+ Allocate();
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/select-lowering.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::AllOf;
+using testing::Capture;
+using testing::CaptureEq;
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class SelectLoweringTest : public GraphTest {
+ public:
+ SelectLoweringTest() : GraphTest(5), lowering_(graph(), common()) {}
+
+ protected:
+ Reduction Reduce(Node* node) { return lowering_.Reduce(node); }
+
+ private:
+ SelectLowering lowering_;
+};
+
+
+TEST_F(SelectLoweringTest, SelectWithSameConditions) {
+ Node* const p0 = Parameter(0);
+ Node* const p1 = Parameter(1);
+ Node* const p2 = Parameter(2);
+ Node* const p3 = Parameter(3);
+ Node* const p4 = Parameter(4);
+
+ Capture<Node*> branch;
+ Capture<Node*> merge;
+ {
+ Reduction const r =
+ Reduce(graph()->NewNode(common()->Select(kMachInt32), p0, p1, p2));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(
+ r.replacement(),
+ IsPhi(
+ kMachInt32, p1, p2,
+ AllOf(CaptureEq(&merge),
+ IsMerge(IsIfTrue(CaptureEq(&branch)),
+ IsIfFalse(AllOf(CaptureEq(&branch),
+ IsBranch(p0, graph()->start())))))));
+ }
+ {
+ Reduction const r =
+ Reduce(graph()->NewNode(common()->Select(kMachInt32), p0, p3, p4));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(), IsPhi(kMachInt32, p3, p4, CaptureEq(&merge)));
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "src/compiler/graph-unittest.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/simplified-operator.h"
#include "src/compiler/simplified-operator-reducer.h"
-#include "src/compiler/typer.h"
#include "src/conversions.h"
+#include "src/types.h"
+#include "test/unittests/compiler/graph-unittest.h"
+#include "test/unittests/compiler/node-test-utils.h"
namespace v8 {
namespace internal {
protected:
Reduction Reduce(Node* node) {
- Typer typer(zone());
MachineOperatorBuilder machine;
JSOperatorBuilder javascript(zone());
- JSGraph jsgraph(graph(), common(), &javascript, &typer, &machine);
+ JSGraph jsgraph(graph(), common(), &javascript, &machine);
SimplifiedOperatorReducer reducer(&jsgraph);
return reducer.Reduce(node);
}
}
}
+
+// -----------------------------------------------------------------------------
+// LoadElement
+
+
+TEST_F(SimplifiedOperatorReducerTest, LoadElementWithConstantKeyAndLength) {
+ ElementAccess const access = {kTypedArrayBoundsCheck, kUntaggedBase, 0,
+ Type::Any(), kMachAnyTagged};
+ ElementAccess access_nocheck = access;
+ access_nocheck.bounds_check = kNoBoundsCheck;
+ Node* const base = Parameter(0);
+ Node* const effect = graph()->start();
+ {
+ Node* const key = NumberConstant(-42.0);
+ Node* const length = NumberConstant(100.0);
+ Reduction r = Reduce(graph()->NewNode(simplified()->LoadElement(access),
+ base, key, length, effect));
+ ASSERT_FALSE(r.Changed());
+ }
+ {
+ Node* const key = NumberConstant(-0.0);
+ Node* const length = NumberConstant(1.0);
+ Reduction r = Reduce(graph()->NewNode(simplified()->LoadElement(access),
+ base, key, length, effect));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsLoadElement(access_nocheck, base, key, length, effect));
+ }
+ {
+ Node* const key = NumberConstant(0);
+ Node* const length = NumberConstant(1);
+ Reduction r = Reduce(graph()->NewNode(simplified()->LoadElement(access),
+ base, key, length, effect));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsLoadElement(access_nocheck, base, key, length, effect));
+ }
+ {
+ Node* const key = NumberConstant(42.2);
+ Node* const length = NumberConstant(128);
+ Reduction r = Reduce(graph()->NewNode(simplified()->LoadElement(access),
+ base, key, length, effect));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsLoadElement(access_nocheck, base, key, length, effect));
+ }
+ {
+ Node* const key = NumberConstant(39.2);
+ Node* const length = NumberConstant(32.0);
+ Reduction r = Reduce(graph()->NewNode(simplified()->LoadElement(access),
+ base, key, length, effect));
+ ASSERT_FALSE(r.Changed());
+ }
+}
+
+
+// -----------------------------------------------------------------------------
+// StoreElement
+
+
+TEST_F(SimplifiedOperatorReducerTest, StoreElementWithConstantKeyAndLength) {
+ ElementAccess const access = {kTypedArrayBoundsCheck, kUntaggedBase, 0,
+ Type::Any(), kMachAnyTagged};
+ ElementAccess access_nocheck = access;
+ access_nocheck.bounds_check = kNoBoundsCheck;
+ Node* const base = Parameter(0);
+ Node* const value = Parameter(1);
+ Node* const effect = graph()->start();
+ Node* const control = graph()->start();
+ {
+ Node* const key = NumberConstant(-72.1);
+ Node* const length = NumberConstant(0.0);
+ Reduction r =
+ Reduce(graph()->NewNode(simplified()->StoreElement(access), base, key,
+ length, value, effect, control));
+ ASSERT_FALSE(r.Changed());
+ }
+ {
+ Node* const key = NumberConstant(-0.0);
+ Node* const length = NumberConstant(999);
+ Reduction r =
+ Reduce(graph()->NewNode(simplified()->StoreElement(access), base, key,
+ length, value, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStoreElement(access_nocheck, base, key, length, value, effect,
+ control));
+ }
+ {
+ Node* const key = NumberConstant(0);
+ Node* const length = NumberConstant(1);
+ Reduction r =
+ Reduce(graph()->NewNode(simplified()->StoreElement(access), base, key,
+ length, value, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStoreElement(access_nocheck, base, key, length, value, effect,
+ control));
+ }
+ {
+ Node* const key = NumberConstant(42.2);
+ Node* const length = NumberConstant(128);
+ Reduction r =
+ Reduce(graph()->NewNode(simplified()->StoreElement(access), base, key,
+ length, value, effect, control));
+ ASSERT_TRUE(r.Changed());
+ EXPECT_THAT(r.replacement(),
+ IsStoreElement(access_nocheck, base, key, length, value, effect,
+ control));
+ }
+ {
+ Node* const key = NumberConstant(39.2);
+ Node* const length = NumberConstant(32.0);
+ Reduction r =
+ Reduce(graph()->NewNode(simplified()->StoreElement(access), base, key,
+ length, value, effect, control));
+ ASSERT_FALSE(r.Changed());
+ }
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
#include "src/compiler/simplified-operator.h"
#include "src/compiler/operator-properties-inl.h"
-#include "src/test/test-utils.h"
+#include "test/unittests/test-utils.h"
namespace v8 {
namespace internal {
namespace compiler {
-// TODO(bmeurer): Drop once we use std::ostream instead of our OStream.
-inline std::ostream& operator<<(std::ostream& os, const ElementAccess& access) {
- OStringStream ost;
- ost << access;
- return os << ost.c_str();
-}
-
-
// -----------------------------------------------------------------------------
// Pure operators.
const PureOperator& pop = GetParam();
const Operator* op = (simplified.*pop.constructor)();
- EXPECT_EQ(pop.value_input_count, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
+ EXPECT_EQ(pop.value_input_count, op->ValueInputCount());
+ EXPECT_EQ(0, op->EffectInputCount());
+ EXPECT_EQ(0, op->ControlInputCount());
EXPECT_EQ(pop.value_input_count, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(1, op->ValueOutputCount());
+ EXPECT_EQ(0, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
namespace {
const ElementAccess kElementAccesses[] = {
- {kTaggedBase, FixedArray::kHeaderSize, Type::Any(), kMachAnyTagged},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachInt8},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachInt16},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachInt32},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachUint8},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachUint16},
- {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
- kMachUint32},
- {kUntaggedBase, 0, Type::Signed32(), kMachInt8},
- {kUntaggedBase, 0, Type::Unsigned32(), kMachUint8},
- {kUntaggedBase, 0, Type::Signed32(), kMachInt16},
- {kUntaggedBase, 0, Type::Unsigned32(), kMachUint16},
- {kUntaggedBase, 0, Type::Signed32(), kMachInt32},
- {kUntaggedBase, 0, Type::Unsigned32(), kMachUint32},
- {kUntaggedBase, 0, Type::Number(), kRepFloat32},
- {kUntaggedBase, 0, Type::Number(), kRepFloat64},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
- kMachInt8},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
- kMachUint8},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
- kMachInt16},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
- kMachUint16},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
- kMachInt32},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
- kMachUint32},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Number(),
- kRepFloat32},
- {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Number(),
- kRepFloat64}};
+ {kNoBoundsCheck, kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
+ kMachAnyTagged},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachInt8},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachInt16},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachInt32},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachUint8},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachUint16},
+ {kNoBoundsCheck, kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag,
+ Type::Any(), kMachUint32},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Signed32(), kMachInt8},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Unsigned32(), kMachUint8},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Signed32(), kMachInt16},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Unsigned32(), kMachUint16},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Signed32(), kMachInt32},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Unsigned32(), kMachUint32},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Number(), kRepFloat32},
+ {kTypedArrayBoundsCheck, kUntaggedBase, 0, Type::Number(), kRepFloat64},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Signed32(), kMachInt8},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Unsigned32(), kMachUint8},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Signed32(), kMachInt16},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Unsigned32(), kMachUint16},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Signed32(), kMachInt32},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Unsigned32(), kMachUint32},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Number(), kRepFloat32},
+ {kTypedArrayBoundsCheck, kTaggedBase, FixedTypedArrayBase::kDataOffset,
+ Type::Number(), kRepFloat64}};
} // namespace
EXPECT_EQ(Operator::kNoThrow | Operator::kNoWrite, op->properties());
EXPECT_EQ(access, ElementAccessOf(op));
- EXPECT_EQ(3, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
+ EXPECT_EQ(3, op->ValueInputCount());
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(0, op->ControlInputCount());
EXPECT_EQ(4, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(1, op->ValueOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
EXPECT_EQ(Operator::kNoRead | Operator::kNoThrow, op->properties());
EXPECT_EQ(access, ElementAccessOf(op));
- EXPECT_EQ(4, OperatorProperties::GetValueInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
+ EXPECT_EQ(4, op->ValueInputCount());
+ EXPECT_EQ(1, op->EffectInputCount());
+ EXPECT_EQ(1, op->ControlInputCount());
EXPECT_EQ(6, OperatorProperties::GetTotalInputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
- EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
- EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+ EXPECT_EQ(0, op->ValueOutputCount());
+ EXPECT_EQ(1, op->EffectOutputCount());
+ EXPECT_EQ(0, op->ControlOutputCount());
}
#include "src/compiler/graph.h"
#include "src/compiler/value-numbering-reducer.h"
-#include "src/test/test-utils.h"
+#include "test/unittests/test-utils.h"
namespace v8 {
namespace internal {
namespace compiler {
-namespace {
+struct TestOperator : public Operator {
+ TestOperator(Operator::Opcode opcode, Operator::Properties properties,
+ size_t value_in, size_t value_out)
+ : Operator(opcode, properties, "TestOp", value_in, 0, 0, value_out, 0,
+ 0) {}
+};
-const SimpleOperator kOp0(0, Operator::kNoProperties, 0, 1, "op0");
-const SimpleOperator kOp1(1, Operator::kNoProperties, 1, 1, "op1");
-} // namespace
+static const TestOperator kOp0(0, Operator::kEliminatable, 0, 1);
+static const TestOperator kOp1(1, Operator::kEliminatable, 1, 1);
class ValueNumberingReducerTest : public TestWithZone {
}
+TEST_F(ValueNumberingReducerTest, OnlyEliminatableNodesAreReduced) {
+ TestOperator op(0, Operator::kNoProperties, 0, 1);
+ Node* n0 = graph()->NewNode(&op);
+ Node* n1 = graph()->NewNode(&op);
+ EXPECT_FALSE(Reduce(n0).Changed());
+ EXPECT_FALSE(Reduce(n1).Changed());
+}
+
+
TEST_F(ValueNumberingReducerTest, OperatorEqualityNotIdentity) {
static const size_t kMaxInputCount = 16;
Node* inputs[kMaxInputCount];
for (size_t i = 0; i < arraysize(inputs); ++i) {
Operator::Opcode opcode = static_cast<Operator::Opcode>(
std::numeric_limits<Operator::Opcode>::max() - i);
- inputs[i] = graph()->NewNode(new (zone()) SimpleOperator(
- opcode, Operator::kNoProperties, 0, 1, "Operator"));
+ inputs[i] = graph()->NewNode(
+ new (zone()) TestOperator(opcode, Operator::kEliminatable, 0, 1));
}
TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
- const SimpleOperator op1(static_cast<Operator::Opcode>(input_count),
- Operator::kNoProperties,
- static_cast<int>(input_count), 1, "op");
+ const TestOperator op1(static_cast<Operator::Opcode>(input_count),
+ Operator::kEliminatable, input_count, 1);
Node* n1 = graph()->NewNode(&op1, static_cast<int>(input_count), inputs);
Reduction r1 = Reduce(n1);
EXPECT_FALSE(r1.Changed());
- const SimpleOperator op2(static_cast<Operator::Opcode>(input_count),
- Operator::kNoProperties,
- static_cast<int>(input_count), 1, "op");
+ const TestOperator op2(static_cast<Operator::Opcode>(input_count),
+ Operator::kEliminatable, input_count, 1);
Node* n2 = graph()->NewNode(&op2, static_cast<int>(input_count), inputs);
Reduction r2 = Reduce(n2);
EXPECT_TRUE(r2.Changed());
for (size_t i = 0; i < arraysize(inputs); ++i) {
Operator::Opcode opcode = static_cast<Operator::Opcode>(
std::numeric_limits<Operator::Opcode>::max() - i);
- inputs[i] = graph()->NewNode(new (zone()) SimpleOperator(
- opcode, Operator::kNoProperties, 0, 1, "Operator"));
+ inputs[i] = graph()->NewNode(
+ new (zone()) TestOperator(opcode, Operator::kEliminatable, 0, 1));
}
TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
- const SimpleOperator op1(1, Operator::kNoProperties,
- static_cast<int>(input_count), 1, "op1");
+ const TestOperator op1(1, Operator::kEliminatable, input_count, 1);
Node* n = graph()->NewNode(&op1, static_cast<int>(input_count), inputs);
Reduction r = Reduce(n);
EXPECT_FALSE(r.Changed());
--- /dev/null
+// 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 "test/unittests/compiler/instruction-selector-unittest.h"
+
+#include "src/compiler/node-matchers.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// -----------------------------------------------------------------------------
+// Conversions.
+
+
+TEST_F(InstructionSelectorTest, ChangeFloat32ToFloat64WithParameter) {
+ StreamBuilder m(this, kMachFloat32, kMachFloat64);
+ m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kSSECvtss2sd, s[0]->arch_opcode());
+ EXPECT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+TEST_F(InstructionSelectorTest, ChangeInt32ToInt64WithParameter) {
+ StreamBuilder m(this, kMachInt64, kMachInt32);
+ m.Return(m.ChangeInt32ToInt64(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Movsxlq, s[0]->arch_opcode());
+}
+
+
+TEST_F(InstructionSelectorTest, ChangeUint32ToFloat64WithParameter) {
+ StreamBuilder m(this, kMachFloat64, kMachUint32);
+ m.Return(m.ChangeUint32ToFloat64(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kSSEUint32ToFloat64, s[0]->arch_opcode());
+}
+
+
+TEST_F(InstructionSelectorTest, ChangeUint32ToUint64WithParameter) {
+ StreamBuilder m(this, kMachUint64, kMachUint32);
+ m.Return(m.ChangeUint32ToUint64(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
+}
+
+
+TEST_F(InstructionSelectorTest, TruncateFloat64ToFloat32WithParameter) {
+ StreamBuilder m(this, kMachFloat64, kMachFloat32);
+ m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kSSECvtsd2ss, s[0]->arch_opcode());
+ EXPECT_EQ(1U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+TEST_F(InstructionSelectorTest, TruncateInt64ToInt32WithParameter) {
+ StreamBuilder m(this, kMachInt32, kMachInt64);
+ m.Return(m.TruncateInt64ToInt32(m.Parameter(0)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Movl, s[0]->arch_opcode());
+}
+
+
+// -----------------------------------------------------------------------------
+// Loads and stores
+
+namespace {
+
+struct MemoryAccess {
+ MachineType type;
+ ArchOpcode load_opcode;
+ ArchOpcode store_opcode;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const MemoryAccess& memacc) {
+ return os << memacc.type;
+}
+
+
+static const MemoryAccess kMemoryAccesses[] = {
+ {kMachInt8, kX64Movsxbl, kX64Movb},
+ {kMachUint8, kX64Movzxbl, kX64Movb},
+ {kMachInt16, kX64Movsxwl, kX64Movw},
+ {kMachUint16, kX64Movzxwl, kX64Movw},
+ {kMachInt32, kX64Movl, kX64Movl},
+ {kMachUint32, kX64Movl, kX64Movl},
+ {kMachInt64, kX64Movq, kX64Movq},
+ {kMachUint64, kX64Movq, kX64Movq},
+ {kMachFloat32, kX64Movss, kX64Movss},
+ {kMachFloat64, kX64Movsd, kX64Movsd}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<MemoryAccess>
+ InstructionSelectorMemoryAccessTest;
+
+
+TEST_P(InstructionSelectorMemoryAccessTest, LoadWithParameters) {
+ const MemoryAccess memacc = GetParam();
+ StreamBuilder m(this, memacc.type, kMachPtr, kMachInt32);
+ m.Return(m.Load(memacc.type, m.Parameter(0), m.Parameter(1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.load_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+TEST_P(InstructionSelectorMemoryAccessTest, StoreWithParameters) {
+ const MemoryAccess memacc = GetParam();
+ StreamBuilder m(this, kMachInt32, kMachPtr, kMachInt32, memacc.type);
+ m.Store(memacc.type, m.Parameter(0), m.Parameter(1), m.Parameter(2));
+ m.Return(m.Int32Constant(0));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(memacc.store_opcode, s[0]->arch_opcode());
+ EXPECT_EQ(3U, s[0]->InputCount());
+ EXPECT_EQ(0U, s[0]->OutputCount());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorMemoryAccessTest,
+ ::testing::ValuesIn(kMemoryAccesses));
+
+// -----------------------------------------------------------------------------
+// ChangeUint32ToUint64.
+
+
+namespace {
+
+typedef Node* (RawMachineAssembler::*Constructor)(Node*, Node*);
+
+
+struct BinaryOperation {
+ Constructor constructor;
+ const char* constructor_name;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const BinaryOperation& bop) {
+ return os << bop.constructor_name;
+}
+
+
+const BinaryOperation kWord32BinaryOperations[] = {
+ {&RawMachineAssembler::Word32And, "Word32And"},
+ {&RawMachineAssembler::Word32Or, "Word32Or"},
+ {&RawMachineAssembler::Word32Xor, "Word32Xor"},
+ {&RawMachineAssembler::Word32Shl, "Word32Shl"},
+ {&RawMachineAssembler::Word32Shr, "Word32Shr"},
+ {&RawMachineAssembler::Word32Sar, "Word32Sar"},
+ {&RawMachineAssembler::Word32Ror, "Word32Ror"},
+ {&RawMachineAssembler::Word32Equal, "Word32Equal"},
+ {&RawMachineAssembler::Int32Add, "Int32Add"},
+ {&RawMachineAssembler::Int32Sub, "Int32Sub"},
+ {&RawMachineAssembler::Int32Mul, "Int32Mul"},
+ {&RawMachineAssembler::Int32MulHigh, "Int32MulHigh"},
+ {&RawMachineAssembler::Int32Div, "Int32Div"},
+ {&RawMachineAssembler::Int32LessThan, "Int32LessThan"},
+ {&RawMachineAssembler::Int32LessThanOrEqual, "Int32LessThanOrEqual"},
+ {&RawMachineAssembler::Int32Mod, "Int32Mod"},
+ {&RawMachineAssembler::Uint32Div, "Uint32Div"},
+ {&RawMachineAssembler::Uint32LessThan, "Uint32LessThan"},
+ {&RawMachineAssembler::Uint32LessThanOrEqual, "Uint32LessThanOrEqual"},
+ {&RawMachineAssembler::Uint32Mod, "Uint32Mod"}};
+
+} // namespace
+
+
+typedef InstructionSelectorTestWithParam<BinaryOperation>
+ InstructionSelectorChangeUint32ToUint64Test;
+
+
+TEST_P(InstructionSelectorChangeUint32ToUint64Test, ChangeUint32ToUint64) {
+ const BinaryOperation& bop = GetParam();
+ StreamBuilder m(this, kMachUint64, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ m.Return(m.ChangeUint32ToUint64((m.*bop.constructor)(p0, p1)));
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+}
+
+
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest,
+ InstructionSelectorChangeUint32ToUint64Test,
+ ::testing::ValuesIn(kWord32BinaryOperations));
+
+
+// -----------------------------------------------------------------------------
+// TruncateInt64ToInt32.
+
+
+TEST_F(InstructionSelectorTest, TruncateInt64ToInt32WithWord64Sar) {
+ StreamBuilder m(this, kMachInt32, kMachInt64);
+ Node* const p = m.Parameter(0);
+ Node* const t = m.TruncateInt64ToInt32(m.Word64Sar(p, m.Int64Constant(32)));
+ m.Return(t);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Shr, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(32, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_TRUE(s.IsSameAsFirst(s[0]->OutputAt(0)));
+ EXPECT_EQ(s.ToVreg(t), s.ToVreg(s[0]->OutputAt(0)));
+}
+
+
+TEST_F(InstructionSelectorTest, TruncateInt64ToInt32WithWord64Shr) {
+ StreamBuilder m(this, kMachInt32, kMachInt64);
+ Node* const p = m.Parameter(0);
+ Node* const t = m.TruncateInt64ToInt32(m.Word64Shr(p, m.Int64Constant(32)));
+ m.Return(t);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Shr, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(32, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_TRUE(s.IsSameAsFirst(s[0]->OutputAt(0)));
+ EXPECT_EQ(s.ToVreg(t), s.ToVreg(s[0]->OutputAt(0)));
+}
+
+
+// -----------------------------------------------------------------------------
+// Addition.
+
+
+TEST_F(InstructionSelectorTest, Int32AddWithInt32AddWithParameters) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const a0 = m.Int32Add(p0, p1);
+ m.Return(m.Int32Add(a0, p0));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(kX64Add32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(1)));
+}
+
+
+// -----------------------------------------------------------------------------
+// Multiplication.
+
+
+TEST_F(InstructionSelectorTest, Int32MulWithInt32MulWithParameters) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const m0 = m.Int32Mul(p0, p1);
+ m.Return(m.Int32Mul(m0, p0));
+ Stream s = m.Build();
+ ASSERT_EQ(2U, s.size());
+ EXPECT_EQ(kX64Imul32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(m0), s.ToVreg(s[0]->OutputAt(0)));
+ EXPECT_EQ(kX64Imul32, s[1]->arch_opcode());
+ ASSERT_EQ(2U, s[1]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[1]->InputAt(0)));
+ EXPECT_EQ(s.ToVreg(m0), s.ToVreg(s[1]->InputAt(1)));
+}
+
+
+TEST_F(InstructionSelectorTest, Int32MulHigh) {
+ StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Int32MulHigh(p0, p1);
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64ImulHigh32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_TRUE(s.IsFixed(s[0]->InputAt(0), rax));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_TRUE(!s.IsUsedAtStart(s[0]->InputAt(1)));
+ ASSERT_LE(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ EXPECT_TRUE(s.IsFixed(s[0]->OutputAt(0), rdx));
+}
+
+
+TEST_F(InstructionSelectorTest, Uint32MulHigh) {
+ StreamBuilder m(this, kMachUint32, kMachUint32, kMachUint32);
+ Node* const p0 = m.Parameter(0);
+ Node* const p1 = m.Parameter(1);
+ Node* const n = m.Uint32MulHigh(p0, p1);
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64UmulHigh32, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_TRUE(s.IsFixed(s[0]->InputAt(0), rax));
+ EXPECT_EQ(s.ToVreg(p1), s.ToVreg(s[0]->InputAt(1)));
+ EXPECT_TRUE(!s.IsUsedAtStart(s[0]->InputAt(1)));
+ ASSERT_LE(1U, s[0]->OutputCount());
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ EXPECT_TRUE(s.IsFixed(s[0]->OutputAt(0), rdx));
+}
+
+
+// -----------------------------------------------------------------------------
+// Word64Shl.
+
+
+TEST_F(InstructionSelectorTest, Word64ShlWithChangeInt32ToInt64) {
+ TRACED_FORRANGE(int64_t, x, 32, 63) {
+ StreamBuilder m(this, kMachInt64, kMachInt32);
+ Node* const p0 = m.Parameter(0);
+ Node* const n = m.Word64Shl(m.ChangeInt32ToInt64(p0), m.Int64Constant(x));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Shl, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(x, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_TRUE(s.IsSameAsFirst(s[0]->Output()));
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ }
+}
+
+
+TEST_F(InstructionSelectorTest, Word64ShlWithChangeUint32ToUint64) {
+ TRACED_FORRANGE(int64_t, x, 32, 63) {
+ StreamBuilder m(this, kMachInt64, kMachUint32);
+ Node* const p0 = m.Parameter(0);
+ Node* const n = m.Word64Shl(m.ChangeUint32ToUint64(p0), m.Int64Constant(x));
+ m.Return(n);
+ Stream s = m.Build();
+ ASSERT_EQ(1U, s.size());
+ EXPECT_EQ(kX64Shl, s[0]->arch_opcode());
+ ASSERT_EQ(2U, s[0]->InputCount());
+ EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
+ EXPECT_EQ(x, s.ToInt32(s[0]->InputAt(1)));
+ ASSERT_EQ(1U, s[0]->OutputCount());
+ EXPECT_TRUE(s.IsSameAsFirst(s[0]->Output()));
+ EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
+ }
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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/base/utils/random-number-generator.h"
+#include "src/compiler/zone-pool.h"
+#include "test/unittests/test-utils.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class ZonePoolTest : public TestWithIsolate {
+ public:
+ ZonePoolTest() : zone_pool_(isolate()) {}
+
+ protected:
+ ZonePool* zone_pool() { return &zone_pool_; }
+
+ void ExpectForPool(size_t current, size_t max, size_t total) {
+ ASSERT_EQ(current, zone_pool()->GetCurrentAllocatedBytes());
+ ASSERT_EQ(max, zone_pool()->GetMaxAllocatedBytes());
+ ASSERT_EQ(total, zone_pool()->GetTotalAllocatedBytes());
+ }
+
+ void Expect(ZonePool::StatsScope* stats, size_t current, size_t max,
+ size_t total) {
+ ASSERT_EQ(current, stats->GetCurrentAllocatedBytes());
+ ASSERT_EQ(max, stats->GetMaxAllocatedBytes());
+ ASSERT_EQ(total, stats->GetTotalAllocatedBytes());
+ }
+
+ size_t Allocate(Zone* zone) {
+ size_t bytes = rng.NextInt(25) + 7;
+ int size_before = zone->allocation_size();
+ zone->New(static_cast<int>(bytes));
+ return static_cast<size_t>(zone->allocation_size() - size_before);
+ }
+
+ private:
+ ZonePool zone_pool_;
+ base::RandomNumberGenerator rng;
+};
+
+
+TEST_F(ZonePoolTest, Empty) {
+ ExpectForPool(0, 0, 0);
+ {
+ ZonePool::StatsScope stats(zone_pool());
+ Expect(&stats, 0, 0, 0);
+ }
+ ExpectForPool(0, 0, 0);
+ {
+ ZonePool::Scope scope(zone_pool());
+ scope.zone();
+ }
+ ExpectForPool(0, 0, 0);
+}
+
+
+TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
+ static const size_t kArraySize = 10;
+
+ ZonePool::Scope* scopes[kArraySize];
+
+ // Initialize.
+ size_t before_stats = 0;
+ for (size_t i = 0; i < kArraySize; ++i) {
+ scopes[i] = new ZonePool::Scope(zone_pool());
+ before_stats += Allocate(scopes[i]->zone()); // Add some stuff.
+ }
+
+ ExpectForPool(before_stats, before_stats, before_stats);
+
+ ZonePool::StatsScope stats(zone_pool());
+
+ size_t before_deletion = 0;
+ for (size_t i = 0; i < kArraySize; ++i) {
+ before_deletion += Allocate(scopes[i]->zone()); // Add some stuff.
+ }
+
+ Expect(&stats, before_deletion, before_deletion, before_deletion);
+ ExpectForPool(before_stats + before_deletion, before_stats + before_deletion,
+ before_stats + before_deletion);
+
+ // Delete the scopes and create new ones.
+ for (size_t i = 0; i < kArraySize; ++i) {
+ delete scopes[i];
+ scopes[i] = new ZonePool::Scope(zone_pool());
+ }
+
+ Expect(&stats, 0, before_deletion, before_deletion);
+ ExpectForPool(0, before_stats + before_deletion,
+ before_stats + before_deletion);
+
+ size_t after_deletion = 0;
+ for (size_t i = 0; i < kArraySize; ++i) {
+ after_deletion += Allocate(scopes[i]->zone()); // Add some stuff.
+ }
+
+ Expect(&stats, after_deletion, std::max(after_deletion, before_deletion),
+ before_deletion + after_deletion);
+ ExpectForPool(after_deletion,
+ std::max(after_deletion, before_stats + before_deletion),
+ before_stats + before_deletion + after_deletion);
+
+ // Cleanup.
+ for (size_t i = 0; i < kArraySize; ++i) {
+ delete scopes[i];
+ }
+
+ Expect(&stats, 0, std::max(after_deletion, before_deletion),
+ before_deletion + after_deletion);
+ ExpectForPool(0, std::max(after_deletion, before_stats + before_deletion),
+ before_stats + before_deletion + after_deletion);
+}
+
+
+TEST_F(ZonePoolTest, SimpleAllocationLoop) {
+ int runs = 20;
+ size_t total_allocated = 0;
+ size_t max_loop_allocation = 0;
+ ZonePool::StatsScope outer_stats(zone_pool());
+ {
+ ZonePool::Scope outer_scope(zone_pool());
+ size_t outer_allocated = 0;
+ for (int i = 0; i < runs; ++i) {
+ {
+ size_t bytes = Allocate(outer_scope.zone());
+ outer_allocated += bytes;
+ total_allocated += bytes;
+ }
+ ZonePool::StatsScope inner_stats(zone_pool());
+ size_t allocated = 0;
+ {
+ ZonePool::Scope inner_scope(zone_pool());
+ for (int j = 0; j < 20; ++j) {
+ size_t bytes = Allocate(inner_scope.zone());
+ allocated += bytes;
+ total_allocated += bytes;
+ max_loop_allocation =
+ std::max(max_loop_allocation, outer_allocated + allocated);
+ Expect(&inner_stats, allocated, allocated, allocated);
+ Expect(&outer_stats, outer_allocated + allocated, max_loop_allocation,
+ total_allocated);
+ ExpectForPool(outer_allocated + allocated, max_loop_allocation,
+ total_allocated);
+ }
+ }
+ Expect(&inner_stats, 0, allocated, allocated);
+ Expect(&outer_stats, outer_allocated, max_loop_allocation,
+ total_allocated);
+ ExpectForPool(outer_allocated, max_loop_allocation, total_allocated);
+ }
+ }
+ Expect(&outer_stats, 0, max_loop_allocation, total_allocated);
+ ExpectForPool(0, max_loop_allocation, total_allocated);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
result.mark_compact_speed_in_bytes_per_ms = kMarkCompactSpeed;
result.incremental_marking_speed_in_bytes_per_ms = kMarkingSpeed;
result.scavenge_speed_in_bytes_per_ms = kScavengeSpeed;
- result.available_new_space_memory = kNewSpaceCapacity;
+ result.used_new_space_size = 0;
result.new_space_capacity = kNewSpaceCapacity;
result.new_space_allocation_throughput_in_bytes_per_ms =
kNewSpaceAllocationThroughput;
}
-TEST(GCIdleTimeHandler, EstimateScavengeTimeInitial) {
- size_t size = 1 * MB;
- size_t time = GCIdleTimeHandler::EstimateScavengeTime(size, 0);
- EXPECT_EQ(size / GCIdleTimeHandler::kInitialConservativeScavengeSpeed, time);
+TEST_F(GCIdleTimeHandlerTest, DoScavengeEmptyNewSpace) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ int idle_time_in_ms = 16;
+ EXPECT_FALSE(GCIdleTimeHandler::ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size, heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms));
}
-TEST(GCIdleTimeHandler, EstimateScavengeTimeNonZero) {
- size_t size = 1 * MB;
- size_t speed = 1 * MB;
- size_t time = GCIdleTimeHandler::EstimateScavengeTime(size, speed);
- EXPECT_EQ(size / speed, time);
+TEST_F(GCIdleTimeHandlerTest, DoScavengeFullNewSpace) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ heap_state.used_new_space_size = kNewSpaceCapacity;
+ int idle_time_in_ms = 16;
+ EXPECT_TRUE(GCIdleTimeHandler::ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size, heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms));
+}
+
+
+TEST_F(GCIdleTimeHandlerTest, DoScavengeUnknownScavengeSpeed) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ heap_state.used_new_space_size = kNewSpaceCapacity;
+ heap_state.scavenge_speed_in_bytes_per_ms = 0;
+ int idle_time_in_ms = 16;
+ EXPECT_FALSE(GCIdleTimeHandler::ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size, heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms));
+}
+
+
+TEST_F(GCIdleTimeHandlerTest, DoScavengeLowScavengeSpeed) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ heap_state.used_new_space_size = kNewSpaceCapacity;
+ heap_state.scavenge_speed_in_bytes_per_ms = 1 * KB;
+ int idle_time_in_ms = 16;
+ EXPECT_FALSE(GCIdleTimeHandler::ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size, heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms));
}
-TEST(GCIdleTimeHandler, ScavangeMayHappenSoonInitial) {
- size_t available = 100 * KB;
- EXPECT_FALSE(GCIdleTimeHandler::ScavangeMayHappenSoon(available, 0));
+TEST_F(GCIdleTimeHandlerTest, DoScavengeHighScavengeSpeed) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ heap_state.used_new_space_size = kNewSpaceCapacity;
+ heap_state.scavenge_speed_in_bytes_per_ms = kNewSpaceCapacity;
+ int idle_time_in_ms = 16;
+ EXPECT_TRUE(GCIdleTimeHandler::ShouldDoScavenge(
+ idle_time_in_ms, heap_state.new_space_capacity,
+ heap_state.used_new_space_size, heap_state.scavenge_speed_in_bytes_per_ms,
+ heap_state.new_space_allocation_throughput_in_bytes_per_ms));
}
-TEST(GCIdleTimeHandler, ScavangeMayHappenSoonNonZeroFalse) {
- size_t available = (GCIdleTimeHandler::kMaxFrameRenderingIdleTime + 1) * KB;
- size_t speed = 1 * KB;
- EXPECT_FALSE(GCIdleTimeHandler::ScavangeMayHappenSoon(available, speed));
+TEST_F(GCIdleTimeHandlerTest, ShouldDoMarkCompact) {
+ size_t idle_time_in_ms = 16;
+ EXPECT_TRUE(GCIdleTimeHandler::ShouldDoMarkCompact(idle_time_in_ms, 0, 0));
}
-TEST(GCIdleTimeHandler, ScavangeMayHappenSoonNonZeroTrue) {
- size_t available = GCIdleTimeHandler::kMaxFrameRenderingIdleTime * KB;
- size_t speed = 1 * KB;
- EXPECT_TRUE(GCIdleTimeHandler::ScavangeMayHappenSoon(available, speed));
+TEST_F(GCIdleTimeHandlerTest, DontDoMarkCompact) {
+ size_t idle_time_in_ms = 1;
+ EXPECT_FALSE(GCIdleTimeHandler::ShouldDoMarkCompact(
+ idle_time_in_ms, kSizeOfObjects, kMarkingSpeed));
}
}
+TEST_F(GCIdleTimeHandlerTest, AfterContextDisposeZeroIdleTime) {
+ GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
+ heap_state.contexts_disposed = 1;
+ heap_state.incremental_marking_stopped = true;
+ heap_state.size_of_objects = GCIdleTimeHandler::kSmallHeapSize / 2;
+ int idle_time_ms = 0;
+ GCIdleTimeAction action = handler()->Compute(idle_time_ms, heap_state);
+ EXPECT_EQ(DO_FULL_GC, action.type);
+}
+
+
TEST_F(GCIdleTimeHandlerTest, AfterContextDisposeSmallIdleTime1) {
GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
heap_state.contexts_disposed = 1;
TEST_F(GCIdleTimeHandlerTest, Scavenge) {
GCIdleTimeHandler::HeapState heap_state = DefaultHeapState();
int idle_time_ms = 10;
- heap_state.available_new_space_memory =
- kNewSpaceAllocationThroughput * idle_time_ms;
+ heap_state.used_new_space_size =
+ heap_state.new_space_capacity -
+ (kNewSpaceAllocationThroughput * idle_time_ms);
GCIdleTimeAction action = handler()->Compute(idle_time_ms, heap_state);
EXPECT_EQ(DO_SCAVENGE, action.type);
}
int idle_time_ms = 10;
heap_state.can_start_incremental_marking = false;
heap_state.incremental_marking_stopped = true;
- heap_state.available_new_space_memory =
- kNewSpaceAllocationThroughput * idle_time_ms;
+ heap_state.used_new_space_size =
+ heap_state.new_space_capacity -
+ (kNewSpaceAllocationThroughput * idle_time_ms);
GCIdleTimeAction action = handler()->Compute(idle_time_ms, heap_state);
EXPECT_EQ(DO_SCAVENGE, action.type);
- heap_state.available_new_space_memory = kNewSpaceCapacity;
+ heap_state.used_new_space_size = 0;
action = handler()->Compute(idle_time_ms, heap_state);
EXPECT_EQ(DO_NOTHING, action.type);
}
--- /dev/null
+// 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 "test/unittests/test-utils.h"
+
+#include "src/base/platform/time.h"
+#include "src/flags.h"
+#include "src/isolate-inl.h"
+
+namespace v8 {
+
+std::ostream& operator<<(std::ostream& os, ExternalArrayType type) {
+ switch (type) {
+ case kExternalInt8Array:
+ return os << "ExternalInt8Array";
+ case kExternalUint8Array:
+ return os << "ExternalUint8Array";
+ case kExternalInt16Array:
+ return os << "ExternalInt16Array";
+ case kExternalUint16Array:
+ return os << "ExternalUint16Array";
+ case kExternalInt32Array:
+ return os << "ExternalInt32Array";
+ case kExternalUint32Array:
+ return os << "ExternalUint32Array";
+ case kExternalFloat32Array:
+ return os << "ExternalFloat32Array";
+ case kExternalFloat64Array:
+ return os << "ExternalFloat64Array";
+ case kExternalUint8ClampedArray:
+ return os << "ExternalUint8ClampedArray";
+ }
+ UNREACHABLE();
+ return os;
+}
+
+
+// static
+Isolate* TestWithIsolate::isolate_ = NULL;
+
+
+TestWithIsolate::TestWithIsolate()
+ : isolate_scope_(isolate()), handle_scope_(isolate()) {}
+
+
+TestWithIsolate::~TestWithIsolate() {}
+
+
+// static
+void TestWithIsolate::SetUpTestCase() {
+ Test::SetUpTestCase();
+ EXPECT_EQ(NULL, isolate_);
+ isolate_ = v8::Isolate::New();
+ EXPECT_TRUE(isolate_ != NULL);
+}
+
+
+// static
+void TestWithIsolate::TearDownTestCase() {
+ ASSERT_TRUE(isolate_ != NULL);
+ isolate_->Dispose();
+ isolate_ = NULL;
+ Test::TearDownTestCase();
+}
+
+
+TestWithContext::TestWithContext()
+ : context_(Context::New(isolate())), context_scope_(context_) {}
+
+
+TestWithContext::~TestWithContext() {}
+
+
+namespace base {
+namespace {
+
+inline int64_t GetRandomSeedFromFlag(int random_seed) {
+ return random_seed ? random_seed : TimeTicks::Now().ToInternalValue();
+}
+
+} // namespace
+
+TestWithRandomNumberGenerator::TestWithRandomNumberGenerator()
+ : rng_(GetRandomSeedFromFlag(internal::FLAG_random_seed)) {}
+
+
+TestWithRandomNumberGenerator::~TestWithRandomNumberGenerator() {}
+
+} // namespace base
+
+
+namespace internal {
+
+TestWithIsolate::~TestWithIsolate() {}
+
+
+Factory* TestWithIsolate::factory() const { return isolate()->factory(); }
+
+
+TestWithZone::~TestWithZone() {}
+
+} // namespace internal
+} // namespace v8
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef V8_TEST_TEST_UTILS_H_
-#define V8_TEST_TEST_UTILS_H_
+#ifndef V8_UNITTESTS_TEST_UTILS_H_
+#define V8_UNITTESTS_TEST_UTILS_H_
#include "include/v8.h"
#include "src/base/macros.h"
+#include "src/base/utils/random-number-generator.h"
#include "src/zone.h"
#include "testing/gtest-support.h"
namespace v8 {
+std::ostream& operator<<(std::ostream&, ExternalArrayType);
+
+
class TestWithIsolate : public ::testing::Test {
public:
TestWithIsolate();
};
+namespace base {
+
+class TestWithRandomNumberGenerator : public ::testing::Test {
+ public:
+ TestWithRandomNumberGenerator();
+ virtual ~TestWithRandomNumberGenerator();
+
+ RandomNumberGenerator* rng() { return &rng_; }
+
+ private:
+ RandomNumberGenerator rng_;
+
+ DISALLOW_COPY_AND_ASSIGN(TestWithRandomNumberGenerator);
+};
+
+} // namespace base
+
+
namespace internal {
// Forward declarations.
} // namespace internal
} // namespace v8
-#endif // V8_TEST_TEST_UTILS_H_
+#endif // V8_UNITTESTS_TEST_UTILS_H_
--- /dev/null
+# 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.
+
+{
+ 'variables': {
+ 'v8_code': 1,
+ },
+ 'includes': ['../../build/toolchain.gypi', '../../build/features.gypi'],
+ 'targets': [
+ {
+ 'target_name': 'unittests',
+ 'type': 'executable',
+ 'variables': {
+ 'optimize': 'max',
+ },
+ 'dependencies': [
+ '../../testing/gmock.gyp:gmock',
+ '../../testing/gtest.gyp:gtest',
+ '../../tools/gyp/v8.gyp:v8_libplatform',
+ ],
+ 'include_dirs': [
+ '../..',
+ ],
+ 'sources': [ ### gcmole(all) ###
+ 'base/bits-unittest.cc',
+ 'base/cpu-unittest.cc',
+ 'base/division-by-constant-unittest.cc',
+ 'base/flags-unittest.cc',
+ 'base/functional-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',
+ 'char-predicates-unittest.cc',
+ 'compiler/change-lowering-unittest.cc',
+ 'compiler/common-operator-unittest.cc',
+ 'compiler/compiler-test-utils.h',
+ 'compiler/diamond-unittest.cc',
+ 'compiler/graph-reducer-unittest.cc',
+ 'compiler/graph-unittest.cc',
+ 'compiler/graph-unittest.h',
+ 'compiler/instruction-selector-unittest.cc',
+ 'compiler/instruction-selector-unittest.h',
+ 'compiler/js-builtin-reducer-unittest.cc',
+ 'compiler/js-operator-unittest.cc',
+ 'compiler/js-typed-lowering-unittest.cc',
+ 'compiler/machine-operator-reducer-unittest.cc',
+ 'compiler/machine-operator-unittest.cc',
+ 'compiler/node-test-utils.cc',
+ 'compiler/node-test-utils.h',
+ 'compiler/register-allocator-unittest.cc',
+ 'compiler/select-lowering-unittest.cc',
+ 'compiler/simplified-operator-reducer-unittest.cc',
+ 'compiler/simplified-operator-unittest.cc',
+ 'compiler/value-numbering-reducer-unittest.cc',
+ 'compiler/zone-pool-unittest.cc',
+ 'libplatform/default-platform-unittest.cc',
+ 'libplatform/task-queue-unittest.cc',
+ 'libplatform/worker-thread-unittest.cc',
+ 'heap/gc-idle-time-handler-unittest.cc',
+ 'run-all-unittests.cc',
+ 'test-utils.h',
+ 'test-utils.cc',
+ ],
+ 'conditions': [
+ ['v8_target_arch=="arm"', {
+ 'sources': [ ### gcmole(arch:arm) ###
+ 'compiler/arm/instruction-selector-arm-unittest.cc',
+ ],
+ }],
+ ['v8_target_arch=="arm64"', {
+ 'sources': [ ### gcmole(arch:arm64) ###
+ 'compiler/arm64/instruction-selector-arm64-unittest.cc',
+ ],
+ }],
+ ['v8_target_arch=="ia32"', {
+ 'sources': [ ### gcmole(arch:ia32) ###
+ 'compiler/ia32/instruction-selector-ia32-unittest.cc',
+ ],
+ }],
+ ['v8_target_arch=="mipsel"', {
+ 'sources': [ ### gcmole(arch:mipsel) ###
+ 'compiler/mips/instruction-selector-mips-unittest.cc',
+ ],
+ }],
+ ['v8_target_arch=="x64"', {
+ 'sources': [ ### gcmole(arch:x64) ###
+ 'compiler/x64/instruction-selector-x64-unittest.cc',
+ ],
+ }],
+ ['component=="shared_library"', {
+ # compiler-unittests can't be built against a shared library, so we
+ # need to depend on the underlying static target in that case.
+ 'conditions': [
+ ['v8_use_snapshot=="true"', {
+ 'dependencies': ['../../tools/gyp/v8.gyp:v8_snapshot'],
+ },
+ {
+ 'dependencies': [
+ '../../tools/gyp/v8.gyp:v8_nosnapshot',
+ ],
+ }],
+ ],
+ }, {
+ 'dependencies': ['../../tools/gyp/v8.gyp:v8'],
+ }],
+ ['os_posix == 1', {
+ # TODO(svenpanne): This is a temporary work-around to fix the warnings
+ # that show up because we use -std=gnu++0x instead of -std=c++11.
+ 'cflags!': [
+ '-pedantic',
+ ],
+ 'direct_dependent_settings': {
+ 'cflags!': [
+ '-pedantic',
+ ],
+ },
+ }],
+ ],
+ },
+ ],
+}
PASS getSortedOwnPropertyNames(Function) is ['arguments', 'caller', 'length', 'name', 'prototype']
PASS getSortedOwnPropertyNames(Function.prototype) is ['apply', 'arguments', 'bind', 'call', 'caller', 'constructor', 'length', 'name', 'toString']
PASS getSortedOwnPropertyNames(Array) is ['arguments', 'caller', 'isArray', 'length', 'name', 'observe', 'prototype', 'unobserve']
-PASS getSortedOwnPropertyNames(Array.prototype) is ['concat', 'constructor', 'entries', 'every', 'filter', 'forEach', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift', 'values']
+PASS getSortedOwnPropertyNames(Array.prototype) is ['concat', 'constructor', 'entries', 'every', 'filter', 'forEach', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift']
PASS getSortedOwnPropertyNames(String) is ['arguments', 'caller', 'fromCharCode', 'length', 'name', 'prototype']
PASS getSortedOwnPropertyNames(String.prototype) is ['anchor', 'big', 'blink', 'bold', 'charAt', 'charCodeAt', 'concat', 'constructor', 'fixed', 'fontcolor', 'fontsize', 'indexOf', 'italics', 'lastIndexOf', 'length', 'link', 'localeCompare', 'match', 'normalize', 'replace', 'search', 'slice', 'small', 'split', 'strike', 'sub', 'substr', 'substring', 'sup', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimLeft', 'trimRight', 'valueOf']
PASS getSortedOwnPropertyNames(Boolean) is ['arguments', 'caller', 'length', 'name', 'prototype']
"Function": "['arguments', 'caller', 'length', 'name', 'prototype']",
"Function.prototype": "['apply', 'arguments', 'bind', 'call', 'caller', 'constructor', 'length', 'name', 'toString']",
"Array": "['arguments', 'caller', 'isArray', 'length', 'name', 'observe', 'prototype', 'unobserve']",
- "Array.prototype": "['concat', 'constructor', 'entries', 'every', 'filter', 'forEach', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift', 'values']",
+ "Array.prototype": "['concat', 'constructor', 'entries', 'every', 'filter', 'forEach', 'indexOf', 'join', 'keys', 'lastIndexOf', 'length', 'map', 'pop', 'push', 'reduce', 'reduceRight', 'reverse', 'shift', 'slice', 'some', 'sort', 'splice', 'toLocaleString', 'toString', 'unshift']",
"String": "['arguments', 'caller', 'fromCharCode', 'length', 'name', 'prototype']",
"String.prototype": "['anchor', 'big', 'blink', 'bold', 'charAt', 'charCodeAt', 'concat', 'constructor', 'fixed', 'fontcolor', 'fontsize', 'indexOf', 'italics', 'lastIndexOf', 'length', 'link', 'localeCompare', 'match', 'normalize', 'replace', 'search', 'slice', 'small', 'split', 'strike', 'sub', 'substr', 'substring', 'sup', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimLeft', 'trimRight', 'valueOf']",
"Boolean": "['arguments', 'caller', 'length', 'name', 'prototype']",
'dfg-double-vote-fuzz': [SKIP],
'reentrant-caching': [SKIP],
'sort-large-array': [SKIP],
+ # Too slow on windows with --nocrankshaft.
+ # TODO(mstarzinger): Too slow with TF.
+ 'array-iterate-backwards': [PASS, NO_VARIANTS],
}], # 'mode == debug'
['simulator', {
+ # Skip tests that timeout with turbofan.
+ 'dfg-int-overflow-in-loop': [PASS, NO_VARIANTS],
+ 'array-iterate-backwards': [PASS, NO_VARIANTS],
'function-apply-aliased': [SKIP],
}], # 'simulator'
['arch == arm64 and simulator_run == True', {
'fast/js/excessive-comma-usage': [SKIP]
}], # 'gc_stress == True'
+['gc_stress == True and mode == debug', {
+ # Skip tests that timout with turbofan.
+ 'array-iterate-backwards': [PASS, NO_VARIANTS]
+}], # 'gc_stress == True and mode == debug'
+
##############################################################################
]
#ifndef V8_TESTING_GTEST_SUPPORT_H_
#define V8_TESTING_GTEST_SUPPORT_H_
-#include "include/v8stdint.h"
+#include <stddef.h>
#include "testing/gtest/include/gtest/gtest.h"
namespace testing {
inline std::string GetTypeName<type>() { \
return #type; \
}
-GET_TYPE_NAME(int8_t)
-GET_TYPE_NAME(uint8_t)
-GET_TYPE_NAME(int16_t)
-GET_TYPE_NAME(uint16_t)
-GET_TYPE_NAME(int32_t)
-GET_TYPE_NAME(uint32_t)
-GET_TYPE_NAME(int64_t)
-GET_TYPE_NAME(uint64_t)
+GET_TYPE_NAME(bool)
+GET_TYPE_NAME(signed char)
+GET_TYPE_NAME(unsigned char)
+GET_TYPE_NAME(short)
+GET_TYPE_NAME(unsigned short)
+GET_TYPE_NAME(int)
+GET_TYPE_NAME(unsigned int)
+GET_TYPE_NAME(long)
+GET_TYPE_NAME(unsigned long)
+GET_TYPE_NAME(long long)
+GET_TYPE_NAME(unsigned long long)
GET_TYPE_NAME(float)
GET_TYPE_NAME(double)
#undef GET_TYPE_NAME
*
* @param {number} size Code entry size in bytes.
* @param {string} opt_name Code entry name.
+ * @param {string} opt_type Code entry type, e.g. SHARED_LIB, CPP.
* @constructor
*/
-CodeMap.CodeEntry = function(size, opt_name) {
+CodeMap.CodeEntry = function(size, opt_name, opt_type) {
this.size = size;
this.name = opt_name || '';
+ this.type = opt_type || '';
this.nameUpdated_ = false;
};
Usage: jco pc
end
+# Print DescriptorArray.
+define jda
+print ((v8::internal::DescriptorArray*)($arg0))->Print()
+end
+document jda
+Print a v8 DescriptorArray object
+Usage: jda tagged_ptr
+end
+
+# Print TransitionArray.
+define jta
+print ((v8::internal::TransitionArray*)($arg0))->Print()
+end
+document jta
+Print a v8 TransitionArray object
+Usage: jta tagged_ptr
+end
+
# Print JavaScript stack trace.
define jst
-print v8::internal::Isolate::Current()->PrintStack(stdout)
+print v8::internal::Isolate::Current()->PrintStack((FILE*) stdout)
end
document jst
Print the current JavaScript stack trace
{ 'name': 'ExternalStringTag', 'value': 'kExternalStringTag' },
{ 'name': 'SlicedStringTag', 'value': 'kSlicedStringTag' },
+ { 'name': 'FailureTag', 'value': 'kFailureTag' },
+ { 'name': 'FailureTagMask', 'value': 'kFailureTagMask' },
{ 'name': 'HeapObjectTag', 'value': 'kHeapObjectTag' },
{ 'name': 'HeapObjectTagMask', 'value': 'kHeapObjectTagMask' },
{ 'name': 'SmiTag', 'value': 'kSmiTag' },
'value': 'DescriptorArray::kFirstIndex' },
{ 'name': 'prop_type_field',
'value': 'FIELD' },
+ { 'name': 'prop_type_first_phantom',
+ 'value': 'TRANSITION' },
{ 'name': 'prop_type_mask',
'value': 'PropertyDetails::TypeField::kMask' },
{ 'name': 'prop_index_mask',
'value': 'DICTIONARY_ELEMENTS' },
{ 'name': 'bit_field2_elements_kind_mask',
- 'value': 'Map::ElementsKindBits::kMask' },
+ 'value': 'Map::kElementsKindMask' },
{ 'name': 'bit_field2_elements_kind_shift',
- 'value': 'Map::ElementsKindBits::kShift' },
+ 'value': 'Map::kElementsKindShift' },
{ 'name': 'bit_field3_dictionary_map_shift',
'value': 'Map::DictionaryMap::kShift' },
* This file is generated by %s. Do not edit directly.
*/
-#include "src/v8.h"
-#include "src/frames.h"
-#include "src/frames-inl.h" /* for architecture-specific frame constants */
+#include "v8.h"
+#include "frames.h"
+#include "frames-inl.h" /* for architecture-specific frame constants */
using namespace v8::internal;
'target_name': 'v8_external_snapshot',
'type': 'static_library',
'conditions': [
- ['want_separate_host_toolset==1', {
- 'toolsets': ['host', 'target'],
- 'dependencies': [
- 'mksnapshot#host',
- 'js2c#host',
- 'natives_blob',
- ]}, {
- 'toolsets': ['target'],
+ [ 'v8_use_external_startup_data==1', {
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ 'dependencies': [
+ 'mksnapshot#host',
+ 'js2c#host',
+ 'natives_blob',
+ ]}, {
+ 'toolsets': ['target'],
+ 'dependencies': [
+ 'mksnapshot',
+ 'js2c',
+ 'natives_blob',
+ ],
+ }],
+ ['component=="shared_library"', {
+ 'defines': [
+ 'V8_SHARED',
+ 'BUILDING_V8_SHARED',
+ ],
+ 'direct_dependent_settings': {
+ 'defines': [
+ 'V8_SHARED',
+ 'USING_V8_SHARED',
+ ],
+ },
+ }],
+ ],
'dependencies': [
- 'mksnapshot',
- 'js2c',
- 'natives_blob',
+ 'v8_base',
],
- }],
- ['component=="shared_library"', {
- 'defines': [
- 'V8_SHARED',
- 'BUILDING_V8_SHARED',
+ 'include_dirs+': [
+ '../..',
],
- 'direct_dependent_settings': {
- 'defines': [
- 'V8_SHARED',
- 'USING_V8_SHARED',
- ],
- },
- }],
- ],
- 'dependencies': [
- 'v8_base',
- ],
- 'include_dirs+': [
- '../..',
- ],
- 'sources': [
- '../../src/natives-external.cc',
- '../../src/snapshot-external.cc',
- ],
- 'actions': [
- {
- 'action_name': 'run_mksnapshot (external)',
- 'inputs': [
- '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)mksnapshot<(EXECUTABLE_SUFFIX)',
+ 'sources': [
+ '../../src/natives-external.cc',
+ '../../src/snapshot-external.cc',
],
- 'conditions': [
- ['want_separate_host_toolset==1', {
- 'target_conditions': [
- ['_toolset=="host"', {
- 'outputs': [
- '<(INTERMEDIATE_DIR)/snapshot.cc',
- '<(PRODUCT_DIR)/snapshot_blob_host.bin',
+ 'actions': [
+ {
+ 'action_name': 'run_mksnapshot (external)',
+ 'inputs': [
+ '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)mksnapshot<(EXECUTABLE_SUFFIX)',
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'target_conditions': [
+ ['_toolset=="host"', {
+ 'outputs': [
+ '<(INTERMEDIATE_DIR)/snapshot.cc',
+ '<(PRODUCT_DIR)/snapshot_blob_host.bin',
+ ],
+ }, {
+ 'outputs': [
+ '<(INTERMEDIATE_DIR)/snapshot.cc',
+ '<(PRODUCT_DIR)/snapshot_blob.bin',
+ ],
+ }],
],
}, {
'outputs': [
],
}],
],
- }, {
- 'outputs': [
- '<(INTERMEDIATE_DIR)/snapshot.cc',
- '<(PRODUCT_DIR)/snapshot_blob.bin',
+ 'variables': {
+ 'mksnapshot_flags': [
+ '--log-snapshot-positions',
+ '--logfile', '<(INTERMEDIATE_DIR)/snapshot.log',
+ ],
+ 'conditions': [
+ ['v8_random_seed!=0', {
+ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'],
+ }],
+ ],
+ },
+ 'action': [
+ '<@(_inputs)',
+ '<@(mksnapshot_flags)',
+ '<@(INTERMEDIATE_DIR)/snapshot.cc',
+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob.bin',
],
- }],
- ],
- 'variables': {
- 'mksnapshot_flags': [
- '--log-snapshot-positions',
- '--logfile', '<(INTERMEDIATE_DIR)/snapshot.log',
- ],
- 'conditions': [
- ['v8_random_seed!=0', {
- 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'],
- }],
- ],
- },
- 'action': [
- '<@(_inputs)',
- '<@(mksnapshot_flags)',
- '<@(INTERMEDIATE_DIR)/snapshot.cc',
- '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob.bin',
+ },
],
- },
+ }],
],
},
{
'../../src/assert-scope.cc',
'../../src/ast-value-factory.cc',
'../../src/ast-value-factory.h',
+ '../../src/ast-numbering.cc',
+ '../../src/ast-numbering.h',
'../../src/ast.cc',
'../../src/ast.h',
'../../src/background-parsing-task.cc',
'../../src/bignum-dtoa.h',
'../../src/bignum.cc',
'../../src/bignum.h',
+ '../../src/bit-vector.cc',
+ '../../src/bit-vector.h',
'../../src/bootstrapper.cc',
'../../src/bootstrapper.h',
'../../src/builtins.cc',
'../../src/bytecodes-irregexp.h',
'../../src/cached-powers.cc',
'../../src/cached-powers.h',
+ '../../src/char-predicates.cc',
'../../src/char-predicates-inl.h',
'../../src/char-predicates.h',
'../../src/checks.cc',
'../../src/codegen.h',
'../../src/compilation-cache.cc',
'../../src/compilation-cache.h',
+ '../../src/compilation-statistics.cc',
+ '../../src/compilation-statistics.h',
'../../src/compiler/access-builder.cc',
'../../src/compiler/access-builder.h',
'../../src/compiler/ast-graph-builder.cc',
'../../src/compiler/ast-graph-builder.h',
+ '../../src/compiler/ast-loop-assignment-analyzer.cc',
+ '../../src/compiler/ast-loop-assignment-analyzer.h',
'../../src/compiler/basic-block-instrumentor.cc',
'../../src/compiler/basic-block-instrumentor.h',
'../../src/compiler/change-lowering.cc',
'../../src/compiler/common-operator.h',
'../../src/compiler/control-builders.cc',
'../../src/compiler/control-builders.h',
+ '../../src/compiler/control-reducer.cc',
+ '../../src/compiler/control-reducer.h',
+ '../../src/compiler/diamond.h',
'../../src/compiler/frame.h',
'../../src/compiler/gap-resolver.cc',
'../../src/compiler/gap-resolver.h',
'../../src/compiler/js-graph.h',
'../../src/compiler/js-inlining.cc',
'../../src/compiler/js-inlining.h',
+ '../../src/compiler/js-intrinsic-builder.cc',
+ '../../src/compiler/js-intrinsic-builder.h',
+ '../../src/compiler/js-operator.cc',
'../../src/compiler/js-operator.h',
'../../src/compiler/js-typed-lowering.cc',
'../../src/compiler/js-typed-lowering.h',
'../../src/compiler/phi-reducer.h',
'../../src/compiler/pipeline.cc',
'../../src/compiler/pipeline.h',
+ '../../src/compiler/pipeline-statistics.cc',
+ '../../src/compiler/pipeline-statistics.h',
'../../src/compiler/raw-machine-assembler.cc',
'../../src/compiler/raw-machine-assembler.h',
'../../src/compiler/register-allocator.cc',
'../../src/compiler/register-allocator.h',
+ '../../src/compiler/register-configuration.cc',
+ '../../src/compiler/register-configuration.h',
'../../src/compiler/representation-change.h',
'../../src/compiler/schedule.cc',
'../../src/compiler/schedule.h',
'../../src/compiler/scheduler.cc',
'../../src/compiler/scheduler.h',
+ '../../src/compiler/select-lowering.cc',
+ '../../src/compiler/select-lowering.h',
'../../src/compiler/simplified-lowering.cc',
'../../src/compiler/simplified-lowering.h',
'../../src/compiler/simplified-operator-reducer.cc',
'../../src/compiler/value-numbering-reducer.h',
'../../src/compiler/verifier.cc',
'../../src/compiler/verifier.h',
+ '../../src/compiler/zone-pool.cc',
+ '../../src/compiler/zone-pool.h',
'../../src/compiler.cc',
'../../src/compiler.h',
'../../src/contexts.cc',
'../../src/cpu-profiler-inl.h',
'../../src/cpu-profiler.cc',
'../../src/cpu-profiler.h',
- '../../src/data-flow.cc',
- '../../src/data-flow.h',
'../../src/date.cc',
'../../src/date.h',
'../../src/dateparser-inl.h',
'../../src/factory.h',
'../../src/fast-dtoa.cc',
'../../src/fast-dtoa.h',
- '../../src/feedback-slots.h',
'../../src/field-index.h',
'../../src/field-index-inl.h',
'../../src/fixed-dtoa.cc',
'../../src/heap/store-buffer-inl.h',
'../../src/heap/store-buffer.cc',
'../../src/heap/store-buffer.h',
- '../../src/heap/sweeper-thread.h',
- '../../src/heap/sweeper-thread.cc',
'../../src/hydrogen-alias-analysis.h',
'../../src/hydrogen-bce.cc',
'../../src/hydrogen-bce.h',
'../../src/rewriter.h',
'../../src/runtime-profiler.cc',
'../../src/runtime-profiler.h',
+ '../../src/runtime/runtime-api.cc',
+ '../../src/runtime/runtime-array.cc',
+ '../../src/runtime/runtime-classes.cc',
'../../src/runtime/runtime-collections.cc',
'../../src/runtime/runtime-compiler.cc',
+ '../../src/runtime/runtime-date.cc',
+ '../../src/runtime/runtime-debug.cc',
+ '../../src/runtime/runtime-function.cc',
+ '../../src/runtime/runtime-generator.cc',
'../../src/runtime/runtime-i18n.cc',
+ '../../src/runtime/runtime-internal.cc',
'../../src/runtime/runtime-json.cc',
+ '../../src/runtime/runtime-literals.cc',
+ '../../src/runtime/runtime-liveedit.cc',
'../../src/runtime/runtime-maths.cc',
'../../src/runtime/runtime-numbers.cc',
+ '../../src/runtime/runtime-object.cc',
+ '../../src/runtime/runtime-observe.cc',
+ '../../src/runtime/runtime-proxy.cc',
'../../src/runtime/runtime-regexp.cc',
+ '../../src/runtime/runtime-scopes.cc',
'../../src/runtime/runtime-strings.cc',
+ '../../src/runtime/runtime-symbol.cc',
'../../src/runtime/runtime-test.cc',
'../../src/runtime/runtime-typedarray.cc',
'../../src/runtime/runtime-uri.cc',
'../../src/unicode-inl.h',
'../../src/unicode.cc',
'../../src/unicode.h',
+ '../../src/unicode-decoder.cc',
+ '../../src/unicode-decoder.h',
'../../src/unique.h',
- '../../src/uri.h',
'../../src/utils-inl.h',
'../../src/utils.cc',
'../../src/utils.h',
'../../src/zone-inl.h',
'../../src/zone.cc',
'../../src/zone.h',
- '../../third_party/fdlibm/fdlibm.cc',
- '../../third_party/fdlibm/fdlibm.h',
+ '../../src/third_party/fdlibm/fdlibm.cc',
+ '../../src/third_party/fdlibm/fdlibm.h',
],
'conditions': [
['want_separate_host_toolset==1', {
'../../src/mips/regexp-macro-assembler-mips.cc',
'../../src/mips/regexp-macro-assembler-mips.h',
'../../src/mips/simulator-mips.cc',
+ '../../src/compiler/mips/code-generator-mips.cc',
+ '../../src/compiler/mips/instruction-codes-mips.h',
+ '../../src/compiler/mips/instruction-selector-mips.cc',
+ '../../src/compiler/mips/linkage-mips.cc',
'../../src/ic/mips/access-compiler-mips.cc',
'../../src/ic/mips/handler-compiler-mips.cc',
'../../src/ic/mips/ic-mips.cc',
'../../src/x64/macro-assembler-x64.h',
'../../src/x64/regexp-macro-assembler-x64.cc',
'../../src/x64/regexp-macro-assembler-x64.h',
- '../../src/compiler/x64/code-generator-x64.cc',
- '../../src/compiler/x64/instruction-codes-x64.h',
- '../../src/compiler/x64/instruction-selector-x64.cc',
- '../../src/compiler/x64/linkage-x64.cc',
'../../src/ic/x64/access-compiler-x64.cc',
'../../src/ic/x64/handler-compiler-x64.cc',
'../../src/ic/x64/ic-x64.cc',
'../../src/ic/x64/stub-cache-x64.cc',
],
}],
+ ['v8_target_arch=="x64"', {
+ 'sources': [
+ '../../src/compiler/x64/code-generator-x64.cc',
+ '../../src/compiler/x64/instruction-codes-x64.h',
+ '../../src/compiler/x64/instruction-selector-x64.cc',
+ '../../src/compiler/x64/linkage-x64.cc',
+ ],
+ }],
['OS=="linux"', {
'link_settings': {
'conditions': [
'../../src/base/division-by-constant.cc',
'../../src/base/division-by-constant.h',
'../../src/base/flags.h',
+ '../../src/base/functional.cc',
+ '../../src/base/functional.h',
'../../src/base/lazy-instance.h',
'../../src/base/logging.cc',
'../../src/base/logging.h',
'toolsets': ['target'],
}],
['OS=="linux"', {
- 'link_settings': {
- 'libraries': [
- '-lrt'
- ]
- },
+ 'conditions': [
+ ['nacl_target_arch=="none"', {
+ 'link_settings': {
+ 'libraries': [
+ '-lrt'
+ ],
+ },
+ }, {
+ 'defines': [
+ 'V8_LIBRT_NOT_AVAILABLE=1',
+ ],
+ }],
+ ],
'sources': [
'../../src/base/platform/platform-linux.cc',
'../../src/base/platform/platform-posix.cc'
'sources': [
'../../src/base/platform/platform-win32.cc',
'../../src/base/win32-headers.h',
- '../../src/base/win32-math.cc',
- '../../src/base/win32-math.h'
],
}],
],
'sources': [
'../../src/base/platform/platform-win32.cc',
'../../src/base/win32-headers.h',
- '../../src/base/win32-math.cc',
- '../../src/base/win32-math.h'
],
'msvs_disabled_warnings': [4351, 4355, 4800],
'link_settings': {
'../../src/array.js',
'../../src/string.js',
'../../src/uri.js',
- '../../third_party/fdlibm/fdlibm.js',
+ '../../src/third_party/fdlibm/fdlibm.js',
'../../src/math.js',
'../../src/apinatives.js',
'../../src/date.js',
'../../src/generator.js',
'../../src/harmony-string.js',
'../../src/harmony-array.js',
+ '../../src/harmony-tostring.js',
+ '../../src/harmony-typedarray.js',
'../../src/harmony-classes.js',
],
'libraries_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries.bin',
'../../src/mksnapshot.cc',
],
'conditions': [
+ ['v8_enable_i18n_support==1', {
+ 'dependencies': [
+ '<(icu_gyp_path):icui18n',
+ '<(icu_gyp_path):icuuc',
+ ]
+ }],
['want_separate_host_toolset==1', {
'toolsets': ['host'],
}, {
def PutInt(blob_file, value):
- assert(value >= 0 and value < (1 << 20))
- size = 1 if (value < 1 << 6) else (2 if (value < 1 << 14) else 3)
- value_with_length = (value << 2) | size
+ assert(value >= 0 and value < (1 << 28))
+ if (value < 1 << 6):
+ size = 1
+ elif (value < 1 << 14):
+ size = 2
+ elif (value < 1 << 22):
+ size = 3
+ else:
+ size = 4
+ value_with_length = (value << 2) | (size - 1)
byte_sequence = bytearray()
for i in xrange(size):
+++ /dev/null
-// 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.
-
-#include <assert.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-#include <vector>
-#include "src/v8.h"
-
-#include "include/libplatform/libplatform.h"
-#include "src/api.h"
-#include "src/base/platform/platform.h"
-#include "src/messages.h"
-#include "src/runtime/runtime.h"
-#include "src/scanner-character-streams.h"
-#include "src/scopeinfo.h"
-#include "tools/shell-utils.h"
-#include "src/string-stream.h"
-#include "src/scanner.h"
-
-
-using namespace v8::internal;
-
-
-class BaselineScanner {
- public:
- BaselineScanner(const char* fname,
- Isolate* isolate,
- Encoding encoding,
- v8::base::ElapsedTimer* timer,
- int repeat)
- : stream_(NULL) {
- int length = 0;
- source_ = ReadFileAndRepeat(fname, &length, repeat);
- unicode_cache_ = new UnicodeCache();
- scanner_ = new Scanner(unicode_cache_);
- switch (encoding) {
- case UTF8:
- stream_ = new Utf8ToUtf16CharacterStream(source_, length);
- break;
- case UTF16: {
- Handle<String> result = isolate->factory()->NewStringFromTwoByte(
- Vector<const uint16_t>(
- reinterpret_cast<const uint16_t*>(source_),
- length / 2)).ToHandleChecked();
- stream_ =
- new GenericStringUtf16CharacterStream(result, 0, result->length());
- break;
- }
- case LATIN1: {
- Handle<String> result = isolate->factory()->NewStringFromOneByte(
- Vector<const uint8_t>(source_, length)).ToHandleChecked();
- stream_ =
- new GenericStringUtf16CharacterStream(result, 0, result->length());
- break;
- }
- }
- timer->Start();
- scanner_->Initialize(stream_);
- }
-
- ~BaselineScanner() {
- delete scanner_;
- delete stream_;
- delete unicode_cache_;
- delete[] source_;
- }
-
- Token::Value Next(int* beg_pos, int* end_pos) {
- Token::Value res = scanner_->Next();
- *beg_pos = scanner_->location().beg_pos;
- *end_pos = scanner_->location().end_pos;
- return res;
- }
-
- private:
- UnicodeCache* unicode_cache_;
- Scanner* scanner_;
- const byte* source_;
- BufferedUtf16CharacterStream* stream_;
-};
-
-
-struct TokenWithLocation {
- Token::Value value;
- size_t beg;
- size_t end;
- TokenWithLocation() : value(Token::ILLEGAL), beg(0), end(0) { }
- TokenWithLocation(Token::Value value, size_t beg, size_t end) :
- value(value), beg(beg), end(end) { }
- bool operator==(const TokenWithLocation& other) {
- return value == other.value && beg == other.beg && end == other.end;
- }
- bool operator!=(const TokenWithLocation& other) {
- return !(*this == other);
- }
- void Print(const char* prefix) const {
- printf("%s %11s at (%d, %d)\n",
- prefix, Token::Name(value),
- static_cast<int>(beg), static_cast<int>(end));
- }
-};
-
-
-v8::base::TimeDelta RunBaselineScanner(const char* fname, Isolate* isolate,
- Encoding encoding, bool dump_tokens,
- std::vector<TokenWithLocation>* tokens,
- int repeat) {
- v8::base::ElapsedTimer timer;
- BaselineScanner scanner(fname, isolate, encoding, &timer, repeat);
- Token::Value token;
- int beg, end;
- do {
- token = scanner.Next(&beg, &end);
- if (dump_tokens) {
- tokens->push_back(TokenWithLocation(token, beg, end));
- }
- } while (token != Token::EOS);
- return timer.Elapsed();
-}
-
-
-void PrintTokens(const char* name,
- const std::vector<TokenWithLocation>& tokens) {
- printf("No of tokens: %d\n",
- static_cast<int>(tokens.size()));
- printf("%s:\n", name);
- for (size_t i = 0; i < tokens.size(); ++i) {
- tokens[i].Print("=>");
- }
-}
-
-
-v8::base::TimeDelta ProcessFile(
- const char* fname,
- Encoding encoding,
- Isolate* isolate,
- bool print_tokens,
- int repeat) {
- if (print_tokens) {
- printf("Processing file %s\n", fname);
- }
- HandleScope handle_scope(isolate);
- std::vector<TokenWithLocation> baseline_tokens;
- v8::base::TimeDelta baseline_time;
- baseline_time = RunBaselineScanner(
- fname, isolate, encoding, print_tokens,
- &baseline_tokens, repeat);
- if (print_tokens) {
- PrintTokens("Baseline", baseline_tokens);
- }
- return baseline_time;
-}
-
-
-int main(int argc, char* argv[]) {
- v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
- v8::V8::InitializeICU();
- v8::Platform* platform = v8::platform::CreateDefaultPlatform();
- v8::V8::InitializePlatform(platform);
- v8::V8::Initialize();
- Encoding encoding = LATIN1;
- bool print_tokens = false;
- std::vector<std::string> fnames;
- std::string benchmark;
- int repeat = 1;
- for (int i = 0; i < argc; ++i) {
- if (strcmp(argv[i], "--latin1") == 0) {
- encoding = LATIN1;
- } else if (strcmp(argv[i], "--utf8") == 0) {
- encoding = UTF8;
- } else if (strcmp(argv[i], "--utf16") == 0) {
- encoding = UTF16;
- } else if (strcmp(argv[i], "--print-tokens") == 0) {
- print_tokens = true;
- } else if (strncmp(argv[i], "--benchmark=", 12) == 0) {
- benchmark = std::string(argv[i]).substr(12);
- } else if (strncmp(argv[i], "--repeat=", 9) == 0) {
- std::string repeat_str = std::string(argv[i]).substr(9);
- repeat = atoi(repeat_str.c_str());
- } else if (i > 0 && argv[i][0] != '-') {
- fnames.push_back(std::string(argv[i]));
- }
- }
- v8::Isolate* isolate = v8::Isolate::New();
- {
- v8::Isolate::Scope isolate_scope(isolate);
- v8::HandleScope handle_scope(isolate);
- v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
- v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
- DCHECK(!context.IsEmpty());
- {
- v8::Context::Scope scope(context);
- double baseline_total = 0;
- for (size_t i = 0; i < fnames.size(); i++) {
- v8::base::TimeDelta time;
- time = ProcessFile(fnames[i].c_str(), encoding,
- reinterpret_cast<Isolate*>(isolate), print_tokens,
- repeat);
- baseline_total += time.InMillisecondsF();
- }
- if (benchmark.empty()) benchmark = "Baseline";
- printf("%s(RunTime): %.f ms\n", benchmark.c_str(), baseline_total);
- }
- }
- v8::V8::Dispose();
- v8::V8::ShutdownPlatform();
- delete platform;
- return 0;
-}
// Filter out possible 'overflow' string.
} else if (firstChar != 'o') {
fullStack.push(parseInt(frame, 16));
+ } else {
+ print("dropping: " + frame);
}
}
return fullStack;
import os
from os.path import join, dirname, abspath
+import re
import subprocess
import sys
import tempfile
try:
p = subprocess.Popen(['file', nexe], stdout=subprocess.PIPE)
out, err = p.communicate()
- lines = out.split('\n')
+ lines = [re.sub("\s+", " " , line) for line in out.split('\n')]
if lines[0].find(": ELF 32-bit LSB executable, Intel 80386") > 0:
return "x86_32"
if lines[0].find(": ELF 64-bit LSB executable, x86-64") > 0:
print("NaCl V8 ARM support is not ready yet.")
sys.exit(1)
else:
- print("Invalid nexe %s" % nexe)
+ print("Invalid nexe %s with NaCl arch %s" % (nexe, nacl_arch))
sys.exit(1)
nacl_sel_ldr = os.path.join(nacl_sdk_dir, "tools", sel_ldr)
nacl_irt = os.path.join(nacl_sdk_dir, "tools", irt)
- nacl_ld_so = os.path.join(nacl_sdk_dir, "toolchain", toolchain,
- "x86_64-nacl", libdir, "runnable-ld.so")
- nacl_lib_path = os.path.join(nacl_sdk_dir, "toolchain", toolchain,
- "x86_64-nacl", libdir)
- return (nacl_sdk_dir, nacl_sel_ldr, nacl_irt, nacl_ld_so, nacl_lib_path)
+ return (nacl_sdk_dir, nacl_sel_ldr, nacl_irt)
def Main():
if (len(sys.argv) == 1):
args = [Escape(arg) for arg in sys.argv[1:]]
- (nacl_sdk_dir, nacl_sel_ldr, nacl_irt, nacl_ld_so,
- nacl_lib_path) = GetNaClResources(sys.argv[1])
+ (nacl_sdk_dir, nacl_sel_ldr, nacl_irt) = GetNaClResources(sys.argv[1])
# sel_ldr Options:
# -c -c: disable validation (for performance)
# -a: allow file access
# -B <irt>: load the IRT
- command = ' '.join([nacl_sel_ldr, '-c', '-c', '-a', '-B', nacl_irt, '--',
- nacl_ld_so, '--library-path', nacl_lib_path] + args)
+ command = ' '.join([nacl_sel_ldr, '-c', '-c', '-a', '-B', nacl_irt, '--'] +
+ args)
error_code = Execute(command)
return error_code
'includes': ['../build/toolchain.gypi', '../build/features.gypi'],
'targets': [
{
- 'target_name': 'lexer-shell',
- 'type': 'executable',
- 'dependencies': [
- '../tools/gyp/v8.gyp:v8',
- '../tools/gyp/v8.gyp:v8_libplatform',
- ],
- 'conditions': [
- ['v8_enable_i18n_support==1', {
- 'dependencies': [
- '<(icu_gyp_path):icui18n',
- '<(icu_gyp_path):icuuc',
- ],
- }],
- ],
- 'include_dirs+': [
- '..',
- ],
- 'sources': [
- 'lexer-shell.cc',
- 'shell-utils.h',
- ],
- },
- {
'target_name': 'parser-shell',
'type': 'executable',
'dependencies': [
or (name in CppLintProcessor.IGNORE_LINT))
def GetPathsToSearch(self):
- return ['src', 'include', 'samples', join('test', 'cctest')]
+ return ['src', 'include', 'samples', join('test', 'cctest'),
+ join('test', 'unittests')]
def GetCpplintScript(self, prio_path):
for path in [prio_path] + os.environ["PATH"].split(os.pathsep):
this.codeMap_ = new CodeMap();
this.topDownTree_ = new CallTree();
this.bottomUpTree_ = new CallTree();
+ this.c_entries_ = {};
};
Profile.prototype.addLibrary = function(
name, startAddr, endAddr) {
var entry = new CodeMap.CodeEntry(
- endAddr - startAddr, name);
+ endAddr - startAddr, name, 'SHARED_LIB');
this.codeMap_.addLibrary(startAddr, entry);
return entry;
};
Profile.prototype.addStaticCode = function(
name, startAddr, endAddr) {
var entry = new CodeMap.CodeEntry(
- endAddr - startAddr, name);
+ endAddr - startAddr, name, 'CPP');
this.codeMap_.addStaticCode(startAddr, entry);
return entry;
};
*/
Profile.prototype.resolveAndFilterFuncs_ = function(stack) {
var result = [];
+ var last_seen_c_function = '';
+ var look_for_first_c_function = false;
for (var i = 0; i < stack.length; ++i) {
var entry = this.codeMap_.findEntry(stack[i]);
if (entry) {
var name = entry.getName();
+ if (i == 0 && (entry.type == 'CPP' || entry.type == 'SHARED_LIB')) {
+ look_for_first_c_function = true;
+ }
+ if (look_for_first_c_function) {
+ if (entry.type == 'CPP') {
+ last_seen_c_function = name;
+ } else if (i > 0 && last_seen_c_function != '') {
+ if (this.c_entries_[last_seen_c_function] === undefined) {
+ this.c_entries_[last_seen_c_function] = 0;
+ }
+ this.c_entries_[last_seen_c_function]++;
+ look_for_first_c_function = false; // Found it, we're done.
+ }
+ }
if (!this.skipThisFunction(name)) {
result.push(name);
}
};
+Profile.CEntryNode = function(name, ticks) {
+ this.name = name;
+ this.ticks = ticks;
+}
+
+
+Profile.prototype.getCEntryProfile = function() {
+ var result = [new Profile.CEntryNode("TOTAL", 0)];
+ var total_ticks = 0;
+ for (var f in this.c_entries_) {
+ var ticks = this.c_entries_[f];
+ total_ticks += ticks;
+ result.push(new Profile.CEntryNode(f, ticks));
+ }
+ result[0].ticks = total_ticks; // Sorting will keep this at index 0.
+ result.sort(function(n1, n2) {
+ return n2.ticks - n1.ticks || (n2.name < n1.name ? -1 : 1)
+ });
+ return result;
+}
+
+
/**
* Cleans up function entries that are not referenced by code entries.
*/
* @constructor
*/
Profile.DynamicCodeEntry = function(size, type, name) {
- CodeMap.CodeEntry.call(this, size, name);
- this.type = type;
+ CodeMap.CodeEntry.call(this, size, name, type);
};
* @constructor
*/
Profile.DynamicFuncCodeEntry = function(size, type, func, state) {
- CodeMap.CodeEntry.call(this, size);
- this.type = type;
+ CodeMap.CodeEntry.call(this, size, '', type);
this.func = func;
this.state = state;
};
from common_includes import *
import push_to_trunk
-PUSH_MESSAGE_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MESSAGE_RE = re.compile(r".* \(based on ([a-fA-F0-9]+)\)$")
class Preparation(Step):
MESSAGE = "Preparation."
self.Die("Could not retrieve bleeding edge revision for trunk push %s"
% last_push)
- # TODO(machenbach): This metric counts all revisions. It could be
- # improved by counting only the revisions on bleeding_edge.
- if int(self["lkgr"]) - int(last_push_be) < 10: # pragma: no cover
- # This makes sure the script doesn't push twice in a row when the cron
- # job retries several times.
- self.Die("Last push too recently: %s" % last_push_be)
+ if self["lkgr"] == last_push_be:
+ print "Already pushed current lkgr %s" % last_push_be
+ return True
-class PushToTrunk(Step):
- MESSAGE = "Pushing to trunk if specified."
+class PushToCandidates(Step):
+ MESSAGE = "Pushing to candidates if specified."
def RunStep(self):
- print "Pushing lkgr %s to trunk." % self["lkgr"]
+ print "Pushing lkgr %s to candidates." % self["lkgr"]
+
+ args = [
+ "--author", self._options.author,
+ "--reviewer", self._options.reviewer,
+ "--revision", self["lkgr"],
+ "--force",
+ ]
+
+ if self._options.svn:
+ args.extend(["--svn", self._options.svn])
+ if self._options.svn_config:
+ args.extend(["--svn-config", self._options.svn_config])
+ if self._options.vc_interface:
+ args.extend(["--vc-interface", self._options.vc_interface])
+ if self._options.work_dir:
+ args.extend(["--work-dir", self._options.work_dir])
# TODO(machenbach): Update the script before calling it.
if self._options.push:
- self._side_effect_handler.Call(
- push_to_trunk.PushToTrunk().Run,
- ["--author", self._options.author,
- "--reviewer", self._options.reviewer,
- "--revision", self["lkgr"],
- "--force"])
+ self._side_effect_handler.Call(push_to_trunk.PushToTrunk().Run, args)
class AutoPush(ScriptsBase):
CheckTreeStatus,
FetchLKGR,
CheckLastPush,
- PushToTrunk,
+ PushToCandidates,
]
MESSAGE = "Detect commit ID of the last push to trunk."
def RunStep(self):
+ self.vc.Fetch()
push_hash = self.FindLastTrunkPush(
branch="origin/candidates", include_patches=True)
self["last_push"] = self.GetCommitPositionNumber(push_hash)
"--sheriff", "--googlers-mapping", self._options.googlers_mapping])
if self._options.dry_run:
args.extend(["--dry-run"])
+ if self._options.work_dir:
+ args.extend(["--work-dir", self._options.work_dir])
self._side_effect_handler.Call(chromium_roll.ChromiumRoll().Run, args)
def RunStep(self):
if not self._options.dry_run:
self.GitReset(self["lkgr"])
- self.vc.Tag(self["candidate_version"])
+ # FIXME(machenbach): Make this work with the git repo.
+ self.vc.Tag(self["candidate_version"],
+ "svn/bleeding_edge",
+ "This won't work!")
class CleanUp(Step):
def RunStep(self):
self["last_push"] = self._options.last_push or self.FindLastTrunkPush(
branch="origin/candidates", include_patches=True)
- self["trunk_revision"] = self.GetCommitPositionNumber(self["last_push"])
self["push_title"] = self.GitLog(n=1, format="%s",
git_hash=self["last_push"])
# Update v8 remotes.
self.GitFetchOrigin()
- self.GitCreateBranch("v8-roll-%s" % self["trunk_revision"],
+ self.GitCreateBranch("v8-roll-%s" % self["last_push"],
cwd=self._options.chromium)
def RunStep(self):
# Patch DEPS file.
if self.Command(
- "roll-dep", "v8 %s" % self["trunk_revision"],
+ "roll-dep", "v8 %s" % self["last_push"],
cwd=self._options.chromium) is None:
- self.Die("Failed to create deps for %s" % self["trunk_revision"])
+ self.Die("Failed to create deps for %s" % self["last_push"])
commit_title = "Update V8 to %s." % self["push_title"].lower()
sheriff = ""
print "CL uploaded."
else:
self.GitCheckout("master", cwd=self._options.chromium)
- self.GitDeleteBranch("v8-roll-%s" % self["trunk_revision"],
+ self.GitDeleteBranch("v8-roll-%s" % self["last_push"],
cwd=self._options.chromium)
print "Dry run - don't upload."
MESSAGE = "Done!"
def RunStep(self):
- print("Congratulations, you have successfully rolled the push r%s it into "
+ print("Congratulations, you have successfully rolled %s into "
"Chromium. Please don't forget to update the v8rel spreadsheet."
- % self["trunk_revision"])
+ % self["last_push"])
# Clean up all temporary files.
Command("rm", "-f %s*" % self._config["PERSISTFILE_BASENAME"])
VERSION_FILE = os.path.join("src", "version.cc")
# V8 base directory.
-DEFAULT_CWD = os.path.dirname(
+V8_BASE = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
def SvnGit(self, rev, branch=""):
raise NotImplementedError()
+ def MasterBranch(self):
+ raise NotImplementedError()
+
+ def CandidateBranch(self):
+ raise NotImplementedError()
+
def RemoteMasterBranch(self):
raise NotImplementedError()
# TODO(machenbach): There is some svn knowledge in this interface. In svn,
# tag and commit are different remote commands, while in git we would commit
# and tag locally and then push/land in one unique step.
- def Tag(self, tag):
+ def Tag(self, tag, remote, message):
+ """Sets a tag for the current commit.
+
+ Assumptions: The commit already landed and the commit message is unique.
+ """
raise NotImplementedError()
def SvnGit(self, rev, branch=""):
return self.step.GitSVNFindGitHash(rev, branch)
+ def MasterBranch(self):
+ return "bleeding_edge"
+
+ def CandidateBranch(self):
+ return "trunk"
+
def RemoteMasterBranch(self):
return "svn/bleeding_edge"
def CLLand(self):
self.step.GitDCommit()
- def Tag(self, tag):
+ def Tag(self, tag, remote, _):
+ self.step.GitSVNFetch()
+ self.step.Git("rebase %s" % remote)
self.step.GitSVNTag(tag)
-class GitReadOnlyMixin(VCInterface):
+class GitTagsOnlyMixin(VCInterface):
def Pull(self):
self.step.GitPull()
def Fetch(self):
self.step.Git("fetch")
+ self.step.GitSVNFetch()
def GetTags(self):
return self.step.Git("tag").strip().splitlines()
def GetBranches(self):
- # Get relevant remote branches, e.g. "origin/branch-heads/3.25".
+ # Get relevant remote branches, e.g. "branch-heads/3.25".
branches = filter(
- lambda s: re.match(r"^origin/branch\-heads/\d+\.\d+$", s),
+ lambda s: re.match(r"^branch\-heads/\d+\.\d+$", s),
self.step.GitRemotes())
- # Remove 'origin/branch-heads/' prefix.
- return map(lambda s: s[20:], branches)
+ # Remove 'branch-heads/' prefix.
+ return map(lambda s: s[13:], branches)
+
+ def MasterBranch(self):
+ return "master"
+
+ def CandidateBranch(self):
+ return "candidates"
def RemoteMasterBranch(self):
return "origin/master"
def RemoteBranch(self, name):
if name in ["candidates", "master"]:
return "origin/%s" % name
- return "origin/branch-heads/%s" % name
+ return "branch-heads/%s" % name
+
+ def PushRef(self, ref):
+ self.step.Git("push origin %s" % ref)
+
+ def Tag(self, tag, remote, message):
+ # Wait for the commit to appear. Assumes unique commit message titles (this
+ # is the case for all automated merge and push commits - also no title is
+ # the prefix of another title).
+ commit = None
+ for wait_interval in [3, 7, 15, 35, 45, 60]:
+ self.step.Git("fetch")
+ commit = self.step.GitLog(n=1, format="%H", grep=message, branch=remote)
+ if commit:
+ break
+ print("The commit has not replicated to git. Waiting for %s seconds." %
+ wait_interval)
+ self.step._side_effect_handler.Sleep(wait_interval)
+ else:
+ self.step.Die("Couldn't determine commit for setting the tag. Maybe the "
+ "git updater is lagging behind?")
+
+ self.step.Git("tag %s %s" % (tag, commit))
+ self.PushRef(tag)
-class GitReadSvnWriteInterface(GitReadOnlyMixin, GitSvnInterface):
+class GitReadSvnWriteInterface(GitTagsOnlyMixin, GitSvnInterface):
pass
+class GitInterface(GitTagsOnlyMixin):
+ def Fetch(self):
+ self.step.Git("fetch")
+
+ def GitSvn(self, hsh, branch=""):
+ return ""
+
+ def SvnGit(self, rev, branch=""):
+ raise NotImplementedError()
+
+ def Land(self):
+ # FIXME(machenbach): This will not work with checkouts from bot_update
+ # after flag day because it will push to the cache. Investigate if it
+ # will work with "cl land".
+ self.step.Git("push origin")
+
+ def CLLand(self):
+ self.step.GitCLLand()
+
+ def PushRef(self, ref):
+ self.step.Git("push https://chromium.googlesource.com/v8/v8 %s" % ref)
+
+
VC_INTERFACES = {
"git_svn": GitSvnInterface,
"git_read_svn_write": GitReadSvnWriteInterface,
+ "git": GitInterface,
}
self.vc.InjectStep(self)
# The testing configuration might set a different default cwd.
- self.default_cwd = self._config.get("DEFAULT_CWD") or DEFAULT_CWD
+ self.default_cwd = (self._config.get("DEFAULT_CWD") or
+ os.path.join(self._options.work_dir, "v8"))
assert self._number >= 0
assert self._config is not None
self.DeleteBranch(self._config["BRANCHNAME"])
def CommonCleanup(self):
- self.GitCheckout(self["current_branch"])
+ if ' ' in self["current_branch"]:
+ self.GitCheckout('master')
+ else:
+ self.GitCheckout(self["current_branch"])
if self._config["BRANCHNAME"] != self["current_branch"]:
self.GitDeleteBranch(self._config["BRANCHNAME"])
(root, self._config["PATCH_FILE"]),
cwd=self._options.svn):
self.Die("Could not apply patch.")
+ for line in self.Command(
+ "svn", "status", cwd=self._options.svn).splitlines():
+ # Check for added and removed items. Svn status has seven status columns.
+ # The first contains ? for unknown and ! for missing.
+ match = re.match(r"^(.)...... (.*)$", line)
+ if match and match.group(1) == "?":
+ self.Command("svn", "add --force %s" % match.group(2),
+ cwd=self._options.svn)
+ if match and match.group(1) == "!":
+ self.Command("svn", "delete --force %s" % match.group(2),
+ cwd=self._options.svn)
+
self.Command(
"svn",
"commit --non-interactive --username=%s --config-dir=%s -m \"%s\"" %
cwd=self._options.svn)
+class BootstrapStep(Step):
+ MESSAGE = "Bootstapping v8 checkout."
+
+ def RunStep(self):
+ if os.path.realpath(self.default_cwd) == os.path.realpath(V8_BASE):
+ self.Die("Can't use v8 checkout with calling script as work checkout.")
+ # Directory containing the working v8 checkout.
+ if not os.path.exists(self._options.work_dir):
+ os.makedirs(self._options.work_dir)
+ if not os.path.exists(self.default_cwd):
+ self.Command("fetch", "v8", cwd=self._options.work_dir)
+
+
class UploadStep(Step):
MESSAGE = "Upload for code review."
parser.add_argument("--vc-interface",
help=("Choose VC interface out of git_svn|"
"git_read_svn_write."))
+ parser.add_argument("--work-dir",
+ help=("Location where to bootstrap a working v8 "
+ "checkout."))
self._PrepareOptions(parser)
if args is None: # pragma: no cover
return None
if not options.vc_interface:
- options.vc_interface = "git_svn"
+ options.vc_interface = "git_read_svn_write"
+ if not options.work_dir:
+ options.work_dir = "/tmp/v8-release-scripts-work-dir"
return options
def RunSteps(self, step_classes, args=None):
os.remove(state_file)
steps = []
- for (number, step_class) in enumerate(step_classes):
+ for (number, step_class) in enumerate([BootstrapStep] + step_classes):
steps.append(MakeStep(step_class, number, self._state, self._config,
options, self._side_effect_handler))
for step in steps[options.step:]:
def Strip(f):
def new_f(*args, **kwargs):
- return f(*args, **kwargs).strip()
+ result = f(*args, **kwargs)
+ if result is None:
+ return result
+ else:
+ return result.strip()
return new_f
def GitBranch(self, **kwargs):
return self.Git("branch", **kwargs)
- def GitCreateBranch(self, name, branch="", **kwargs):
+ def GitCreateBranch(self, name, remote="", **kwargs):
assert name
- self.Git(MakeArgs(["checkout -b", name, branch]), **kwargs)
+ remote_args = ["--upstream", remote] if remote else []
+ self.Git(MakeArgs(["new-branch", name] + remote_args), **kwargs)
def GitDeleteBranch(self, name, **kwargs):
assert name
self.Git(
"cl dcommit -f --bypass-hooks", retry_on=lambda x: x is None, **kwargs)
+ def GitCLLand(self, **kwargs):
+ self.Git(
+ "cl land -f --bypass-hooks", retry_on=lambda x: x is None, **kwargs)
+
def GitDiff(self, loc1, loc2, **kwargs):
return self.Git(MakeArgs(["diff", loc1, loc2]), **kwargs)
from common_includes import *
+def IsSvnNumber(rev):
+ return rev.isdigit() and len(rev) < 8
+
class Preparation(Step):
MESSAGE = "Preparation."
self._options.revisions))
port_revision_list = []
for revision in self["full_revision_list"]:
- # Search for commits which matches the "Port rXXX" pattern.
+ # Search for commits which matches the "Port XXX" pattern.
git_hashes = self.GitLog(reverse=True, format="%H",
- grep="Port r%d" % int(revision),
+ grep="Port %s" % revision,
branch=self.vc.RemoteMasterBranch())
for git_hash in git_hashes.splitlines():
- svn_revision = self.vc.GitSvn(git_hash, self.vc.RemoteMasterBranch())
- if not svn_revision: # pragma: no cover
- self.Die("Cannot determine svn revision for %s" % git_hash)
revision_title = self.GitLog(n=1, format="%s", git_hash=git_hash)
# Is this revision included in the original revision list?
- if svn_revision in self["full_revision_list"]:
- print("Found port of r%s -> r%s (already included): %s"
- % (revision, svn_revision, revision_title))
+ if git_hash in self["full_revision_list"]:
+ print("Found port of %s -> %s (already included): %s"
+ % (revision, git_hash, revision_title))
else:
- print("Found port of r%s -> r%s: %s"
- % (revision, svn_revision, revision_title))
- port_revision_list.append(svn_revision)
+ print("Found port of %s -> %s: %s"
+ % (revision, git_hash, revision_title))
+ port_revision_list.append(git_hash)
# Do we find any port?
if len(port_revision_list) > 0:
self["full_revision_list"].extend(port_revision_list)
-class FindGitRevisions(Step):
- MESSAGE = "Find the git revisions associated with the patches."
+class CreateCommitMessage(Step):
+ MESSAGE = "Create commit message."
def RunStep(self):
- self["patch_commit_hashes"] = []
- for revision in self["full_revision_list"]:
- next_hash = self.vc.SvnGit(revision, self.vc.RemoteMasterBranch())
- if not next_hash: # pragma: no cover
- self.Die("Cannot determine git hash for r%s" % revision)
- self["patch_commit_hashes"].append(next_hash)
# Stringify: [123, 234] -> "r123, r234"
self["revision_list"] = ", ".join(map(lambda s: "r%s" % s,
if not self["revision_list"]: # pragma: no cover
self.Die("Revision list is empty.")
+ if self._options.revert and not self._options.revert_bleeding_edge:
+ action_text = "Rollback of %s"
+ else:
+ action_text = "Merged %s"
+
# The commit message title is added below after the version is specified.
- self["new_commit_msg"] = ""
+ msg_pieces = [
+ "\n".join(action_text % s for s in self["full_revision_list"]),
+ ]
+ msg_pieces.append("\n\n")
- for commit_hash in self["patch_commit_hashes"]:
+ for commit_hash in self["full_revision_list"]:
patch_merge_desc = self.GitLog(n=1, format="%s", git_hash=commit_hash)
- self["new_commit_msg"] += "%s\n\n" % patch_merge_desc
+ msg_pieces.append("%s\n\n" % patch_merge_desc)
bugs = []
- for commit_hash in self["patch_commit_hashes"]:
+ for commit_hash in self["full_revision_list"]:
msg = self.GitLog(n=1, git_hash=commit_hash)
- for bug in re.findall(r"^[ \t]*BUG[ \t]*=[ \t]*(.*?)[ \t]*$", msg,
- re.M):
- bugs.extend(map(lambda s: s.strip(), bug.split(",")))
+ for bug in re.findall(r"^[ \t]*BUG[ \t]*=[ \t]*(.*?)[ \t]*$", msg, re.M):
+ bugs.extend(s.strip() for s in bug.split(","))
bug_aggregate = ",".join(sorted(filter(lambda s: s and s != "none", bugs)))
if bug_aggregate:
- self["new_commit_msg"] += "BUG=%s\nLOG=N\n" % bug_aggregate
+ msg_pieces.append("BUG=%s\nLOG=N\n" % bug_aggregate)
+
+ self["new_commit_msg"] = "".join(msg_pieces)
class ApplyPatches(Step):
MESSAGE = "Apply patches for selected revisions."
def RunStep(self):
- for commit_hash in self["patch_commit_hashes"]:
+ for commit_hash in self["full_revision_list"]:
print("Applying patch for %s to %s..."
% (commit_hash, self["merge_to_branch"]))
patch = self.GitGetPatch(commit_hash)
def RunStep(self):
# Add a commit message title.
- if self._options.revert:
- if not self._options.revert_bleeding_edge:
- title = ("Version %s (rollback of %s)"
- % (self["version"], self["revision_list"]))
- else:
- title = "Revert %s." % self["revision_list"]
+ if self._options.revert and self._options.revert_bleeding_edge:
+ # TODO(machenbach): Find a better convention if multiple patches are
+ # reverted in one CL.
+ self["commit_title"] = "Revert on master"
else:
- title = ("Version %s (merged %s)"
- % (self["version"], self["revision_list"]))
- self["new_commit_msg"] = "%s\n\n%s" % (title, self["new_commit_msg"])
+ self["commit_title"] = "Version %s (cherry-pick)" % self["version"]
+ self["new_commit_msg"] = "%s\n\n%s" % (self["commit_title"],
+ self["new_commit_msg"])
TextToFile(self["new_commit_msg"], self.Config("COMMITMSG_FILE"))
self.GitCommit(file_name=self.Config("COMMITMSG_FILE"))
def RunStep(self):
if self._options.revert_bleeding_edge:
return
- print "Creating tag svn/tags/%s" % self["version"]
- self.vc.Tag(self["version"])
+ print "Creating tag %s" % self["version"]
+ self.vc.Tag(self["version"],
+ self.vc.RemoteBranch(self["merge_to_branch"]),
+ self["commit_title"])
class CleanUp(Step):
options.bypass_upload_hooks = True
# CC ulan to make sure that fixes are merged to Google3.
options.cc = "ulan@chromium.org"
+
+ # Thd old git-svn workflow is deprecated for this script.
+ assert options.vc_interface != "git_svn"
+
+ # Make sure to use git hashes in the new workflows.
+ for revision in options.revisions:
+ if (IsSvnNumber(revision) or
+ (revision[0:1] == "r" and IsSvnNumber(revision[1:]))):
+ print "Please provide full git hashes of the patches to merge."
+ print "Got: %s" % revision
+ return False
return True
def _Config(self):
Preparation,
CreateBranch,
SearchArchitecturePorts,
- FindGitRevisions,
+ CreateCommitMessage,
ApplyPatches,
PrepareVersion,
IncrementVersion,
from common_includes import *
-PUSH_MESSAGE_SUFFIX = " (based on bleeding_edge revision r%d)"
-PUSH_MESSAGE_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_SVN_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_GIT_SUFFIX = " (based on %s)"
+PUSH_MSG_GIT_RE = re.compile(r".* \(based on (?P<git_rev>[a-fA-F0-9]+)\)$")
class Preparation(Step):
MESSAGE = "Preparation."
def RunStep(self):
if self._options.revision:
- self["push_hash"] = self.vc.SvnGit(self._options.revision)
+ self["push_hash"] = self._options.revision
else:
self["push_hash"] = self.GitLog(n=1, format="%H", git_hash="HEAD")
if not self["push_hash"]: # pragma: no cover
# Retrieve the bleeding edge revision of the last push from the text in
# the push commit message.
last_push_title = self.GitLog(n=1, format="%s", git_hash=last_push)
- last_push_be_svn = PUSH_MESSAGE_RE.match(last_push_title).group(1)
- if not last_push_be_svn: # pragma: no cover
- self.Die("Could not retrieve bleeding edge revision for trunk push %s"
- % last_push)
- last_push_bleeding_edge = self.vc.SvnGit(last_push_be_svn)
+ # TODO(machenbach): This is only needed for the git transition. Can be
+ # removed after one successful trunk push.
+ match = PUSH_MSG_SVN_RE.match(last_push_title)
+ if match:
+ last_push_be_svn = match.group(1)
+ if not last_push_be_svn: # pragma: no cover
+ self.Die("Could not retrieve bleeding edge rev for trunk push %s"
+ % last_push)
+ last_push_bleeding_edge = self.vc.SvnGit(last_push_be_svn)
+ else:
+ last_push_bleeding_edge = PUSH_MSG_GIT_RE.match(
+ last_push_title).group("git_rev")
+
if not last_push_bleeding_edge: # pragma: no cover
self.Die("Could not retrieve bleeding edge git hash for trunk push %s"
% last_push)
- # This points to the svn revision of the last push on trunk.
+ # This points to the git hash of the last push on trunk.
self["last_push_trunk"] = last_push
# This points to the last bleeding_edge revision that went into the last
# push.
# Remove date and trailing white space.
text = re.sub(r"^%s: " % self["date"], "", text.rstrip())
- # Retrieve svn revision for showing the used bleeding edge revision in the
- # commit message.
- self["svn_revision"] = self.vc.GitSvn(self["push_hash"])
- suffix = PUSH_MESSAGE_SUFFIX % int(self["svn_revision"])
+ # Show the used master hash in the commit message.
+ suffix = PUSH_MSG_GIT_SUFFIX % self["push_hash"]
text = MSub(r"^(Version \d+\.\d+\.\d+)$", "\\1%s" % suffix, text)
# Remove indentation and merge paragraphs into single long lines, keeping
if not text: # pragma: no cover
self.Die("Commit message editing failed.")
+ self["commit_title"] = text.splitlines()[0]
TextToFile(text, self.Config("COMMITMSG_FILE"))
MESSAGE = "Commit to SVN."
def RunStep(self):
- result = self.vc.Land()
+ if self._options.svn:
+ self.SVNCommit("trunk", self["commit_title"])
+ else:
+ self.vc.Land()
class TagRevision(Step):
MESSAGE = "Tag the new revision."
def RunStep(self):
- self.vc.Tag(self["version"])
+ self.vc.Tag(
+ self["version"], self.vc.RemoteCandidateBranch(), self["commit_title"])
class CleanUp(Step):
parser.add_argument("-l", "--last-push",
help="The git commit ID of the last push to trunk.")
parser.add_argument("-R", "--revision",
- help="The svn revision to push (defaults to HEAD).")
+ help="The git commit ID to push (defaults to HEAD).")
def _ProcessOptions(self, options): # pragma: no cover
if not options.manual and not options.reviewer:
if not options.manual and not options.author:
print "Specify your chromium.org email with -a in (semi-)automatic mode."
return False
- if options.revision and not int(options.revision) > 0:
- print("The --revision flag must be a positiv integer pointing to a "
- "valid svn revision.")
- return False
options.tbr_commit = not options.manual
return True
}
# Expression for retrieving the bleeding edge revision from a commit message.
-PUSH_MESSAGE_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_SVN_RE = re.compile(r".* \(based on bleeding_edge revision r(\d+)\)$")
+PUSH_MSG_GIT_RE = re.compile(r".* \(based on ([a-fA-F0-9]+)\)$")
# Expression for retrieving the merged patches from a merge commit message
# (old and new format).
MERGE_MESSAGE_RE = re.compile(r"^.*[M|m]erged (.+)(\)| into).*$", re.M)
+CHERRY_PICK_TITLE_GIT_RE = re.compile(r"^.* \(cherry\-pick\)\.?$")
+
+# New git message for cherry-picked CLs. One message per line.
+MERGE_MESSAGE_GIT_RE = re.compile(r"^Merged ([a-fA-F0-9]+)\.?$")
+
# Expression for retrieving reverted patches from a commit message (old and
# new format).
ROLLBACK_MESSAGE_RE = re.compile(r"^.*[R|r]ollback of (.+)(\)| in).*$", re.M)
+# New git message for reverted CLs. One message per line.
+ROLLBACK_MESSAGE_GIT_RE = re.compile(r"^Rollback of ([a-fA-F0-9]+)\.?$")
+
# Expression for retrieving the code review link.
REVIEW_LINK_RE = re.compile(r"^Review URL: (.+)$", re.M)
and len(releases) > self._options.max_releases)
def GetBleedingEdgeFromPush(self, title):
- return MatchSafe(PUSH_MESSAGE_RE.match(title))
+ return MatchSafe(PUSH_MSG_SVN_RE.match(title))
+
+ def GetBleedingEdgeGitFromPush(self, title):
+ return MatchSafe(PUSH_MSG_GIT_RE.match(title))
def GetMergedPatches(self, body):
patches = MatchSafe(MERGE_MESSAGE_RE.search(body))
patches = "-%s" % patches
return patches
+ def GetMergedPatchesGit(self, body):
+ patches = []
+ for line in body.splitlines():
+ patch = MatchSafe(MERGE_MESSAGE_GIT_RE.match(line))
+ if patch:
+ patches.append(patch)
+ patch = MatchSafe(ROLLBACK_MESSAGE_GIT_RE.match(line))
+ if patch:
+ patches.append("-%s" % patch)
+ return ", ".join(patches)
+
+
def GetReleaseDict(
- self, git_hash, bleeding_edge_rev, branch, version, patches, cl_body):
+ self, git_hash, bleeding_edge_rev, bleeding_edge_git, branch, version,
+ patches, cl_body):
revision = self.vc.GitSvn(git_hash)
return {
# The SVN revision on the branch.
"revision": revision,
+ # The git revision on the branch.
+ "revision_git": git_hash,
# The SVN revision on bleeding edge (only for newer trunk pushes).
"bleeding_edge": bleeding_edge_rev,
+ # The same for git.
+ "bleeding_edge_git": bleeding_edge_git,
# The branch name.
"branch": branch,
# The version for displaying in the form 3.26.3 or 3.26.3.12.
patches = ""
if self["patch"] != "0":
version += ".%s" % self["patch"]
- patches = self.GetMergedPatches(body)
+ if CHERRY_PICK_TITLE_GIT_RE.match(body.splitlines()[0]):
+ patches = self.GetMergedPatchesGit(body)
+ else:
+ patches = self.GetMergedPatches(body)
title = self.GitLog(n=1, format="%s", git_hash=git_hash)
+ bleeding_edge_revision = self.GetBleedingEdgeFromPush(title)
+ bleeding_edge_git = ""
+ if bleeding_edge_revision:
+ bleeding_edge_git = self.vc.SvnGit(bleeding_edge_revision,
+ self.vc.RemoteMasterBranch())
+ else:
+ bleeding_edge_git = self.GetBleedingEdgeGitFromPush(title)
return self.GetReleaseDict(
- git_hash, self.GetBleedingEdgeFromPush(title), branch, version,
+ git_hash, bleeding_edge_revision, bleeding_edge_git, branch, version,
patches, body), self["patch"]
- def GetReleasesFromBleedingEdge(self):
+ def GetReleasesFromMaster(self):
tag_text = self.SVN("log https://v8.googlecode.com/svn/tags -v --limit 20")
releases = []
for (tag, revision) in re.findall(BLEEDING_EDGE_TAGS_RE, tag_text):
# Add bleeding edge release. It does not contain patches or a code
# review link, as tags are not uploaded.
releases.append(self.GetReleaseDict(
- git_hash, revision, "bleeding_edge", tag, "", ""))
+ git_hash, revision, git_hash, self.vc.MasterBranch(), tag, "", ""))
return releases
def GetReleasesFromBranch(self, branch):
self.GitReset(self.vc.RemoteBranch(branch))
- # TODO(machenbach): Rename this when switching to the git mirror.
- if branch == 'bleeding_edge':
- return self.GetReleasesFromBleedingEdge()
+ if branch == self.vc.MasterBranch():
+ return self.GetReleasesFromMaster()
releases = []
try:
# TODO(machenbach): This omits patches if the version file wasn't
# manipulated correctly. Find a better way to detect the point where
# the parent of the branch head leads to the trunk branch.
- if branch != "trunk" and patch_level == "0":
+ if branch != self.vc.CandidateBranch() and patch_level == "0":
break
# Allow Ctrl-C interrupt.
beta, stable = SortBranches(branches)[0:2]
releases += self.GetReleasesFromBranch(stable)
releases += self.GetReleasesFromBranch(beta)
- releases += self.GetReleasesFromBranch("trunk")
- releases += self.GetReleasesFromBranch("bleeding_edge")
+ releases += self.GetReleasesFromBranch(self.vc.CandidateBranch())
+ releases += self.GetReleasesFromBranch(self.vc.MasterBranch())
elif self._options.branch == 'all': # pragma: no cover
# Retrieve the full release history.
for branch in branches:
releases += self.GetReleasesFromBranch(branch)
- releases += self.GetReleasesFromBranch("trunk")
- releases += self.GetReleasesFromBranch("bleeding_edge")
+ releases += self.GetReleasesFromBranch(self.vc.CandidateBranch())
+ releases += self.GetReleasesFromBranch(self.vc.MasterBranch())
else: # pragma: no cover
# Retrieve history for a specified branch.
- assert self._options.branch in branches + ["trunk", "bleeding_edge"]
+ assert self._options.branch in (branches +
+ [self.vc.CandidateBranch(), self.vc.MasterBranch()])
releases += self.GetReleasesFromBranch(self._options.branch)
self["releases"] = sorted(releases,
def RunStep(self):
cwd = self._options.chromium
releases = filter(
- lambda r: r["branch"] in ["trunk", "bleeding_edge"], self["releases"])
+ lambda r: r["branch"] in [self.vc.CandidateBranch(),
+ self.vc.MasterBranch()],
+ self["releases"])
if not releases: # pragma: no cover
print "No releases detected. Skipping chromium history."
return True
def RunStep(self):
cwd = self._options.chromium
- trunk_releases = filter(lambda r: r["branch"] == "trunk", self["releases"])
+ trunk_releases = filter(lambda r: r["branch"] == self.vc.CandidateBranch(),
+ self["releases"])
if not trunk_releases: # pragma: no cover
print "No trunk releases detected. Skipping chromium history."
return True
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* %s" % TEST_CONFIG["BRANCHNAME"]),
RL("Y"),
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* %s" % TEST_CONFIG["BRANCHNAME"]),
RL("n"),
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* %s" % TEST_CONFIG["BRANCHNAME"]),
RL("Y"),
])
self.MakeStep().InitialEnvironmentChecks(TEST_CONFIG["DEFAULT_CWD"])
+ def testTagTimeout(self):
+ self.Expect([
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\"Title\" origin/candidates", ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\"Title\" origin/candidates", ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\"Title\" origin/candidates", ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\"Title\" origin/candidates", ""),
+ ])
+ args = ["--branch", "candidates", "--vc-interface", "git_read_svn_write",
+ "ab12345"]
+ self._state["version"] = "tag_name"
+ self._state["commit_title"] = "Title"
+ self.assertRaises(Exception,
+ lambda: self.RunStep(MergeToBranch, TagRevision, args))
+
def testReadAndPersistVersion(self):
self.WriteFakeVersionFile(build=5)
step = self.MakeStep()
self.Expect([
Cmd("git checkout -f hash1 -- src/version.cc", ""),
- Cmd("git checkout -f svn/bleeding_edge -- src/version.cc",
+ Cmd("git checkout -f origin/master -- src/version.cc",
"", cb=lambda: self.WriteFakeVersionFile(22, 6)),
RL("Y"), # Increment build number.
])
f.write(change_log)
self.Expect([
- Cmd("git diff svn/trunk hash1", "patch content"),
- Cmd("git svn find-rev hash1", "123455\n"),
+ Cmd("git diff origin/candidates hash1", "patch content"),
])
self._state["push_hash"] = "hash1"
Chromium issue 12345
Performance and stability improvements on all platforms.\n"""
- commit_msg = """Version 3.22.5 (based on bleeding_edge revision r123455)
+ commit_msg = """Version 3.22.5 (based on hash1)
Log text 1. Chromium issue 12345
12345).
Performance and stability improvements on all platforms.\n"""
- commit_msg = """Version 3.22.5 (based on bleeding_edge revision r123455)
+ commit_msg = """Version 3.22.5 (based on hash1)
Long commit message that fills more than 80 characters (Chromium issue 12345).
commit_msg = """Line with "quotation marks"."""
self._TestSquashCommits(change_log, commit_msg)
+ def testBootstrapper(self):
+ work_dir = self.MakeEmptyTempDirectory()
+ class FakeScript(ScriptsBase):
+ def _Steps(self):
+ return []
+
+ # Use the test configuration without the fake testing default work dir.
+ fake_config = dict(TEST_CONFIG)
+ del(fake_config["DEFAULT_CWD"])
+
+ self.Expect([
+ Cmd("fetch v8", "", cwd=work_dir),
+ ])
+ FakeScript(fake_config, self).Run(["--work-dir", work_dir])
+
def _PushToTrunk(self, force=False, manual=False):
TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
def CheckSVNCommit():
commit = FileToText(TEST_CONFIG["COMMITMSG_FILE"])
self.assertEquals(
-"""Version 3.22.5 (based on bleeding_edge revision r123455)
+"""Version 3.22.5 (based on push_hash)
Log text 1 (issue 321).
expectations += [
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* branch2\n"),
Cmd("git branch", " branch1\n* branch2\n"),
- Cmd("git checkout -b %s svn/bleeding_edge" % TEST_CONFIG["BRANCHNAME"],
+ Cmd(("git new-branch %s --upstream origin/master" %
+ TEST_CONFIG["BRANCHNAME"]),
""),
- Cmd("git svn find-rev r123455", "push_hash\n"),
Cmd(("git log -1 --format=%H --grep="
"\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based\" "
- "svn/trunk"), "hash2\n"),
+ "origin/candidates"), "hash2\n"),
Cmd("git log -1 hash2", "Log message\n"),
]
if manual:
expectations.append(RL("Y")) # Confirm last push.
expectations += [
Cmd("git log -1 --format=%s hash2",
- "Version 3.4.5 (based on bleeding_edge revision r1234)\n"),
- Cmd("git svn find-rev r1234", "hash3\n"),
- Cmd("git checkout -f svn/bleeding_edge -- src/version.cc",
+ "Version 3.4.5 (based on abc3)\n"),
+ Cmd("git checkout -f origin/master -- src/version.cc",
"", cb=self.WriteFakeVersionFile),
Cmd("git checkout -f hash2 -- src/version.cc", "",
cb=self.WriteFakeVersionFile),
if manual:
expectations.append(RL("")) # Increment build number.
expectations += [
- Cmd("git log --format=%H hash3..push_hash", "rev1\n"),
+ Cmd("git log --format=%H abc3..push_hash", "rev1\n"),
Cmd("git log -1 --format=%s rev1", "Log text 1.\n"),
Cmd("git log -1 --format=%B rev1", "Text\nLOG=YES\nBUG=v8:321\nText\n"),
Cmd("git log -1 --format=%an rev1", "author1@chromium.org\n"),
expectations.append(
Cmd("vi %s" % TEST_CONFIG["CHANGELOG_ENTRY_FILE"], ""))
expectations += [
+ Cmd("git fetch", ""),
Cmd("git svn fetch", "fetch result\n"),
- Cmd("git checkout -f svn/bleeding_edge", ""),
- Cmd("git diff svn/trunk push_hash", "patch content\n"),
- Cmd("git svn find-rev push_hash", "123455\n"),
- Cmd("git checkout -b %s svn/trunk" % TEST_CONFIG["TRUNKBRANCH"], "",
- cb=ResetToTrunk),
+ Cmd("git checkout -f origin/master", ""),
+ Cmd("git diff origin/candidates push_hash", "patch content\n"),
+ Cmd(("git new-branch %s --upstream origin/candidates" %
+ TEST_CONFIG["TRUNKBRANCH"]), "", cb=ResetToTrunk),
Cmd("git apply --index --reject \"%s\"" % TEST_CONFIG["PATCH_FILE"], ""),
- Cmd("git checkout -f svn/trunk -- %s" % TEST_CONFIG["CHANGELOG_FILE"], "",
+ Cmd(("git checkout -f origin/candidates -- %s" %
+ TEST_CONFIG["CHANGELOG_FILE"]), "",
cb=ResetChangeLog),
- Cmd("git checkout -f svn/trunk -- src/version.cc", "",
+ Cmd("git checkout -f origin/candidates -- src/version.cc", "",
cb=self.WriteFakeVersionFile),
Cmd("git commit -aF \"%s\"" % TEST_CONFIG["COMMITMSG_FILE"], "",
cb=CheckSVNCommit),
expectations.append(RL("Y")) # Sanity check.
expectations += [
Cmd("git svn dcommit 2>&1", ""),
- Cmd("git svn tag 3.22.5 -m \"Tagging version 3.22.5\"", ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep="
+ "\"Version 3.22.5 (based on push_hash)\""
+ " origin/candidates", "hsh_to_tag"),
+ Cmd("git tag 3.22.5 hsh_to_tag", ""),
+ Cmd("git push origin 3.22.5", ""),
Cmd("git checkout -f some_branch", ""),
Cmd("git branch -D %s" % TEST_CONFIG["BRANCHNAME"], ""),
Cmd("git branch -D %s" % TEST_CONFIG["TRUNKBRANCH"], ""),
]
self.Expect(expectations)
- args = ["-a", "author@chromium.org", "--revision", "123455"]
+ args = ["-a", "author@chromium.org", "--revision", "push_hash",
+ "--vc-interface", "git_read_svn_write",]
if force: args.append("-f")
if manual: args.append("-m")
else: args += ["-r", "reviewer@chromium.org"]
def testPushToTrunkForced(self):
self._PushToTrunk(force=True)
+ def testPushToTrunkGit(self):
+ svn_root = self.MakeEmptyTempDirectory()
+ TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
+
+ # The version file on bleeding edge has build level 5, while the version
+ # file from trunk has build level 4.
+ self.WriteFakeVersionFile(build=5)
+
+ TEST_CONFIG["CHANGELOG_ENTRY_FILE"] = self.MakeEmptyTempFile()
+ TEST_CONFIG["CHANGELOG_FILE"] = self.MakeEmptyTempFile()
+ bleeding_edge_change_log = "2014-03-17: Sentinel\n"
+ TextToFile(bleeding_edge_change_log, TEST_CONFIG["CHANGELOG_FILE"])
+
+ def ResetChangeLog():
+ """On 'git co -b new_branch svn/trunk', and 'git checkout -- ChangeLog',
+ the ChangLog will be reset to its content on trunk."""
+ trunk_change_log = """1999-04-05: Version 3.22.4
+
+ Performance and stability improvements on all platforms.\n"""
+ TextToFile(trunk_change_log, TEST_CONFIG["CHANGELOG_FILE"])
+
+ def ResetToTrunk():
+ ResetChangeLog()
+ self.WriteFakeVersionFile()
+
+ def CheckSVNCommit():
+ commit = FileToText(TEST_CONFIG["COMMITMSG_FILE"])
+ self.assertEquals(
+"""Version 3.22.5 (based on push_hash)
+
+Log text 1 (issue 321).
+
+Performance and stability improvements on all platforms.""", commit)
+ version = FileToText(
+ os.path.join(TEST_CONFIG["DEFAULT_CWD"], VERSION_FILE))
+ self.assertTrue(re.search(r"#define MINOR_VERSION\s+22", version))
+ self.assertTrue(re.search(r"#define BUILD_NUMBER\s+5", version))
+ self.assertFalse(re.search(r"#define BUILD_NUMBER\s+6", version))
+ self.assertTrue(re.search(r"#define PATCH_LEVEL\s+0", version))
+ self.assertTrue(re.search(r"#define IS_CANDIDATE_VERSION\s+0", version))
+
+ # Check that the change log on the trunk branch got correctly modified.
+ change_log = FileToText(TEST_CONFIG["CHANGELOG_FILE"])
+ self.assertEquals(
+"""1999-07-31: Version 3.22.5
+
+ Log text 1 (issue 321).
+
+ Performance and stability improvements on all platforms.
+
+
+1999-04-05: Version 3.22.4
+
+ Performance and stability improvements on all platforms.\n""",
+ change_log)
+
+ expectations = [
+ Cmd("git status -s -uno", ""),
+ Cmd("git status -s -b -uno", "## some_branch\n"),
+ Cmd("git fetch", ""),
+ Cmd("git branch", " branch1\n* branch2\n"),
+ Cmd("git branch", " branch1\n* branch2\n"),
+ Cmd(("git new-branch %s --upstream origin/master" %
+ TEST_CONFIG["BRANCHNAME"]),
+ ""),
+ Cmd(("git log -1 --format=%H --grep="
+ "\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based\" "
+ "origin/candidates"), "hash2\n"),
+ Cmd("git log -1 hash2", "Log message\n"),
+ Cmd("git log -1 --format=%s hash2",
+ "Version 3.4.5 (based on abc3)\n"),
+ Cmd("git checkout -f origin/master -- src/version.cc",
+ "", cb=self.WriteFakeVersionFile),
+ Cmd("git checkout -f hash2 -- src/version.cc", "",
+ cb=self.WriteFakeVersionFile),
+ Cmd("git log --format=%H abc3..push_hash", "rev1\n"),
+ Cmd("git log -1 --format=%s rev1", "Log text 1.\n"),
+ Cmd("git log -1 --format=%B rev1", "Text\nLOG=YES\nBUG=v8:321\nText\n"),
+ Cmd("git log -1 --format=%an rev1", "author1@chromium.org\n"),
+ Cmd("git fetch", ""),
+ Cmd("git checkout -f origin/master", ""),
+ Cmd("git diff origin/candidates push_hash", "patch content\n"),
+ Cmd(("git new-branch %s --upstream origin/candidates" %
+ TEST_CONFIG["TRUNKBRANCH"]), "", cb=ResetToTrunk),
+ Cmd("git apply --index --reject \"%s\"" % TEST_CONFIG["PATCH_FILE"], ""),
+ Cmd(("git checkout -f origin/candidates -- %s" %
+ TEST_CONFIG["CHANGELOG_FILE"]), "",
+ cb=ResetChangeLog),
+ Cmd("git checkout -f origin/candidates -- src/version.cc", "",
+ cb=self.WriteFakeVersionFile),
+ Cmd("git commit -aF \"%s\"" % TEST_CONFIG["COMMITMSG_FILE"], "",
+ cb=CheckSVNCommit),
+ # TODO(machenbach): Change test to pure git after flag day.
+ # Cmd("git push origin", ""),
+ Cmd("git diff HEAD^ HEAD", "patch content"),
+ Cmd("svn update", "", cwd=svn_root),
+ Cmd("svn status", "", cwd=svn_root),
+ Cmd("patch -d trunk -p1 -i %s" %
+ TEST_CONFIG["PATCH_FILE"], "Applied patch...", cwd=svn_root),
+ Cmd("svn status", "M OWNERS\n? new_file\n! AUTHORS",
+ cwd=svn_root),
+ Cmd("svn add --force new_file", "", cwd=svn_root),
+ Cmd("svn delete --force AUTHORS", "", cwd=svn_root),
+ Cmd("svn commit --non-interactive --username=author@chromium.org "
+ "--config-dir=[CONFIG_DIR] "
+ "-m \"Version 3.22.5 (based on push_hash)\"",
+ "", cwd=svn_root),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep="
+ "\"Version 3.22.5 (based on push_hash)\""
+ " origin/candidates", "hsh_to_tag"),
+ Cmd("git tag 3.22.5 hsh_to_tag", ""),
+ Cmd("git push https://chromium.googlesource.com/v8/v8 3.22.5", ""),
+ Cmd("git checkout -f some_branch", ""),
+ Cmd("git branch -D %s" % TEST_CONFIG["BRANCHNAME"], ""),
+ Cmd("git branch -D %s" % TEST_CONFIG["TRUNKBRANCH"], ""),
+ ]
+ self.Expect(expectations)
+
+ args = ["-a", "author@chromium.org", "--revision", "push_hash",
+ "--vc-interface", "git", "-f", "-r", "reviewer@chromium.org",
+ "--svn", svn_root, "--svn-config", "[CONFIG_DIR]",
+ "--work-dir", TEST_CONFIG["DEFAULT_CWD"]]
+ PushToTrunk(TEST_CONFIG, self).Run(args)
+
+ cl = FileToText(TEST_CONFIG["CHANGELOG_FILE"])
+ self.assertTrue(re.search(r"^\d\d\d\d\-\d+\-\d+: Version 3\.22\.5", cl))
+ self.assertTrue(re.search(r" Log text 1 \(issue 321\).", cl))
+ self.assertTrue(re.search(r"1999\-04\-05: Version 3\.22\.4", cl))
+
+ # Note: The version file is on build number 5 again in the end of this test
+ # since the git command that merges to the bleeding edge branch is mocked
+ # out.
+
C_V8_22624_LOG = """V8 CL.
git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22624 123
Cmd(("git log -1 --format=%H --grep="
"\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]*\" "
"origin/candidates"), "push_hash\n"),
- Cmd("git log -1 --format=%B push_hash", self.C_V8_22624_LOG),
Cmd("git log -1 --format=%s push_hash",
"Version 3.22.5 (based on bleeding_edge revision r22622)\n"),
URL("https://chromium-build.appspot.com/p/chromium/sheriff_v8.js",
Cmd("gclient sync --nohooks", "syncing...", cwd=chrome_dir),
Cmd("git pull", "", cwd=chrome_dir),
Cmd("git fetch origin", ""),
- Cmd("git checkout -b v8-roll-22624", "", cwd=chrome_dir),
- Cmd("roll-dep v8 22624", "rolled", cb=WriteDeps, cwd=chrome_dir),
+ Cmd("git new-branch v8-roll-push_hash", "", cwd=chrome_dir),
+ Cmd("roll-dep v8 push_hash", "rolled", cb=WriteDeps, cwd=chrome_dir),
Cmd(("git commit -am \"Update V8 to version 3.22.5 "
"(based on bleeding_edge revision r22622).\n\n"
"Please reply to the V8 sheriff c_name@chromium.org in "
self.Expect([
Cmd(("git log -1 --format=%H --grep="
"\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based\" "
- "svn/trunk"), "hash2\n"),
+ "origin/candidates"), "hash2\n"),
Cmd("git log -1 --format=%s hash2",
- "Version 3.4.5 (based on bleeding_edge revision r99)\n"),
+ "Version 3.4.5 (based on abc123)\n"),
])
- self._state["lkgr"] = "101"
-
- self.assertRaises(Exception, lambda: self.RunStep(auto_push.AutoPush,
- CheckLastPush,
- AUTO_PUSH_ARGS))
+ self._state["lkgr"] = "abc123"
+ self.assertEquals(0, self.RunStep(
+ auto_push.AutoPush, CheckLastPush, AUTO_PUSH_ARGS))
def testAutoPush(self):
TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
- Cmd("git svn fetch", ""),
+ Cmd("git fetch", ""),
URL("https://v8-status.appspot.com/current?format=json",
"{\"message\": \"Tree is throttled\"}"),
URL("https://v8-status.appspot.com/lkgr", Exception("Network problem")),
- URL("https://v8-status.appspot.com/lkgr", "100"),
+ URL("https://v8-status.appspot.com/lkgr", "abc123"),
Cmd(("git log -1 --format=%H --grep=\""
"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based\""
- " svn/trunk"), "push_hash\n"),
+ " origin/candidates"), "push_hash\n"),
Cmd("git log -1 --format=%s push_hash",
- "Version 3.4.5 (based on bleeding_edge revision r79)\n"),
+ "Version 3.4.5 (based on abc101)\n"),
])
- auto_push.AutoPush(TEST_CONFIG, self).Run(AUTO_PUSH_ARGS + ["--push"])
+ auto_push.AutoPush(TEST_CONFIG, self).Run(
+ AUTO_PUSH_ARGS + ["--push", "--vc-interface", "git"])
state = json.loads(FileToText("%s-state.json"
% TEST_CONFIG["PERSISTFILE_BASENAME"]))
- self.assertEquals("100", state["lkgr"])
+ self.assertEquals("abc123", state["lkgr"])
def testAutoPushStoppedBySettings(self):
TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
])
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
URL("https://v8-status.appspot.com/current?format=json",
"{\"message\": \"Tree is throttled (no push)\"}"),
URL("https://codereview.chromium.org/search",
"owner=author%40chromium.org&limit=30&closed=3&format=json",
("{\"results\": [{\"subject\": \"different\"}]}")),
+ Cmd("git fetch", ""),
+ Cmd("git svn fetch", ""),
Cmd(("git log -1 --format=%H --grep="
"\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]*\" "
"origin/candidates"), "push_hash\n"),
URL("https://codereview.chromium.org/search",
"owner=author%40chromium.org&limit=30&closed=3&format=json",
("{\"results\": [{\"subject\": \"different\"}]}")),
+ Cmd("git fetch", ""),
+ Cmd("git svn fetch", ""),
Cmd(("git log -1 --format=%H --grep="
"\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]*\" "
"origin/candidates"), "push_hash\n"),
return lambda: self.assertEquals(patch,
FileToText(TEST_CONFIG["TEMPORARY_PATCH_FILE"]))
- msg = """Version 3.22.5.1 (merged r12345, r23456, r34567, r45678, r56789)
-
-Title4
-
-Title2
-
-Title3
-
-Title1
-
-Revert "Something"
-
-BUG=123,234,345,456,567,v8:123
-LOG=N
-"""
-
- def VerifySVNCommit():
- commit = FileToText(TEST_CONFIG["COMMITMSG_FILE"])
- self.assertEquals(msg, commit)
- version = FileToText(
- os.path.join(TEST_CONFIG["DEFAULT_CWD"], VERSION_FILE))
- self.assertTrue(re.search(r"#define MINOR_VERSION\s+22", version))
- self.assertTrue(re.search(r"#define BUILD_NUMBER\s+5", version))
- self.assertTrue(re.search(r"#define PATCH_LEVEL\s+1", version))
- self.assertTrue(re.search(r"#define IS_CANDIDATE_VERSION\s+0", version))
-
- self.Expect([
- Cmd("git status -s -uno", ""),
- Cmd("git status -s -b -uno", "## some_branch\n"),
- Cmd("git svn fetch", ""),
- Cmd("git branch", " branch1\n* branch2\n"),
- Cmd("git checkout -b %s svn/trunk" % TEST_CONFIG["BRANCHNAME"], ""),
- Cmd(("git log --format=%H --grep=\"Port r12345\" "
- "--reverse svn/bleeding_edge"),
- "hash1\nhash2"),
- Cmd("git svn find-rev hash1 svn/bleeding_edge", "45678"),
- Cmd("git log -1 --format=%s hash1", "Title1"),
- Cmd("git svn find-rev hash2 svn/bleeding_edge", "23456"),
- Cmd("git log -1 --format=%s hash2", "Title2"),
- Cmd(("git log --format=%H --grep=\"Port r23456\" "
- "--reverse svn/bleeding_edge"),
- ""),
- Cmd(("git log --format=%H --grep=\"Port r34567\" "
- "--reverse svn/bleeding_edge"),
- "hash3"),
- Cmd("git svn find-rev hash3 svn/bleeding_edge", "56789"),
- Cmd("git log -1 --format=%s hash3", "Title3"),
- RL("Y"), # Automatically add corresponding ports (34567, 56789)?
- Cmd("git svn find-rev r12345 svn/bleeding_edge", "hash4"),
- # Simulate svn being down which stops the script.
- Cmd("git svn find-rev r23456 svn/bleeding_edge", None),
- # Restart script in the failing step.
- Cmd("git svn find-rev r12345 svn/bleeding_edge", "hash4"),
- Cmd("git svn find-rev r23456 svn/bleeding_edge", "hash2"),
- Cmd("git svn find-rev r34567 svn/bleeding_edge", "hash3"),
- Cmd("git svn find-rev r45678 svn/bleeding_edge", "hash1"),
- Cmd("git svn find-rev r56789 svn/bleeding_edge", "hash5"),
- Cmd("git log -1 --format=%s hash4", "Title4"),
- Cmd("git log -1 --format=%s hash2", "Title2"),
- Cmd("git log -1 --format=%s hash3", "Title3"),
- Cmd("git log -1 --format=%s hash1", "Title1"),
- Cmd("git log -1 --format=%s hash5", "Revert \"Something\""),
- Cmd("git log -1 hash4", "Title4\nBUG=123\nBUG=234"),
- Cmd("git log -1 hash2", "Title2\n BUG = v8:123,345"),
- Cmd("git log -1 hash3", "Title3\nLOG=n\nBUG=567, 456"),
- Cmd("git log -1 hash1", "Title1\nBUG="),
- Cmd("git log -1 hash5", "Revert \"Something\"\nBUG=none"),
- Cmd("git log -1 -p hash4", "patch4"),
- Cmd(("git apply --index --reject \"%s\"" %
- TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
- "", cb=VerifyPatch("patch4")),
- Cmd("git log -1 -p hash2", "patch2"),
- Cmd(("git apply --index --reject \"%s\"" %
- TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
- "", cb=VerifyPatch("patch2")),
- Cmd("git log -1 -p hash3", "patch3"),
- Cmd(("git apply --index --reject \"%s\"" %
- TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
- "", cb=VerifyPatch("patch3")),
- Cmd("git log -1 -p hash1", "patch1"),
- Cmd(("git apply --index --reject \"%s\"" %
- TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
- "", cb=VerifyPatch("patch1")),
- Cmd("git log -1 -p hash5", "patch5\n"),
- Cmd(("git apply --index --reject \"%s\"" %
- TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
- "", cb=VerifyPatch("patch5\n")),
- Cmd("git apply --index --reject \"%s\"" % extra_patch, ""),
- RL("Y"), # Automatically increment patch level?
- Cmd("git commit -aF \"%s\"" % TEST_CONFIG["COMMITMSG_FILE"], ""),
- RL("reviewer@chromium.org"), # V8 reviewer.
- Cmd("git cl upload --send-mail -r \"reviewer@chromium.org\" "
- "--bypass-hooks --cc \"ulan@chromium.org\"", ""),
- Cmd("git checkout -f %s" % TEST_CONFIG["BRANCHNAME"], ""),
- RL("LGTM"), # Enter LGTM for V8 CL.
- Cmd("git cl presubmit", "Presubmit successfull\n"),
- Cmd("git cl dcommit -f --bypass-hooks", "Closing issue\n",
- cb=VerifySVNCommit),
- Cmd("git svn tag 3.22.5.1 -m \"Tagging version 3.22.5.1\"", ""),
- Cmd("git checkout -f some_branch", ""),
- Cmd("git branch -D %s" % TEST_CONFIG["BRANCHNAME"], ""),
- ])
-
- # r12345 and r34567 are patches. r23456 (included) and r45678 are the MIPS
- # ports of r12345. r56789 is the MIPS port of r34567.
- args = ["-f", "-p", extra_patch, "--branch", "trunk",
- "--vc-interface", "git_svn", "12345", "23456", "34567"]
+ msg = """Version 3.22.5.1 (cherry-pick)
- # The first run of the script stops because of the svn being down.
- self.assertRaises(GitFailedException,
- lambda: MergeToBranch(TEST_CONFIG, self).Run(args))
-
- # Test that state recovery after restarting the script works.
- args += ["-s", "3"]
- MergeToBranch(TEST_CONFIG, self).Run(args)
-
- def testMergeToBranchNewGit(self):
- TEST_CONFIG["ALREADY_MERGING_SENTINEL_FILE"] = self.MakeEmptyTempFile()
- TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
- self.WriteFakeVersionFile(build=5)
- os.environ["EDITOR"] = "vi"
- extra_patch = self.MakeEmptyTempFile()
-
- def VerifyPatch(patch):
- return lambda: self.assertEquals(patch,
- FileToText(TEST_CONFIG["TEMPORARY_PATCH_FILE"]))
-
- msg = """Version 3.22.5.1 (merged r12345, r23456, r34567, r45678, r56789)
+Merged ab12345
+Merged ab23456
+Merged ab34567
+Merged ab45678
+Merged ab56789
Title4
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
Cmd("git fetch", ""),
+ Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* branch2\n"),
- Cmd("git checkout -b %s origin/candidates" %
+ Cmd("git new-branch %s --upstream origin/candidates" %
TEST_CONFIG["BRANCHNAME"], ""),
- Cmd(("git log --format=%H --grep=\"Port r12345\" "
+ Cmd(("git log --format=%H --grep=\"Port ab12345\" "
"--reverse origin/master"),
- "hash1\nhash2"),
- Cmd("git svn find-rev hash1 origin/master", "45678"),
- Cmd("git log -1 --format=%s hash1", "Title1"),
- Cmd("git svn find-rev hash2 origin/master", "23456"),
- Cmd("git log -1 --format=%s hash2", "Title2"),
- Cmd(("git log --format=%H --grep=\"Port r23456\" "
+ "ab45678\nab23456"),
+ Cmd("git log -1 --format=%s ab45678", "Title1"),
+ Cmd("git log -1 --format=%s ab23456", "Title2"),
+ Cmd(("git log --format=%H --grep=\"Port ab23456\" "
"--reverse origin/master"),
""),
- Cmd(("git log --format=%H --grep=\"Port r34567\" "
+ Cmd(("git log --format=%H --grep=\"Port ab34567\" "
"--reverse origin/master"),
- "hash3"),
- Cmd("git svn find-rev hash3 origin/master", "56789"),
- Cmd("git log -1 --format=%s hash3", "Title3"),
- RL("Y"), # Automatically add corresponding ports (34567, 56789)?
- Cmd("git svn find-rev r12345 origin/master",
- "Partial-rebuilding bla\nDone rebuilding blub\nhash4"),
- # Simulate svn being down which stops the script.
- Cmd("git svn find-rev r23456 origin/master", None),
+ "ab56789"),
+ Cmd("git log -1 --format=%s ab56789", "Title3"),
+ RL("Y"), # Automatically add corresponding ports (ab34567, ab56789)?
+ # Simulate git being down which stops the script.
+ Cmd("git log -1 --format=%s ab12345", None),
# Restart script in the failing step.
- Cmd("git svn find-rev r12345 origin/master", "hash4"),
- Cmd("git svn find-rev r23456 origin/master", "hash2"),
- Cmd("git svn find-rev r34567 origin/master", "hash3"),
- Cmd("git svn find-rev r45678 origin/master", "hash1"),
- Cmd("git svn find-rev r56789 origin/master", "hash5"),
- Cmd("git log -1 --format=%s hash4", "Title4"),
- Cmd("git log -1 --format=%s hash2", "Title2"),
- Cmd("git log -1 --format=%s hash3", "Title3"),
- Cmd("git log -1 --format=%s hash1", "Title1"),
- Cmd("git log -1 --format=%s hash5", "Revert \"Something\""),
- Cmd("git log -1 hash4", "Title4\nBUG=123\nBUG=234"),
- Cmd("git log -1 hash2", "Title2\n BUG = v8:123,345"),
- Cmd("git log -1 hash3", "Title3\nLOG=n\nBUG=567, 456"),
- Cmd("git log -1 hash1", "Title1\nBUG="),
- Cmd("git log -1 hash5", "Revert \"Something\"\nBUG=none"),
- Cmd("git log -1 -p hash4", "patch4"),
+ Cmd("git log -1 --format=%s ab12345", "Title4"),
+ Cmd("git log -1 --format=%s ab23456", "Title2"),
+ Cmd("git log -1 --format=%s ab34567", "Title3"),
+ Cmd("git log -1 --format=%s ab45678", "Title1"),
+ Cmd("git log -1 --format=%s ab56789", "Revert \"Something\""),
+ Cmd("git log -1 ab12345", "Title4\nBUG=123\nBUG=234"),
+ Cmd("git log -1 ab23456", "Title2\n BUG = v8:123,345"),
+ Cmd("git log -1 ab34567", "Title3\nLOG=n\nBUG=567, 456"),
+ Cmd("git log -1 ab45678", "Title1\nBUG="),
+ Cmd("git log -1 ab56789", "Revert \"Something\"\nBUG=none"),
+ Cmd("git log -1 -p ab12345", "patch4"),
Cmd(("git apply --index --reject \"%s\"" %
TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
"", cb=VerifyPatch("patch4")),
- Cmd("git log -1 -p hash2", "patch2"),
+ Cmd("git log -1 -p ab23456", "patch2"),
Cmd(("git apply --index --reject \"%s\"" %
TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
"", cb=VerifyPatch("patch2")),
- Cmd("git log -1 -p hash3", "patch3"),
+ Cmd("git log -1 -p ab34567", "patch3"),
Cmd(("git apply --index --reject \"%s\"" %
TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
"", cb=VerifyPatch("patch3")),
- Cmd("git log -1 -p hash1", "patch1"),
+ Cmd("git log -1 -p ab45678", "patch1"),
Cmd(("git apply --index --reject \"%s\"" %
TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
"", cb=VerifyPatch("patch1")),
- Cmd("git log -1 -p hash5", "patch5\n"),
+ Cmd("git log -1 -p ab56789", "patch5\n"),
Cmd(("git apply --index --reject \"%s\"" %
TEST_CONFIG["TEMPORARY_PATCH_FILE"]),
"", cb=VerifyPatch("patch5\n")),
Cmd("git cl presubmit", "Presubmit successfull\n"),
Cmd("git cl dcommit -f --bypass-hooks", "Closing issue\n",
cb=VerifySVNCommit),
- Cmd("git svn tag 3.22.5.1 -m \"Tagging version 3.22.5.1\"", ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\""
+ "Version 3.22.5.1 (cherry-pick)"
+ "\" origin/candidates",
+ ""),
+ Cmd("git fetch", ""),
+ Cmd("git log -1 --format=%H --grep=\""
+ "Version 3.22.5.1 (cherry-pick)"
+ "\" origin/candidates",
+ "hsh_to_tag"),
+ Cmd("git tag 3.22.5.1 hsh_to_tag", ""),
+ Cmd("git push origin 3.22.5.1", ""),
Cmd("git checkout -f some_branch", ""),
Cmd("git branch -D %s" % TEST_CONFIG["BRANCHNAME"], ""),
])
- # r12345 and r34567 are patches. r23456 (included) and r45678 are the MIPS
- # ports of r12345. r56789 is the MIPS port of r34567.
+ # ab12345 and ab34567 are patches. ab23456 (included) and ab45678 are the
+ # MIPS ports of ab12345. ab56789 is the MIPS port of ab34567.
args = ["-f", "-p", extra_patch, "--branch", "candidates",
- "--vc-interface", "git_read_svn_write", "12345", "23456", "34567"]
+ "ab12345", "ab23456", "ab34567"]
- # The first run of the script stops because of the svn being down.
+ # The first run of the script stops because of git being down.
self.assertRaises(GitFailedException,
lambda: MergeToBranch(TEST_CONFIG, self).Run(args))
# Test that state recovery after restarting the script works.
- args += ["-s", "3"]
+ args += ["-s", "4"]
MergeToBranch(TEST_CONFIG, self).Run(args)
def testReleases(self):
self.Expect([
Cmd("git status -s -uno", ""),
Cmd("git status -s -b -uno", "## some_branch\n"),
+ Cmd("git fetch", ""),
Cmd("git svn fetch", ""),
Cmd("git branch", " branch1\n* branch2\n"),
- Cmd("git checkout -b %s" % TEST_CONFIG["BRANCHNAME"], ""),
- Cmd("git branch -r", " svn/3.21\n svn/3.3\n"),
- Cmd("git reset --hard svn/3.3", ""),
- Cmd("git log --format=%H", "hash1\nhash2"),
+ Cmd("git new-branch %s" % TEST_CONFIG["BRANCHNAME"], ""),
+ Cmd("git branch -r", " branch-heads/3.21\n branch-heads/3.3\n"),
+ Cmd("git reset --hard branch-heads/3.3", ""),
+ Cmd("git log --format=%H", "hash1\nhash_234"),
Cmd("git diff --name-only hash1 hash1^", ""),
- Cmd("git diff --name-only hash2 hash2^", VERSION_FILE),
- Cmd("git checkout -f hash2 -- %s" % VERSION_FILE, "",
+ Cmd("git diff --name-only hash_234 hash_234^", VERSION_FILE),
+ Cmd("git checkout -f hash_234 -- %s" % VERSION_FILE, "",
cb=ResetVersion(3, 1, 1)),
- Cmd("git log -1 --format=%B hash2",
- "Version 3.3.1.1 (merged 12)\n\nReview URL: fake.com\n"),
- Cmd("git log -1 --format=%s hash2", ""),
- Cmd("git svn find-rev hash2", "234"),
- Cmd("git log -1 --format=%ci hash2", "18:15"),
+ Cmd("git log -1 --format=%B hash_234",
+ "Version 3.3.1.1 (cherry-pick).\n\n"
+ "Merged abc12.\n\n"
+ "Review URL: fake.com\n"),
+ Cmd("git log -1 --format=%s hash_234", ""),
+ Cmd("git svn find-rev hash_234", "234"),
+ Cmd("git log -1 --format=%ci hash_234", "18:15"),
Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
cb=ResetVersion(22, 5)),
- Cmd("git reset --hard svn/3.21", ""),
- Cmd("git log --format=%H", "hash3\nhash4\nhash5\n"),
- Cmd("git diff --name-only hash3 hash3^", VERSION_FILE),
- Cmd("git checkout -f hash3 -- %s" % VERSION_FILE, "",
+ Cmd("git reset --hard branch-heads/3.21", ""),
+ Cmd("git log --format=%H", "hash_123\nhash4\nhash5\n"),
+ Cmd("git diff --name-only hash_123 hash_123^", VERSION_FILE),
+ Cmd("git checkout -f hash_123 -- %s" % VERSION_FILE, "",
cb=ResetVersion(21, 2)),
- Cmd("git log -1 --format=%B hash3", ""),
- Cmd("git log -1 --format=%s hash3", ""),
- Cmd("git svn find-rev hash3", "123"),
- Cmd("git log -1 --format=%ci hash3", "03:15"),
+ Cmd("git log -1 --format=%B hash_123", ""),
+ Cmd("git log -1 --format=%s hash_123", ""),
+ Cmd("git svn find-rev hash_123", "123"),
+ Cmd("git log -1 --format=%ci hash_123", "03:15"),
Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
cb=ResetVersion(22, 5)),
- Cmd("git reset --hard svn/trunk", ""),
- Cmd("git log --format=%H", "hash6\n"),
- Cmd("git diff --name-only hash6 hash6^", VERSION_FILE),
- Cmd("git checkout -f hash6 -- %s" % VERSION_FILE, "",
+ Cmd("git reset --hard origin/candidates", ""),
+ Cmd("git log --format=%H", "hash_345\n"),
+ Cmd("git diff --name-only hash_345 hash_345^", VERSION_FILE),
+ Cmd("git checkout -f hash_345 -- %s" % VERSION_FILE, "",
cb=ResetVersion(22, 3)),
- Cmd("git log -1 --format=%B hash6", ""),
- Cmd("git log -1 --format=%s hash6", ""),
- Cmd("git svn find-rev hash6", "345"),
- Cmd("git log -1 --format=%ci hash6", ""),
+ Cmd("git log -1 --format=%B hash_345", ""),
+ Cmd("git log -1 --format=%s hash_345", ""),
+ Cmd("git svn find-rev hash_345", "345"),
+ Cmd("git log -1 --format=%ci hash_345", ""),
Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
cb=ResetVersion(22, 5)),
- Cmd("git reset --hard svn/bleeding_edge", ""),
+ Cmd("git reset --hard origin/master", ""),
Cmd("svn log https://v8.googlecode.com/svn/tags -v --limit 20",
tag_response_text),
Cmd("git svn find-rev r22626", "hash_22626"),
Cmd("git status -s -uno", "", cwd=chrome_dir),
Cmd("git checkout -f master", "", cwd=chrome_dir),
Cmd("git pull", "", cwd=chrome_dir),
- Cmd("git checkout -b %s" % TEST_CONFIG["BRANCHNAME"], "", cwd=chrome_dir),
+ Cmd("git new-branch %s" % TEST_CONFIG["BRANCHNAME"], "",
+ cwd=chrome_dir),
Cmd("git fetch origin", "", cwd=chrome_v8_dir),
Cmd("git log --format=%H --grep=\"V8\"", "c_hash1\nc_hash2\nc_hash3\n",
cwd=chrome_dir),
])
args = ["-c", TEST_CONFIG["CHROMIUM"],
+ "--vc-interface", "git_read_svn_write",
"--json", json_output,
"--csv", csv_output,
"--max-releases", "1"]
Releases(TEST_CONFIG, self).Run(args)
# Check expected output.
- csv = ("3.28.41,bleeding_edge,22626,,\r\n"
- "3.28.40,bleeding_edge,22624,4567,\r\n"
- "3.22.3,trunk,345,3456:4566,\r\n"
+ csv = ("3.28.41,master,22626,,\r\n"
+ "3.28.40,master,22624,4567,\r\n"
+ "3.22.3,candidates,345,3456:4566,\r\n"
"3.21.2,3.21,123,,\r\n"
- "3.3.1.1,3.3,234,,12\r\n")
+ "3.3.1.1,3.3,234,,abc12\r\n")
self.assertEquals(csv, FileToText(csv_output))
expected_json = [
- {"bleeding_edge": "22626", "patches_merged": "", "version": "3.28.41",
- "chromium_revision": "", "branch": "bleeding_edge", "revision": "22626",
- "review_link": "", "date": "01:23", "chromium_branch": "",
- "revision_link": "https://code.google.com/p/v8/source/detail?r=22626"},
- {"bleeding_edge": "22624", "patches_merged": "", "version": "3.28.40",
- "chromium_revision": "4567", "branch": "bleeding_edge",
- "revision": "22624", "review_link": "", "date": "02:34",
- "chromium_branch": "",
- "revision_link": "https://code.google.com/p/v8/source/detail?r=22624"},
- {"bleeding_edge": "", "patches_merged": "", "version": "3.22.3",
- "chromium_revision": "3456:4566", "branch": "trunk", "revision": "345",
- "review_link": "", "date": "", "chromium_branch": "7",
- "revision_link": "https://code.google.com/p/v8/source/detail?r=345"},
- {"patches_merged": "", "bleeding_edge": "", "version": "3.21.2",
- "chromium_revision": "", "branch": "3.21", "revision": "123",
- "review_link": "", "date": "03:15", "chromium_branch": "",
- "revision_link": "https://code.google.com/p/v8/source/detail?r=123"},
- {"patches_merged": "12", "bleeding_edge": "", "version": "3.3.1.1",
- "chromium_revision": "", "branch": "3.3", "revision": "234",
- "review_link": "fake.com", "date": "18:15", "chromium_branch": "",
- "revision_link": "https://code.google.com/p/v8/source/detail?r=234"},
+ {
+ "revision": "22626",
+ "revision_git": "hash_22626",
+ "bleeding_edge": "22626",
+ "bleeding_edge_git": "hash_22626",
+ "patches_merged": "",
+ "version": "3.28.41",
+ "chromium_revision": "",
+ "branch": "master",
+ "review_link": "",
+ "date": "01:23",
+ "chromium_branch": "",
+ "revision_link": "https://code.google.com/p/v8/source/detail?r=22626",
+ },
+ {
+ "revision": "22624",
+ "revision_git": "hash_22624",
+ "bleeding_edge": "22624",
+ "bleeding_edge_git": "hash_22624",
+ "patches_merged": "",
+ "version": "3.28.40",
+ "chromium_revision": "4567",
+ "branch": "master",
+ "review_link": "",
+ "date": "02:34",
+ "chromium_branch": "",
+ "revision_link": "https://code.google.com/p/v8/source/detail?r=22624",
+ },
+ {
+ "revision": "345",
+ "revision_git": "hash_345",
+ "bleeding_edge": "",
+ "bleeding_edge_git": "",
+ "patches_merged": "",
+ "version": "3.22.3",
+ "chromium_revision": "3456:4566",
+ "branch": "candidates",
+ "review_link": "",
+ "date": "",
+ "chromium_branch": "7",
+ "revision_link": "https://code.google.com/p/v8/source/detail?r=345",
+ },
+ {
+ "revision": "123",
+ "revision_git": "hash_123",
+ "patches_merged": "",
+ "bleeding_edge": "",
+ "bleeding_edge_git": "",
+ "version": "3.21.2",
+ "chromium_revision": "",
+ "branch": "3.21",
+ "review_link": "",
+ "date": "03:15",
+ "chromium_branch": "",
+ "revision_link": "https://code.google.com/p/v8/source/detail?r=123",
+ },
+ {
+ "revision": "234",
+ "revision_git": "hash_234",
+ "patches_merged": "abc12",
+ "bleeding_edge": "",
+ "bleeding_edge_git": "",
+ "version": "3.3.1.1",
+ "chromium_revision": "",
+ "branch": "3.3",
+ "review_link": "fake.com",
+ "date": "18:15",
+ "chromium_branch": "",
+ "revision_link": "https://code.google.com/p/v8/source/detail?r=234",
+ },
]
self.assertEquals(expected_json, json.loads(FileToText(json_output)))
Cmd(("git log --format=%H --grep="
"\"^git-svn-id: [^@]*@12345 [A-Za-z0-9-]*$\""),
"lkgr_hash"),
- Cmd("git checkout -b auto-bump-up-version lkgr_hash", ""),
+ Cmd("git new-branch auto-bump-up-version --upstream lkgr_hash", ""),
Cmd("git checkout -f master", ""),
Cmd("git branch", "auto-bump-up-version\n* master"),
Cmd("git branch -D auto-bump-up-version", ""),
Cmd("git pull", ""),
URL("https://v8-status.appspot.com/current?format=json",
"{\"message\": \"Tree is open\"}"),
- Cmd("git checkout -b auto-bump-up-version master", "",
+ Cmd("git new-branch auto-bump-up-version --upstream master", "",
cb=ResetVersion(11, 4)),
Cmd("git commit -am \"[Auto-roll] Bump up version to 3.11.6.0\n\n"
"TBR=author@chromium.org\" "
Cmd("svn status", "", cwd=svn_root),
Cmd("patch -d branches/bleeding_edge -p1 -i %s" %
TEST_CONFIG["PATCH_FILE"], "Applied patch...", cwd=svn_root),
+ Cmd("svn status", "M src/version.cc", cwd=svn_root),
Cmd("svn commit --non-interactive --username=author@chromium.org "
"--config-dir=[CONFIG_DIR] "
"-m \"[Auto-roll] Bump up version to 3.11.6.0\"",
"--svn", svn_root,
"--svn-config", "[CONFIG_DIR]"])
- def testAutoTag(self):
- self.WriteFakeVersionFile()
-
- def ResetVersion(minor, build, patch=0):
- return lambda: self.WriteFakeVersionFile(minor=minor,
- build=build,
- patch=patch)
-
- self.Expect([
- Cmd("git status -s -uno", ""),
- Cmd("git status -s -b -uno", "## some_branch\n"),
- Cmd("git svn fetch", ""),
- Cmd("git branch", " branch1\n* branch2\n"),
- Cmd("git checkout -f master", ""),
- Cmd("git svn rebase", ""),
- Cmd("git checkout -b %s" % TEST_CONFIG["BRANCHNAME"], "",
- cb=ResetVersion(4, 5)),
- Cmd("git branch -r",
- "svn/tags/3.4.2\nsvn/tags/3.2.1.0\nsvn/branches/3.4"),
- Cmd(("git log --format=%H --grep="
- "\"\\[Auto\\-roll\\] Bump up version to\""),
- "hash125\nhash118\nhash111\nhash101"),
- Cmd("git checkout -f hash125 -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 4)),
- Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 5)),
- Cmd("git checkout -f hash118 -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 3)),
- Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 5)),
- Cmd("git checkout -f hash111 -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 2)),
- Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
- cb=ResetVersion(4, 5)),
- URL("https://v8-status.appspot.com/revisions?format=json",
- "[{\"revision\": \"126\", \"status\": true},"
- "{\"revision\": \"123\", \"status\": true},"
- "{\"revision\": \"112\", \"status\": true}]"),
- Cmd("git svn find-rev hash118", "118"),
- Cmd("git svn find-rev hash125", "125"),
- Cmd("git svn find-rev r123", "hash123"),
- Cmd("git log -1 --format=%at hash123", "1"),
- Cmd("git reset --hard hash123", ""),
- Cmd("git svn tag 3.4.3 -m \"Tagging version 3.4.3\"", ""),
- Cmd("git checkout -f some_branch", ""),
- Cmd("git branch -D %s" % TEST_CONFIG["BRANCHNAME"], ""),
- ])
-
- AutoTag(TEST_CONFIG, self).Run(["-a", "author@chromium.org"])
-
# Test that we bail out if the last change was a version change.
def testBumpUpVersionBailout1(self):
self._state["latest"] = "latest_hash"
"simulator": utils.UseSimulator(arch),
"system": utils.GuessOS(),
"tsan": False,
+ "msan": False,
}
all_tests = []
num_tests = 0
fi
echo "Running benchmark..."
-perf record -R -e cycles -c $SAMPLE_EVERY_N_CYCLES -f -i $@ --ll-prof
+perf record -R -e cycles -c $SAMPLE_EVERY_N_CYCLES -i $@ --ll-prof
from testrunner.local import execution
from testrunner.local import progress
from testrunner.local import testsuite
+from testrunner.local.testsuite import VARIANT_FLAGS
from testrunner.local import utils
from testrunner.local import verbose
from testrunner.network import network_execution
ARCH_GUESS = utils.DefaultArch()
-DEFAULT_TESTS = ["mjsunit", "fuzz-natives", "base-unittests",
- "cctest", "compiler-unittests", "heap-unittests",
- "libplatform-unittests", "message", "preparser"]
+DEFAULT_TESTS = [
+ "mjsunit",
+ "unittests",
+ "cctest",
+ "message",
+ "preparser",
+]
# Map of test name synonyms to lists of test suites. Should be ordered by
# expected runtimes (suites with slow test cases first). These groups are
TEST_MAP = {
"default": [
"mjsunit",
- "fuzz-natives",
"cctest",
"message",
"preparser",
"webkit",
],
"unittests": [
- "compiler-unittests",
- "heap-unittests",
- "base-unittests",
- "libplatform-unittests",
+ "unittests",
],
}
TIMEOUT_SCALEFACTOR = {"debug" : 4,
"release" : 1 }
-# Use this to run several variants of the tests.
-VARIANT_FLAGS = {
- "default": [],
- "stress": ["--stress-opt", "--always-opt"],
- "turbofan": ["--turbo-asm", "--turbo-filter=*", "--always-opt"],
- "nocrankshaft": ["--nocrankshaft"]}
-
VARIANTS = ["default", "stress", "turbofan", "nocrankshaft"]
MODE_FLAGS = {
default="v8tests")
result.add_option("--random-seed", default=0, dest="random_seed",
help="Default seed for initializing random generator")
+ result.add_option("--msan",
+ help="Regard test expectations for MSAN",
+ default=False, action="store_true")
return result
if options.tsan:
VARIANTS = ["default"]
+ suppressions_file = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+ 'sanitizers', 'tsan_suppressions.txt')
+ tsan_options = '%s suppressions=%s' % (
+ os.environ.get('TSAN_OPTIONS', ''), suppressions_file)
+ os.environ['TSAN_OPTIONS'] = tsan_options
if options.j == 0:
options.j = multiprocessing.cpu_count()
"simulator": utils.UseSimulator(arch),
"system": utils.GuessOS(),
"tsan": options.tsan,
+ "msan": options.msan,
}
all_tests = []
num_tests = 0
Path pieces are concatenated. D8 is always run with the suite's path as cwd.
"""
+from collections import OrderedDict
import json
import math
import optparse
"x64",
"arm64"]
-GENERIC_RESULTS_RE = re.compile(
- r"^Trace\(([^\)]+)\), Result\(([^\)]+)\), StdDev\(([^\)]+)\)$")
+GENERIC_RESULTS_RE = re.compile(r"^RESULT ([^:]+): ([^=]+)= ([^ ]+) ([^ ]*)$")
+RESULT_STDDEV_RE = re.compile(r"^\{([^\}]+)\}$")
+RESULT_LIST_RE = re.compile(r"^\[([^\]]+)\]$")
+
def GeometricMean(values):
def Run(self, runner):
"""Iterates over several runs and handles the output."""
- traces = {}
+ traces = OrderedDict()
for stdout in runner():
for line in stdout.strip().splitlines():
match = GENERIC_RESULTS_RE.match(line)
if match:
- trace = match.group(1)
- result = match.group(2)
- stddev = match.group(3)
+ stddev = ""
+ graph = match.group(1)
+ trace = match.group(2)
+ body = match.group(3)
+ units = match.group(4)
+ match_stddev = RESULT_STDDEV_RE.match(body)
+ match_list = RESULT_LIST_RE.match(body)
+ if match_stddev:
+ result, stddev = map(str.strip, match_stddev.group(1).split(","))
+ results = [result]
+ elif match_list:
+ results = map(str.strip, match_list.group(1).split(","))
+ else:
+ results = [body.strip()]
+
trace_result = traces.setdefault(trace, Results([{
- "graphs": self.graphs + [trace],
- "units": self.units,
+ "graphs": self.graphs + [graph, trace],
+ "units": (units or self.units).strip(),
"results": [],
"stddev": "",
}], []))
- trace_result.traces[0]["results"].append(result)
+ trace_result.traces[0]["results"].extend(results)
trace_result.traces[0]["stddev"] = stddev
return reduce(lambda r, t: r + t, traces.itervalues(), Results())
--- /dev/null
+# Suppressions for TSan v2
+# https://code.google.com/p/thread-sanitizer/wiki/Suppressions
+
+# Incorrectly detected lock cycles in test-lockers
+# https://code.google.com/p/thread-sanitizer/issues/detail?id=81
+deadlock:LockAndUnlockDifferentIsolatesThread::Run
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Utility functions used by parser-shell and lexer-shell.
+// Utility functions used by parser-shell.
#include <stdio.h>
CRASH = "CRASH"
SLOW = "SLOW"
FLAKY = "FLAKY"
+FAST_VARIANTS = "FAST_VARIANTS"
NO_VARIANTS = "NO_VARIANTS"
# These are just for the status files and are mapped below in DEFS:
FAIL_OK = "FAIL_OK"
KEYWORDS = {}
for key in [SKIP, FAIL, PASS, OKAY, TIMEOUT, CRASH, SLOW, FLAKY, FAIL_OK,
- NO_VARIANTS, PASS_OR_FAIL, ALWAYS]:
+ FAST_VARIANTS, NO_VARIANTS, PASS_OR_FAIL, ALWAYS]:
KEYWORDS[key] = key
DEFS = {FAIL_OK: [FAIL, OKAY],
return NO_VARIANTS in outcomes
+def OnlyFastVariants(outcomes):
+ return FAST_VARIANTS in outcomes
+
+
def IsFlaky(outcomes):
return FLAKY in outcomes
from . import utils
from ..objects import testcase
+# Use this to run several variants of the tests.
+VARIANT_FLAGS = {
+ "default": [],
+ "stress": ["--stress-opt", "--always-opt"],
+ "turbofan": ["--turbo-asm", "--turbo-filter=*", "--always-opt"],
+ "nocrankshaft": ["--nocrankshaft"]}
+
+FAST_VARIANT_FLAGS = [
+ f for v, f in VARIANT_FLAGS.iteritems() if v in ["default", "turbofan"]
+]
+
class TestSuite(object):
@staticmethod
def VariantFlags(self, testcase, default_flags):
if testcase.outcomes and statusfile.OnlyStandardVariant(testcase.outcomes):
return [[]]
+ if testcase.outcomes and statusfile.OnlyFastVariants(testcase.outcomes):
+ return filter(lambda flags: flags in FAST_VARIANT_FLAGS, default_flags)
return default_flags
def DownloadData(self):
this.ticks_.total, null);
}
+ print('\n [C++ entry points]:');
+ print(' ticks cpp total name');
+ var c_entry_functions = this.profile_.getCEntryProfile();
+ var total_c_entry = c_entry_functions[0].ticks;
+ for (var i = 1; i < c_entry_functions.length; i++) {
+ c = c_entry_functions[i];
+ this.printLine(c.name, c.ticks, total_c_entry, totalTicks);
+ }
+
this.printHeavyProfHeader();
var heavyProfile = this.profile_.getBottomUpProfile();
var heavyView = this.viewBuilder_.buildView(heavyProfile);
test_input = dict(V8_GENERIC_JSON)
self._WriteTestInput(test_input)
self._MockCommand(["."], [
- "Trace(Test1), Result(1.234), StdDev(0.23)\n"
- "Trace(Test2), Result(10657567), StdDev(106)\n"])
+ "RESULT Infra: Constant1= 11 count\n"
+ "RESULT Infra: Constant2= [10,5,10,15] count\n"
+ "RESULT Infra: Constant3= {12,1.2} count\n"])
self.assertEquals(0, self._CallMain())
- self._VerifyResults("test", "ms", [
- {"name": "Test1", "results": ["1.234"], "stddev": "0.23"},
- {"name": "Test2", "results": ["10657567"], "stddev": "106"},
- ])
+ self.assertEquals([
+ {"units": "count",
+ "graphs": ["test", "Infra", "Constant1"],
+ "results": ["11"],
+ "stddev": ""},
+ {"units": "count",
+ "graphs": ["test", "Infra", "Constant2"],
+ "results": ["10", "5", "10", "15"],
+ "stddev": ""},
+ {"units": "count",
+ "graphs": ["test", "Infra", "Constant3"],
+ "results": ["12"],
+ "stddev": "1.2"},
+ ], self._LoadResults()["traces"])
self._VerifyErrors([])
self._VerifyMock(path.join("out", "x64.release", "cc"), "--flag", "")
-You can modify this file to create no-op changelists...
+You can modify this file to create no-op changelists.
Try to write something funny. And please don't add trailing whitespace.
A Smi walks into a bar and says:
"I'm so deoptimized today!"
The doubles heard this and started to unbox.
-The Smi looked at them when a crazy v8-autoroll account showed up.
+The Smi looked at them when a crazy v8-autoroll account showed up..
projects / platform / upstream / nodejs.git / commitdiff