Commit fe67c23

3. Traps caused by compiled WebAssembly code. These correspond to fatal errors coming from the WebAssembly VM. This can occur for example when performing an integer division by zero, or when converting a large floating point number to an integer when the float is out of range of the numbers representable by that integer type. See the linker flag ``-s BINARYEN_TRAP_MODE`` for more details.

Binaryen codegen options

Fastcomp/asm2wasm

In fastcomp/asm2wasm, emscripten will emit code that is optimized for size and speed, which means it emits code that may trap on the things mentioned before. That mode is called ``allow``. The other modes are ``clamp``, which will avoid traps by clamping values to a reasonable range, and ``js``, which ensures the exact same behavior as JavaScript does (which also does clamping, but makes sure to clamp exactly like JavaScript does, and also do other things JavaScript would).

In general, using ``clamp`` is safest, as whether such a trap occurs depends on how the LLVM optimizer optimizes code. In other words, there is no guarantee that this will not be an issue, and updating LLVM can make a problem appear or vanish (the wasm spec process has recognized this problem and intends to standardize `new operations that avoid it <https://github.com/WebAssembly/design/issues/1143>`_). Also, there is not a big downside to using ``clamp``: it is only slightly larger and slower than the default ``allow``, in most cases. To do so, build with

::

However, if the default (to allow traps) works in your codebase, then it may be worth keeping it that way, for the (small) benefits. Note that ``js``, which preserves the exact same behavior as JavaScript does, adds a large amount of overhead, so unless you really need that, use ``clamp`` (``js`` is often useful for debugging, though).

LLVM wasm backend

var NEED_ALL_ASM2WASM_IMPORTS = BINARYEN_TRAP_MODE == 'js';

var BINARYEN_TRAP_MODE = "allow";

#if NEED_ALL_ASM2WASM_IMPORTS

,

"f64-to-int": function(x) {

return x | 0;

},

"i32s-div": function(x, y) {

return ((x | 0) / (y | 0)) | 0;

},

"i32u-div": function(x, y) {

return ((x >>> 0) / (y >>> 0)) >>> 0;

},

"i32s-rem": function(x, y) {

return ((x | 0) % (y | 0)) | 0;

},

"i32u-rem": function(x, y) {

return ((x >>> 0) % (y >>> 0)) >>> 0;

}

#endif // NEED_ALL_ASM2WASM_IMPORTS

js_args += ['-s', 'BINARYEN=1', '-s', 'BINARYEN_TRAP_MODE="js"']

if not self.is_wasm_backend():

self.emcc_args += ['-s', 'BINARYEN_TRAP_MODE=js']

@no_wasm_backend('uses BINARYEN_TRAP_MODE (the wasm backend only supports non-trapping)')

def test_binaryen_trap_mode(self):

if not self.is_wasm():

self.skipTest('wasm test')

TRAP_OUTPUTS = ('trap', 'RuntimeError')

default = 'allow'

print('default is', default)

for mode in ['js', 'clamp', 'allow', '']:

if mode == 'js' and self.is_wasm_backend():

# wasm backend does not use asm2wasm imports, which js trap mode requires

continue

print('mode:', mode)

self.set_setting('BINARYEN_TRAP_MODE', mode or default)

if not mode:

mode = default

print(' idiv')

self.do_run(open(path_from_root('tests', 'wasm', 'trap-idiv.cpp')).read(), {

'js': '|0|',

'clamp': '|0|',

'allow': TRAP_OUTPUTS

}[mode], assert_returncode=NON_ZERO if mode == 'allow' else 0)

print(' f2i')

self.do_run(open(path_from_root('tests', 'wasm', 'trap-f2i.cpp')).read(), {

'js': '|1337|\n|4294967295|', # JS did an fmod 2^32 | normal

'clamp': '|-2147483648|\n|4294967295|',

'allow': TRAP_OUTPUTS

}[mode], assert_returncode=NON_ZERO if mode == 'allow' else 0)